35 #ifndef _BLAZE_MATH_ADAPTORS_UPPERMATRIX_SPARSE_H_
36 #define _BLAZE_MATH_ADAPTORS_UPPERMATRIX_SPARSE_H_
97 class UpperMatrix<MT,SO,false>
98 :
public SparseMatrix< UpperMatrix<MT,SO,false>, SO >
109 typedef UpperMatrix<MT,SO,false>
This;
125 template<
typename ET >
128 typedef UpperMatrix< typename MT::template Rebind<ET>::Other > Other;
134 enum { smpAssignable = 0 };
140 explicit inline UpperMatrix();
141 explicit inline UpperMatrix(
size_t n );
142 explicit inline UpperMatrix(
size_t n,
size_t nonzeros );
143 explicit inline UpperMatrix(
size_t n,
const std::vector<size_t>& nonzeros );
145 inline UpperMatrix(
const UpperMatrix& m );
146 template<
typename MT2,
bool SO2 >
inline UpperMatrix(
const Matrix<MT2,SO2>& m );
157 inline Reference operator()(
size_t i,
size_t j );
158 inline ConstReference operator()(
size_t i,
size_t j )
const;
159 inline Reference at(
size_t i,
size_t j );
160 inline ConstReference at(
size_t i,
size_t j )
const;
161 inline Iterator
begin (
size_t i );
162 inline ConstIterator
begin (
size_t i )
const;
163 inline ConstIterator
cbegin(
size_t i )
const;
164 inline Iterator
end (
size_t i );
165 inline ConstIterator
end (
size_t i )
const;
166 inline ConstIterator
cend (
size_t i )
const;
173 inline UpperMatrix& operator=(
const UpperMatrix& rhs );
175 template<
typename MT2,
bool SO2 >
176 inline typename DisableIf< IsComputation<MT2>, UpperMatrix& >::Type
177 operator=(
const Matrix<MT2,SO2>& rhs );
179 template<
typename MT2,
bool SO2 >
180 inline typename EnableIf< IsComputation<MT2>, UpperMatrix& >::Type
181 operator=(
const Matrix<MT2,SO2>& rhs );
183 template<
typename MT2,
bool SO2 >
184 inline typename DisableIf< IsComputation<MT2>, UpperMatrix& >::Type
185 operator+=(
const Matrix<MT2,SO2>& rhs );
187 template<
typename MT2,
bool SO2 >
188 inline typename EnableIf< IsComputation<MT2>, UpperMatrix& >::Type
189 operator+=(
const Matrix<MT2,SO2>& rhs );
191 template<
typename MT2,
bool SO2 >
192 inline typename DisableIf< IsComputation<MT2>, UpperMatrix& >::Type
193 operator-=(
const Matrix<MT2,SO2>& rhs );
195 template<
typename MT2,
bool SO2 >
196 inline typename EnableIf< IsComputation<MT2>, UpperMatrix& >::Type
197 operator-=(
const Matrix<MT2,SO2>& rhs );
199 template<
typename MT2,
bool SO2 >
200 inline UpperMatrix& operator*=(
const Matrix<MT2,SO2>& rhs );
202 template<
typename Other >
203 inline typename EnableIf< IsNumeric<Other>, UpperMatrix >::Type&
204 operator*=( Other rhs );
206 template<
typename Other >
207 inline typename EnableIf< IsNumeric<Other>, UpperMatrix >::Type&
208 operator/=( Other rhs );
215 inline size_t rows()
const;
218 inline size_t capacity(
size_t i )
const;
220 inline size_t nonZeros(
size_t i )
const;
222 inline void reset(
size_t i );
224 inline Iterator
set(
size_t i,
size_t j,
const ElementType& value );
225 inline Iterator insert(
size_t i,
size_t j,
const ElementType& value );
226 inline void erase(
size_t i,
size_t j );
227 inline Iterator erase(
size_t i, Iterator pos );
228 inline Iterator erase(
size_t i, Iterator first, Iterator last );
229 inline void resize (
size_t n,
bool preserve=
true );
230 inline void reserve(
size_t nonzeros );
231 inline void reserve(
size_t i,
size_t nonzeros );
233 inline void trim(
size_t i );
234 template<
typename Other >
inline UpperMatrix& scale(
const Other& scalar );
235 template<
typename Other >
inline UpperMatrix& scaleDiagonal( Other scale );
236 inline void swap( UpperMatrix& m ) ;
238 static inline size_t maxNonZeros();
239 static inline size_t maxNonZeros(
size_t n );
246 inline Iterator find (
size_t i,
size_t j );
247 inline ConstIterator find (
size_t i,
size_t j )
const;
248 inline Iterator lowerBound(
size_t i,
size_t j );
249 inline ConstIterator lowerBound(
size_t i,
size_t j )
const;
250 inline Iterator upperBound(
size_t i,
size_t j );
251 inline ConstIterator upperBound(
size_t i,
size_t j )
const;
258 inline void append (
size_t i,
size_t j,
const ElementType& value,
bool check=
false );
259 inline void finalize(
size_t i );
273 template<
typename Other >
inline bool canAlias (
const Other* alias )
const;
274 template<
typename Other >
inline bool isAliased(
const Other* alias )
const;
276 inline bool canSMPAssign()
const;
284 inline void resetLower();
296 template<
typename MT2,
bool SO2,
bool DF2 >
297 friend bool isDefault(
const UpperMatrix<MT2,SO2,DF2>& m );
299 template<
typename MT2,
bool SO2,
bool DF2 >
300 friend MT2& derestrict( UpperMatrix<MT2,SO2,DF2>& m );
335 template<
typename MT
337 inline UpperMatrix<MT,SO,false>::UpperMatrix()
354 template<
typename MT
356 inline UpperMatrix<MT,SO,false>::UpperMatrix(
size_t n )
376 template<
typename MT
378 inline UpperMatrix<MT,SO,false>::UpperMatrix(
size_t n,
size_t nonzeros )
379 : matrix_( n, n, nonzeros )
400 template<
typename MT
402 inline UpperMatrix<MT,SO,false>::UpperMatrix(
size_t n,
const std::vector<size_t>& nonzeros )
403 : matrix_( n, n, nonzeros )
419 template<
typename MT
421 inline UpperMatrix<MT,SO,false>::UpperMatrix(
const UpperMatrix& m )
422 : matrix_( m.matrix_ )
441 template<
typename MT
443 template<
typename MT2
445 inline UpperMatrix<MT,SO,false>::UpperMatrix(
const Matrix<MT2,SO2>& m )
448 if( !IsUpper<MT2>::value && !
isUpper( matrix_ ) ) {
452 if( !IsUpper<MT2>::value )
486 template<
typename MT
489 UpperMatrix<MT,SO,false>::operator()(
size_t i,
size_t j )
516 template<
typename MT
519 UpperMatrix<MT,SO,false>::operator()(
size_t i,
size_t j )
const
547 template<
typename MT
550 UpperMatrix<MT,SO,false>::at(
size_t i,
size_t j )
581 template<
typename MT
584 UpperMatrix<MT,SO,false>::at(
size_t i,
size_t j )
const
610 template<
typename MT
615 return matrix_.begin(i);
633 template<
typename MT
638 return matrix_.begin(i);
656 template<
typename MT
661 return matrix_.cbegin(i);
679 template<
typename MT
684 return matrix_.end(i);
702 template<
typename MT
707 return matrix_.end(i);
725 template<
typename MT
730 return matrix_.cend(i);
754 template<
typename MT
756 inline UpperMatrix<MT,SO,false>&
757 UpperMatrix<MT,SO,false>::operator=(
const UpperMatrix& rhs )
759 matrix_ = rhs.matrix_;
783 template<
typename MT
785 template<
typename MT2
787 inline typename DisableIf< IsComputation<MT2>, UpperMatrix<MT,SO,false>& >::Type
788 UpperMatrix<MT,SO,false>::operator=(
const Matrix<MT2,SO2>& rhs )
790 if( !IsUpper<MT2>::value && !
isUpper( ~rhs ) ) {
796 if( !IsUpper<MT2>::value )
821 template<
typename MT
823 template<
typename MT2
825 inline typename EnableIf< IsComputation<MT2>, UpperMatrix<MT,SO,false>& >::Type
826 UpperMatrix<MT,SO,false>::operator=(
const Matrix<MT2,SO2>& rhs )
828 if( !IsSquare<MT2>::value && !
isSquare( ~rhs ) ) {
832 if( IsUpper<MT2>::value ) {
842 move( matrix_, tmp );
845 if( !IsUpper<MT2>::value )
870 template<
typename MT
872 template<
typename MT2
874 inline typename DisableIf< IsComputation<MT2>, UpperMatrix<MT,SO,false>& >::Type
875 UpperMatrix<MT,SO,false>::operator+=(
const Matrix<MT2,SO2>& rhs )
877 if( !IsUpper<MT2>::value && !
isUpper( ~rhs ) ) {
883 if( !IsUpper<MT2>::value )
908 template<
typename MT
910 template<
typename MT2
912 inline typename EnableIf< IsComputation<MT2>, UpperMatrix<MT,SO,false>& >::Type
913 UpperMatrix<MT,SO,false>::operator+=(
const Matrix<MT2,SO2>& rhs )
915 if( IsSquare<MT2>::value && !
isSquare( ~rhs ) ) {
919 if( IsUpper<MT2>::value ) {
932 if( !IsUpper<MT2>::value )
957 template<
typename MT
959 template<
typename MT2
961 inline typename DisableIf< IsComputation<MT2>, UpperMatrix<MT,SO,false>& >::Type
962 UpperMatrix<MT,SO,false>::operator-=(
const Matrix<MT2,SO2>& rhs )
964 if( !IsUpper<MT2>::value && !
isUpper( ~rhs ) ) {
970 if( !IsUpper<MT2>::value )
995 template<
typename MT
997 template<
typename MT2
999 inline typename EnableIf< IsComputation<MT2>, UpperMatrix<MT,SO,false>& >::Type
1000 UpperMatrix<MT,SO,false>::operator-=(
const Matrix<MT2,SO2>& rhs )
1002 if( !IsSquare<MT2>::value && !
isSquare( ~rhs ) ) {
1006 if( IsUpper<MT2>::value ) {
1019 if( !IsUpper<MT2>::value )
1043 template<
typename MT
1045 template<
typename MT2
1047 inline UpperMatrix<MT,SO,false>&
1048 UpperMatrix<MT,SO,false>::operator*=(
const Matrix<MT2,SO2>& rhs )
1050 if( matrix_.rows() != (~rhs).
columns() ) {
1054 MT tmp( matrix_ * ~rhs );
1060 move( matrix_, tmp );
1062 if( !IsUpper<MT2>::value )
1082 template<
typename MT
1084 template<
typename Other >
1085 inline typename EnableIf< IsNumeric<Other>, UpperMatrix<MT,SO,false> >::Type&
1086 UpperMatrix<MT,SO,false>::operator*=( Other rhs )
1102 template<
typename MT
1104 template<
typename Other >
1105 inline typename EnableIf< IsNumeric<Other>, UpperMatrix<MT,SO,false> >::Type&
1106 UpperMatrix<MT,SO,false>::operator/=( Other rhs )
1131 template<
typename MT
1135 return matrix_.rows();
1147 template<
typename MT
1151 return matrix_.columns();
1163 template<
typename MT
1167 return matrix_.capacity();
1185 template<
typename MT
1189 return matrix_.capacity(i);
1201 template<
typename MT
1205 return matrix_.nonZeros();
1223 template<
typename MT
1227 return matrix_.nonZeros(i);
1239 template<
typename MT
1262 template<
typename MT
1280 template<
typename MT
1308 template<
typename MT
1317 return matrix_.set( i, j, value );
1340 template<
typename MT
1343 UpperMatrix<MT,SO,false>::insert(
size_t i,
size_t j,
const ElementType& value )
1349 return matrix_.insert( i, j, value );
1365 template<
typename MT
1367 inline void UpperMatrix<MT,SO,false>::erase(
size_t i,
size_t j )
1369 matrix_.erase( i, j );
1387 template<
typename MT
1390 UpperMatrix<MT,SO,false>::erase(
size_t i,
Iterator pos )
1392 return matrix_.erase( i, pos );
1411 template<
typename MT
1416 return matrix_.erase( i, first, last );
1437 template<
typename MT
1445 matrix_.resize( n, n, preserve );
1462 template<
typename MT
1464 inline void UpperMatrix<MT,SO,false>::reserve(
size_t nonzeros )
1466 matrix_.reserve( nonzeros );
1486 template<
typename MT
1488 inline void UpperMatrix<MT,SO,false>::reserve(
size_t i,
size_t nonzeros )
1490 matrix_.reserve( i, nonzeros );
1507 template<
typename MT
1509 inline void UpperMatrix<MT,SO,false>::trim()
1529 template<
typename MT
1531 inline void UpperMatrix<MT,SO,false>::trim(
size_t i )
1546 template<
typename MT
1548 template<
typename Other >
1549 inline UpperMatrix<MT,SO,false>&
1550 UpperMatrix<MT,SO,false>::scale(
const Other& scalar )
1552 matrix_.scale( scalar );
1566 template<
typename MT
1568 template<
typename Other >
1569 inline UpperMatrix<MT,SO,false>&
1570 UpperMatrix<MT,SO,false>::scaleDiagonal( Other scalar )
1572 matrix_.scaleDiagonal( scalar );
1587 template<
typename MT
1593 swap( matrix_, m.matrix_ );
1610 template<
typename MT
1612 inline size_t UpperMatrix<MT,SO,false>::maxNonZeros()
1616 return maxNonZeros( Rows<MT>::value );
1632 template<
typename MT
1634 inline size_t UpperMatrix<MT,SO,false>::maxNonZeros(
size_t n )
1636 return ( ( n + 1UL ) * n ) / 2UL;
1648 template<
typename MT
1650 inline void UpperMatrix<MT,SO,false>::resetLower()
1653 for(
size_t j=0UL; j<
columns(); ++j )
1654 matrix_.erase( j, matrix_.upperBound( j, j ), matrix_.end( j ) );
1657 for(
size_t i=1UL; i<
rows(); ++i )
1658 matrix_.erase( i, matrix_.begin( i ), matrix_.lowerBound( i, i ) );
1689 template<
typename MT
1692 UpperMatrix<MT,SO,false>::find(
size_t i,
size_t j )
1694 return matrix_.find( i, j );
1716 template<
typename MT
1719 UpperMatrix<MT,SO,false>::find(
size_t i,
size_t j )
const
1721 return matrix_.find( i, j );
1743 template<
typename MT
1746 UpperMatrix<MT,SO,false>::lowerBound(
size_t i,
size_t j )
1748 return matrix_.lowerBound( i, j );
1770 template<
typename MT
1773 UpperMatrix<MT,SO,false>::lowerBound(
size_t i,
size_t j )
const
1775 return matrix_.lowerBound( i, j );
1797 template<
typename MT
1800 UpperMatrix<MT,SO,false>::upperBound(
size_t i,
size_t j )
1802 return matrix_.upperBound( i, j );
1824 template<
typename MT
1827 UpperMatrix<MT,SO,false>::upperBound(
size_t i,
size_t j )
const
1829 return matrix_.upperBound( i, j );
1893 template<
typename MT
1895 inline void UpperMatrix<MT,SO,false>::append(
size_t i,
size_t j,
const ElementType& value,
bool check )
1901 matrix_.append( i, j, value, check );
1921 template<
typename MT
1923 inline void UpperMatrix<MT,SO,false>::finalize(
size_t i )
1925 matrix_.finalize( i );
1949 template<
typename MT
1980 template<
typename MT
1982 template<
typename Other >
1983 inline bool UpperMatrix<MT,SO,false>::canAlias(
const Other* alias )
const
1985 return matrix_.canAlias( alias );
2002 template<
typename MT
2004 template<
typename Other >
2005 inline bool UpperMatrix<MT,SO,false>::isAliased(
const Other* alias )
const
2007 return matrix_.isAliased( alias );
2024 template<
typename MT
2026 inline bool UpperMatrix<MT,SO,false>::canSMPAssign()
const
2028 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
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
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 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: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
bool isUpper(const DenseMatrix< MT, SO > &dm)
Checks if the given dense matrix is an upper triangular matrix.
Definition: DenseMatrix.h:1277
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
Header file for the UpperProxy class.
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.
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: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.
#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: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 the IsUpper type trait.
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