35 #ifndef _BLAZE_MATH_ADAPTORS_DIAGONALMATRIX_SPARSE_H_
36 #define _BLAZE_MATH_ADAPTORS_DIAGONALMATRIX_SPARSE_H_
93 class DiagonalMatrix<MT,SO,false>
94 :
public SparseMatrix< DiagonalMatrix<MT,SO,false>, SO >
105 typedef DiagonalMatrix<MT,SO,false>
This;
121 template<
typename ET >
124 typedef DiagonalMatrix< typename MT::template Rebind<ET>::Other > Other;
130 enum { smpAssignable = 0 };
136 explicit inline DiagonalMatrix();
137 explicit inline DiagonalMatrix(
size_t n );
138 explicit inline DiagonalMatrix(
size_t n,
size_t nonzeros );
139 explicit inline DiagonalMatrix(
size_t n,
const std::vector<size_t>& nonzeros );
141 inline DiagonalMatrix(
const DiagonalMatrix& m );
142 template<
typename MT2,
bool SO2 >
inline DiagonalMatrix(
const Matrix<MT2,SO2>& m );
153 inline Reference operator()(
size_t i,
size_t j );
154 inline ConstReference operator()(
size_t i,
size_t j )
const;
155 inline Iterator
begin (
size_t i );
156 inline ConstIterator
begin (
size_t i )
const;
157 inline ConstIterator
cbegin(
size_t i )
const;
158 inline Iterator
end (
size_t i );
159 inline ConstIterator
end (
size_t i )
const;
160 inline ConstIterator
cend (
size_t i )
const;
167 inline DiagonalMatrix& operator=(
const DiagonalMatrix& rhs );
169 template<
typename MT2,
bool SO2 >
170 inline typename DisableIf< IsComputation<MT2>, DiagonalMatrix& >::Type
171 operator=(
const Matrix<MT2,SO2>& rhs );
173 template<
typename MT2,
bool SO2 >
174 inline typename EnableIf< IsComputation<MT2>, DiagonalMatrix& >::Type
175 operator=(
const Matrix<MT2,SO2>& rhs );
177 template<
typename MT2,
bool SO2 >
178 inline typename DisableIf< IsComputation<MT2>, DiagonalMatrix& >::Type
179 operator+=(
const Matrix<MT2,SO2>& rhs );
181 template<
typename MT2,
bool SO2 >
182 inline typename EnableIf< IsComputation<MT2>, DiagonalMatrix& >::Type
183 operator+=(
const Matrix<MT2,SO2>& rhs );
185 template<
typename MT2,
bool SO2 >
186 inline typename DisableIf< IsComputation<MT2>, DiagonalMatrix& >::Type
187 operator-=(
const Matrix<MT2,SO2>& rhs );
189 template<
typename MT2,
bool SO2 >
190 inline typename EnableIf< IsComputation<MT2>, DiagonalMatrix& >::Type
191 operator-=(
const Matrix<MT2,SO2>& rhs );
193 template<
typename MT2,
bool SO2 >
194 inline DiagonalMatrix& operator*=(
const Matrix<MT2,SO2>& rhs );
196 template<
typename Other >
197 inline typename EnableIf< IsNumeric<Other>, DiagonalMatrix >::Type&
198 operator*=( Other rhs );
200 template<
typename Other >
201 inline typename EnableIf< IsNumeric<Other>, DiagonalMatrix >::Type&
202 operator/=( Other rhs );
209 inline size_t rows()
const;
212 inline size_t capacity(
size_t i )
const;
214 inline size_t nonZeros(
size_t i )
const;
216 inline void reset(
size_t i );
218 inline Iterator
set(
size_t i,
size_t j,
const ElementType& value );
219 inline Iterator insert(
size_t i,
size_t j,
const ElementType& value );
220 inline void erase(
size_t i,
size_t j );
221 inline Iterator erase(
size_t i, Iterator pos );
222 inline Iterator erase(
size_t i, Iterator first, Iterator last );
223 inline void resize (
size_t n,
bool preserve=
true );
224 inline void reserve(
size_t nonzeros );
225 inline void reserve(
size_t i,
size_t nonzeros );
227 inline void trim(
size_t i );
228 template<
typename Other >
inline DiagonalMatrix& scale(
const Other& scalar );
229 template<
typename Other >
inline DiagonalMatrix& scaleDiagonal( Other scale );
230 inline void swap( DiagonalMatrix& m ) ;
237 inline Iterator find (
size_t i,
size_t j );
238 inline ConstIterator find (
size_t i,
size_t j )
const;
239 inline Iterator lowerBound(
size_t i,
size_t j );
240 inline ConstIterator lowerBound(
size_t i,
size_t j )
const;
241 inline Iterator upperBound(
size_t i,
size_t j );
242 inline ConstIterator upperBound(
size_t i,
size_t j )
const;
249 inline void append (
size_t i,
size_t j,
const ElementType& value,
bool check=
false );
250 inline void finalize(
size_t i );
257 template<
typename Other >
inline bool canAlias (
const Other* alias )
const;
258 template<
typename Other >
inline bool isAliased(
const Other* alias )
const;
260 inline bool canSMPAssign()
const;
268 inline void resetNonDiagonal();
280 template<
typename MT2,
bool SO2,
bool DF2 >
281 friend bool isDefault(
const DiagonalMatrix<MT2,SO2,DF2>& m );
283 template<
typename MT2,
bool SO2,
bool DF2 >
284 friend MT2& derestrict( DiagonalMatrix<MT2,SO2,DF2>& m );
318 template<
typename MT
320 inline DiagonalMatrix<MT,SO,false>::DiagonalMatrix()
337 template<
typename MT
339 inline DiagonalMatrix<MT,SO,false>::DiagonalMatrix(
size_t n )
359 template<
typename MT
361 inline DiagonalMatrix<MT,SO,false>::DiagonalMatrix(
size_t n,
size_t nonzeros )
362 : matrix_( n, n, nonzeros )
383 template<
typename MT
385 inline DiagonalMatrix<MT,SO,false>::DiagonalMatrix(
size_t n,
const std::vector<size_t>& nonzeros )
386 : matrix_( n, n, nonzeros )
402 template<
typename MT
404 inline DiagonalMatrix<MT,SO,false>::DiagonalMatrix(
const DiagonalMatrix& m )
405 : matrix_( m.matrix_ )
423 template<
typename MT
425 template<
typename MT2
427 inline DiagonalMatrix<MT,SO,false>::DiagonalMatrix(
const Matrix<MT2,SO2>& m )
430 if( !IsDiagonal<MT2>::value && !
isDiagonal( matrix_ ) )
431 throw std::invalid_argument(
"Invalid setup of diagonal matrix" );
433 if( !IsDiagonal<MT2>::value )
462 template<
typename MT
465 DiagonalMatrix<MT,SO,false>::operator()(
size_t i,
size_t j )
488 template<
typename MT
491 DiagonalMatrix<MT,SO,false>::operator()(
size_t i,
size_t j )
const
514 template<
typename MT
519 return matrix_.begin(i);
537 template<
typename MT
542 return matrix_.begin(i);
560 template<
typename MT
565 return matrix_.cbegin(i);
583 template<
typename MT
588 return matrix_.end(i);
606 template<
typename MT
611 return matrix_.end(i);
629 template<
typename MT
634 return matrix_.cend(i);
658 template<
typename MT
660 inline DiagonalMatrix<MT,SO,false>&
661 DiagonalMatrix<MT,SO,false>::operator=(
const DiagonalMatrix& rhs )
663 matrix_ = rhs.matrix_;
684 template<
typename MT
686 template<
typename MT2
688 inline typename DisableIf< IsComputation<MT2>, DiagonalMatrix<MT,SO,false>& >::Type
689 DiagonalMatrix<MT,SO,false>::operator=(
const Matrix<MT2,SO2>& rhs )
691 if( !IsDiagonal<MT2>::value && !
isDiagonal( ~rhs ) )
692 throw std::invalid_argument(
"Invalid assignment to diagonal matrix" );
696 if( !IsDiagonal<MT2>::value )
718 template<
typename MT
720 template<
typename MT2
722 inline typename EnableIf< IsComputation<MT2>, DiagonalMatrix<MT,SO,false>& >::Type
723 DiagonalMatrix<MT,SO,false>::operator=(
const Matrix<MT2,SO2>& rhs )
725 if( !IsSquare<MT2>::value && !
isSquare( ~rhs ) )
726 throw std::invalid_argument(
"Invalid assignment to diagonal matrix" );
728 if( IsDiagonal<MT2>::value ) {
735 throw std::invalid_argument(
"Invalid assignment to diagonal matrix" );
737 move( matrix_, tmp );
740 if( !IsDiagonal<MT2>::value )
762 template<
typename MT
764 template<
typename MT2
766 inline typename DisableIf< IsComputation<MT2>, DiagonalMatrix<MT,SO,false>& >::Type
767 DiagonalMatrix<MT,SO,false>::operator+=(
const Matrix<MT2,SO2>& rhs )
769 if( !IsDiagonal<MT2>::value && !
isDiagonal( ~rhs ) )
770 throw std::invalid_argument(
"Invalid assignment to diagonal matrix" );
774 if( !IsDiagonal<MT2>::value )
796 template<
typename MT
798 template<
typename MT2
800 inline typename EnableIf< IsComputation<MT2>, DiagonalMatrix<MT,SO,false>& >::Type
801 DiagonalMatrix<MT,SO,false>::operator+=(
const Matrix<MT2,SO2>& rhs )
803 if( !IsSquare<MT2>::value && !
isSquare( ~rhs ) )
804 throw std::invalid_argument(
"Invalid assignment to diagonal matrix" );
806 if( IsDiagonal<MT2>::value ) {
813 throw std::invalid_argument(
"Invalid assignment to diagonal matrix" );
818 if( !IsDiagonal<MT2>::value )
840 template<
typename MT
842 template<
typename MT2
844 inline typename DisableIf< IsComputation<MT2>, DiagonalMatrix<MT,SO,false>& >::Type
845 DiagonalMatrix<MT,SO,false>::operator-=(
const Matrix<MT2,SO2>& rhs )
847 if( !IsDiagonal<MT2>::value && !
isDiagonal( ~rhs ) )
848 throw std::invalid_argument(
"Invalid assignment to diagonal matrix" );
852 if( !IsDiagonal<MT2>::value )
874 template<
typename MT
876 template<
typename MT2
878 inline typename EnableIf< IsComputation<MT2>, DiagonalMatrix<MT,SO,false>& >::Type
879 DiagonalMatrix<MT,SO,false>::operator-=(
const Matrix<MT2,SO2>& rhs )
881 if( !IsSquare<MT2>::value && !
isSquare( ~rhs ) )
882 throw std::invalid_argument(
"Invalid assignment to diagonal matrix" );
884 if( IsDiagonal<MT2>::value ) {
891 throw std::invalid_argument(
"Invalid assignment to diagonal matrix" );
896 if( !IsDiagonal<MT2>::value )
917 template<
typename MT
919 template<
typename MT2
921 inline DiagonalMatrix<MT,SO,false>&
922 DiagonalMatrix<MT,SO,false>::operator*=(
const Matrix<MT2,SO2>& rhs )
924 if( matrix_.rows() != (~rhs).
columns() )
925 throw std::invalid_argument(
"Invalid assignment to diagonal matrix" );
927 MT tmp( matrix_ * ~rhs );
930 throw std::invalid_argument(
"Invalid assignment to diagonal matrix" );
932 move( matrix_, tmp );
934 if( !IsDiagonal<MT2>::value )
951 template<
typename MT
953 template<
typename Other >
954 inline typename EnableIf< IsNumeric<Other>, DiagonalMatrix<MT,SO,false> >::Type&
955 DiagonalMatrix<MT,SO,false>::operator*=( Other rhs )
971 template<
typename MT
973 template<
typename Other >
974 inline typename EnableIf< IsNumeric<Other>, DiagonalMatrix<MT,SO,false> >::Type&
975 DiagonalMatrix<MT,SO,false>::operator/=( Other rhs )
1000 template<
typename MT
1004 return matrix_.rows();
1016 template<
typename MT
1020 return matrix_.columns();
1032 template<
typename MT
1036 return matrix_.capacity();
1054 template<
typename MT
1058 return matrix_.capacity(i);
1070 template<
typename MT
1074 return matrix_.nonZeros();
1092 template<
typename MT
1096 return matrix_.nonZeros(i);
1108 template<
typename MT
1131 template<
typename MT
1149 template<
typename MT
1177 template<
typename MT
1183 throw std::invalid_argument(
"Invalid access to upper matrix element" );
1185 return matrix_.set( i, j, value );
1208 template<
typename MT
1211 DiagonalMatrix<MT,SO,false>::insert(
size_t i,
size_t j,
const ElementType& value )
1214 throw std::invalid_argument(
"Invalid access to upper matrix element" );
1216 return matrix_.insert( i, j, value );
1232 template<
typename MT
1234 inline void DiagonalMatrix<MT,SO,false>::erase(
size_t i,
size_t j )
1236 matrix_.erase( i, j );
1254 template<
typename MT
1257 DiagonalMatrix<MT,SO,false>::erase(
size_t i,
Iterator pos )
1259 return matrix_.erase( i, pos );
1279 template<
typename MT
1282 DiagonalMatrix<MT,SO,false>::erase(
size_t i,
Iterator first,
Iterator last )
1284 return matrix_.erase( i, first, last );
1305 template<
typename MT
1313 matrix_.resize( n, n, preserve );
1330 template<
typename MT
1332 inline void DiagonalMatrix<MT,SO,false>::reserve(
size_t nonzeros )
1334 matrix_.reserve( nonzeros );
1354 template<
typename MT
1356 inline void DiagonalMatrix<MT,SO,false>::reserve(
size_t i,
size_t nonzeros )
1358 matrix_.reserve( i, nonzeros );
1375 template<
typename MT
1377 inline void DiagonalMatrix<MT,SO,false>::trim()
1397 template<
typename MT
1399 inline void DiagonalMatrix<MT,SO,false>::trim(
size_t i )
1414 template<
typename MT
1416 template<
typename Other >
1417 inline DiagonalMatrix<MT,SO,false>&
1418 DiagonalMatrix<MT,SO,false>::scale(
const Other& scalar )
1420 matrix_.scale( scalar );
1434 template<
typename MT
1436 template<
typename Other >
1437 inline DiagonalMatrix<MT,SO,false>&
1438 DiagonalMatrix<MT,SO,false>::scaleDiagonal( Other scalar )
1440 matrix_.scaleDiagonal( scalar );
1455 template<
typename MT
1461 swap( matrix_, m.matrix_ );
1473 template<
typename MT
1475 inline void DiagonalMatrix<MT,SO,false>::resetNonDiagonal()
1477 for(
size_t i=0UL; i<
rows(); ++i ) {
1478 matrix_.erase( i, matrix_.begin( i ), matrix_.lowerBound( i, i ) );
1479 matrix_.erase( i, matrix_.upperBound( i, i ), matrix_.end( i ) );
1510 template<
typename MT
1513 DiagonalMatrix<MT,SO,false>::find(
size_t i,
size_t j )
1515 return matrix_.find( i, j );
1537 template<
typename MT
1540 DiagonalMatrix<MT,SO,false>::find(
size_t i,
size_t j )
const
1542 return matrix_.find( i, j );
1564 template<
typename MT
1567 DiagonalMatrix<MT,SO,false>::lowerBound(
size_t i,
size_t j )
1569 return matrix_.lowerBound( i, j );
1591 template<
typename MT
1594 DiagonalMatrix<MT,SO,false>::lowerBound(
size_t i,
size_t j )
const
1596 return matrix_.lowerBound( i, j );
1618 template<
typename MT
1621 DiagonalMatrix<MT,SO,false>::upperBound(
size_t i,
size_t j )
1623 return matrix_.upperBound( i, j );
1645 template<
typename MT
1648 DiagonalMatrix<MT,SO,false>::upperBound(
size_t i,
size_t j )
const
1650 return matrix_.upperBound( i, j );
1714 template<
typename MT
1716 inline void DiagonalMatrix<MT,SO,false>::append(
size_t i,
size_t j,
const ElementType& value,
bool check )
1719 throw std::invalid_argument(
"Invalid access to upper matrix element" );
1721 matrix_.append( i, j, value, check );
1741 template<
typename MT
1743 inline void DiagonalMatrix<MT,SO,false>::finalize(
size_t i )
1745 matrix_.finalize( i );
1770 template<
typename MT
1772 template<
typename Other >
1773 inline bool DiagonalMatrix<MT,SO,false>::canAlias(
const Other* alias )
const
1775 return matrix_.canAlias( alias );
1792 template<
typename MT
1794 template<
typename Other >
1795 inline bool DiagonalMatrix<MT,SO,false>::isAliased(
const Other* alias )
const
1797 return matrix_.isAliased( alias );
1814 template<
typename MT
1816 inline bool DiagonalMatrix<MT,SO,false>::canSMPAssign()
const
1818 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_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:1431
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 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
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
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: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
CompressedMatrix< Type, true > This
Type of this CompressedMatrix instance.
Definition: CompressedMatrix.h:2501
#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.
CompressedMatrix< Type, false > OppositeType
Result type with opposite storage order for expression template evaluations.
Definition: CompressedMatrix.h:2503
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 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: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
Constraint on the data type.
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
const Type & ConstReference
Reference to a constant matrix value.
Definition: CompressedMatrix.h:2509
Header file for the EnableIf class template.
void clear(const DiagonalProxy< MT > &proxy)
Clearing the represented element.
Definition: DiagonalProxy.h:841
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:2506
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:2510
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:200
BLAZE_ALWAYS_INLINE EnableIf< And< IsIntegral< T >, HasSize< T, 2UL > >, sse_int16_t >::Type set(T value)
Sets all values in the vector to the given 2-byte integral value.
Definition: Set.h:73
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: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
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.
#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