35 #ifndef _BLAZE_MATH_ADAPTORS_SYMMETRICMATRIX_DENSENUMERIC_H_
36 #define _BLAZE_MATH_ADAPTORS_SYMMETRICMATRIX_DENSENUMERIC_H_
104 template<
typename MT
106 class SymmetricMatrix<MT,SO,true,true>
107 :
public DenseMatrix< SymmetricMatrix<MT,SO,true,true>, SO >
114 typedef IntrinsicTrait<ET> IT;
119 typedef SymmetricMatrix<MT,SO,true,true>
This;
124 typedef typename MT::IntrinsicType IntrinsicType;
129 typedef typename MT::Pointer Pointer;
130 typedef typename MT::ConstPointer ConstPointer;
137 template<
typename ET >
140 typedef SymmetricMatrix< typename MT::template Rebind<ET>::Other > Other;
151 typedef std::random_access_iterator_tag IteratorCategory;
153 typedef NumericProxy<MT> PointerType;
154 typedef NumericProxy<MT> ReferenceType;
155 typedef ptrdiff_t DifferenceType;
158 typedef IteratorCategory iterator_category;
159 typedef ValueType value_type;
160 typedef PointerType pointer;
161 typedef ReferenceType reference;
162 typedef DifferenceType difference_type;
195 inline Iterator& operator+=(
size_t inc ) {
196 ( SO )?( row_ += inc ):( column_ += inc );
207 inline Iterator& operator-=(
size_t dec ) {
208 ( SO )?( row_ -= dec ):( column_ -= dec );
219 ( SO )?( ++row_ ):( ++column_ );
229 inline const Iterator operator++(
int ) {
242 ( SO )?( --row_ ):( --column_ );
252 inline const Iterator operator--(
int ) {
265 return ReferenceType( *matrix_, row_, column_ );
274 inline PointerType operator->()
const {
275 return PointerType( *matrix_, row_, column_ );
286 return matrix_->begin( column_ ) + row_;
288 return matrix_->begin( row_ ) + column_;
300 return ( SO )?( lhs.row_ == rhs.row_ ):( lhs.column_ == rhs.column_ );
336 return ( SO )?( lhs.row_ != rhs.row_ ):( lhs.column_ != rhs.column_ );
372 return ( SO )?( lhs.row_ < rhs.row_ ):( lhs.column_ < rhs.column_ );
408 return ( SO )?( lhs.row_ > rhs.row_ ):( lhs.column_ > rhs.column_ );
444 return ( SO )?( lhs.row_ <= rhs.row_ ):( lhs.column_ <= rhs.column_ );
480 return ( SO )?( lhs.row_ >= rhs.row_ ):( lhs.column_ >= rhs.column_ );
515 return ( SO )?( row_ - rhs.row_ ):( column_ - rhs.column_ );
528 return Iterator( *it.matrix_, it.row_ + inc, it.column_ );
530 return Iterator( *it.matrix_, it.row_, it.column_ + inc );
543 return Iterator( *it.matrix_, it.row_ + inc, it.column_ );
545 return Iterator( *it.matrix_, it.row_, it.column_ + inc );
558 return Iterator( *it.matrix_, it.row_ - dec, it.column_ );
560 return Iterator( *it.matrix_, it.row_, it.column_ - dec );
575 enum { vectorizable = MT::vectorizable };
578 enum { smpAssignable = MT::smpAssignable };
584 explicit inline SymmetricMatrix();
585 explicit inline SymmetricMatrix(
size_t n );
587 inline SymmetricMatrix(
const SymmetricMatrix& m );
588 template<
typename MT2 >
inline SymmetricMatrix(
const Matrix<MT2,SO>& m );
589 template<
typename MT2 >
inline SymmetricMatrix(
const Matrix<MT2,!SO>& m );
600 inline Reference operator()(
size_t i,
size_t j );
601 inline ConstReference operator()(
size_t i,
size_t j )
const;
602 inline ConstPointer data ()
const;
603 inline ConstPointer data (
size_t i )
const;
605 inline ConstIterator
begin (
size_t i )
const;
606 inline ConstIterator
cbegin(
size_t i )
const;
608 inline ConstIterator
end (
size_t i )
const;
609 inline ConstIterator
cend (
size_t i )
const;
616 inline SymmetricMatrix& operator=(
const SymmetricMatrix& rhs );
618 template<
typename MT2 >
619 inline typename DisableIf< IsComputation<MT2>, SymmetricMatrix& >::Type
620 operator=(
const Matrix<MT2,SO>& rhs );
622 template<
typename MT2 >
623 inline typename EnableIf< IsComputation<MT2>, SymmetricMatrix& >::Type
624 operator=(
const Matrix<MT2,SO>& rhs );
626 template<
typename MT2 >
627 inline SymmetricMatrix& operator=(
const Matrix<MT2,!SO>& rhs );
629 template<
typename MT2 >
630 inline typename DisableIf< IsComputation<MT2>, SymmetricMatrix& >::Type
631 operator+=(
const Matrix<MT2,SO>& rhs );
633 template<
typename MT2 >
634 inline typename EnableIf< IsComputation<MT2>, SymmetricMatrix& >::Type
635 operator+=(
const Matrix<MT2,SO>& rhs );
637 template<
typename MT2 >
638 inline SymmetricMatrix& operator+=(
const Matrix<MT2,!SO>& rhs );
640 template<
typename MT2 >
641 inline typename DisableIf< IsComputation<MT2>, SymmetricMatrix& >::Type
642 operator-=(
const Matrix<MT2,SO>& rhs );
644 template<
typename MT2 >
645 inline typename EnableIf< IsComputation<MT2>, SymmetricMatrix& >::Type
646 operator-=(
const Matrix<MT2,SO>& rhs );
648 template<
typename MT2 >
649 inline SymmetricMatrix& operator-=(
const Matrix<MT2,!SO>& rhs );
651 template<
typename MT2,
bool SO2 >
652 inline SymmetricMatrix& operator*=(
const Matrix<MT2,SO2>& rhs );
654 template<
typename Other >
655 inline typename EnableIf< IsNumeric<Other>, SymmetricMatrix >::Type&
656 operator*=( Other rhs );
658 template<
typename Other >
659 inline typename EnableIf< IsNumeric<Other>, SymmetricMatrix >::Type&
660 operator/=( Other rhs );
667 inline size_t rows()
const;
671 inline size_t capacity(
size_t i )
const;
673 inline size_t nonZeros(
size_t i )
const;
675 inline void reset(
size_t i );
677 void resize (
size_t n,
bool preserve=
true );
678 inline void extend (
size_t n,
bool preserve=
true );
679 inline void reserve(
size_t elements );
680 inline SymmetricMatrix& transpose();
681 template<
typename Other >
inline SymmetricMatrix& scale(
const Other& scalar );
682 inline void swap( SymmetricMatrix& m ) ;
689 template<
typename Other >
inline bool canAlias (
const Other* alias )
const;
690 template<
typename Other >
inline bool isAliased(
const Other* alias )
const;
692 inline bool isAligned ()
const;
693 inline bool canSMPAssign()
const;
698 inline void store (
size_t i,
size_t j,
const IntrinsicType& value );
699 inline void storeu(
size_t i,
size_t j,
const IntrinsicType& value );
700 inline void stream(
size_t i,
size_t j,
const IntrinsicType& value );
713 template<
typename MT2,
bool SO2,
bool DF2,
bool NF2 >
714 friend bool isDefault(
const SymmetricMatrix<MT2,SO2,DF2,NF2>& m );
749 template<
typename MT
751 inline SymmetricMatrix<MT,SO,true,true>::SymmetricMatrix()
766 template<
typename MT
768 inline SymmetricMatrix<MT,SO,true,true>::SymmetricMatrix(
size_t n )
769 : matrix_( n, n, ElementType() )
785 template<
typename MT
787 inline SymmetricMatrix<MT,SO,true,true>::SymmetricMatrix(
const SymmetricMatrix& m )
788 : matrix_( m.matrix_ )
806 template<
typename MT
808 template<
typename MT2 >
809 inline SymmetricMatrix<MT,SO,true,true>::SymmetricMatrix(
const Matrix<MT2,SO>& m )
812 if( !IsSymmetric<MT2>::value && !
isSymmetric( matrix_ ) )
813 throw std::invalid_argument(
"Invalid setup of symmetric matrix" );
831 template<
typename MT
833 template<
typename MT2 >
834 inline SymmetricMatrix<MT,SO,true,true>::SymmetricMatrix(
const Matrix<MT2,!SO>& m )
835 : matrix_(
trans( ~m ) )
837 if( !IsSymmetric<MT2>::value && !
isSymmetric( matrix_ ) )
838 throw std::invalid_argument(
"Invalid setup of symmetric matrix" );
866 template<
typename MT
869 SymmetricMatrix<MT,SO,true,true>::operator()(
size_t i,
size_t j )
892 template<
typename MT
895 SymmetricMatrix<MT,SO,true,true>::operator()(
size_t i,
size_t j )
const
920 template<
typename MT
922 inline typename SymmetricMatrix<MT,SO,true,true>::ConstPointer
923 SymmetricMatrix<MT,SO,true,true>::data()
const
925 return matrix_.data();
942 template<
typename MT
944 inline typename SymmetricMatrix<MT,SO,true,true>::ConstPointer
945 SymmetricMatrix<MT,SO,true,true>::data(
size_t i )
const
947 return matrix_.data(i);
965 template<
typename MT
991 template<
typename MT
996 return matrix_.begin(i);
1014 template<
typename MT
1019 return matrix_.cbegin(i);
1037 template<
typename MT
1063 template<
typename MT
1068 return matrix_.end(i);
1086 template<
typename MT
1091 return matrix_.cend(i);
1115 template<
typename MT
1117 inline SymmetricMatrix<MT,SO,true,true>&
1118 SymmetricMatrix<MT,SO,true,true>::operator=(
const SymmetricMatrix& rhs )
1120 matrix_ = rhs.matrix_;
1141 template<
typename MT
1143 template<
typename MT2 >
1144 inline typename DisableIf< IsComputation<MT2>, SymmetricMatrix<MT,SO,true,true>& >::Type
1145 SymmetricMatrix<MT,SO,true,true>::operator=(
const Matrix<MT2,SO>& rhs )
1147 if( !IsSymmetric<MT2>::value && !
isSymmetric( ~rhs ) )
1148 throw std::invalid_argument(
"Invalid assignment to symmetric matrix" );
1171 template<
typename MT
1173 template<
typename MT2 >
1174 inline typename EnableIf< IsComputation<MT2>, SymmetricMatrix<MT,SO,true,true>& >::Type
1175 SymmetricMatrix<MT,SO,true,true>::operator=(
const Matrix<MT2,SO>& rhs )
1177 if( !IsSquare<MT2>::value && !
isSquare( ~rhs ) )
1178 throw std::invalid_argument(
"Invalid assignment to symmetric matrix" );
1180 if( IsSymmetric<MT2>::value ) {
1187 throw std::invalid_argument(
"Invalid assignment to symmetric matrix" );
1189 move( matrix_, tmp );
1211 template<
typename MT
1213 template<
typename MT2 >
1214 inline SymmetricMatrix<MT,SO,true,true>&
1215 SymmetricMatrix<MT,SO,true,true>::operator=(
const Matrix<MT2,!SO>& rhs )
1217 return this->operator=(
trans( ~rhs ) );
1236 template<
typename MT
1238 template<
typename MT2 >
1239 inline typename DisableIf< IsComputation<MT2>, SymmetricMatrix<MT,SO,true,true>& >::Type
1240 SymmetricMatrix<MT,SO,true,true>::operator+=(
const Matrix<MT2,SO>& rhs )
1242 if( !IsSymmetric<MT2>::value && !
isSymmetric( ~rhs ) )
1243 throw std::invalid_argument(
"Invalid assignment to symmetric matrix" );
1266 template<
typename MT
1268 template<
typename MT2 >
1269 inline typename EnableIf< IsComputation<MT2>, SymmetricMatrix<MT,SO,true,true>& >::Type
1270 SymmetricMatrix<MT,SO,true,true>::operator+=(
const Matrix<MT2,SO>& rhs )
1272 if( !IsSquare<MT2>::value && !
isSquare( ~rhs ) )
1273 throw std::invalid_argument(
"Invalid assignment to symmetric matrix" );
1275 if( IsSymmetric<MT2>::value ) {
1282 throw std::invalid_argument(
"Invalid assignment to symmetric matrix" );
1307 template<
typename MT
1309 template<
typename MT2 >
1310 inline SymmetricMatrix<MT,SO,true,true>&
1311 SymmetricMatrix<MT,SO,true,true>::operator+=(
const Matrix<MT2,!SO>& rhs )
1313 return this->operator+=(
trans( ~rhs ) );
1332 template<
typename MT
1334 template<
typename MT2 >
1335 inline typename DisableIf< IsComputation<MT2>, SymmetricMatrix<MT,SO,true,true>& >::Type
1336 SymmetricMatrix<MT,SO,true,true>::operator-=(
const Matrix<MT2,SO>& rhs )
1338 if( !IsSymmetric<MT2>::value && !
isSymmetric( ~rhs ) )
1339 throw std::invalid_argument(
"Invalid assignment to symmetric matrix" );
1362 template<
typename MT
1364 template<
typename MT2 >
1365 inline typename EnableIf< IsComputation<MT2>, SymmetricMatrix<MT,SO,true,true>& >::Type
1366 SymmetricMatrix<MT,SO,true,true>::operator-=(
const Matrix<MT2,SO>& rhs )
1368 if( !IsSquare<MT2>::value && !
isSquare( ~rhs ) )
1369 throw std::invalid_argument(
"Invalid assignment to symmetric matrix" );
1371 if( IsSymmetric<MT2>::value ) {
1378 throw std::invalid_argument(
"Invalid assignment to symmetric matrix" );
1403 template<
typename MT
1405 template<
typename MT2 >
1406 inline SymmetricMatrix<MT,SO,true,true>&
1407 SymmetricMatrix<MT,SO,true,true>::operator-=(
const Matrix<MT2,!SO>& rhs )
1409 return this->operator-=(
trans( ~rhs ) );
1427 template<
typename MT
1429 template<
typename MT2
1431 inline SymmetricMatrix<MT,SO,true,true>&
1432 SymmetricMatrix<MT,SO,true,true>::operator*=(
const Matrix<MT2,SO2>& rhs )
1434 if( matrix_.rows() != (~rhs).
columns() )
1435 throw std::invalid_argument(
"Invalid assignment to symmetric matrix" );
1437 MT tmp( matrix_ * ~rhs );
1440 throw std::invalid_argument(
"Invalid assignment to symmetric matrix" );
1442 move( matrix_, tmp );
1458 template<
typename MT
1460 template<
typename Other >
1461 inline typename EnableIf< IsNumeric<Other>, SymmetricMatrix<MT,SO,true,true> >::Type&
1462 SymmetricMatrix<MT,SO,true,true>::operator*=( Other rhs )
1478 template<
typename MT
1480 template<
typename Other >
1481 inline typename EnableIf< IsNumeric<Other>, SymmetricMatrix<MT,SO,true,true> >::Type&
1482 SymmetricMatrix<MT,SO,true,true>::operator/=( Other rhs )
1507 template<
typename MT
1511 return matrix_.rows();
1523 template<
typename MT
1527 return matrix_.columns();
1545 template<
typename MT
1549 return matrix_.spacing();
1561 template<
typename MT
1565 return matrix_.capacity();
1582 template<
typename MT
1586 return matrix_.capacity(i);
1598 template<
typename MT
1602 return matrix_.nonZeros();
1620 template<
typename MT
1624 return matrix_.nonZeros(i);
1636 template<
typename MT
1682 template<
typename MT
1686 row ( matrix_, i ).reset();
1687 column( matrix_, i ).reset();
1705 template<
typename MT
1752 template<
typename MT
1762 const size_t oldsize( matrix_.rows() );
1764 matrix_.resize( n, n,
true );
1767 const size_t increment( n - oldsize );
1768 submatrix( matrix_, 0UL, oldsize, oldsize, increment ).reset();
1769 submatrix( matrix_, oldsize, 0UL, increment, n ).reset();
1789 template<
typename MT
1791 inline void SymmetricMatrix<MT,SO,true,true>::extend(
size_t n,
bool preserve )
1812 template<
typename MT
1814 inline void SymmetricMatrix<MT,SO,true,true>::reserve(
size_t elements )
1816 matrix_.reserve( elements );
1828 template<
typename MT
1830 inline SymmetricMatrix<MT,SO,true,true>& SymmetricMatrix<MT,SO,true,true>::transpose()
1845 template<
typename MT
1847 template<
typename Other >
1848 inline SymmetricMatrix<MT,SO,true,true>&
1849 SymmetricMatrix<MT,SO,true,true>::scale(
const Other& scalar )
1851 matrix_.scale( scalar );
1866 template<
typename MT
1872 swap( matrix_, m.matrix_ );
1897 template<
typename MT
1899 template<
typename Other >
1900 inline bool SymmetricMatrix<MT,SO,true,true>::canAlias(
const Other* alias )
const
1902 return matrix_.canAlias( alias );
1919 template<
typename MT
1921 template<
typename Other >
1922 inline bool SymmetricMatrix<MT,SO,true,true>::isAliased(
const Other* alias )
const
1924 return matrix_.isAliased( alias );
1940 template<
typename MT
1942 inline bool SymmetricMatrix<MT,SO,true,true>::isAligned()
const
1944 return matrix_.isAligned();
1961 template<
typename MT
1963 inline bool SymmetricMatrix<MT,SO,true,true>::canSMPAssign()
const
1965 return matrix_.canSMPAssign();
1987 template<
typename MT
1992 return matrix_.load( i, j );
2014 template<
typename MT
2019 return matrix_.loadu( i, j );
2042 template<
typename MT
2046 matrix_.store( i, j, value );
2050 for(
size_t k=i; k<kend; ++k )
2051 matrix_(j,k) = matrix_(k,j);
2055 for(
size_t k=j; k<kend; ++k )
2056 matrix_(k,i) = matrix_(i,k);
2080 template<
typename MT
2084 matrix_.storeu( i, j, value );
2088 for(
size_t k=i; k<kend; ++k )
2089 matrix_(j,k) = matrix_(k,j);
2093 for(
size_t k=j; k<kend; ++k )
2094 matrix_(k,i) = matrix_(i,k);
2118 template<
typename MT
2122 matrix_.stream( i, j, value );
2126 for(
size_t k=i; k<kend; ++k )
2127 matrix_(j,k) = matrix_(k,j);
2131 for(
size_t k=j; k<kend; ++k )
2132 matrix_(k,i) = matrix_(i,k);
Header file for all restructuring submatrix functions.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_CONST(T)
Constraint on the data type.In case the given data type is a const-qualified type, a compilation error is created.
Definition: Const.h:116
Constraint on the data type.
Header file for mathematical functions.
#define BLAZE_USER_ASSERT(expr, msg)
Run time assertion macro for user checks.In case of an invalid run time expression, the program execution is terminated. The BLAZE_USER_ASSERT macro can be disabled by setting the BLAZE_USER_ASSERT flag to zero or by defining NDEBUG during the compilation.
Definition: Assert.h:117
Header file for the UNUSED_PARAMETER function template.
const DMatDMatMultExpr< T1, T2 > operator*(const DenseMatrix< T1, false > &lhs, const DenseMatrix< T2, false > &rhs)
Multiplication operator for the multiplication of two row-major dense matrices ( ).
Definition: DMatDMatMultExpr.h:8247
Header file for basic type definitions.
BLAZE_ALWAYS_INLINE bool isSquare(const Matrix< MT, SO > &matrix)
Checks if the given matrix is a square matrix.
Definition: Matrix.h:902
BLAZE_ALWAYS_INLINE MT::ConstIterator cbegin(const Matrix< MT, SO > &matrix, size_t i)
Returns an iterator to the first element of row/column i.
Definition: Matrix.h:237
void move(CompressedMatrix< Type, SO > &dst, CompressedMatrix< Type, SO > &src)
Moving the contents of one compressed matrix to another.
Definition: CompressedMatrix.h:4825
BLAZE_ALWAYS_INLINE size_t size(const Vector< VT, TF > &vector)
Returns the current size/dimension of the vector.
Definition: Vector.h:264
BLAZE_ALWAYS_INLINE EnableIf< And< IsIntegral< T >, HasSize< T, 2UL > > >::Type stream(T *address, const sse_int16_t &value)
Aligned, non-temporal store of a vector of 2-byte integral values.
Definition: Stream.h:76
BLAZE_ALWAYS_INLINE MT::ConstIterator cend(const Matrix< MT, SO > &matrix, size_t i)
Returns an iterator just past the last element of row/column i.
Definition: Matrix.h:300
bool operator<=(const NegativeAccuracy< A > &, const T &rhs)
Less-or-equal-than comparison between a NegativeAccuracy object and a floating point value...
Definition: Accuracy.h:404
BLAZE_ALWAYS_INLINE MT::Iterator end(Matrix< MT, SO > &matrix, size_t i)
Returns an iterator just past the last element of row/column i.
Definition: Matrix.h:258
#define BLAZE_CONSTRAINT_MUST_BE_MATRIX_WITH_STORAGE_ORDER(T, SO)
Constraint on the data type.In case the given data type T is not a dense or sparse matrix type and in...
Definition: StorageOrder.h:242
#define BLAZE_CONSTRAINT_MUST_BE_DENSE_MATRIX_TYPE(T)
Constraint on the data type.In case the given data type T is not a dense, N-dimensional matrix type...
Definition: DenseMatrix.h:79
Constraint on the data type.
bool isSymmetric(const DenseMatrix< MT, SO > &dm)
Checks if the given dense matrix is symmetric.
Definition: DenseMatrix.h:692
Constraint on the data type.
void reset(const DiagonalProxy< MT > &proxy)
Resetting the represented element to the default initial values.
Definition: DiagonalProxy.h:821
const This & CompositeType
Data type for composite expression templates.
Definition: CompressedMatrix.h:2507
BLAZE_ALWAYS_INLINE size_t capacity(const Matrix< MT, SO > &matrix)
Returns the maximum capacity of the matrix.
Definition: Matrix.h:348
BLAZE_ALWAYS_INLINE size_t rows(const Matrix< MT, SO > &matrix)
Returns the current number of rows of the matrix.
Definition: Matrix.h:316
void clear(CompressedMatrix< Type, SO > &m)
Clearing the given compressed matrix.
Definition: CompressedMatrix.h:4762
DisableIf< Or< IsComputation< MT >, IsTransExpr< MT > >, typename ColumnExprTrait< MT >::Type >::Type column(Matrix< MT, SO > &matrix, size_t index)
Creating a view on a specific column of the given matrix.
Definition: Column.h:103
void UNUSED_PARAMETER(const T1 &)
Suppression of unused parameter warnings.
Definition: Unused.h:81
bool operator>(const NegativeAccuracy< A > &lhs, const T &rhs)
Greater-than comparison between a NegativeAccuracy object and a floating point value.
Definition: Accuracy.h:366
CompressedMatrix< Type, true > This
Type of this CompressedMatrix instance.
Definition: CompressedMatrix.h:2501
bool operator>=(const NegativeAccuracy< A > &, const T &rhs)
Greater-or-equal-than comparison between a NegativeAccuracy object and a floating point value...
Definition: Accuracy.h:442
#define BLAZE_CONSTRAINT_MUST_NOT_BE_VOLATILE(T)
Constraint on the data type.In case the given data type is a volatile-qualified type, a compilation error is created.
Definition: Volatile.h:116
BLAZE_ALWAYS_INLINE size_t nonZeros(const Matrix< MT, SO > &matrix)
Returns the total number of non-zero elements in the matrix.
Definition: Matrix.h:386
Constraint on the data type.
Header file for the NumericProxy class.
CompressedMatrix< Type, false > OppositeType
Result type with opposite storage order for expression template evaluations.
Definition: CompressedMatrix.h:2503
Header file for the implementation of the base template of the SymmetricMatrix.
bool isDefault(const DiagonalProxy< MT > &proxy)
Returns whether the represented element is in default state.
Definition: DiagonalProxy.h:861
Constraint on the data type.
Header file for the DenseColumn class template.
Header file for the IsSquare type trait.
Constraint on the data type.
Header file for the DenseSubmatrix class template.
Header file for the DisableIf class template.
Header file for the IsSymmetric type trait.
Header file for the clear shim.
Namespace of the Blaze C++ math library.
Definition: Blaze.h:57
#define BLAZE_ALWAYS_INLINE
Platform dependent setup of an enforced inline keyword.
Definition: Inline.h:85
BLAZE_ALWAYS_INLINE EnableIf< And< IsIntegral< T >, HasSize< T, 2UL > >, sse_int16_t >::Type loadu(const T *address)
Loads a vector of 2-byte integral values.
Definition: Loadu.h:76
Header file for the If class template.
void swap(CompressedMatrix< Type, SO > &a, CompressedMatrix< Type, SO > &b)
Swapping the contents of two compressed matrices.
Definition: CompressedMatrix.h:4807
const Element * ConstIterator
Iterator over constant elements.
Definition: CompressedMatrix.h:2511
#define BLAZE_CONSTRAINT_MUST_NOT_BE_POINTER_TYPE(T)
Constraint on the data type.In case the given data type T is not a pointer type, a compilation error ...
Definition: Pointer.h:116
BLAZE_ALWAYS_INLINE EnableIf< And< IsIntegral< T >, HasSize< T, 2UL > > >::Type store(T *address, const sse_int16_t &value)
Aligned store of a vector of 2-byte integral values.
Definition: Store.h:80
const MT::ElementType min(const DenseMatrix< MT, SO > &dm)
Returns the smallest element of the dense matrix.
Definition: DenseMatrix.h:1602
Header file for the DenseMatrix base class.
Constraint on the data type.
const DenseIterator< Type > operator+(const DenseIterator< Type > &it, ptrdiff_t inc)
Addition between a DenseIterator and an integral value.
Definition: DenseIterator.h:556
CompressedMatrix< Type, false > TransposeType
Transpose type for expression template evaluations.
Definition: CompressedMatrix.h:2504
Constraints on the storage order of matrix types.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_UPPER_MATRIX_TYPE(T)
Constraint on the data type.In case the given data type T is a upper triangular matrix type...
Definition: Upper.h:118
BLAZE_ALWAYS_INLINE MT::Iterator begin(Matrix< MT, SO > &matrix, size_t i)
Returns an iterator to the first element of row/column i.
Definition: Matrix.h:195
BLAZE_ALWAYS_INLINE void resize(Matrix< MT, SO > &matrix, size_t rows, size_t columns, bool preserve=true)
Changing the size of the matrix.
Definition: Matrix.h:535
Type ElementType
Type of the sparse matrix elements.
Definition: CompressedMatrix.h:2505
Header file for all forward declarations for expression class templates.
const Type & ConstReference
Reference to a constant matrix value.
Definition: CompressedMatrix.h:2509
Header file for the EnableIf class template.
Header file for utility functions for dense matrices.
void clear(const DiagonalProxy< MT > &proxy)
Clearing the represented element.
Definition: DiagonalProxy.h:841
Header file for all restructuring column functions.
BLAZE_ALWAYS_INLINE EnableIf< And< IsIntegral< T >, HasSize< T, 2UL > >, sse_int16_t >::Type load(const T *address)
Loads a vector of 2-byte integral values.
Definition: Load.h:79
Header file for the IsNumeric type trait.
const bool spacing
Adding an additional spacing line between two log messages.This setting gives the opportunity to add ...
Definition: Logging.h:70
DisableIf< Or< IsComputation< MT >, IsTransExpr< MT > >, typename RowExprTrait< MT >::Type >::Type row(Matrix< MT, SO > &matrix, size_t index)
Creating a view on a specific row of the given matrix.
Definition: Row.h:103
#define BLAZE_CONSTRAINT_MUST_NOT_BE_SYMMETRIC_MATRIX_TYPE(T)
Constraint on the data type.In case the given data type T is a symmetric matrix type, a compilation error is created.
Definition: Symmetric.h:116
const Type & ReturnType
Return type for expression template evaluations.
Definition: CompressedMatrix.h:2506
Header file for run time assertion macros.
Header file for the DenseRow class template.
Constraint on the data type.
Constraint on the data type.
const DenseIterator< Type > operator-(const DenseIterator< Type > &it, ptrdiff_t inc)
Subtraction between a DenseIterator and an integral value.
Definition: DenseIterator.h:585
#define BLAZE_CONSTRAINT_MUST_BE_NUMERIC_TYPE(T)
Constraint on the data type.In case the given data type T is not a numeric (integral or floating poin...
Definition: Numeric.h:79
BLAZE_ALWAYS_INLINE EnableIf< And< IsIntegral< T >, HasSize< T, 2UL > > >::Type storeu(T *address, const sse_int16_t &value)
Unaligned store of a vector of 2-byte integral values.
Definition: Storeu.h:77
#define BLAZE_CONSTRAINT_MUST_NOT_BE_LOWER_MATRIX_TYPE(T)
Constraint on the data type.In case the given data type T is a lower triangular matrix type...
Definition: Lower.h:118
#define BLAZE_CONSTRAINT_MUST_NOT_BE_REFERENCE_TYPE(T)
Constraint on the data type.In case the given data type T is not a reference type, a compilation error is created.
Definition: Reference.h:116
Element * Iterator
Iterator over non-constant elements.
Definition: CompressedMatrix.h:2510
Constraint on the data type.
Constraint on the data type.
void swap(DiagonalMatrix< MT, SO, DF > &a, DiagonalMatrix< MT, SO, DF > &b)
Swapping the contents of two matrices.
Definition: DiagonalMatrix.h:200
Header file for all intrinsic functionality.
Header file for the move shim.
SubmatrixExprTrait< MT, unaligned >::Type submatrix(Matrix< MT, SO > &matrix, size_t row, size_t column, size_t m, size_t n)
Creating a view on a specific submatrix of the given matrix.
Definition: Submatrix.h:143
bool operator<(const NegativeAccuracy< A > &lhs, const T &rhs)
Less-than comparison between a NegativeAccuracy object and a floating point value.
Definition: Accuracy.h:328
#define BLAZE_CONSTRAINT_MUST_BE_RESIZABLE(T)
Constraint on the data type.In case the given data type T is not resizable, i.e. does not have a 'res...
Definition: Resizable.h:79
const DMatTransExpr< MT,!SO > trans(const DenseMatrix< MT, SO > &dm)
Calculation of the transpose of the given dense matrix.
Definition: DMatTransExpr.h:937
Header file for the IsComputation type trait class.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_EXPRESSION_TYPE(T)
Constraint on the data type.In case the given data type T is an expression (i.e. a type derived from ...
Definition: Expression.h:118
bool operator==(const NegativeAccuracy< A > &lhs, const T &rhs)
Equality comparison between a NegativeAccuracy object and a floating point value. ...
Definition: Accuracy.h:249
This ResultType
Result type for expression template evaluations.
Definition: CompressedMatrix.h:2502
BLAZE_ALWAYS_INLINE size_t columns(const Matrix< MT, SO > &matrix)
Returns the current number of columns of the matrix.
Definition: Matrix.h:332
bool operator!=(const NegativeAccuracy< A > &lhs, const T &rhs)
Inequality comparison between a NegativeAccuracy object and a floating point value.
Definition: Accuracy.h:289
MatrixAccessProxy< This > Reference
Reference to a non-constant matrix value.
Definition: CompressedMatrix.h:2508
#define BLAZE_STATIC_ASSERT(expr)
Compile time assertion macro.In case of an invalid compile time expression, a compilation error is cr...
Definition: StaticAssert.h:143
Header file for the IsResizable type trait.
System settings for the inline keywords.
#define BLAZE_INTERNAL_ASSERT(expr, msg)
Run time assertion macro for internal checks.In case of an invalid run time expression, the program execution is terminated. The BLAZE_INTERNAL_ASSERT macro can be disabled by setting the BLAZE_USER_ASSERTION flag to zero or by defining NDEBUG during the compilation.
Definition: Assert.h:101
Header file for all restructuring row functions.