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 );
158 inline LowerMatrix(
const LowerMatrix& m );
159 inline LowerMatrix( LowerMatrix&& m ) noexcept;
161 template<
typename MT2,
bool SO2 >
162 inline LowerMatrix(
const Matrix<MT2,SO2>& m );
173 inline Reference operator()(
size_t i,
size_t j );
175 inline Reference at(
size_t i,
size_t j );
189 inline LowerMatrix& operator=(
const LowerMatrix& rhs );
190 inline LowerMatrix& operator=( LowerMatrix&& rhs ) noexcept;
192 template<
typename MT2,
bool SO2 >
193 inline DisableIf_< IsComputation<MT2>, LowerMatrix& > operator=(
const Matrix<MT2,SO2>& rhs );
195 template<
typename MT2,
bool SO2 >
196 inline EnableIf_< IsComputation<MT2>, LowerMatrix& > operator=(
const Matrix<MT2,SO2>& rhs );
198 template<
typename MT2,
bool SO2 >
199 inline DisableIf_< IsComputation<MT2>, LowerMatrix& >
operator+=(
const Matrix<MT2,SO2>& rhs );
201 template<
typename MT2,
bool SO2 >
202 inline EnableIf_< IsComputation<MT2>, LowerMatrix& >
operator+=(
const Matrix<MT2,SO2>& rhs );
204 template<
typename MT2,
bool SO2 >
205 inline DisableIf_< IsComputation<MT2>, LowerMatrix& >
operator-=(
const Matrix<MT2,SO2>& rhs );
207 template<
typename MT2,
bool SO2 >
208 inline EnableIf_< IsComputation<MT2>, LowerMatrix& >
operator-=(
const Matrix<MT2,SO2>& rhs );
210 template<
typename MT2,
bool SO2 >
211 inline LowerMatrix& operator%=(
const Matrix<MT2,SO2>& rhs );
213 template<
typename MT2,
bool SO2 >
214 inline LowerMatrix&
operator*=(
const Matrix<MT2,SO2>& rhs );
216 template<
typename Other >
217 inline EnableIf_< IsNumeric<Other>, LowerMatrix >&
operator*=( Other rhs );
219 template<
typename Other >
220 inline EnableIf_< IsNumeric<Other>, LowerMatrix >&
operator/=( Other rhs );
227 inline size_t rows() const noexcept;
228 inline
size_t columns() const noexcept;
229 inline
size_t capacity() const noexcept;
230 inline
size_t capacity(
size_t i ) const noexcept;
232 inline
size_t nonZeros(
size_t i ) const;
234 inline
void reset(
size_t i );
236 inline
void resize (
size_t n,
bool preserve=true );
237 inline
void reserve(
size_t nonzeros );
238 inline
void reserve(
size_t i,
size_t nonzeros );
240 inline
void trim(
size_t i );
242 inline
void swap( LowerMatrix& m ) noexcept;
244 static inline constexpr
size_t maxNonZeros() noexcept;
245 static inline constexpr
size_t maxNonZeros(
size_t n ) noexcept;
254 inline
void append (
size_t i,
size_t j, const
ElementType& value,
bool check=false );
255 inline
void finalize(
size_t i );
262 inline
void erase(
size_t i,
size_t j );
266 template< typename Pred >
267 inline
void erase( Pred predicate );
269 template< typename Pred >
270 inline
void erase(
size_t i,
Iterator first,
Iterator last, Pred predicate );
277 inline
Iterator find (
size_t i,
size_t j );
279 inline
Iterator lowerBound(
size_t i,
size_t j );
281 inline
Iterator upperBound(
size_t i,
size_t j );
289 template< typename Other > inline LowerMatrix& scale( const Other& scalar );
290 template< typename Other > inline LowerMatrix& scaleDiagonal( const Other& scale );
297 inline
bool isIntact() const noexcept;
304 template< typename Other > inline
bool canAlias ( const Other* alias ) const noexcept;
305 template< typename Other > inline
bool isAliased( const Other* alias ) const noexcept;
307 inline
bool canSMPAssign() const noexcept;
315 inline
void resetUpper();
327 template<
bool RF, typename MT2,
bool SO2,
bool DF2 >
328 friend
bool isDefault( const LowerMatrix<MT2,SO2,DF2>& m );
330 template< typename MT2,
bool SO2,
bool DF2 >
331 friend MT2& derestrict( LowerMatrix<MT2,SO2,DF2>& m );
366 template< typename MT
368 inline LowerMatrix<MT,SO,false>::LowerMatrix()
385 template<
typename MT
387 inline LowerMatrix<MT,SO,false>::LowerMatrix(
size_t n )
407 template<
typename MT
409 inline LowerMatrix<MT,SO,false>::LowerMatrix(
size_t n,
size_t nonzeros )
410 : matrix_( n, n, nonzeros )
431 template<
typename MT
433 inline LowerMatrix<MT,SO,false>::LowerMatrix(
size_t n,
const std::vector<size_t>& nonzeros )
434 : matrix_( n, n, nonzeros )
450 template<
typename MT
452 inline LowerMatrix<MT,SO,false>::LowerMatrix(
const LowerMatrix& m )
453 : matrix_( m.matrix_ )
468 template<
typename MT
470 inline LowerMatrix<MT,SO,false>::LowerMatrix( LowerMatrix&& m ) noexcept
471 : matrix_( std::move( m.matrix_ ) )
490 template<
typename MT
492 template<
typename MT2
494 inline LowerMatrix<MT,SO,false>::LowerMatrix(
const Matrix<MT2,SO2>& m )
497 if( !IsLower<MT2>::value && !
isLower( matrix_ ) ) {
501 if( !IsLower<MT2>::value )
535 template<
typename MT
538 LowerMatrix<MT,SO,false>::operator()(
size_t i,
size_t j )
565 template<
typename MT
568 LowerMatrix<MT,SO,false>::operator()(
size_t i,
size_t j )
const 596 template<
typename MT
599 LowerMatrix<MT,SO,false>::at(
size_t i,
size_t j )
630 template<
typename MT
633 LowerMatrix<MT,SO,false>::at(
size_t i,
size_t j )
const 659 template<
typename MT
664 return matrix_.begin(i);
682 template<
typename MT
687 return matrix_.begin(i);
705 template<
typename MT
710 return matrix_.cbegin(i);
728 template<
typename MT
733 return matrix_.end(i);
751 template<
typename MT
756 return matrix_.end(i);
774 template<
typename MT
779 return matrix_.cend(i);
803 template<
typename MT
805 inline LowerMatrix<MT,SO,false>&
806 LowerMatrix<MT,SO,false>::operator=(
const LowerMatrix& rhs )
808 matrix_ = rhs.matrix_;
826 template<
typename MT
828 inline LowerMatrix<MT,SO,false>&
829 LowerMatrix<MT,SO,false>::operator=( LowerMatrix&& rhs ) noexcept
831 matrix_ = std::move( rhs.matrix_ );
855 template<
typename MT
857 template<
typename MT2
859 inline DisableIf_< IsComputation<MT2>, LowerMatrix<MT,SO,false>& >
860 LowerMatrix<MT,SO,false>::operator=(
const Matrix<MT2,SO2>& rhs )
862 if( !IsLower<MT2>::value && !
isLower( ~rhs ) ) {
868 if( !IsLower<MT2>::value )
893 template<
typename MT
895 template<
typename MT2
897 inline EnableIf_< IsComputation<MT2>, LowerMatrix<MT,SO,false>& >
898 LowerMatrix<MT,SO,false>::operator=(
const Matrix<MT2,SO2>& rhs )
900 if( !IsSquare<MT2>::value && !
isSquare( ~rhs ) ) {
904 if( IsLower<MT2>::value ) {
914 matrix_ = std::move( tmp );
917 if( !IsLower<MT2>::value )
942 template<
typename MT
944 template<
typename MT2
946 inline DisableIf_< IsComputation<MT2>, LowerMatrix<MT,SO,false>& >
949 if( !IsLower<MT2>::value && !
isLower( ~rhs ) ) {
955 if( !IsLower<MT2>::value )
980 template<
typename MT
982 template<
typename MT2
984 inline EnableIf_< IsComputation<MT2>, LowerMatrix<MT,SO,false>& >
987 if( !IsSquare<MT2>::value && !
isSquare( ~rhs ) ) {
991 if( IsLower<MT2>::value ) {
995 const ResultType_<MT2> tmp( ~rhs );
1004 if( !IsLower<MT2>::value )
1029 template<
typename MT
1031 template<
typename MT2
1033 inline DisableIf_< IsComputation<MT2>, LowerMatrix<MT,SO,false>& >
1036 if( !IsLower<MT2>::value && !
isLower( ~rhs ) ) {
1042 if( !IsLower<MT2>::value )
1067 template<
typename MT
1069 template<
typename MT2
1071 inline EnableIf_< IsComputation<MT2>, LowerMatrix<MT,SO,false>& >
1074 if( !IsSquare<MT2>::value && !
isSquare( ~rhs ) ) {
1078 if( IsLower<MT2>::value ) {
1082 const ResultType_<MT2> tmp( ~rhs );
1091 if( !IsLower<MT2>::value )
1114 template<
typename MT
1116 template<
typename MT2
1118 inline LowerMatrix<MT,SO,false>&
1119 LowerMatrix<MT,SO,false>::operator%=(
const Matrix<MT2,SO2>& rhs )
1121 if( !IsSquare<MT2>::value && !
isSquare( ~rhs ) ) {
1127 if( !IsLower<MT2>::value )
1151 template<
typename MT
1153 template<
typename MT2
1155 inline LowerMatrix<MT,SO,false>&
1158 if( matrix_.rows() != (~rhs).
columns() ) {
1162 MT tmp( matrix_ * ~rhs );
1168 matrix_ = std::move( tmp );
1170 if( !IsLower<MT2>::value )
1190 template<
typename MT
1192 template<
typename Other >
1193 inline EnableIf_< IsNumeric<Other>, LowerMatrix<MT,SO,false> >&
1210 template<
typename MT
1212 template<
typename Other >
1213 inline EnableIf_< IsNumeric<Other>, LowerMatrix<MT,SO,false> >&
1239 template<
typename MT
1243 return matrix_.rows();
1255 template<
typename MT
1259 return matrix_.columns();
1271 template<
typename MT
1275 return matrix_.capacity();
1293 template<
typename MT
1297 return matrix_.capacity(i);
1309 template<
typename MT
1313 return matrix_.nonZeros();
1331 template<
typename MT
1335 return matrix_.nonZeros(i);
1347 template<
typename MT
1370 template<
typename MT
1388 template<
typename MT
1415 template<
typename MT
1423 matrix_.resize( n, n, preserve );
1440 template<
typename MT
1442 inline void LowerMatrix<MT,SO,false>::reserve(
size_t nonzeros )
1444 matrix_.reserve( nonzeros );
1464 template<
typename MT
1466 inline void LowerMatrix<MT,SO,false>::reserve(
size_t i,
size_t nonzeros )
1468 matrix_.reserve( i, nonzeros );
1485 template<
typename MT
1487 inline void LowerMatrix<MT,SO,false>::trim()
1507 template<
typename MT
1509 inline void LowerMatrix<MT,SO,false>::trim(
size_t i )
1527 template<
typename MT
1531 matrix_.shrinkToFit();
1544 template<
typename MT
1550 swap( matrix_, m.matrix_ );
1567 template<
typename MT
1569 inline constexpr
size_t LowerMatrix<MT,SO,false>::maxNonZeros() noexcept
1573 return maxNonZeros( Rows<MT>::value );
1589 template<
typename MT
1591 inline constexpr
size_t LowerMatrix<MT,SO,false>::maxNonZeros(
size_t n ) noexcept
1593 return ( ( n + 1UL ) * n ) / 2UL;
1605 template<
typename MT
1607 inline void LowerMatrix<MT,SO,false>::resetUpper()
1610 for(
size_t j=1UL; j<
columns(); ++j )
1611 matrix_.erase( j, matrix_.begin( j ), matrix_.lowerBound( j, j ) );
1614 for(
size_t i=0UL; i<
rows(); ++i )
1615 matrix_.erase( i, matrix_.upperBound( i, i ), matrix_.end( i ) );
1646 template<
typename MT
1655 return matrix_.set( i, j, value );
1678 template<
typename MT
1681 LowerMatrix<MT,SO,false>::insert(
size_t i,
size_t j,
const ElementType& value )
1687 return matrix_.insert( i, j, value );
1743 template<
typename MT
1745 inline void LowerMatrix<MT,SO,false>::append(
size_t i,
size_t j,
const ElementType& value,
bool check )
1751 matrix_.append( i, j, value, check );
1771 template<
typename MT
1773 inline void LowerMatrix<MT,SO,false>::finalize(
size_t i )
1775 matrix_.finalize( i );
1799 template<
typename MT
1801 inline void LowerMatrix<MT,SO,false>::erase(
size_t i,
size_t j )
1803 matrix_.erase( i, j );
1821 template<
typename MT
1824 LowerMatrix<MT,SO,false>::erase(
size_t i,
Iterator pos )
1826 return matrix_.erase( i, pos );
1845 template<
typename MT
1850 return matrix_.erase( i, first, last );
1878 template<
typename MT
1880 template<
typename Pred >
1881 inline void LowerMatrix<MT,SO,false>::erase( Pred predicate )
1883 matrix_.erase( predicate );
1919 template<
typename MT
1921 template<
typename Pred >
1922 inline void LowerMatrix<MT,SO,false>::erase(
size_t i,
Iterator first,
Iterator last, Pred predicate )
1924 matrix_.erase( i, first, last, predicate );
1956 template<
typename MT
1959 LowerMatrix<MT,SO,false>::find(
size_t i,
size_t j )
1961 return matrix_.find( i, j );
1983 template<
typename MT
1986 LowerMatrix<MT,SO,false>::find(
size_t i,
size_t j )
const 1988 return matrix_.find( i, j );
2010 template<
typename MT
2013 LowerMatrix<MT,SO,false>::lowerBound(
size_t i,
size_t j )
2015 return matrix_.lowerBound( i, j );
2037 template<
typename MT
2040 LowerMatrix<MT,SO,false>::lowerBound(
size_t i,
size_t j )
const 2042 return matrix_.lowerBound( i, j );
2064 template<
typename MT
2067 LowerMatrix<MT,SO,false>::upperBound(
size_t i,
size_t j )
2069 return matrix_.upperBound( i, j );
2091 template<
typename MT
2094 LowerMatrix<MT,SO,false>::upperBound(
size_t i,
size_t j )
const 2096 return matrix_.upperBound( i, j );
2128 template<
typename MT
2130 template<
typename Other >
2131 inline LowerMatrix<MT,SO,false>&
2132 LowerMatrix<MT,SO,false>::scale(
const Other& scalar )
2134 matrix_.scale( scalar );
2151 template<
typename MT
2153 template<
typename Other >
2154 inline LowerMatrix<MT,SO,false>&
2155 LowerMatrix<MT,SO,false>::scaleDiagonal(
const Other& scalar )
2157 matrix_.scaleDiagonal( scalar );
2182 template<
typename MT
2213 template<
typename MT
2215 template<
typename Other >
2216 inline bool LowerMatrix<MT,SO,false>::canAlias(
const Other* alias )
const noexcept
2218 return matrix_.canAlias( alias );
2235 template<
typename MT
2237 template<
typename Other >
2238 inline bool LowerMatrix<MT,SO,false>::isAliased(
const Other* alias )
const noexcept
2240 return matrix_.isAliased( alias );
2257 template<
typename MT
2259 inline bool LowerMatrix<MT,SO,false>::canSMPAssign() const noexcept
2261 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:3079
bool isLower(const DenseMatrix< MT, SO > &dm)
Checks if the given dense matrix is a lower triangular matrix.
Definition: DenseMatrix.h:1073
#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:356
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
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:1411
Constraint on the data type.
This ResultType
Result type for expression template evaluations.
Definition: CompressedMatrix.h:3078
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:198
CompressedMatrix< Type, true > This
Type of this CompressedMatrix instance.
Definition: CompressedMatrix.h:3076
Constraint on the data type.
void reset(const DiagonalProxy< MT > &proxy)
Resetting the represented element to the default initial values.
Definition: DiagonalProxy.h:560
BLAZE_ALWAYS_INLINE void shrinkToFit(Matrix< MT, SO > &matrix)
Requesting the removal of unused capacity.
Definition: Matrix.h:609
void clear(CompressedMatrix< Type, SO > &m)
Clearing the given compressed matrix.
Definition: CompressedMatrix.h:5845
CompressedMatrix< Type, false > TransposeType
Transpose type for expression template evaluations.
Definition: CompressedMatrix.h:3080
const Type & ConstReference
Reference to a constant matrix value.
Definition: CompressedMatrix.h:3085
#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:394
Element * Iterator
Iterator over non-constant elements.
Definition: CompressedMatrix.h:3086
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:1393
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:308
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:242
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 DisableIf class template.
MatrixAccessProxy< This > Reference
Reference to a non-constant matrix value.
Definition: CompressedMatrix.h:3084
Header file for the clear shim.
Namespace of the Blaze C++ math library.
Definition: Blaze.h:57
#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:5924
bool isIntact(const CompressedMatrix< Type, SO > &m)
Returns whether the invariants of the given compressed matrix are intact.
Definition: CompressedMatrix.h:5907
SparseMatrix< This, true > BaseType
Base type of this CompressedMatrix instance.
Definition: CompressedMatrix.h:3077
#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:3081
#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.
const Element * ConstIterator
Iterator over constant elements.
Definition: CompressedMatrix.h:3087
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:1027
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:340
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:548
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:264
Header file for the EnableIf class template.
void clear(const DiagonalProxy< MT > &proxy)
Clearing the represented element.
Definition: DiagonalProxy.h:580
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
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:270
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:324
const Type & ReturnType
Return type for expression template evaluations.
Definition: CompressedMatrix.h:3082
#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:3083
#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:252
bool isDefault(const DiagonalProxy< MT > &proxy)
Returns whether the represented element is in default state.
Definition: DiagonalProxy.h:600
#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:742
#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