35 #ifndef _BLAZE_MATH_ADAPTORS_DIAGONALMATRIX_SPARSE_H_
36 #define _BLAZE_MATH_ADAPTORS_DIAGONALMATRIX_SPARSE_H_
96 class DiagonalMatrix<MT,SO,false>
97 :
public SparseMatrix< DiagonalMatrix<MT,SO,false>, SO >
108 typedef DiagonalMatrix<MT,SO,false>
This;
124 template<
typename ET >
127 typedef DiagonalMatrix< typename MT::template Rebind<ET>::Other > Other;
133 enum { smpAssignable = 0 };
139 explicit inline DiagonalMatrix();
140 explicit inline DiagonalMatrix(
size_t n );
141 explicit inline DiagonalMatrix(
size_t n,
size_t nonzeros );
142 explicit inline DiagonalMatrix(
size_t n,
const std::vector<size_t>& nonzeros );
144 inline DiagonalMatrix(
const DiagonalMatrix& m );
145 template<
typename MT2,
bool SO2 >
inline DiagonalMatrix(
const Matrix<MT2,SO2>& m );
156 inline Reference operator()(
size_t i,
size_t j );
157 inline ConstReference operator()(
size_t i,
size_t j )
const;
158 inline Reference at(
size_t i,
size_t j );
159 inline ConstReference at(
size_t i,
size_t j )
const;
160 inline Iterator
begin (
size_t i );
161 inline ConstIterator
begin (
size_t i )
const;
162 inline ConstIterator
cbegin(
size_t i )
const;
163 inline Iterator
end (
size_t i );
164 inline ConstIterator
end (
size_t i )
const;
165 inline ConstIterator
cend (
size_t i )
const;
172 inline DiagonalMatrix& operator=(
const DiagonalMatrix& rhs );
174 template<
typename MT2,
bool SO2 >
175 inline typename DisableIf< IsComputation<MT2>, DiagonalMatrix& >::Type
176 operator=(
const Matrix<MT2,SO2>& rhs );
178 template<
typename MT2,
bool SO2 >
179 inline typename EnableIf< IsComputation<MT2>, DiagonalMatrix& >::Type
180 operator=(
const Matrix<MT2,SO2>& rhs );
182 template<
typename MT2,
bool SO2 >
183 inline typename DisableIf< IsComputation<MT2>, DiagonalMatrix& >::Type
184 operator+=(
const Matrix<MT2,SO2>& rhs );
186 template<
typename MT2,
bool SO2 >
187 inline typename EnableIf< IsComputation<MT2>, DiagonalMatrix& >::Type
188 operator+=(
const Matrix<MT2,SO2>& rhs );
190 template<
typename MT2,
bool SO2 >
191 inline typename DisableIf< IsComputation<MT2>, DiagonalMatrix& >::Type
192 operator-=(
const Matrix<MT2,SO2>& rhs );
194 template<
typename MT2,
bool SO2 >
195 inline typename EnableIf< IsComputation<MT2>, DiagonalMatrix& >::Type
196 operator-=(
const Matrix<MT2,SO2>& rhs );
198 template<
typename MT2,
bool SO2 >
199 inline DiagonalMatrix& operator*=(
const Matrix<MT2,SO2>& rhs );
201 template<
typename Other >
202 inline typename EnableIf< IsNumeric<Other>, DiagonalMatrix >::Type&
203 operator*=( Other rhs );
205 template<
typename Other >
206 inline typename EnableIf< IsNumeric<Other>, DiagonalMatrix >::Type&
207 operator/=( Other rhs );
214 inline size_t rows()
const;
217 inline size_t capacity(
size_t i )
const;
219 inline size_t nonZeros(
size_t i )
const;
221 inline void reset(
size_t i );
223 inline Iterator
set(
size_t i,
size_t j,
const ElementType& value );
224 inline Iterator insert(
size_t i,
size_t j,
const ElementType& value );
225 inline void erase(
size_t i,
size_t j );
226 inline Iterator erase(
size_t i, Iterator pos );
227 inline Iterator erase(
size_t i, Iterator first, Iterator last );
228 inline void resize (
size_t n,
bool preserve=
true );
229 inline void reserve(
size_t nonzeros );
230 inline void reserve(
size_t i,
size_t nonzeros );
232 inline void trim(
size_t i );
233 template<
typename Other >
inline DiagonalMatrix& scale(
const Other& scalar );
234 template<
typename Other >
inline DiagonalMatrix& scaleDiagonal( Other scale );
235 inline void swap( DiagonalMatrix& m ) ;
242 inline Iterator find (
size_t i,
size_t j );
243 inline ConstIterator find (
size_t i,
size_t j )
const;
244 inline Iterator lowerBound(
size_t i,
size_t j );
245 inline ConstIterator lowerBound(
size_t i,
size_t j )
const;
246 inline Iterator upperBound(
size_t i,
size_t j );
247 inline ConstIterator upperBound(
size_t i,
size_t j )
const;
254 inline void append (
size_t i,
size_t j,
const ElementType& value,
bool check=
false );
255 inline void finalize(
size_t i );
269 template<
typename Other >
inline bool canAlias (
const Other* alias )
const;
270 template<
typename Other >
inline bool isAliased(
const Other* alias )
const;
272 inline bool canSMPAssign()
const;
280 inline void resetNonDiagonal();
292 template<
typename MT2,
bool SO2,
bool DF2 >
293 friend bool isDefault(
const DiagonalMatrix<MT2,SO2,DF2>& m );
295 template<
typename MT2,
bool SO2,
bool DF2 >
296 friend MT2& derestrict( DiagonalMatrix<MT2,SO2,DF2>& m );
331 template<
typename MT
333 inline DiagonalMatrix<MT,SO,false>::DiagonalMatrix()
350 template<
typename MT
352 inline DiagonalMatrix<MT,SO,false>::DiagonalMatrix(
size_t n )
372 template<
typename MT
374 inline DiagonalMatrix<MT,SO,false>::DiagonalMatrix(
size_t n,
size_t nonzeros )
375 : matrix_( n, n, nonzeros )
396 template<
typename MT
398 inline DiagonalMatrix<MT,SO,false>::DiagonalMatrix(
size_t n,
const std::vector<size_t>& nonzeros )
399 : matrix_( n, n, nonzeros )
415 template<
typename MT
417 inline DiagonalMatrix<MT,SO,false>::DiagonalMatrix(
const DiagonalMatrix& m )
418 : matrix_( m.matrix_ )
437 template<
typename MT
439 template<
typename MT2
441 inline DiagonalMatrix<MT,SO,false>::DiagonalMatrix(
const Matrix<MT2,SO2>& m )
444 if( !IsDiagonal<MT2>::value && !
isDiagonal( matrix_ ) ) {
448 if( !IsDiagonal<MT2>::value )
482 template<
typename MT
485 DiagonalMatrix<MT,SO,false>::operator()(
size_t i,
size_t j )
512 template<
typename MT
515 DiagonalMatrix<MT,SO,false>::operator()(
size_t i,
size_t j )
const
543 template<
typename MT
546 DiagonalMatrix<MT,SO,false>::at(
size_t i,
size_t j )
577 template<
typename MT
580 DiagonalMatrix<MT,SO,false>::at(
size_t i,
size_t j )
const
606 template<
typename MT
611 return matrix_.begin(i);
629 template<
typename MT
634 return matrix_.begin(i);
652 template<
typename MT
657 return matrix_.cbegin(i);
675 template<
typename MT
680 return matrix_.end(i);
698 template<
typename MT
703 return matrix_.end(i);
721 template<
typename MT
726 return matrix_.cend(i);
750 template<
typename MT
752 inline DiagonalMatrix<MT,SO,false>&
753 DiagonalMatrix<MT,SO,false>::operator=(
const DiagonalMatrix& rhs )
755 matrix_ = rhs.matrix_;
779 template<
typename MT
781 template<
typename MT2
783 inline typename DisableIf< IsComputation<MT2>, DiagonalMatrix<MT,SO,false>& >::Type
784 DiagonalMatrix<MT,SO,false>::operator=(
const Matrix<MT2,SO2>& rhs )
786 if( !IsDiagonal<MT2>::value && !
isDiagonal( ~rhs ) ) {
792 if( !IsDiagonal<MT2>::value )
817 template<
typename MT
819 template<
typename MT2
821 inline typename EnableIf< IsComputation<MT2>, DiagonalMatrix<MT,SO,false>& >::Type
822 DiagonalMatrix<MT,SO,false>::operator=(
const Matrix<MT2,SO2>& rhs )
824 if( !IsSquare<MT2>::value && !
isSquare( ~rhs ) ) {
828 if( IsDiagonal<MT2>::value ) {
838 move( matrix_, tmp );
841 if( !IsDiagonal<MT2>::value )
866 template<
typename MT
868 template<
typename MT2
870 inline typename DisableIf< IsComputation<MT2>, DiagonalMatrix<MT,SO,false>& >::Type
871 DiagonalMatrix<MT,SO,false>::operator+=(
const Matrix<MT2,SO2>& rhs )
873 if( !IsDiagonal<MT2>::value && !
isDiagonal( ~rhs ) ) {
879 if( !IsDiagonal<MT2>::value )
904 template<
typename MT
906 template<
typename MT2
908 inline typename EnableIf< IsComputation<MT2>, DiagonalMatrix<MT,SO,false>& >::Type
909 DiagonalMatrix<MT,SO,false>::operator+=(
const Matrix<MT2,SO2>& rhs )
911 if( !IsSquare<MT2>::value && !
isSquare( ~rhs ) ) {
915 if( IsDiagonal<MT2>::value ) {
928 if( !IsDiagonal<MT2>::value )
953 template<
typename MT
955 template<
typename MT2
957 inline typename DisableIf< IsComputation<MT2>, DiagonalMatrix<MT,SO,false>& >::Type
958 DiagonalMatrix<MT,SO,false>::operator-=(
const Matrix<MT2,SO2>& rhs )
960 if( !IsDiagonal<MT2>::value && !
isDiagonal( ~rhs ) ) {
966 if( !IsDiagonal<MT2>::value )
991 template<
typename MT
993 template<
typename MT2
995 inline typename EnableIf< IsComputation<MT2>, DiagonalMatrix<MT,SO,false>& >::Type
996 DiagonalMatrix<MT,SO,false>::operator-=(
const Matrix<MT2,SO2>& rhs )
998 if( !IsSquare<MT2>::value && !
isSquare( ~rhs ) ) {
1002 if( IsDiagonal<MT2>::value ) {
1015 if( !IsDiagonal<MT2>::value )
1039 template<
typename MT
1041 template<
typename MT2
1043 inline DiagonalMatrix<MT,SO,false>&
1044 DiagonalMatrix<MT,SO,false>::operator*=(
const Matrix<MT2,SO2>& rhs )
1046 if( matrix_.rows() != (~rhs).
columns() ) {
1050 MT tmp( matrix_ * ~rhs );
1056 move( matrix_, tmp );
1058 if( !IsDiagonal<MT2>::value )
1078 template<
typename MT
1080 template<
typename Other >
1081 inline typename EnableIf< IsNumeric<Other>, DiagonalMatrix<MT,SO,false> >::Type&
1082 DiagonalMatrix<MT,SO,false>::operator*=( Other rhs )
1098 template<
typename MT
1100 template<
typename Other >
1101 inline typename EnableIf< IsNumeric<Other>, DiagonalMatrix<MT,SO,false> >::Type&
1102 DiagonalMatrix<MT,SO,false>::operator/=( Other rhs )
1127 template<
typename MT
1131 return matrix_.rows();
1143 template<
typename MT
1147 return matrix_.columns();
1159 template<
typename MT
1163 return matrix_.capacity();
1181 template<
typename MT
1185 return matrix_.capacity(i);
1197 template<
typename MT
1201 return matrix_.nonZeros();
1219 template<
typename MT
1223 return matrix_.nonZeros(i);
1235 template<
typename MT
1258 template<
typename MT
1276 template<
typename MT
1304 template<
typename MT
1313 return matrix_.set( i, j, value );
1336 template<
typename MT
1339 DiagonalMatrix<MT,SO,false>::insert(
size_t i,
size_t j,
const ElementType& value )
1345 return matrix_.insert( i, j, value );
1361 template<
typename MT
1363 inline void DiagonalMatrix<MT,SO,false>::erase(
size_t i,
size_t j )
1365 matrix_.erase( i, j );
1383 template<
typename MT
1386 DiagonalMatrix<MT,SO,false>::erase(
size_t i,
Iterator pos )
1388 return matrix_.erase( i, pos );
1408 template<
typename MT
1411 DiagonalMatrix<MT,SO,false>::erase(
size_t i,
Iterator first,
Iterator last )
1413 return matrix_.erase( i, first, last );
1434 template<
typename MT
1442 matrix_.resize( n, n, preserve );
1459 template<
typename MT
1461 inline void DiagonalMatrix<MT,SO,false>::reserve(
size_t nonzeros )
1463 matrix_.reserve( nonzeros );
1483 template<
typename MT
1485 inline void DiagonalMatrix<MT,SO,false>::reserve(
size_t i,
size_t nonzeros )
1487 matrix_.reserve( i, nonzeros );
1504 template<
typename MT
1506 inline void DiagonalMatrix<MT,SO,false>::trim()
1526 template<
typename MT
1528 inline void DiagonalMatrix<MT,SO,false>::trim(
size_t i )
1543 template<
typename MT
1545 template<
typename Other >
1546 inline DiagonalMatrix<MT,SO,false>&
1547 DiagonalMatrix<MT,SO,false>::scale(
const Other& scalar )
1549 matrix_.scale( scalar );
1563 template<
typename MT
1565 template<
typename Other >
1566 inline DiagonalMatrix<MT,SO,false>&
1567 DiagonalMatrix<MT,SO,false>::scaleDiagonal( Other scalar )
1569 matrix_.scaleDiagonal( scalar );
1584 template<
typename MT
1590 swap( matrix_, m.matrix_ );
1602 template<
typename MT
1604 inline void DiagonalMatrix<MT,SO,false>::resetNonDiagonal()
1606 for(
size_t i=0UL; i<
rows(); ++i ) {
1607 matrix_.erase( i, matrix_.begin( i ), matrix_.lowerBound( i, i ) );
1608 matrix_.erase( i, matrix_.upperBound( i, i ), matrix_.end( i ) );
1639 template<
typename MT
1642 DiagonalMatrix<MT,SO,false>::find(
size_t i,
size_t j )
1644 return matrix_.find( i, j );
1666 template<
typename MT
1669 DiagonalMatrix<MT,SO,false>::find(
size_t i,
size_t j )
const
1671 return matrix_.find( i, j );
1693 template<
typename MT
1696 DiagonalMatrix<MT,SO,false>::lowerBound(
size_t i,
size_t j )
1698 return matrix_.lowerBound( i, j );
1720 template<
typename MT
1723 DiagonalMatrix<MT,SO,false>::lowerBound(
size_t i,
size_t j )
const
1725 return matrix_.lowerBound( i, j );
1747 template<
typename MT
1750 DiagonalMatrix<MT,SO,false>::upperBound(
size_t i,
size_t j )
1752 return matrix_.upperBound( i, j );
1774 template<
typename MT
1777 DiagonalMatrix<MT,SO,false>::upperBound(
size_t i,
size_t j )
const
1779 return matrix_.upperBound( i, j );
1843 template<
typename MT
1845 inline void DiagonalMatrix<MT,SO,false>::append(
size_t i,
size_t j,
const ElementType& value,
bool check )
1851 matrix_.append( i, j, value, check );
1871 template<
typename MT
1873 inline void DiagonalMatrix<MT,SO,false>::finalize(
size_t i )
1875 matrix_.finalize( i );
1899 template<
typename MT
1930 template<
typename MT
1932 template<
typename Other >
1933 inline bool DiagonalMatrix<MT,SO,false>::canAlias(
const Other* alias )
const
1935 return matrix_.canAlias( alias );
1952 template<
typename MT
1954 template<
typename Other >
1955 inline bool DiagonalMatrix<MT,SO,false>::isAliased(
const Other* alias )
const
1957 return matrix_.isAliased( alias );
1974 template<
typename MT
1976 inline bool DiagonalMatrix<MT,SO,false>::canSMPAssign()
const
1978 return matrix_.canSMPAssign();
#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
#define BLAZE_THROW_INVALID_ARGUMENT(MESSAGE)
Macro for the emission of a std::invalid_argument exceptionThis macro encapsulates the default way of...
Definition: Exception.h:187
BLAZE_ALWAYS_INLINE EnableIf< And< IsIntegral< T >, HasSize< T, 2UL > >, simd_int16_t >::Type set(T value)
Sets all values in the vector to the given 2-byte integral value.
Definition: Set.h:73
#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
bool isDiagonal(const DenseMatrix< MT, SO > &dm)
Checks if the give dense matrix is diagonal.
Definition: DenseMatrix.h:1511
Header file for the Rows type trait.
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:603
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:229
void move(CompressedMatrix< Type, SO > &dst, CompressedMatrix< Type, SO > &src)
Moving the contents of one compressed matrix to another.
Definition: CompressedMatrix.h:5016
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:292
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:250
#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:81
Header file for the IsDiagonal type trait.
Header file for the implementation of the base template of the DiagonalMatrix.
Constraint on the data type.
Constraint on the data type.
void reset(const DiagonalProxy< MT > &proxy)
Resetting the represented element to the default initial values.
Definition: DiagonalProxy.h:507
const This & CompositeType
Data type for composite expression templates.
Definition: CompressedMatrix.h:2588
BLAZE_ALWAYS_INLINE size_t capacity(const Matrix< MT, SO > &matrix)
Returns the maximum capacity of the matrix.
Definition: Matrix.h:340
BLAZE_ALWAYS_INLINE size_t rows(const Matrix< MT, SO > &matrix)
Returns the current number of rows of the matrix.
Definition: Matrix.h:308
void clear(CompressedMatrix< Type, SO > &m)
Clearing the given compressed matrix.
Definition: CompressedMatrix.h:4926
CompressedMatrix< Type, true > This
Type of this CompressedMatrix instance.
Definition: CompressedMatrix.h:2582
#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:378
Constraint on the data type.
CompressedMatrix< Type, false > OppositeType
Result type with opposite storage order for expression template evaluations.
Definition: CompressedMatrix.h:2584
bool isDefault(const DiagonalProxy< MT > &proxy)
Returns whether the represented element is in default state.
Definition: DiagonalProxy.h:547
Constraint on the data type.
Constraint on the data type.
Header file for the SparseMatrix base class.
Header file for utility functions for sparse matrices.
Header file for the IsSquare type trait.
Constraint on the data type.
Header file for the DisableIf class template.
Header file for the DiagonalProxy class.
Header file for the clear shim.
Namespace of the Blaze C++ math library.
Definition: Blaze.h:57
void swap(CompressedMatrix< Type, SO > &a, CompressedMatrix< Type, SO > &b)
Swapping the contents of two compressed matrices.
Definition: CompressedMatrix.h:4998
bool isIntact(const CompressedMatrix< Type, SO > &m)
Returns whether the invariants of the given compressed matrix are intact.
Definition: CompressedMatrix.h:4980
const Element * ConstIterator
Iterator over constant elements.
Definition: CompressedMatrix.h:2592
#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
#define BLAZE_THROW_OUT_OF_RANGE(MESSAGE)
Macro for the emission of a std::out_of_range exceptionThis macro encapsulates the default way of Bla...
Definition: Exception.h:331
Header file for the Columns type trait.
Constraint on the data type.
CompressedMatrix< Type, false > TransposeType
Transpose type for expression template evaluations.
Definition: CompressedMatrix.h:2585
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:187
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:532
Type ElementType
Type of the sparse matrix elements.
Definition: CompressedMatrix.h:2586
const Type & ConstReference
Reference to a constant matrix value.
Definition: CompressedMatrix.h:2590
Header file for the EnableIf class template.
void clear(const DiagonalProxy< MT > &proxy)
Clearing the represented element.
Definition: DiagonalProxy.h:527
Header file for the IsNumeric type trait.
#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:2587
Header file for run time assertion macros.
Constraint on the data type.
Constraint on the data type.
#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:2591
Header file for the isDefault shim.
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:256
Header file for the move shim.
#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
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
This ResultType
Result type for expression template evaluations.
Definition: CompressedMatrix.h:2583
BLAZE_ALWAYS_INLINE size_t columns(const Matrix< MT, SO > &matrix)
Returns the current number of columns of the matrix.
Definition: Matrix.h:324
bool isIntact(const DiagonalMatrix< MT, SO, DF > &m)
Returns whether the invariants of the given diagonal matrix are intact.
Definition: DiagonalMatrix.h:237
MatrixAccessProxy< This > Reference
Reference to a non-constant matrix value.
Definition: CompressedMatrix.h:2589
#define BLAZE_CONSTRAINT_MUST_NOT_BE_HERMITIAN_MATRIX_TYPE(T)
Constraint on the data type.In case the given data type T is an Hermitian matrix type, a compilation error is created.
Definition: Hermitian.h:116
Header file for exception macros.
#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
#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
#define BLAZE_CONSTRAINT_MUST_BE_SPARSE_MATRIX_TYPE(T)
Constraint on the data type.In case the given data type T is not a sparse, N-dimensional matrix type...
Definition: SparseMatrix.h:79