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 >
106 typedef OppositeType_<MT> OT;
107 typedef TransposeType_<MT> TT;
108 typedef ElementType_<MT> ET;
113 typedef StrictlyLowerMatrix<MT,SO,false>
This;
114 typedef SparseMatrix<This,SO>
BaseType;
121 typedef StrictlyLowerProxy<MT>
Reference;
130 template<
typename NewType >
133 typedef StrictlyLowerMatrix< typename MT::template Rebind<NewType>::Other > Other;
140 template<
size_t NewM
144 typedef StrictlyLowerMatrix< typename MT::template Resize<NewM,NewN>::Other > Other;
150 enum :
bool { smpAssignable =
false };
156 explicit inline StrictlyLowerMatrix();
157 explicit inline StrictlyLowerMatrix(
size_t n );
158 explicit inline StrictlyLowerMatrix(
size_t n,
size_t nonzeros );
159 explicit inline StrictlyLowerMatrix(
size_t n,
const std::vector<size_t>& nonzeros );
161 inline StrictlyLowerMatrix(
const StrictlyLowerMatrix& m );
162 inline StrictlyLowerMatrix( StrictlyLowerMatrix&& m ) noexcept;
164 template<
typename MT2,
bool SO2 >
165 inline StrictlyLowerMatrix(
const Matrix<MT2,SO2>& m );
176 inline Reference operator()(
size_t i,
size_t j );
177 inline ConstReference operator()(
size_t i,
size_t j )
const;
178 inline Reference at(
size_t i,
size_t j );
179 inline ConstReference at(
size_t i,
size_t j )
const;
180 inline Iterator
begin (
size_t i );
181 inline ConstIterator
begin (
size_t i )
const;
182 inline ConstIterator
cbegin(
size_t i )
const;
183 inline Iterator
end (
size_t i );
184 inline ConstIterator
end (
size_t i )
const;
185 inline ConstIterator
cend (
size_t i )
const;
192 inline StrictlyLowerMatrix& operator=(
const StrictlyLowerMatrix& rhs );
193 inline StrictlyLowerMatrix& operator=( StrictlyLowerMatrix&& rhs ) noexcept;
195 template<
typename MT2,
bool SO2 >
196 inline DisableIf_< IsComputation<MT2>, StrictlyLowerMatrix& >
197 operator=(
const Matrix<MT2,SO2>& rhs );
199 template<
typename MT2,
bool SO2 >
200 inline EnableIf_< IsComputation<MT2>, StrictlyLowerMatrix& >
201 operator=(
const Matrix<MT2,SO2>& rhs );
203 template<
typename MT2,
bool SO2 >
204 inline DisableIf_< IsComputation<MT2>, StrictlyLowerMatrix& >
207 template<
typename MT2,
bool SO2 >
208 inline EnableIf_< IsComputation<MT2>, StrictlyLowerMatrix& >
211 template<
typename MT2,
bool SO2 >
212 inline DisableIf_< IsComputation<MT2>, StrictlyLowerMatrix& >
215 template<
typename MT2,
bool SO2 >
216 inline EnableIf_< IsComputation<MT2>, StrictlyLowerMatrix& >
219 template<
typename MT2,
bool SO2 >
220 inline StrictlyLowerMatrix&
operator*=(
const Matrix<MT2,SO2>& rhs );
222 template<
typename Other >
223 inline EnableIf_< IsNumeric<Other>, StrictlyLowerMatrix >&
operator*=( Other rhs );
225 template<
typename Other >
226 inline EnableIf_< IsNumeric<Other>, StrictlyLowerMatrix >&
operator/=( Other rhs );
233 inline size_t rows() const noexcept;
234 inline
size_t columns() const noexcept;
235 inline
size_t capacity() const noexcept;
236 inline
size_t capacity(
size_t i ) const noexcept;
238 inline
size_t nonZeros(
size_t i ) const;
240 inline
void reset(
size_t i );
242 inline
void resize (
size_t n,
bool preserve=true );
243 inline
void reserve(
size_t nonzeros );
244 inline
void reserve(
size_t i,
size_t nonzeros );
246 inline
void trim(
size_t i );
247 inline
void swap( StrictlyLowerMatrix& m ) noexcept;
249 static inline constexpr
size_t maxNonZeros() noexcept;
250 static inline constexpr
size_t maxNonZeros(
size_t n ) noexcept;
257 inline Iterator
set (
size_t i,
size_t j, const ElementType& value );
258 inline Iterator insert (
size_t i,
size_t j, const ElementType& value );
259 inline
void append (
size_t i,
size_t j, const ElementType& value,
bool check=false );
260 inline
void finalize(
size_t i );
267 inline
void erase(
size_t i,
size_t j );
268 inline Iterator erase(
size_t i, Iterator pos );
269 inline Iterator erase(
size_t i, Iterator first, Iterator last );
271 template< typename Pred >
272 inline
void erase( Pred predicate );
274 template< typename Pred >
275 inline
void erase(
size_t i, Iterator first, Iterator last, Pred predicate );
282 inline Iterator find (
size_t i,
size_t j );
283 inline ConstIterator find (
size_t i,
size_t j ) const;
284 inline Iterator lowerBound(
size_t i,
size_t j );
285 inline ConstIterator lowerBound(
size_t i,
size_t j ) const;
286 inline Iterator upperBound(
size_t i,
size_t j );
287 inline ConstIterator upperBound(
size_t i,
size_t j ) const;
294 template< typename Other > inline StrictlyLowerMatrix& scale( const Other& scalar );
295 template< typename Other > inline StrictlyLowerMatrix& scaleDiagonal( const Other& scale );
302 inline
bool isIntact() const noexcept;
309 template< typename Other > inline
bool canAlias ( const Other* alias ) const noexcept;
310 template< typename Other > inline
bool isAliased( const Other* alias ) const noexcept;
312 inline
bool canSMPAssign() const noexcept;
320 inline
void resetUpper();
332 template< typename MT2,
bool SO2,
bool DF2 >
333 friend MT2& derestrict( StrictlyLowerMatrix<MT2,SO2,DF2>& m );
368 template< typename MT
370 inline StrictlyLowerMatrix<MT,SO,false>::StrictlyLowerMatrix()
387 template<
typename MT
389 inline StrictlyLowerMatrix<MT,SO,false>::StrictlyLowerMatrix(
size_t n )
410 template<
typename MT
412 inline StrictlyLowerMatrix<MT,SO,false>::StrictlyLowerMatrix(
size_t n,
size_t nonzeros )
413 : matrix_( n, n,
max( nonzeros, n ) )
437 template<
typename MT
439 inline StrictlyLowerMatrix<MT,SO,false>::StrictlyLowerMatrix(
size_t n,
const std::vector<size_t>& nonzeros )
440 : matrix_( n, n, nonzeros )
456 template<
typename MT
458 inline StrictlyLowerMatrix<MT,SO,false>::StrictlyLowerMatrix(
const StrictlyLowerMatrix& m )
459 : matrix_( m.matrix_ )
474 template<
typename MT
476 inline StrictlyLowerMatrix<MT,SO,false>::StrictlyLowerMatrix( StrictlyLowerMatrix&& m ) noexcept
477 : matrix_( std::move( m.matrix_ ) )
497 template<
typename MT
499 template<
typename MT2
501 inline StrictlyLowerMatrix<MT,SO,false>::StrictlyLowerMatrix(
const Matrix<MT2,SO2>& m )
504 if( IsUniTriangular<MT2>::value ||
509 if( !IsStrictlyLower<MT2>::value )
543 template<
typename MT
546 StrictlyLowerMatrix<MT,SO,false>::operator()(
size_t i,
size_t j )
573 template<
typename MT
576 StrictlyLowerMatrix<MT,SO,false>::operator()(
size_t i,
size_t j )
const 604 template<
typename MT
607 StrictlyLowerMatrix<MT,SO,false>::at(
size_t i,
size_t j )
638 template<
typename MT
641 StrictlyLowerMatrix<MT,SO,false>::at(
size_t i,
size_t j )
const 667 template<
typename MT
672 return matrix_.begin(i);
690 template<
typename MT
695 return matrix_.begin(i);
713 template<
typename MT
718 return matrix_.cbegin(i);
736 template<
typename MT
741 return matrix_.end(i);
759 template<
typename MT
764 return matrix_.end(i);
782 template<
typename MT
787 return matrix_.cend(i);
811 template<
typename MT
813 inline StrictlyLowerMatrix<MT,SO,false>&
814 StrictlyLowerMatrix<MT,SO,false>::operator=(
const StrictlyLowerMatrix& rhs )
816 matrix_ = rhs.matrix_;
834 template<
typename MT
836 inline StrictlyLowerMatrix<MT,SO,false>&
837 StrictlyLowerMatrix<MT,SO,false>::operator=( StrictlyLowerMatrix&& rhs ) noexcept
839 matrix_ = std::move( rhs.matrix_ );
863 template<
typename MT
865 template<
typename MT2
867 inline DisableIf_< IsComputation<MT2>, StrictlyLowerMatrix<MT,SO,false>& >
868 StrictlyLowerMatrix<MT,SO,false>::operator=(
const Matrix<MT2,SO2>& rhs )
870 if( IsUniTriangular<MT2>::value ||
877 if( !IsStrictlyLower<MT2>::value )
902 template<
typename MT
904 template<
typename MT2
906 inline EnableIf_< IsComputation<MT2>, StrictlyLowerMatrix<MT,SO,false>& >
907 StrictlyLowerMatrix<MT,SO,false>::operator=(
const Matrix<MT2,SO2>& rhs )
909 if( IsUniTriangular<MT2>::value || ( !IsSquare<MT2>::value && !
isSquare( ~rhs ) ) ) {
913 if( IsStrictlyLower<MT2>::value ) {
923 matrix_ = std::move( tmp );
926 if( !IsStrictlyLower<MT2>::value )
951 template<
typename MT
953 template<
typename MT2
955 inline DisableIf_< IsComputation<MT2>, StrictlyLowerMatrix<MT,SO,false>& >
958 if( IsUniTriangular<MT2>::value ||
965 if( !IsStrictlyLower<MT2>::value )
990 template<
typename MT
992 template<
typename MT2
994 inline EnableIf_< IsComputation<MT2>, StrictlyLowerMatrix<MT,SO,false>& >
997 if( IsUniTriangular<MT2>::value || ( !IsSquare<MT2>::value && !
isSquare( ~rhs ) ) ) {
1001 if( IsStrictlyLower<MT2>::value ) {
1005 const ResultType_<MT2> tmp( ~rhs );
1014 if( !IsStrictlyLower<MT2>::value )
1039 template<
typename MT
1041 template<
typename MT2
1043 inline DisableIf_< IsComputation<MT2>, StrictlyLowerMatrix<MT,SO,false>& >
1046 if( IsUniTriangular<MT2>::value ||
1053 if( !IsStrictlyLower<MT2>::value )
1078 template<
typename MT
1080 template<
typename MT2
1082 inline EnableIf_< IsComputation<MT2>, StrictlyLowerMatrix<MT,SO,false>& >
1085 if( IsUniTriangular<MT2>::value || ( !IsSquare<MT2>::value && !
isSquare( ~rhs ) ) ) {
1089 if( IsStrictlyLower<MT2>::value ) {
1093 const ResultType_<MT2> tmp( ~rhs );
1102 if( !IsStrictlyLower<MT2>::value )
1126 template<
typename MT
1128 template<
typename MT2
1130 inline StrictlyLowerMatrix<MT,SO,false>&
1133 if( matrix_.rows() != (~rhs).
columns() ) {
1137 MT tmp( matrix_ * ~rhs );
1143 matrix_ = std::move( tmp );
1145 if( !IsStrictlyLower<MT2>::value )
1165 template<
typename MT
1167 template<
typename Other >
1168 inline EnableIf_< IsNumeric<Other>, StrictlyLowerMatrix<MT,SO,false> >&
1185 template<
typename MT
1187 template<
typename Other >
1188 inline EnableIf_< IsNumeric<Other>, StrictlyLowerMatrix<MT,SO,false> >&
1214 template<
typename MT
1218 return matrix_.rows();
1230 template<
typename MT
1234 return matrix_.columns();
1246 template<
typename MT
1250 return matrix_.capacity();
1268 template<
typename MT
1272 return matrix_.capacity(i);
1284 template<
typename MT
1288 return matrix_.nonZeros();
1306 template<
typename MT
1310 return matrix_.nonZeros(i);
1322 template<
typename MT
1327 for(
size_t j=0UL; j<
columns(); ++j ) {
1328 matrix_.erase( j, matrix_.lowerBound(j+1UL,j), matrix_.end(j) );
1332 for(
size_t i=1UL; i<
rows(); ++i ) {
1333 matrix_.erase( i, matrix_.begin(i), matrix_.lowerBound(i,i) );
1354 template<
typename MT
1359 matrix_.erase( i, matrix_.lowerBound(i+1UL,i), matrix_.end(i) );
1362 matrix_.erase( i, matrix_.begin(i), matrix_.lowerBound(i,i) );
1377 template<
typename MT
1383 if( IsResizable<MT>::value ) {
1409 template<
typename MT
1417 matrix_.resize( n, n, preserve );
1434 template<
typename MT
1436 inline void StrictlyLowerMatrix<MT,SO,false>::reserve(
size_t nonzeros )
1438 matrix_.reserve( nonzeros );
1459 template<
typename MT
1461 inline void StrictlyLowerMatrix<MT,SO,false>::reserve(
size_t i,
size_t nonzeros )
1463 matrix_.reserve( i, nonzeros );
1480 template<
typename MT
1482 inline void StrictlyLowerMatrix<MT,SO,false>::trim()
1502 template<
typename MT
1504 inline void StrictlyLowerMatrix<MT,SO,false>::trim(
size_t i )
1519 template<
typename MT
1525 swap( matrix_, m.matrix_ );
1543 template<
typename MT
1545 inline constexpr
size_t StrictlyLowerMatrix<MT,SO,false>::maxNonZeros() noexcept
1549 return maxNonZeros( Rows<MT>::value );
1565 template<
typename MT
1567 inline constexpr
size_t StrictlyLowerMatrix<MT,SO,false>::maxNonZeros(
size_t n ) noexcept
1569 return ( ( n - 1UL ) * n ) / 2UL;
1581 template<
typename MT
1583 inline void StrictlyLowerMatrix<MT,SO,false>::resetUpper()
1586 for(
size_t j=1UL; j<
columns(); ++j )
1587 matrix_.erase( j, matrix_.begin( j ), matrix_.lowerBound( j, j ) );
1590 for(
size_t i=0UL; i<
rows(); ++i )
1591 matrix_.erase( i, matrix_.upperBound( i, i ), matrix_.end( i ) );
1622 template<
typename MT
1631 return matrix_.set( i, j, value );
1654 template<
typename MT
1657 StrictlyLowerMatrix<MT,SO,false>::insert(
size_t i,
size_t j,
const ElementType& value )
1663 return matrix_.insert( i, j, value );
1719 template<
typename MT
1721 inline void StrictlyLowerMatrix<MT,SO,false>::append(
size_t i,
size_t j,
const ElementType& value,
bool check )
1727 matrix_.append( i, j, value, check );
1747 template<
typename MT
1749 inline void StrictlyLowerMatrix<MT,SO,false>::finalize(
size_t i )
1751 matrix_.finalize( i );
1775 template<
typename MT
1777 inline void StrictlyLowerMatrix<MT,SO,false>::erase(
size_t i,
size_t j )
1779 matrix_.erase( i, j );
1797 template<
typename MT
1800 StrictlyLowerMatrix<MT,SO,false>::erase(
size_t i, Iterator pos )
1802 return matrix_.erase( i, pos );
1822 template<
typename MT
1825 StrictlyLowerMatrix<MT,SO,false>::erase(
size_t i, Iterator first, Iterator last )
1827 return matrix_.erase( i, first, last );
1855 template<
typename MT
1857 template<
typename Pred >
1858 inline void StrictlyLowerMatrix<MT,SO,false>::erase( Pred predicate )
1860 matrix_.erase( predicate );
1896 template<
typename MT
1898 template<
typename Pred >
1899 inline void StrictlyLowerMatrix<MT,SO,false>::erase(
size_t i, Iterator first, Iterator last, Pred predicate )
1901 matrix_.erase( i, first, last, predicate );
1933 template<
typename MT
1936 StrictlyLowerMatrix<MT,SO,false>::find(
size_t i,
size_t j )
1938 return matrix_.find( i, j );
1960 template<
typename MT
1963 StrictlyLowerMatrix<MT,SO,false>::find(
size_t i,
size_t j )
const 1965 return matrix_.find( i, j );
1987 template<
typename MT
1990 StrictlyLowerMatrix<MT,SO,false>::lowerBound(
size_t i,
size_t j )
1992 return matrix_.lowerBound( i, j );
2014 template<
typename MT
2017 StrictlyLowerMatrix<MT,SO,false>::lowerBound(
size_t i,
size_t j )
const 2019 return matrix_.lowerBound( i, j );
2041 template<
typename MT
2044 StrictlyLowerMatrix<MT,SO,false>::upperBound(
size_t i,
size_t j )
2046 return matrix_.upperBound( i, j );
2068 template<
typename MT
2071 StrictlyLowerMatrix<MT,SO,false>::upperBound(
size_t i,
size_t j )
const 2073 return matrix_.upperBound( i, j );
2094 template<
typename MT
2096 template<
typename Other >
2097 inline StrictlyLowerMatrix<MT,SO,false>&
2098 StrictlyLowerMatrix<MT,SO,false>::scale(
const Other& scalar )
2100 matrix_.scale( scalar );
2114 template<
typename MT
2116 template<
typename Other >
2117 inline StrictlyLowerMatrix<MT,SO,false>&
2118 StrictlyLowerMatrix<MT,SO,false>::scaleDiagonal(
const Other& scalar )
2120 matrix_.scaleDiagonal( scalar );
2145 template<
typename MT
2176 template<
typename MT
2178 template<
typename Other >
2179 inline bool StrictlyLowerMatrix<MT,SO,false>::canAlias(
const Other* alias )
const noexcept
2181 return matrix_.canAlias( alias );
2198 template<
typename MT
2200 template<
typename Other >
2201 inline bool StrictlyLowerMatrix<MT,SO,false>::isAliased(
const Other* alias )
const noexcept
2203 return matrix_.isAliased( alias );
2220 template<
typename MT
2222 inline bool StrictlyLowerMatrix<MT,SO,false>::canSMPAssign() const noexcept
2224 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:79
#define BLAZE_THROW_INVALID_ARGUMENT(MESSAGE)
Macro for the emission of a std::invalid_argument exception.This macro encapsulates the default way o...
Definition: Exception.h:235
Header file for auxiliary alias declarations.
Header file for mathematical functions.
bool isStrictlyLower(const DenseMatrix< MT, SO > &dm)
Checks if the given dense matrix is a strictly lower triangular matrix.
Definition: DenseMatrix.h:1238
#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.
BLAZE_ALWAYS_INLINE size_t capacity(const Matrix< MT, SO > &matrix) noexcept
Returns the maximum capacity of the matrix.
Definition: Matrix.h:352
Header file for basic type definitions.
Header file for the implementation of the base template of the StrictlyLowerMatrix.
#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:63
BLAZE_ALWAYS_INLINE T1 & operator/=(SIMDPack< T1 > &lhs, const SIMDPack< T2 > &rhs)
Division assignment operator for the division of two SIMD packs.
Definition: BasicTypes.h:1339
Constraint on the data type.
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:194
Constraint on the data type.
void reset(const DiagonalProxy< MT > &proxy)
Resetting the represented element to the default initial values.
Definition: DiagonalProxy.h:533
const This & CompositeType
Data type for composite expression templates.
Definition: CompressedMatrix.h:2935
void clear(CompressedMatrix< Type, SO > &m)
Clearing the given compressed matrix.
Definition: CompressedMatrix.h:5556
CompressedMatrix< Type, true > This
Type of this CompressedMatrix instance.
Definition: CompressedMatrix.h:2928
#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:79
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:390
BLAZE_ALWAYS_INLINE T1 & operator*=(SIMDPack< T1 > &lhs, const SIMDPack< T2 > &rhs)
Multiplication assignment operator for the multiplication of two SIMD packs.
Definition: BasicTypes.h:1321
Constraint on the data type.
const ElementType_< MT > max(const DenseMatrix< MT, SO > &dm)
Returns the largest element of the dense matrix.
Definition: DenseMatrix.h:1802
CompressedMatrix< Type, false > OppositeType
Result type with opposite storage order for expression template evaluations.
Definition: CompressedMatrix.h:2931
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:304
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:238
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) noexcept
Swapping the contents of two compressed matrices.
Definition: CompressedMatrix.h:5635
bool isIntact(const CompressedMatrix< Type, SO > &m)
Returns whether the invariants of the given compressed matrix are intact.
Definition: CompressedMatrix.h:5618
const Element * ConstIterator
Iterator over constant elements.
Definition: CompressedMatrix.h:2939
#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:79
#define BLAZE_THROW_OUT_OF_RANGE(MESSAGE)
Macro for the emission of a std::out_of_range exception.This macro encapsulates the default way of Bl...
Definition: Exception.h:331
Header file for the Columns type trait.
Constraint on the data type.
BLAZE_ALWAYS_INLINE size_t columns(const Matrix< MT, SO > &matrix) noexcept
Returns the current number of columns of the matrix.
Definition: Matrix.h:336
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:2932
Constraints on the storage order of matrix types.
Header file for the exception macros of the math module.
#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:81
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:544
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:260
Type ElementType
Type of the compressed matrix elements.
Definition: CompressedMatrix.h:2933
const Type & ConstReference
Reference to a constant matrix value.
Definition: CompressedMatrix.h:2937
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:553
Header file for the IsNumeric type trait.
BLAZE_ALWAYS_INLINE const EnableIf_< And< IsIntegral< T >, HasSize< T, 1UL > >, If_< IsSigned< T >, SIMDint8, SIMDuint8 > > set(T value) noexcept
Sets all values in the vector to the given 1-byte integral value.
Definition: Set.h:76
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:79
const Type & ReturnType
Return type for expression template evaluations.
Definition: CompressedMatrix.h:2934
BLAZE_ALWAYS_INLINE T1 & operator+=(SIMDPack< T1 > &lhs, const SIMDPack< T2 > &rhs)
Addition assignment operator for the addition of two SIMD packs.
Definition: BasicTypes.h:1285
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:81
#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:79
Element * Iterator
Iterator over non-constant elements.
Definition: CompressedMatrix.h:2938
Header file for the isDefault shim.
void swap(DiagonalMatrix< MT, SO, DF > &a, DiagonalMatrix< MT, SO, DF > &b) noexcept
Swapping the contents of two matrices.
Definition: DiagonalMatrix.h:267
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:81
BLAZE_ALWAYS_INLINE size_t rows(const Matrix< MT, SO > &matrix) noexcept
Returns the current number of rows of the matrix.
Definition: Matrix.h:320
SparseMatrix< This, true > BaseType
Base type of this CompressedMatrix instance.
Definition: CompressedMatrix.h:2929
#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:61
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:81
This ResultType
Result type for expression template evaluations.
Definition: CompressedMatrix.h:2930
bool isIntact(const DiagonalMatrix< MT, SO, DF > &m)
Returns whether the invariants of the given diagonal matrix are intact.
Definition: DiagonalMatrix.h:249
MatrixAccessProxy< This > Reference
Reference to a non-constant matrix value.
Definition: CompressedMatrix.h:2936
#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:79
BLAZE_ALWAYS_INLINE T1 & operator-=(SIMDPack< T1 > &lhs, const SIMDPack< T2 > &rhs)
Subtraction assignment operator for the subtraction of two SIMD packs.
Definition: BasicTypes.h:1303
#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:112
BLAZE_ALWAYS_INLINE bool isSquare(const Matrix< MT, SO > &matrix) noexcept
Checks if the given matrix is a square matrix.
Definition: Matrix.h:677
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:61