35 #ifndef _BLAZE_MATH_ADAPTORS_UPPERMATRIX_SPARSE_H_
36 #define _BLAZE_MATH_ADAPTORS_UPPERMATRIX_SPARSE_H_
95 class UpperMatrix<MT,SO,false>
96 :
public SparseMatrix< UpperMatrix<MT,SO,false>, SO >
107 typedef UpperMatrix<MT,SO,false>
This;
123 template<
typename ET >
126 typedef UpperMatrix< typename MT::template Rebind<ET>::Other > Other;
132 enum { smpAssignable = 0 };
138 explicit inline UpperMatrix();
139 explicit inline UpperMatrix(
size_t n );
140 explicit inline UpperMatrix(
size_t n,
size_t nonzeros );
141 explicit inline UpperMatrix(
size_t n,
const std::vector<size_t>& nonzeros );
143 inline UpperMatrix(
const UpperMatrix& m );
144 template<
typename MT2,
bool SO2 >
inline UpperMatrix(
const Matrix<MT2,SO2>& m );
155 inline Reference operator()(
size_t i,
size_t j );
156 inline ConstReference operator()(
size_t i,
size_t j )
const;
157 inline Iterator
begin (
size_t i );
158 inline ConstIterator
begin (
size_t i )
const;
159 inline ConstIterator
cbegin(
size_t i )
const;
160 inline Iterator
end (
size_t i );
161 inline ConstIterator
end (
size_t i )
const;
162 inline ConstIterator
cend (
size_t i )
const;
169 inline UpperMatrix& operator=(
const UpperMatrix& rhs );
171 template<
typename MT2,
bool SO2 >
172 inline typename DisableIf< IsComputation<MT2>, UpperMatrix& >::Type
173 operator=(
const Matrix<MT2,SO2>& rhs );
175 template<
typename MT2,
bool SO2 >
176 inline typename EnableIf< IsComputation<MT2>, UpperMatrix& >::Type
177 operator=(
const Matrix<MT2,SO2>& rhs );
179 template<
typename MT2,
bool SO2 >
180 inline typename DisableIf< IsComputation<MT2>, UpperMatrix& >::Type
181 operator+=(
const Matrix<MT2,SO2>& rhs );
183 template<
typename MT2,
bool SO2 >
184 inline typename EnableIf< IsComputation<MT2>, UpperMatrix& >::Type
185 operator+=(
const Matrix<MT2,SO2>& rhs );
187 template<
typename MT2,
bool SO2 >
188 inline typename DisableIf< IsComputation<MT2>, UpperMatrix& >::Type
189 operator-=(
const Matrix<MT2,SO2>& rhs );
191 template<
typename MT2,
bool SO2 >
192 inline typename EnableIf< IsComputation<MT2>, UpperMatrix& >::Type
193 operator-=(
const Matrix<MT2,SO2>& rhs );
195 template<
typename MT2,
bool SO2 >
196 inline UpperMatrix& operator*=(
const Matrix<MT2,SO2>& rhs );
198 template<
typename Other >
199 inline typename EnableIf< IsNumeric<Other>, UpperMatrix >::Type&
200 operator*=( Other rhs );
202 template<
typename Other >
203 inline typename EnableIf< IsNumeric<Other>, UpperMatrix >::Type&
204 operator/=( Other rhs );
211 inline size_t rows()
const;
214 inline size_t capacity(
size_t i )
const;
216 inline size_t nonZeros(
size_t i )
const;
218 inline void reset(
size_t i );
220 inline Iterator
set(
size_t i,
size_t j,
const ElementType& value );
221 inline Iterator insert(
size_t i,
size_t j,
const ElementType& value );
222 inline void erase(
size_t i,
size_t j );
223 inline Iterator erase(
size_t i, Iterator pos );
224 inline Iterator erase(
size_t i, Iterator first, Iterator last );
225 inline void resize (
size_t n,
bool preserve=
true );
226 inline void reserve(
size_t nonzeros );
227 inline void reserve(
size_t i,
size_t nonzeros );
229 inline void trim(
size_t i );
230 template<
typename Other >
inline UpperMatrix& scale(
const Other& scalar );
231 template<
typename Other >
inline UpperMatrix& scaleDiagonal( Other scale );
232 inline void swap( UpperMatrix& m ) ;
234 static inline size_t maxNonZeros();
235 static inline size_t maxNonZeros(
size_t n );
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 );
262 template<
typename Other >
inline bool canAlias (
const Other* alias )
const;
263 template<
typename Other >
inline bool isAliased(
const Other* alias )
const;
265 inline bool canSMPAssign()
const;
273 inline void resetLower();
285 template<
typename MT2,
bool SO2,
bool DF2 >
286 friend bool isDefault(
const UpperMatrix<MT2,SO2,DF2>& m );
288 template<
typename MT2,
bool SO2,
bool DF2 >
289 friend MT2& derestrict( UpperMatrix<MT2,SO2,DF2>& m );
323 template<
typename MT
325 inline UpperMatrix<MT,SO,false>::UpperMatrix()
342 template<
typename MT
344 inline UpperMatrix<MT,SO,false>::UpperMatrix(
size_t n )
364 template<
typename MT
366 inline UpperMatrix<MT,SO,false>::UpperMatrix(
size_t n,
size_t nonzeros )
367 : matrix_( n, n, nonzeros )
388 template<
typename MT
390 inline UpperMatrix<MT,SO,false>::UpperMatrix(
size_t n,
const std::vector<size_t>& nonzeros )
391 : matrix_( n, n, nonzeros )
407 template<
typename MT
409 inline UpperMatrix<MT,SO,false>::UpperMatrix(
const UpperMatrix& m )
410 : matrix_( m.matrix_ )
428 template<
typename MT
430 template<
typename MT2
432 inline UpperMatrix<MT,SO,false>::UpperMatrix(
const Matrix<MT2,SO2>& m )
435 if( !IsUpper<MT2>::value && !
isUpper( matrix_ ) )
436 throw std::invalid_argument(
"Invalid setup of upper matrix" );
438 if( !IsUpper<MT2>::value )
467 template<
typename MT
470 UpperMatrix<MT,SO,false>::operator()(
size_t i,
size_t j )
493 template<
typename MT
496 UpperMatrix<MT,SO,false>::operator()(
size_t i,
size_t j )
const
519 template<
typename MT
524 return matrix_.begin(i);
542 template<
typename MT
547 return matrix_.begin(i);
565 template<
typename MT
570 return matrix_.cbegin(i);
588 template<
typename MT
593 return matrix_.end(i);
611 template<
typename MT
616 return matrix_.end(i);
634 template<
typename MT
639 return matrix_.cend(i);
663 template<
typename MT
665 inline UpperMatrix<MT,SO,false>&
666 UpperMatrix<MT,SO,false>::operator=(
const UpperMatrix& rhs )
668 matrix_ = rhs.matrix_;
689 template<
typename MT
691 template<
typename MT2
693 inline typename DisableIf< IsComputation<MT2>, UpperMatrix<MT,SO,false>& >::Type
694 UpperMatrix<MT,SO,false>::operator=(
const Matrix<MT2,SO2>& rhs )
696 if( !IsUpper<MT2>::value && !
isUpper( ~rhs ) )
697 throw std::invalid_argument(
"Invalid assignment to upper matrix" );
701 if( !IsUpper<MT2>::value )
723 template<
typename MT
725 template<
typename MT2
727 inline typename EnableIf< IsComputation<MT2>, UpperMatrix<MT,SO,false>& >::Type
728 UpperMatrix<MT,SO,false>::operator=(
const Matrix<MT2,SO2>& rhs )
730 if( !IsSquare<MT2>::value && !
isSquare( ~rhs ) )
731 throw std::invalid_argument(
"Invalid assignment to upper matrix" );
733 if( IsUpper<MT2>::value ) {
740 throw std::invalid_argument(
"Invalid assignment to upper matrix" );
742 move( matrix_, tmp );
745 if( !IsUpper<MT2>::value )
767 template<
typename MT
769 template<
typename MT2
771 inline typename DisableIf< IsComputation<MT2>, UpperMatrix<MT,SO,false>& >::Type
772 UpperMatrix<MT,SO,false>::operator+=(
const Matrix<MT2,SO2>& rhs )
774 if( !IsUpper<MT2>::value && !
isUpper( ~rhs ) )
775 throw std::invalid_argument(
"Invalid assignment to upper matrix" );
779 if( !IsUpper<MT2>::value )
801 template<
typename MT
803 template<
typename MT2
805 inline typename EnableIf< IsComputation<MT2>, UpperMatrix<MT,SO,false>& >::Type
806 UpperMatrix<MT,SO,false>::operator+=(
const Matrix<MT2,SO2>& rhs )
808 if( IsSquare<MT2>::value && !
isSquare( ~rhs ) )
809 throw std::invalid_argument(
"Invalid assignment to upper matrix" );
811 if( IsUpper<MT2>::value ) {
818 throw std::invalid_argument(
"Invalid assignment to upper matrix" );
823 if( !IsUpper<MT2>::value )
845 template<
typename MT
847 template<
typename MT2
849 inline typename DisableIf< IsComputation<MT2>, UpperMatrix<MT,SO,false>& >::Type
850 UpperMatrix<MT,SO,false>::operator-=(
const Matrix<MT2,SO2>& rhs )
852 if( !IsUpper<MT2>::value && !
isUpper( ~rhs ) )
853 throw std::invalid_argument(
"Invalid assignment to upper matrix" );
857 if( !IsUpper<MT2>::value )
879 template<
typename MT
881 template<
typename MT2
883 inline typename EnableIf< IsComputation<MT2>, UpperMatrix<MT,SO,false>& >::Type
884 UpperMatrix<MT,SO,false>::operator-=(
const Matrix<MT2,SO2>& rhs )
886 if( !IsSquare<MT2>::value && !
isSquare( ~rhs ) )
887 throw std::invalid_argument(
"Invalid assignment to upper matrix" );
889 if( IsUpper<MT2>::value ) {
896 throw std::invalid_argument(
"Invalid assignment to upper matrix" );
901 if( !IsUpper<MT2>::value )
922 template<
typename MT
924 template<
typename MT2
926 inline UpperMatrix<MT,SO,false>&
927 UpperMatrix<MT,SO,false>::operator*=(
const Matrix<MT2,SO2>& rhs )
929 if( matrix_.rows() != (~rhs).
columns() )
930 throw std::invalid_argument(
"Invalid assignment to upper matrix" );
932 MT tmp( matrix_ * ~rhs );
935 throw std::invalid_argument(
"Invalid assignment to upper matrix" );
937 move( matrix_, tmp );
939 if( !IsUpper<MT2>::value )
956 template<
typename MT
958 template<
typename Other >
959 inline typename EnableIf< IsNumeric<Other>, UpperMatrix<MT,SO,false> >::Type&
960 UpperMatrix<MT,SO,false>::operator*=( Other rhs )
976 template<
typename MT
978 template<
typename Other >
979 inline typename EnableIf< IsNumeric<Other>, UpperMatrix<MT,SO,false> >::Type&
980 UpperMatrix<MT,SO,false>::operator/=( Other rhs )
1005 template<
typename MT
1009 return matrix_.rows();
1021 template<
typename MT
1025 return matrix_.columns();
1037 template<
typename MT
1041 return matrix_.capacity();
1059 template<
typename MT
1063 return matrix_.capacity(i);
1075 template<
typename MT
1079 return matrix_.nonZeros();
1097 template<
typename MT
1101 return matrix_.nonZeros(i);
1113 template<
typename MT
1136 template<
typename MT
1154 template<
typename MT
1182 template<
typename MT
1188 throw std::invalid_argument(
"Invalid access to lower matrix element" );
1190 return matrix_.set( i, j, value );
1213 template<
typename MT
1216 UpperMatrix<MT,SO,false>::insert(
size_t i,
size_t j,
const ElementType& value )
1219 throw std::invalid_argument(
"Invalid access to lower matrix element" );
1221 return matrix_.insert( i, j, value );
1237 template<
typename MT
1239 inline void UpperMatrix<MT,SO,false>::erase(
size_t i,
size_t j )
1241 matrix_.erase( i, j );
1259 template<
typename MT
1262 UpperMatrix<MT,SO,false>::erase(
size_t i,
Iterator pos )
1264 return matrix_.erase( i, pos );
1283 template<
typename MT
1288 return matrix_.erase( i, first, last );
1309 template<
typename MT
1317 matrix_.resize( n, n, preserve );
1334 template<
typename MT
1336 inline void UpperMatrix<MT,SO,false>::reserve(
size_t nonzeros )
1338 matrix_.reserve( nonzeros );
1358 template<
typename MT
1360 inline void UpperMatrix<MT,SO,false>::reserve(
size_t i,
size_t nonzeros )
1362 matrix_.reserve( i, nonzeros );
1379 template<
typename MT
1381 inline void UpperMatrix<MT,SO,false>::trim()
1401 template<
typename MT
1403 inline void UpperMatrix<MT,SO,false>::trim(
size_t i )
1418 template<
typename MT
1420 template<
typename Other >
1421 inline UpperMatrix<MT,SO,false>&
1422 UpperMatrix<MT,SO,false>::scale(
const Other& scalar )
1424 matrix_.scale( scalar );
1438 template<
typename MT
1440 template<
typename Other >
1441 inline UpperMatrix<MT,SO,false>&
1442 UpperMatrix<MT,SO,false>::scaleDiagonal( Other scalar )
1444 matrix_.scaleDiagonal( scalar );
1459 template<
typename MT
1465 swap( matrix_, m.matrix_ );
1482 template<
typename MT
1484 inline size_t UpperMatrix<MT,SO,false>::maxNonZeros()
1488 return maxNonZeros( Rows<MT>::value );
1504 template<
typename MT
1506 inline size_t UpperMatrix<MT,SO,false>::maxNonZeros(
size_t n )
1508 return ( ( n + 1UL ) * n ) / 2UL;
1520 template<
typename MT
1522 inline void UpperMatrix<MT,SO,false>::resetLower()
1525 for(
size_t j=0UL; j<
columns(); ++j )
1526 matrix_.erase( j, matrix_.upperBound( j, j ), matrix_.end( j ) );
1529 for(
size_t i=1UL; i<
rows(); ++i )
1530 matrix_.erase( i, matrix_.begin( i ), matrix_.lowerBound( i, i ) );
1561 template<
typename MT
1564 UpperMatrix<MT,SO,false>::find(
size_t i,
size_t j )
1566 return matrix_.find( i, j );
1588 template<
typename MT
1591 UpperMatrix<MT,SO,false>::find(
size_t i,
size_t j )
const
1593 return matrix_.find( i, j );
1615 template<
typename MT
1618 UpperMatrix<MT,SO,false>::lowerBound(
size_t i,
size_t j )
1620 return matrix_.lowerBound( i, j );
1642 template<
typename MT
1645 UpperMatrix<MT,SO,false>::lowerBound(
size_t i,
size_t j )
const
1647 return matrix_.lowerBound( i, j );
1669 template<
typename MT
1672 UpperMatrix<MT,SO,false>::upperBound(
size_t i,
size_t j )
1674 return matrix_.upperBound( i, j );
1696 template<
typename MT
1699 UpperMatrix<MT,SO,false>::upperBound(
size_t i,
size_t j )
const
1701 return matrix_.upperBound( i, j );
1765 template<
typename MT
1767 inline void UpperMatrix<MT,SO,false>::append(
size_t i,
size_t j,
const ElementType& value,
bool check )
1770 throw std::invalid_argument(
"Invalid access to lower matrix element" );
1772 matrix_.append( i, j, value, check );
1792 template<
typename MT
1794 inline void UpperMatrix<MT,SO,false>::finalize(
size_t i )
1796 matrix_.finalize( i );
1821 template<
typename MT
1823 template<
typename Other >
1824 inline bool UpperMatrix<MT,SO,false>::canAlias(
const Other* alias )
const
1826 return matrix_.canAlias( alias );
1843 template<
typename MT
1845 template<
typename Other >
1846 inline bool UpperMatrix<MT,SO,false>::isAliased(
const Other* alias )
const
1848 return matrix_.isAliased( alias );
1865 template<
typename MT
1867 inline bool UpperMatrix<MT,SO,false>::canSMPAssign()
const
1869 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
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: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
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 implementation of the base template of the UpperMatrix.
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 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
bool isUpper(const DenseMatrix< MT, SO > &dm)
Checks if the given dense matrix is an upper triangular matrix.
Definition: DenseMatrix.h:1197
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 the UpperProxy class.
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.
Header file for all adaptor forward declarations.
#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.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_RESIZABLE(T)
Constraint on the data type.In case the given data type T is resizable, i.e. has a 'resize' member fu...
Definition: Resizable.h:118
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
Header file for the IsUpper type trait.
#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