35 #ifndef _BLAZE_MATH_ADAPTORS_STRICTLYLOWERMATRIX_SPARSE_H_
36 #define _BLAZE_MATH_ADAPTORS_STRICTLYLOWERMATRIX_SPARSE_H_
101 class StrictlyLowerMatrix<MT,SO,false>
102 :
public SparseMatrix< StrictlyLowerMatrix<MT,SO,false>, SO >
113 typedef StrictlyLowerMatrix<MT,SO,false>
This;
120 typedef StrictlyLowerProxy<MT>
Reference;
129 template<
typename ET >
132 typedef StrictlyLowerMatrix< typename MT::template Rebind<ET>::Other > Other;
138 enum { smpAssignable = 0 };
144 explicit inline StrictlyLowerMatrix();
145 explicit inline StrictlyLowerMatrix(
size_t n );
146 explicit inline StrictlyLowerMatrix(
size_t n,
size_t nonzeros );
147 explicit inline StrictlyLowerMatrix(
size_t n,
const std::vector<size_t>& nonzeros );
149 inline StrictlyLowerMatrix(
const StrictlyLowerMatrix& m );
150 template<
typename MT2,
bool SO2 >
inline StrictlyLowerMatrix(
const Matrix<MT2,SO2>& m );
161 inline Reference operator()(
size_t i,
size_t j );
162 inline ConstReference operator()(
size_t i,
size_t j )
const;
163 inline Reference at(
size_t i,
size_t j );
164 inline ConstReference at(
size_t i,
size_t j )
const;
165 inline Iterator
begin (
size_t i );
166 inline ConstIterator
begin (
size_t i )
const;
167 inline ConstIterator
cbegin(
size_t i )
const;
168 inline Iterator
end (
size_t i );
169 inline ConstIterator
end (
size_t i )
const;
170 inline ConstIterator
cend (
size_t i )
const;
177 inline StrictlyLowerMatrix& operator=(
const StrictlyLowerMatrix& rhs );
179 template<
typename MT2,
bool SO2 >
180 inline typename DisableIf< IsComputation<MT2>, StrictlyLowerMatrix& >::Type
181 operator=(
const Matrix<MT2,SO2>& rhs );
183 template<
typename MT2,
bool SO2 >
184 inline typename EnableIf< IsComputation<MT2>, StrictlyLowerMatrix& >::Type
185 operator=(
const Matrix<MT2,SO2>& rhs );
187 template<
typename MT2,
bool SO2 >
188 inline typename DisableIf< IsComputation<MT2>, StrictlyLowerMatrix& >::Type
189 operator+=(
const Matrix<MT2,SO2>& rhs );
191 template<
typename MT2,
bool SO2 >
192 inline typename EnableIf< IsComputation<MT2>, StrictlyLowerMatrix& >::Type
193 operator+=(
const Matrix<MT2,SO2>& rhs );
195 template<
typename MT2,
bool SO2 >
196 inline typename DisableIf< IsComputation<MT2>, StrictlyLowerMatrix& >::Type
197 operator-=(
const Matrix<MT2,SO2>& rhs );
199 template<
typename MT2,
bool SO2 >
200 inline typename EnableIf< IsComputation<MT2>, StrictlyLowerMatrix& >::Type
201 operator-=(
const Matrix<MT2,SO2>& rhs );
203 template<
typename MT2,
bool SO2 >
204 inline StrictlyLowerMatrix& operator*=(
const Matrix<MT2,SO2>& rhs );
206 template<
typename Other >
207 inline typename EnableIf< IsNumeric<Other>, StrictlyLowerMatrix >::Type&
208 operator*=( Other rhs );
210 template<
typename Other >
211 inline typename EnableIf< IsNumeric<Other>, StrictlyLowerMatrix >::Type&
212 operator/=( Other rhs );
219 inline size_t rows()
const;
222 inline size_t capacity(
size_t i )
const;
224 inline size_t nonZeros(
size_t i )
const;
226 inline void reset(
size_t i );
228 inline Iterator
set(
size_t i,
size_t j,
const ElementType& value );
229 inline Iterator insert(
size_t i,
size_t j,
const ElementType& value );
230 inline void erase(
size_t i,
size_t j );
231 inline Iterator erase(
size_t i, Iterator pos );
232 inline Iterator erase(
size_t i, Iterator first, Iterator last );
233 inline void resize (
size_t n,
bool preserve=
true );
234 inline void reserve(
size_t nonzeros );
235 inline void reserve(
size_t i,
size_t nonzeros );
237 inline void trim(
size_t i );
239 template<
typename Other >
inline StrictlyLowerMatrix& scale(
const Other& scalar );
240 template<
typename Other >
inline StrictlyLowerMatrix& scaleDiagonal( Other scale );
242 inline void swap( StrictlyLowerMatrix& m ) ;
244 static inline size_t maxNonZeros();
245 static inline size_t maxNonZeros(
size_t n );
252 inline Iterator find (
size_t i,
size_t j );
253 inline ConstIterator find (
size_t i,
size_t j )
const;
254 inline Iterator lowerBound(
size_t i,
size_t j );
255 inline ConstIterator lowerBound(
size_t i,
size_t j )
const;
256 inline Iterator upperBound(
size_t i,
size_t j );
257 inline ConstIterator upperBound(
size_t i,
size_t j )
const;
264 inline void append (
size_t i,
size_t j,
const ElementType& value,
bool check=
false );
265 inline void finalize(
size_t i );
279 template<
typename Other >
inline bool canAlias (
const Other* alias )
const;
280 template<
typename Other >
inline bool isAliased(
const Other* alias )
const;
282 inline bool canSMPAssign()
const;
290 inline void resetUpper();
302 template<
typename MT2,
bool SO2,
bool DF2 >
303 friend MT2& derestrict( StrictlyLowerMatrix<MT2,SO2,DF2>& m );
338 template<
typename MT
340 inline StrictlyLowerMatrix<MT,SO,false>::StrictlyLowerMatrix()
357 template<
typename MT
359 inline StrictlyLowerMatrix<MT,SO,false>::StrictlyLowerMatrix(
size_t n )
380 template<
typename MT
382 inline StrictlyLowerMatrix<MT,SO,false>::StrictlyLowerMatrix(
size_t n,
size_t nonzeros )
383 : matrix_( n, n,
max( nonzeros, n ) )
407 template<
typename MT
409 inline StrictlyLowerMatrix<MT,SO,false>::StrictlyLowerMatrix(
size_t n,
const std::vector<size_t>& nonzeros )
410 : matrix_( n, n, nonzeros )
426 template<
typename MT
428 inline StrictlyLowerMatrix<MT,SO,false>::StrictlyLowerMatrix(
const StrictlyLowerMatrix& m )
429 : matrix_( m.matrix_ )
449 template<
typename MT
451 template<
typename MT2
453 inline StrictlyLowerMatrix<MT,SO,false>::StrictlyLowerMatrix(
const Matrix<MT2,SO2>& m )
456 if( IsUniTriangular<MT2>::value ||
461 if( !IsStrictlyLower<MT2>::value )
495 template<
typename MT
498 StrictlyLowerMatrix<MT,SO,false>::operator()(
size_t i,
size_t j )
525 template<
typename MT
528 StrictlyLowerMatrix<MT,SO,false>::operator()(
size_t i,
size_t j )
const
556 template<
typename MT
559 StrictlyLowerMatrix<MT,SO,false>::at(
size_t i,
size_t j )
590 template<
typename MT
593 StrictlyLowerMatrix<MT,SO,false>::at(
size_t i,
size_t j )
const
619 template<
typename MT
624 return matrix_.begin(i);
642 template<
typename MT
647 return matrix_.begin(i);
665 template<
typename MT
670 return matrix_.cbegin(i);
688 template<
typename MT
693 return matrix_.end(i);
711 template<
typename MT
716 return matrix_.end(i);
734 template<
typename MT
739 return matrix_.cend(i);
763 template<
typename MT
765 inline StrictlyLowerMatrix<MT,SO,false>&
766 StrictlyLowerMatrix<MT,SO,false>::operator=(
const StrictlyLowerMatrix& rhs )
768 matrix_ = rhs.matrix_;
792 template<
typename MT
794 template<
typename MT2
796 inline typename DisableIf< IsComputation<MT2>, StrictlyLowerMatrix<MT,SO,false>& >::Type
797 StrictlyLowerMatrix<MT,SO,false>::operator=(
const Matrix<MT2,SO2>& rhs )
799 if( IsUniTriangular<MT2>::value ||
806 if( !IsStrictlyLower<MT2>::value )
831 template<
typename MT
833 template<
typename MT2
835 inline typename EnableIf< IsComputation<MT2>, StrictlyLowerMatrix<MT,SO,false>& >::Type
836 StrictlyLowerMatrix<MT,SO,false>::operator=(
const Matrix<MT2,SO2>& rhs )
838 if( IsUniTriangular<MT2>::value || ( !IsSquare<MT2>::value && !
isSquare( ~rhs ) ) ) {
842 if( IsStrictlyLower<MT2>::value ) {
852 move( matrix_, tmp );
855 if( !IsStrictlyLower<MT2>::value )
880 template<
typename MT
882 template<
typename MT2
884 inline typename DisableIf< IsComputation<MT2>, StrictlyLowerMatrix<MT,SO,false>& >::Type
885 StrictlyLowerMatrix<MT,SO,false>::operator+=(
const Matrix<MT2,SO2>& rhs )
887 if( IsUniTriangular<MT2>::value ||
894 if( !IsStrictlyLower<MT2>::value )
919 template<
typename MT
921 template<
typename MT2
923 inline typename EnableIf< IsComputation<MT2>, StrictlyLowerMatrix<MT,SO,false>& >::Type
924 StrictlyLowerMatrix<MT,SO,false>::operator+=(
const Matrix<MT2,SO2>& rhs )
926 if( IsUniTriangular<MT2>::value || ( !IsSquare<MT2>::value && !
isSquare( ~rhs ) ) ) {
930 if( IsStrictlyLower<MT2>::value ) {
943 if( !IsStrictlyLower<MT2>::value )
968 template<
typename MT
970 template<
typename MT2
972 inline typename DisableIf< IsComputation<MT2>, StrictlyLowerMatrix<MT,SO,false>& >::Type
973 StrictlyLowerMatrix<MT,SO,false>::operator-=(
const Matrix<MT2,SO2>& rhs )
975 if( IsUniTriangular<MT2>::value ||
982 if( !IsStrictlyLower<MT2>::value )
1007 template<
typename MT
1009 template<
typename MT2
1011 inline typename EnableIf< IsComputation<MT2>, StrictlyLowerMatrix<MT,SO,false>& >::Type
1012 StrictlyLowerMatrix<MT,SO,false>::operator-=(
const Matrix<MT2,SO2>& rhs )
1014 if( IsUniTriangular<MT2>::value || ( !IsSquare<MT2>::value && !
isSquare( ~rhs ) ) ) {
1018 if( IsStrictlyLower<MT2>::value ) {
1031 if( !IsStrictlyLower<MT2>::value )
1055 template<
typename MT
1057 template<
typename MT2
1059 inline StrictlyLowerMatrix<MT,SO,false>&
1060 StrictlyLowerMatrix<MT,SO,false>::operator*=(
const Matrix<MT2,SO2>& rhs )
1062 if( matrix_.rows() != (~rhs).
columns() ) {
1066 MT tmp( matrix_ * ~rhs );
1072 move( matrix_, tmp );
1074 if( !IsStrictlyLower<MT2>::value )
1094 template<
typename MT
1096 template<
typename Other >
1097 inline typename EnableIf< IsNumeric<Other>, StrictlyLowerMatrix<MT,SO,false> >::Type&
1098 StrictlyLowerMatrix<MT,SO,false>::operator*=( Other rhs )
1114 template<
typename MT
1116 template<
typename Other >
1117 inline typename EnableIf< IsNumeric<Other>, StrictlyLowerMatrix<MT,SO,false> >::Type&
1118 StrictlyLowerMatrix<MT,SO,false>::operator/=( Other rhs )
1143 template<
typename MT
1147 return matrix_.rows();
1159 template<
typename MT
1163 return matrix_.columns();
1175 template<
typename MT
1179 return matrix_.capacity();
1197 template<
typename MT
1201 return matrix_.capacity(i);
1213 template<
typename MT
1217 return matrix_.nonZeros();
1235 template<
typename MT
1239 return matrix_.nonZeros(i);
1251 template<
typename MT
1256 for(
size_t j=0UL; j<
columns(); ++j ) {
1257 matrix_.erase( j, matrix_.lowerBound(j+1UL,j), matrix_.end(j) );
1261 for(
size_t i=1UL; i<
rows(); ++i ) {
1262 matrix_.erase( i, matrix_.begin(i), matrix_.lowerBound(i,i) );
1283 template<
typename MT
1288 matrix_.erase( i, matrix_.lowerBound(i+1UL,i), matrix_.end(i) );
1291 matrix_.erase( i, matrix_.begin(i), matrix_.lowerBound(i,i) );
1306 template<
typename MT
1312 if( IsResizable<MT>::value ) {
1339 template<
typename MT
1348 return matrix_.set( i, j, value );
1371 template<
typename MT
1374 StrictlyLowerMatrix<MT,SO,false>::insert(
size_t i,
size_t j,
const ElementType& value )
1380 return matrix_.insert( i, j, value );
1396 template<
typename MT
1398 inline void StrictlyLowerMatrix<MT,SO,false>::erase(
size_t i,
size_t j )
1400 matrix_.erase( i, j );
1418 template<
typename MT
1421 StrictlyLowerMatrix<MT,SO,false>::erase(
size_t i,
Iterator pos )
1423 return matrix_.erase( i, pos );
1443 template<
typename MT
1446 StrictlyLowerMatrix<MT,SO,false>::erase(
size_t i,
Iterator first,
Iterator last )
1448 return matrix_.erase( i, first, last );
1469 template<
typename MT
1477 matrix_.resize( n, n, preserve );
1494 template<
typename MT
1496 inline void StrictlyLowerMatrix<MT,SO,false>::reserve(
size_t nonzeros )
1498 matrix_.reserve( nonzeros );
1519 template<
typename MT
1521 inline void StrictlyLowerMatrix<MT,SO,false>::reserve(
size_t i,
size_t nonzeros )
1523 matrix_.reserve( i, nonzeros );
1540 template<
typename MT
1542 inline void StrictlyLowerMatrix<MT,SO,false>::trim()
1562 template<
typename MT
1564 inline void StrictlyLowerMatrix<MT,SO,false>::trim(
size_t i )
1579 template<
typename MT
1581 template<
typename Other >
1582 inline StrictlyLowerMatrix<MT,SO,false>&
1583 StrictlyLowerMatrix<MT,SO,false>::scale(
const Other& scalar )
1585 matrix_.scale( scalar );
1599 template<
typename MT
1601 template<
typename Other >
1602 inline StrictlyLowerMatrix<MT,SO,false>&
1603 StrictlyLowerMatrix<MT,SO,false>::scaleDiagonal( Other scalar )
1605 matrix_.scaleDiagonal( scalar );
1620 template<
typename MT
1626 swap( matrix_, m.matrix_ );
1644 template<
typename MT
1646 inline size_t StrictlyLowerMatrix<MT,SO,false>::maxNonZeros()
1650 return maxNonZeros( Rows<MT>::value );
1666 template<
typename MT
1668 inline size_t StrictlyLowerMatrix<MT,SO,false>::maxNonZeros(
size_t n )
1670 return ( ( n - 1UL ) * n ) / 2UL;
1682 template<
typename MT
1684 inline void StrictlyLowerMatrix<MT,SO,false>::resetUpper()
1687 for(
size_t j=1UL; j<
columns(); ++j )
1688 matrix_.erase( j, matrix_.begin( j ), matrix_.lowerBound( j, j ) );
1691 for(
size_t i=0UL; i<
rows(); ++i )
1692 matrix_.erase( i, matrix_.upperBound( i, i ), matrix_.end( i ) );
1723 template<
typename MT
1726 StrictlyLowerMatrix<MT,SO,false>::find(
size_t i,
size_t j )
1728 return matrix_.find( i, j );
1750 template<
typename MT
1753 StrictlyLowerMatrix<MT,SO,false>::find(
size_t i,
size_t j )
const
1755 return matrix_.find( i, j );
1777 template<
typename MT
1780 StrictlyLowerMatrix<MT,SO,false>::lowerBound(
size_t i,
size_t j )
1782 return matrix_.lowerBound( i, j );
1804 template<
typename MT
1807 StrictlyLowerMatrix<MT,SO,false>::lowerBound(
size_t i,
size_t j )
const
1809 return matrix_.lowerBound( i, j );
1831 template<
typename MT
1834 StrictlyLowerMatrix<MT,SO,false>::upperBound(
size_t i,
size_t j )
1836 return matrix_.upperBound( i, j );
1858 template<
typename MT
1861 StrictlyLowerMatrix<MT,SO,false>::upperBound(
size_t i,
size_t j )
const
1863 return matrix_.upperBound( i, j );
1927 template<
typename MT
1929 inline void StrictlyLowerMatrix<MT,SO,false>::append(
size_t i,
size_t j,
const ElementType& value,
bool check )
1935 matrix_.append( i, j, value, check );
1955 template<
typename MT
1957 inline void StrictlyLowerMatrix<MT,SO,false>::finalize(
size_t i )
1959 matrix_.finalize( i );
1983 template<
typename MT
2014 template<
typename MT
2016 template<
typename Other >
2017 inline bool StrictlyLowerMatrix<MT,SO,false>::canAlias(
const Other* alias )
const
2019 return matrix_.canAlias( alias );
2036 template<
typename MT
2038 template<
typename Other >
2039 inline bool StrictlyLowerMatrix<MT,SO,false>::isAliased(
const Other* alias )
const
2041 return matrix_.isAliased( alias );
2058 template<
typename MT
2060 inline bool StrictlyLowerMatrix<MT,SO,false>::canSMPAssign()
const
2062 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
const MT::ElementType max(const DenseMatrix< MT, SO > &dm)
Returns the largest element of the dense matrix.
Definition: DenseMatrix.h:1729
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
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 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
bool isStrictlyLower(const DenseMatrix< MT, SO > &dm)
Checks if the given dense matrix is a strictly lower triangular matrix.
Definition: DenseMatrix.h:1201
#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
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 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.
Header file for the SparseElement base class.
Header file for the IsUniTriangular type trait.
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.
Header file for the IsStrictlyLower type trait.
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.
Header file for the StrictlyLowerProxy class.
#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 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
Header file for the IsResizable type trait.
Header file for the implementation of the base template of the StrictlyLowerMatrix.
#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