35 #ifndef _BLAZE_MATH_ADAPTORS_LOWERMATRIX_SPARSE_H_ 36 #define _BLAZE_MATH_ADAPTORS_LOWERMATRIX_SPARSE_H_ 98 class LowerMatrix<MT,SO,false>
99 :
public SparseMatrix< LowerMatrix<MT,SO,false>, SO >
103 using OT = OppositeType_<MT>;
104 using TT = TransposeType_<MT>;
105 using ET = ElementType_<MT>;
110 using This = LowerMatrix<MT,SO,false>;
111 using BaseType = SparseMatrix<This,SO>;
127 template<
typename NewType >
130 using Other = LowerMatrix< typename MT::template Rebind<NewType>::Other >;
137 template<
size_t NewM
141 using Other = LowerMatrix< typename MT::template Resize<NewM,NewN>::Other >;
147 enum :
bool { smpAssignable =
false };
153 explicit inline LowerMatrix();
154 explicit inline LowerMatrix(
size_t n );
155 explicit inline LowerMatrix(
size_t n,
size_t nonzeros );
156 explicit inline LowerMatrix(
size_t n,
const std::vector<size_t>& nonzeros );
157 explicit inline LowerMatrix( initializer_list< initializer_list<ElementType> > list );
159 inline LowerMatrix(
const LowerMatrix& m );
160 inline LowerMatrix( LowerMatrix&& m ) noexcept;
162 template<
typename MT2,
bool SO2 >
163 inline LowerMatrix(
const Matrix<MT2,SO2>& m );
174 inline Reference operator()(
size_t i,
size_t j );
176 inline Reference at(
size_t i,
size_t j );
190 inline LowerMatrix& operator=( initializer_list< initializer_list<ElementType> > list );
192 inline LowerMatrix& operator=(
const LowerMatrix& rhs );
193 inline LowerMatrix& operator=( LowerMatrix&& rhs ) noexcept;
195 template<
typename MT2,
bool SO2 >
196 inline DisableIf_< IsComputation<MT2>, LowerMatrix& > operator=(
const Matrix<MT2,SO2>& rhs );
198 template<
typename MT2,
bool SO2 >
199 inline EnableIf_< IsComputation<MT2>, LowerMatrix& > operator=(
const Matrix<MT2,SO2>& rhs );
201 template<
typename MT2,
bool SO2 >
202 inline DisableIf_< IsComputation<MT2>, LowerMatrix& >
operator+=(
const Matrix<MT2,SO2>& rhs );
204 template<
typename MT2,
bool SO2 >
205 inline EnableIf_< IsComputation<MT2>, LowerMatrix& >
operator+=(
const Matrix<MT2,SO2>& rhs );
207 template<
typename MT2,
bool SO2 >
208 inline DisableIf_< IsComputation<MT2>, LowerMatrix& >
operator-=(
const Matrix<MT2,SO2>& rhs );
210 template<
typename MT2,
bool SO2 >
211 inline EnableIf_< IsComputation<MT2>, LowerMatrix& >
operator-=(
const Matrix<MT2,SO2>& rhs );
213 template<
typename MT2,
bool SO2 >
214 inline LowerMatrix& operator%=(
const Matrix<MT2,SO2>& rhs );
221 inline size_t rows() const noexcept;
222 inline
size_t columns() const noexcept;
223 inline
size_t capacity() const noexcept;
224 inline
size_t capacity(
size_t i ) const noexcept;
226 inline
size_t nonZeros(
size_t i ) const;
228 inline
void reset(
size_t i );
230 inline
void resize (
size_t n,
bool preserve=true );
231 inline
void reserve(
size_t nonzeros );
232 inline
void reserve(
size_t i,
size_t nonzeros );
234 inline
void trim(
size_t i );
236 inline
void swap( LowerMatrix& m ) noexcept;
238 static inline constexpr
size_t maxNonZeros() noexcept;
239 static inline constexpr
size_t maxNonZeros(
size_t n ) noexcept;
248 inline
void append (
size_t i,
size_t j, const
ElementType& value,
bool check=false );
249 inline
void finalize(
size_t i );
256 inline
void erase(
size_t i,
size_t j );
260 template< typename Pred >
261 inline
void erase( Pred predicate );
263 template< typename Pred >
264 inline
void erase(
size_t i,
Iterator first,
Iterator last, Pred predicate );
271 inline
Iterator find (
size_t i,
size_t j );
273 inline
Iterator lowerBound(
size_t i,
size_t j );
275 inline
Iterator upperBound(
size_t i,
size_t j );
283 template< typename Other > inline LowerMatrix& scale( const Other& scalar );
290 inline
bool isIntact() const noexcept;
297 template< typename Other > inline
bool canAlias ( const Other* alias ) const noexcept;
298 template< typename Other > inline
bool isAliased( const Other* alias ) const noexcept;
300 inline
bool canSMPAssign() const noexcept;
308 inline
void resetUpper();
320 template<
bool RF, typename MT2,
bool SO2,
bool DF2 >
321 friend
bool isDefault( const LowerMatrix<MT2,SO2,DF2>& m );
323 template< typename MT2,
bool SO2,
bool DF2 >
324 friend MT2& derestrict( LowerMatrix<MT2,SO2,DF2>& m );
359 template< typename MT
361 inline LowerMatrix<MT,SO,false>::LowerMatrix()
378 template<
typename MT
380 inline LowerMatrix<MT,SO,false>::LowerMatrix(
size_t n )
400 template<
typename MT
402 inline LowerMatrix<MT,SO,false>::LowerMatrix(
size_t n,
size_t nonzeros )
403 : matrix_( n, n, nonzeros )
424 template<
typename MT
426 inline LowerMatrix<MT,SO,false>::LowerMatrix(
size_t n,
const std::vector<size_t>& nonzeros )
427 : matrix_( n, n, nonzeros )
461 template<
typename MT
463 inline LowerMatrix<MT,SO,false>::LowerMatrix( initializer_list< initializer_list<ElementType> > list )
482 template<
typename MT
484 inline LowerMatrix<MT,SO,false>::LowerMatrix(
const LowerMatrix& m )
485 : matrix_( m.matrix_ )
500 template<
typename MT
502 inline LowerMatrix<MT,SO,false>::LowerMatrix( LowerMatrix&& m ) noexcept
503 : matrix_( std::move( m.matrix_ ) )
522 template<
typename MT
524 template<
typename MT2
526 inline LowerMatrix<MT,SO,false>::LowerMatrix(
const Matrix<MT2,SO2>& m )
529 if( !IsLower<MT2>::value && !
isLower( matrix_ ) ) {
533 if( !IsLower<MT2>::value )
567 template<
typename MT
570 LowerMatrix<MT,SO,false>::operator()(
size_t i,
size_t j )
597 template<
typename MT
600 LowerMatrix<MT,SO,false>::operator()(
size_t i,
size_t j )
const 628 template<
typename MT
631 LowerMatrix<MT,SO,false>::at(
size_t i,
size_t j )
662 template<
typename MT
665 LowerMatrix<MT,SO,false>::at(
size_t i,
size_t j )
const 691 template<
typename MT
696 return matrix_.begin(i);
714 template<
typename MT
719 return matrix_.begin(i);
737 template<
typename MT
742 return matrix_.cbegin(i);
760 template<
typename MT
765 return matrix_.end(i);
783 template<
typename MT
788 return matrix_.end(i);
806 template<
typename MT
811 return matrix_.cend(i);
850 template<
typename MT
852 inline LowerMatrix<MT,SO,false>&
853 LowerMatrix<MT,SO,false>::operator=( initializer_list< initializer_list<ElementType> > list )
855 const InitializerMatrix<ElementType> tmp( list, list.size() );
882 template<
typename MT
884 inline LowerMatrix<MT,SO,false>&
885 LowerMatrix<MT,SO,false>::operator=(
const LowerMatrix& rhs )
887 matrix_ = rhs.matrix_;
905 template<
typename MT
907 inline LowerMatrix<MT,SO,false>&
908 LowerMatrix<MT,SO,false>::operator=( LowerMatrix&& rhs ) noexcept
910 matrix_ = std::move( rhs.matrix_ );
934 template<
typename MT
936 template<
typename MT2
938 inline DisableIf_< IsComputation<MT2>, LowerMatrix<MT,SO,false>& >
939 LowerMatrix<MT,SO,false>::operator=(
const Matrix<MT2,SO2>& rhs )
941 if( !IsLower<MT2>::value && !
isLower( ~rhs ) ) {
947 if( !IsLower<MT2>::value )
972 template<
typename MT
974 template<
typename MT2
976 inline EnableIf_< IsComputation<MT2>, LowerMatrix<MT,SO,false>& >
977 LowerMatrix<MT,SO,false>::operator=(
const Matrix<MT2,SO2>& rhs )
979 if( !IsSquare<MT2>::value && !
isSquare( ~rhs ) ) {
983 if( IsLower<MT2>::value ) {
993 matrix_ = std::move( tmp );
996 if( !IsLower<MT2>::value )
1021 template<
typename MT
1023 template<
typename MT2
1025 inline DisableIf_< IsComputation<MT2>, LowerMatrix<MT,SO,false>& >
1028 if( !IsLower<MT2>::value && !
isLower( ~rhs ) ) {
1034 if( !IsLower<MT2>::value )
1059 template<
typename MT
1061 template<
typename MT2
1063 inline EnableIf_< IsComputation<MT2>, LowerMatrix<MT,SO,false>& >
1066 if( !IsSquare<MT2>::value && !
isSquare( ~rhs ) ) {
1070 if( IsLower<MT2>::value ) {
1074 const ResultType_<MT2> tmp( ~rhs );
1083 if( !IsLower<MT2>::value )
1108 template<
typename MT
1110 template<
typename MT2
1112 inline DisableIf_< IsComputation<MT2>, LowerMatrix<MT,SO,false>& >
1115 if( !IsLower<MT2>::value && !
isLower( ~rhs ) ) {
1121 if( !IsLower<MT2>::value )
1146 template<
typename MT
1148 template<
typename MT2
1150 inline EnableIf_< IsComputation<MT2>, LowerMatrix<MT,SO,false>& >
1153 if( !IsSquare<MT2>::value && !
isSquare( ~rhs ) ) {
1157 if( IsLower<MT2>::value ) {
1161 const ResultType_<MT2> tmp( ~rhs );
1170 if( !IsLower<MT2>::value )
1193 template<
typename MT
1195 template<
typename MT2
1197 inline LowerMatrix<MT,SO,false>&
1198 LowerMatrix<MT,SO,false>::operator%=(
const Matrix<MT2,SO2>& rhs )
1200 if( !IsSquare<MT2>::value && !
isSquare( ~rhs ) ) {
1206 if( !IsLower<MT2>::value )
1232 template<
typename MT
1236 return matrix_.rows();
1248 template<
typename MT
1252 return matrix_.columns();
1264 template<
typename MT
1268 return matrix_.capacity();
1286 template<
typename MT
1290 return matrix_.capacity(i);
1302 template<
typename MT
1306 return matrix_.nonZeros();
1324 template<
typename MT
1328 return matrix_.nonZeros(i);
1340 template<
typename MT
1363 template<
typename MT
1381 template<
typename MT
1408 template<
typename MT
1416 matrix_.resize( n, n, preserve );
1433 template<
typename MT
1435 inline void LowerMatrix<MT,SO,false>::reserve(
size_t nonzeros )
1437 matrix_.reserve( nonzeros );
1457 template<
typename MT
1459 inline void LowerMatrix<MT,SO,false>::reserve(
size_t i,
size_t nonzeros )
1461 matrix_.reserve( i, nonzeros );
1478 template<
typename MT
1480 inline void LowerMatrix<MT,SO,false>::trim()
1500 template<
typename MT
1502 inline void LowerMatrix<MT,SO,false>::trim(
size_t i )
1520 template<
typename MT
1524 matrix_.shrinkToFit();
1537 template<
typename MT
1543 swap( matrix_, m.matrix_ );
1560 template<
typename MT
1562 inline constexpr
size_t LowerMatrix<MT,SO,false>::maxNonZeros() noexcept
1566 return maxNonZeros( Size<MT,0UL>::value );
1582 template<
typename MT
1584 inline constexpr
size_t LowerMatrix<MT,SO,false>::maxNonZeros(
size_t n ) noexcept
1586 return ( ( n + 1UL ) * n ) / 2UL;
1598 template<
typename MT
1600 inline void LowerMatrix<MT,SO,false>::resetUpper()
1603 for(
size_t j=1UL; j<
columns(); ++j )
1604 matrix_.erase( j, matrix_.begin( j ), matrix_.lowerBound( j, j ) );
1607 for(
size_t i=0UL; i<
rows(); ++i )
1608 matrix_.erase( i, matrix_.upperBound( i, i ), matrix_.end( i ) );
1639 template<
typename MT
1648 return matrix_.set( i, j, value );
1671 template<
typename MT
1674 LowerMatrix<MT,SO,false>::insert(
size_t i,
size_t j,
const ElementType& value )
1680 return matrix_.insert( i, j, value );
1736 template<
typename MT
1738 inline void LowerMatrix<MT,SO,false>::append(
size_t i,
size_t j,
const ElementType& value,
bool check )
1744 matrix_.append( i, j, value, check );
1764 template<
typename MT
1766 inline void LowerMatrix<MT,SO,false>::finalize(
size_t i )
1768 matrix_.finalize( i );
1792 template<
typename MT
1794 inline void LowerMatrix<MT,SO,false>::erase(
size_t i,
size_t j )
1796 matrix_.erase( i, j );
1814 template<
typename MT
1817 LowerMatrix<MT,SO,false>::erase(
size_t i,
Iterator pos )
1819 return matrix_.erase( i, pos );
1838 template<
typename MT
1843 return matrix_.erase( i, first, last );
1871 template<
typename MT
1873 template<
typename Pred >
1874 inline void LowerMatrix<MT,SO,false>::erase( Pred predicate )
1876 matrix_.erase( predicate );
1912 template<
typename MT
1914 template<
typename Pred >
1915 inline void LowerMatrix<MT,SO,false>::erase(
size_t i,
Iterator first,
Iterator last, Pred predicate )
1917 matrix_.erase( i, first, last, predicate );
1949 template<
typename MT
1952 LowerMatrix<MT,SO,false>::find(
size_t i,
size_t j )
1954 return matrix_.find( i, j );
1976 template<
typename MT
1979 LowerMatrix<MT,SO,false>::find(
size_t i,
size_t j )
const 1981 return matrix_.find( i, j );
2003 template<
typename MT
2006 LowerMatrix<MT,SO,false>::lowerBound(
size_t i,
size_t j )
2008 return matrix_.lowerBound( i, j );
2030 template<
typename MT
2033 LowerMatrix<MT,SO,false>::lowerBound(
size_t i,
size_t j )
const 2035 return matrix_.lowerBound( i, j );
2057 template<
typename MT
2060 LowerMatrix<MT,SO,false>::upperBound(
size_t i,
size_t j )
2062 return matrix_.upperBound( i, j );
2084 template<
typename MT
2087 LowerMatrix<MT,SO,false>::upperBound(
size_t i,
size_t j )
const 2089 return matrix_.upperBound( i, j );
2121 template<
typename MT
2123 template<
typename Other >
2124 inline LowerMatrix<MT,SO,false>&
2125 LowerMatrix<MT,SO,false>::scale(
const Other& scalar )
2127 matrix_.scale( scalar );
2152 template<
typename MT
2183 template<
typename MT
2185 template<
typename Other >
2186 inline bool LowerMatrix<MT,SO,false>::canAlias(
const Other* alias )
const noexcept
2188 return matrix_.canAlias( alias );
2205 template<
typename MT
2207 template<
typename Other >
2208 inline bool LowerMatrix<MT,SO,false>::isAliased(
const Other* alias )
const noexcept
2210 return matrix_.isAliased( alias );
2227 template<
typename MT
2229 inline bool LowerMatrix<MT,SO,false>::canSMPAssign() const noexcept
2231 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.
CompressedMatrix< Type, false > OppositeType
Result type with opposite storage order for expression template evaluations.
Definition: CompressedMatrix.h:3077
bool isLower(const DenseMatrix< MT, SO > &dm)
Checks if the given dense matrix is a lower triangular matrix.
Definition: DenseMatrix.h:1214
#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
BLAZE_ALWAYS_INLINE size_t capacity(const Matrix< MT, SO > &matrix) noexcept
Returns the maximum capacity of the matrix.
Definition: Matrix.h:522
Header file for basic type definitions.
#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
Constraint on the data type.
This ResultType
Result type for expression template evaluations.
Definition: CompressedMatrix.h:3076
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:364
CompressedMatrix< Type, true > This
Type of this CompressedMatrix instance.
Definition: CompressedMatrix.h:3074
Constraint on the data type.
void reset(const DiagonalProxy< MT > &proxy)
Resetting the represented element to the default initial values.
Definition: DiagonalProxy.h:588
BLAZE_ALWAYS_INLINE void shrinkToFit(Matrix< MT, SO > &matrix)
Requesting the removal of unused capacity.
Definition: Matrix.h:775
void clear(CompressedMatrix< Type, SO > &m)
Clearing the given compressed matrix.
Definition: CompressedMatrix.h:5829
CompressedMatrix< Type, false > TransposeType
Transpose type for expression template evaluations.
Definition: CompressedMatrix.h:3078
const Type & ConstReference
Reference to a constant matrix value.
Definition: CompressedMatrix.h:3083
#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:560
Element * Iterator
Iterator over non-constant elements.
Definition: CompressedMatrix.h:3084
Header file for the extended initializer_list functionality.
Constraint on the data type.
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:474
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:408
Constraint on the data type.
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 implementation of a matrix representation of an initializer list.
Header file for the DisableIf class template.
MatrixAccessProxy< This > Reference
Reference to a non-constant matrix value.
Definition: CompressedMatrix.h:3082
Header file for the clear shim.
Namespace of the Blaze C++ math library.
Definition: Blaze.h:58
#define BLAZE_CONSTRAINT_MUST_BE_STATIC_TYPE(T)
Constraint on the data type.In case the given data type T is not a static data type, i.e. a vector or matrix with dimensions fixed at compile time, a compilation error is created.
Definition: Static.h:61
void swap(CompressedMatrix< Type, SO > &a, CompressedMatrix< Type, SO > &b) noexcept
Swapping the contents of two compressed matrices.
Definition: CompressedMatrix.h:5908
bool isIntact(const CompressedMatrix< Type, SO > &m)
Returns whether the invariants of the given compressed matrix are intact.
Definition: CompressedMatrix.h:5891
SparseMatrix< This, true > BaseType
Base type of this CompressedMatrix instance.
Definition: CompressedMatrix.h:3075
#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
Type ElementType
Type of the compressed matrix elements.
Definition: CompressedMatrix.h:3079
#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
const Element * ConstIterator
Iterator over constant elements.
Definition: CompressedMatrix.h:3085
Constraint on the data type.
decltype(auto) decllow(const DenseMatrix< MT, SO > &dm)
Declares the given dense matrix expression dm as lower.
Definition: DMatDeclLowExpr.h:1026
Header file for the IsLower type trait.
Header file for the LowerProxy class.
BLAZE_ALWAYS_INLINE size_t columns(const Matrix< MT, SO > &matrix) noexcept
Returns the current number of columns of the matrix.
Definition: Matrix.h:506
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:714
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:430
Header file for the EnableIf class template.
void clear(const DiagonalProxy< MT > &proxy)
Clearing the represented element.
Definition: DiagonalProxy.h:608
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
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:1357
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
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:272
Constraint on the data type.
Constraint on the data type.
BLAZE_ALWAYS_INLINE size_t rows(const Matrix< MT, SO > &matrix) noexcept
Returns the current number of rows of the matrix.
Definition: Matrix.h:490
const Type & ReturnType
Return type for expression template evaluations.
Definition: CompressedMatrix.h:3080
#define BLAZE_CONSTRAINT_MUST_BE_RESIZABLE_TYPE(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 implementation of the base template of the LowerMatrix.
Header file for the IsComputation type trait class.
const This & CompositeType
Data type for composite expression templates.
Definition: CompressedMatrix.h:3081
#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
bool isIntact(const DiagonalMatrix< MT, SO, DF > &m)
Returns whether the invariants of the given diagonal matrix are intact.
Definition: DiagonalMatrix.h:254
bool isDefault(const DiagonalProxy< MT > &proxy)
Returns whether the represented element is in default state.
Definition: DiagonalProxy.h:628
#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:1375
#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:908
Header file for the Size 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