35 #ifndef _BLAZE_MATH_ADAPTORS_STRICTLYLOWERMATRIX_SPARSE_H_
36 #define _BLAZE_MATH_ADAPTORS_STRICTLYLOWERMATRIX_SPARSE_H_
98 class StrictlyLowerMatrix<MT,SO,false>
99 :
public SparseMatrix< StrictlyLowerMatrix<MT,SO,false>, SO >
110 typedef StrictlyLowerMatrix<MT,SO,false>
This;
117 typedef StrictlyLowerProxy<MT>
Reference;
126 template<
typename ET >
129 typedef StrictlyLowerMatrix< typename MT::template Rebind<ET>::Other > Other;
135 enum { smpAssignable = 0 };
141 explicit inline StrictlyLowerMatrix();
142 explicit inline StrictlyLowerMatrix(
size_t n );
143 explicit inline StrictlyLowerMatrix(
size_t n,
size_t nonzeros );
144 explicit inline StrictlyLowerMatrix(
size_t n,
const std::vector<size_t>& nonzeros );
146 inline StrictlyLowerMatrix(
const StrictlyLowerMatrix& m );
147 template<
typename MT2,
bool SO2 >
inline StrictlyLowerMatrix(
const Matrix<MT2,SO2>& m );
158 inline Reference operator()(
size_t i,
size_t j );
159 inline ConstReference operator()(
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 StrictlyLowerMatrix& operator=(
const StrictlyLowerMatrix& rhs );
174 template<
typename MT2,
bool SO2 >
175 inline typename DisableIf< IsComputation<MT2>, StrictlyLowerMatrix& >::Type
176 operator=(
const Matrix<MT2,SO2>& rhs );
178 template<
typename MT2,
bool SO2 >
179 inline typename EnableIf< IsComputation<MT2>, StrictlyLowerMatrix& >::Type
180 operator=(
const Matrix<MT2,SO2>& rhs );
182 template<
typename MT2,
bool SO2 >
183 inline typename DisableIf< IsComputation<MT2>, StrictlyLowerMatrix& >::Type
184 operator+=(
const Matrix<MT2,SO2>& rhs );
186 template<
typename MT2,
bool SO2 >
187 inline typename EnableIf< IsComputation<MT2>, StrictlyLowerMatrix& >::Type
188 operator+=(
const Matrix<MT2,SO2>& rhs );
190 template<
typename MT2,
bool SO2 >
191 inline typename DisableIf< IsComputation<MT2>, StrictlyLowerMatrix& >::Type
192 operator-=(
const Matrix<MT2,SO2>& rhs );
194 template<
typename MT2,
bool SO2 >
195 inline typename EnableIf< IsComputation<MT2>, StrictlyLowerMatrix& >::Type
196 operator-=(
const Matrix<MT2,SO2>& rhs );
198 template<
typename MT2,
bool SO2 >
199 inline StrictlyLowerMatrix& operator*=(
const Matrix<MT2,SO2>& rhs );
201 template<
typename Other >
202 inline typename EnableIf< IsNumeric<Other>, StrictlyLowerMatrix >::Type&
203 operator*=( Other rhs );
205 template<
typename Other >
206 inline typename EnableIf< IsNumeric<Other>, StrictlyLowerMatrix >::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 );
234 template<
typename Other >
inline StrictlyLowerMatrix& scale(
const Other& scalar );
235 template<
typename Other >
inline StrictlyLowerMatrix& scaleDiagonal( Other scale );
237 inline void swap( StrictlyLowerMatrix& m ) ;
239 static inline size_t maxNonZeros();
240 static inline size_t maxNonZeros(
size_t n );
247 inline Iterator find (
size_t i,
size_t j );
248 inline ConstIterator find (
size_t i,
size_t j )
const;
249 inline Iterator lowerBound(
size_t i,
size_t j );
250 inline ConstIterator lowerBound(
size_t i,
size_t j )
const;
251 inline Iterator upperBound(
size_t i,
size_t j );
252 inline ConstIterator upperBound(
size_t i,
size_t j )
const;
259 inline void append (
size_t i,
size_t j,
const ElementType& value,
bool check=
false );
260 inline void finalize(
size_t i );
267 template<
typename Other >
inline bool canAlias (
const Other* alias )
const;
268 template<
typename Other >
inline bool isAliased(
const Other* alias )
const;
270 inline bool canSMPAssign()
const;
278 inline void resetUpper();
290 template<
typename MT2,
bool SO2,
bool DF2 >
291 friend MT2& derestrict( StrictlyLowerMatrix<MT2,SO2,DF2>& m );
325 template<
typename MT
327 inline StrictlyLowerMatrix<MT,SO,false>::StrictlyLowerMatrix()
344 template<
typename MT
346 inline StrictlyLowerMatrix<MT,SO,false>::StrictlyLowerMatrix(
size_t n )
367 template<
typename MT
369 inline StrictlyLowerMatrix<MT,SO,false>::StrictlyLowerMatrix(
size_t n,
size_t nonzeros )
370 : matrix_( n, n,
max( nonzeros, n ) )
394 template<
typename MT
396 inline StrictlyLowerMatrix<MT,SO,false>::StrictlyLowerMatrix(
size_t n,
const std::vector<size_t>& nonzeros )
397 : matrix_( n, n, nonzeros )
413 template<
typename MT
415 inline StrictlyLowerMatrix<MT,SO,false>::StrictlyLowerMatrix(
const StrictlyLowerMatrix& m )
416 : matrix_( m.matrix_ )
435 template<
typename MT
437 template<
typename MT2
439 inline StrictlyLowerMatrix<MT,SO,false>::StrictlyLowerMatrix(
const Matrix<MT2,SO2>& m )
442 if( IsUniTriangular<MT2>::value ||
444 throw std::invalid_argument(
"Invalid setup of strictly lower matrix" );
446 if( !IsStrictlyLower<MT2>::value )
475 template<
typename MT
478 StrictlyLowerMatrix<MT,SO,false>::operator()(
size_t i,
size_t j )
501 template<
typename MT
504 StrictlyLowerMatrix<MT,SO,false>::operator()(
size_t i,
size_t j )
const
527 template<
typename MT
532 return matrix_.begin(i);
550 template<
typename MT
555 return matrix_.begin(i);
573 template<
typename MT
578 return matrix_.cbegin(i);
596 template<
typename MT
601 return matrix_.end(i);
619 template<
typename MT
624 return matrix_.end(i);
642 template<
typename MT
647 return matrix_.cend(i);
671 template<
typename MT
673 inline StrictlyLowerMatrix<MT,SO,false>&
674 StrictlyLowerMatrix<MT,SO,false>::operator=(
const StrictlyLowerMatrix& rhs )
676 matrix_ = rhs.matrix_;
697 template<
typename MT
699 template<
typename MT2
701 inline typename DisableIf< IsComputation<MT2>, StrictlyLowerMatrix<MT,SO,false>& >::Type
702 StrictlyLowerMatrix<MT,SO,false>::operator=(
const Matrix<MT2,SO2>& rhs )
704 if( IsUniTriangular<MT2>::value ||
706 throw std::invalid_argument(
"Invalid assignment to strictly lower matrix" );
710 if( !IsStrictlyLower<MT2>::value )
732 template<
typename MT
734 template<
typename MT2
736 inline typename EnableIf< IsComputation<MT2>, StrictlyLowerMatrix<MT,SO,false>& >::Type
737 StrictlyLowerMatrix<MT,SO,false>::operator=(
const Matrix<MT2,SO2>& rhs )
739 if( IsUniTriangular<MT2>::value || ( !IsSquare<MT2>::value && !
isSquare( ~rhs ) ) )
740 throw std::invalid_argument(
"Invalid assignment to strictly lower matrix" );
742 if( IsStrictlyLower<MT2>::value ) {
749 throw std::invalid_argument(
"Invalid assignment to strictly lower matrix" );
751 move( matrix_, tmp );
754 if( !IsStrictlyLower<MT2>::value )
776 template<
typename MT
778 template<
typename MT2
780 inline typename DisableIf< IsComputation<MT2>, StrictlyLowerMatrix<MT,SO,false>& >::Type
781 StrictlyLowerMatrix<MT,SO,false>::operator+=(
const Matrix<MT2,SO2>& rhs )
783 if( IsUniTriangular<MT2>::value ||
785 throw std::invalid_argument(
"Invalid assignment to strictly lower matrix" );
789 if( !IsStrictlyLower<MT2>::value )
811 template<
typename MT
813 template<
typename MT2
815 inline typename EnableIf< IsComputation<MT2>, StrictlyLowerMatrix<MT,SO,false>& >::Type
816 StrictlyLowerMatrix<MT,SO,false>::operator+=(
const Matrix<MT2,SO2>& rhs )
818 if( IsUniTriangular<MT2>::value || ( !IsSquare<MT2>::value && !
isSquare( ~rhs ) ) )
819 throw std::invalid_argument(
"Invalid assignment to strictly lower matrix" );
821 if( IsStrictlyLower<MT2>::value ) {
828 throw std::invalid_argument(
"Invalid assignment to strictly lower matrix" );
833 if( !IsStrictlyLower<MT2>::value )
855 template<
typename MT
857 template<
typename MT2
859 inline typename DisableIf< IsComputation<MT2>, StrictlyLowerMatrix<MT,SO,false>& >::Type
860 StrictlyLowerMatrix<MT,SO,false>::operator-=(
const Matrix<MT2,SO2>& rhs )
862 if( IsUniTriangular<MT2>::value ||
864 throw std::invalid_argument(
"Invalid assignment to strictly lower matrix" );
868 if( !IsStrictlyLower<MT2>::value )
890 template<
typename MT
892 template<
typename MT2
894 inline typename EnableIf< IsComputation<MT2>, StrictlyLowerMatrix<MT,SO,false>& >::Type
895 StrictlyLowerMatrix<MT,SO,false>::operator-=(
const Matrix<MT2,SO2>& rhs )
897 if( IsUniTriangular<MT2>::value || ( !IsSquare<MT2>::value && !
isSquare( ~rhs ) ) )
898 throw std::invalid_argument(
"Invalid assignment to strictly lower matrix" );
900 if( IsStrictlyLower<MT2>::value ) {
907 throw std::invalid_argument(
"Invalid assignment to strictly lower matrix" );
912 if( !IsStrictlyLower<MT2>::value )
933 template<
typename MT
935 template<
typename MT2
937 inline StrictlyLowerMatrix<MT,SO,false>&
938 StrictlyLowerMatrix<MT,SO,false>::operator*=(
const Matrix<MT2,SO2>& rhs )
940 if( matrix_.rows() != (~rhs).
columns() )
941 throw std::invalid_argument(
"Invalid assignment to strictly lower matrix" );
943 MT tmp( matrix_ * ~rhs );
946 throw std::invalid_argument(
"Invalid assignment to strictly lower matrix" );
948 move( matrix_, tmp );
950 if( !IsStrictlyLower<MT2>::value )
967 template<
typename MT
969 template<
typename Other >
970 inline typename EnableIf< IsNumeric<Other>, StrictlyLowerMatrix<MT,SO,false> >::Type&
971 StrictlyLowerMatrix<MT,SO,false>::operator*=( Other rhs )
987 template<
typename MT
989 template<
typename Other >
990 inline typename EnableIf< IsNumeric<Other>, StrictlyLowerMatrix<MT,SO,false> >::Type&
991 StrictlyLowerMatrix<MT,SO,false>::operator/=( Other rhs )
1016 template<
typename MT
1020 return matrix_.rows();
1032 template<
typename MT
1036 return matrix_.columns();
1048 template<
typename MT
1052 return matrix_.capacity();
1070 template<
typename MT
1074 return matrix_.capacity(i);
1086 template<
typename MT
1090 return matrix_.nonZeros();
1108 template<
typename MT
1112 return matrix_.nonZeros(i);
1124 template<
typename MT
1129 for(
size_t j=0UL; j<
columns(); ++j ) {
1130 matrix_.erase( j, matrix_.lowerBound(j+1UL,j), matrix_.end(j) );
1134 for(
size_t i=1UL; i<
rows(); ++i ) {
1135 matrix_.erase( i, matrix_.begin(i), matrix_.lowerBound(i,i) );
1156 template<
typename MT
1161 matrix_.erase( i, matrix_.lowerBound(i+1UL,i), matrix_.end(i) );
1164 matrix_.erase( i, matrix_.begin(i), matrix_.lowerBound(i,i) );
1179 template<
typename MT
1185 if( IsResizable<MT>::value ) {
1212 template<
typename MT
1218 throw std::invalid_argument(
"Invalid access to diagonal or upper matrix element" );
1220 return matrix_.set( i, j, value );
1243 template<
typename MT
1246 StrictlyLowerMatrix<MT,SO,false>::insert(
size_t i,
size_t j,
const ElementType& value )
1249 throw std::invalid_argument(
"Invalid access to diagonal or upper matrix element" );
1251 return matrix_.insert( i, j, value );
1267 template<
typename MT
1269 inline void StrictlyLowerMatrix<MT,SO,false>::erase(
size_t i,
size_t j )
1271 matrix_.erase( i, j );
1289 template<
typename MT
1292 StrictlyLowerMatrix<MT,SO,false>::erase(
size_t i,
Iterator pos )
1294 return matrix_.erase( i, pos );
1314 template<
typename MT
1317 StrictlyLowerMatrix<MT,SO,false>::erase(
size_t i,
Iterator first,
Iterator last )
1319 return matrix_.erase( i, first, last );
1340 template<
typename MT
1348 matrix_.resize( n, n, preserve );
1365 template<
typename MT
1367 inline void StrictlyLowerMatrix<MT,SO,false>::reserve(
size_t nonzeros )
1369 matrix_.reserve( nonzeros );
1390 template<
typename MT
1392 inline void StrictlyLowerMatrix<MT,SO,false>::reserve(
size_t i,
size_t nonzeros )
1394 matrix_.reserve( i, nonzeros );
1411 template<
typename MT
1413 inline void StrictlyLowerMatrix<MT,SO,false>::trim()
1433 template<
typename MT
1435 inline void StrictlyLowerMatrix<MT,SO,false>::trim(
size_t i )
1450 template<
typename MT
1452 template<
typename Other >
1453 inline StrictlyLowerMatrix<MT,SO,false>&
1454 StrictlyLowerMatrix<MT,SO,false>::scale(
const Other& scalar )
1456 matrix_.scale( scalar );
1470 template<
typename MT
1472 template<
typename Other >
1473 inline StrictlyLowerMatrix<MT,SO,false>&
1474 StrictlyLowerMatrix<MT,SO,false>::scaleDiagonal( Other scalar )
1476 matrix_.scaleDiagonal( scalar );
1491 template<
typename MT
1497 swap( matrix_, m.matrix_ );
1515 template<
typename MT
1517 inline size_t StrictlyLowerMatrix<MT,SO,false>::maxNonZeros()
1521 return maxNonZeros( Rows<MT>::value );
1537 template<
typename MT
1539 inline size_t StrictlyLowerMatrix<MT,SO,false>::maxNonZeros(
size_t n )
1541 return ( ( n - 1UL ) * n ) / 2UL;
1553 template<
typename MT
1555 inline void StrictlyLowerMatrix<MT,SO,false>::resetUpper()
1558 for(
size_t j=1UL; j<
columns(); ++j )
1559 matrix_.erase( j, matrix_.begin( j ), matrix_.lowerBound( j, j ) );
1562 for(
size_t i=0UL; i<
rows(); ++i )
1563 matrix_.erase( i, matrix_.upperBound( i, i ), matrix_.end( i ) );
1594 template<
typename MT
1597 StrictlyLowerMatrix<MT,SO,false>::find(
size_t i,
size_t j )
1599 return matrix_.find( i, j );
1621 template<
typename MT
1624 StrictlyLowerMatrix<MT,SO,false>::find(
size_t i,
size_t j )
const
1626 return matrix_.find( i, j );
1648 template<
typename MT
1651 StrictlyLowerMatrix<MT,SO,false>::lowerBound(
size_t i,
size_t j )
1653 return matrix_.lowerBound( i, j );
1675 template<
typename MT
1678 StrictlyLowerMatrix<MT,SO,false>::lowerBound(
size_t i,
size_t j )
const
1680 return matrix_.lowerBound( i, j );
1702 template<
typename MT
1705 StrictlyLowerMatrix<MT,SO,false>::upperBound(
size_t i,
size_t j )
1707 return matrix_.upperBound( i, j );
1729 template<
typename MT
1732 StrictlyLowerMatrix<MT,SO,false>::upperBound(
size_t i,
size_t j )
const
1734 return matrix_.upperBound( i, j );
1798 template<
typename MT
1800 inline void StrictlyLowerMatrix<MT,SO,false>::append(
size_t i,
size_t j,
const ElementType& value,
bool check )
1803 throw std::invalid_argument(
"Invalid access to diagonal or upper matrix element" );
1805 matrix_.append( i, j, value, check );
1825 template<
typename MT
1827 inline void StrictlyLowerMatrix<MT,SO,false>::finalize(
size_t i )
1829 matrix_.finalize( i );
1854 template<
typename MT
1856 template<
typename Other >
1857 inline bool StrictlyLowerMatrix<MT,SO,false>::canAlias(
const Other* alias )
const
1859 return matrix_.canAlias( alias );
1876 template<
typename MT
1878 template<
typename Other >
1879 inline bool StrictlyLowerMatrix<MT,SO,false>::isAliased(
const Other* alias )
const
1881 return matrix_.isAliased( alias );
1898 template<
typename MT
1900 inline bool StrictlyLowerMatrix<MT,SO,false>::canSMPAssign()
const
1902 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
const MT::ElementType max(const DenseMatrix< MT, SO > &dm)
Returns the largest element of the dense matrix.
Definition: DenseMatrix.h:1649
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: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
bool isStrictlyLower(const DenseMatrix< MT, SO > &dm)
Checks if the given dense matrix is a strictly lower triangular matrix.
Definition: DenseMatrix.h:1121
#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
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: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.
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: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.
Header file for the IsStrictlyLower type trait.
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.
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: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.
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