35 #ifndef _BLAZE_MATH_ADAPTORS_LOWERMATRIX_SPARSE_H_
36 #define _BLAZE_MATH_ADAPTORS_LOWERMATRIX_SPARSE_H_
97 class LowerMatrix<MT,SO,false>
98 :
public SparseMatrix< LowerMatrix<MT,SO,false>, SO >
102 typedef OppositeType_<MT> OT;
103 typedef TransposeType_<MT> TT;
104 typedef ElementType_<MT> ET;
109 typedef LowerMatrix<MT,SO,false>
This;
110 typedef SparseMatrix<This,SO>
BaseType;
126 template<
typename ET >
129 typedef LowerMatrix< typename MT::template Rebind<ET>::Other > Other;
135 enum :
bool { smpAssignable =
false };
141 explicit inline LowerMatrix();
142 explicit inline LowerMatrix(
size_t n );
143 explicit inline LowerMatrix(
size_t n,
size_t nonzeros );
144 explicit inline LowerMatrix(
size_t n,
const std::vector<size_t>& nonzeros );
146 inline LowerMatrix(
const LowerMatrix& m );
147 inline LowerMatrix( LowerMatrix&& m ) noexcept;
149 template< typename MT2,
bool SO2 >
150 inline LowerMatrix( const Matrix<MT2,SO2>& m );
161 inline Reference operator()(
size_t i,
size_t j );
162 inline ConstReference operator()(
size_t i,
size_t j ) const;
163 inline Reference at(
size_t i,
size_t j );
164 inline ConstReference at(
size_t i,
size_t j ) const;
165 inline Iterator
begin (
size_t i );
166 inline ConstIterator
begin (
size_t i ) const;
167 inline ConstIterator
cbegin(
size_t i ) const;
168 inline Iterator
end (
size_t i );
169 inline ConstIterator
end (
size_t i ) const;
170 inline ConstIterator
cend (
size_t i ) const;
177 inline LowerMatrix& operator=( const LowerMatrix& rhs );
178 inline LowerMatrix& operator=( LowerMatrix&& rhs ) noexcept;
180 template< typename MT2,
bool SO2 >
181 inline
DisableIf_< IsComputation<MT2>, LowerMatrix& > operator=( const Matrix<MT2,SO2>& rhs );
183 template< typename MT2,
bool SO2 >
184 inline
EnableIf_< IsComputation<MT2>, LowerMatrix& > operator=( const Matrix<MT2,SO2>& rhs );
186 template< typename MT2,
bool SO2 >
187 inline
DisableIf_< IsComputation<MT2>, LowerMatrix& > operator+=( const Matrix<MT2,SO2>& rhs );
189 template< typename MT2,
bool SO2 >
190 inline
EnableIf_< IsComputation<MT2>, LowerMatrix& > operator+=( const Matrix<MT2,SO2>& rhs );
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 LowerMatrix& operator*=( const Matrix<MT2,SO2>& rhs );
201 template< typename Other >
202 inline
EnableIf_< IsNumeric<Other>, LowerMatrix >& operator*=( Other rhs );
204 template< typename Other >
205 inline
EnableIf_< IsNumeric<Other>, LowerMatrix >& operator/=( Other rhs );
212 inline
size_t rows() const noexcept;
213 inline
size_t columns() const noexcept;
214 inline
size_t capacity() const noexcept;
215 inline
size_t capacity(
size_t i ) const noexcept;
217 inline
size_t nonZeros(
size_t i ) const;
219 inline
void reset(
size_t i );
221 inline Iterator
set(
size_t i,
size_t j, const ElementType& value );
222 inline Iterator insert(
size_t i,
size_t j, const ElementType& value );
223 inline
void erase(
size_t i,
size_t j );
224 inline Iterator erase(
size_t i, Iterator pos );
225 inline Iterator erase(
size_t i, Iterator first, Iterator last );
226 inline
void resize (
size_t n,
bool preserve=true );
227 inline
void reserve(
size_t nonzeros );
228 inline
void reserve(
size_t i,
size_t nonzeros );
230 inline
void trim(
size_t i );
231 template< typename Other > inline LowerMatrix& scale( const Other& scalar );
232 template< typename Other > inline LowerMatrix& scaleDiagonal( Other scale );
233 inline
void swap( LowerMatrix& m ) noexcept;
235 static inline constexpr
size_t maxNonZeros() noexcept;
236 static inline constexpr
size_t maxNonZeros(
size_t n ) noexcept;
243 inline Iterator find (
size_t i,
size_t j );
244 inline ConstIterator find (
size_t i,
size_t j ) const;
245 inline Iterator lowerBound(
size_t i,
size_t j );
246 inline ConstIterator lowerBound(
size_t i,
size_t j ) const;
247 inline Iterator upperBound(
size_t i,
size_t j );
248 inline ConstIterator upperBound(
size_t i,
size_t j ) const;
255 inline
void append (
size_t i,
size_t j, const ElementType& value,
bool check=false );
256 inline
void finalize(
size_t i );
263 inline
bool isIntact() const noexcept;
270 template< typename Other > inline
bool canAlias ( const Other* alias ) const noexcept;
271 template< typename Other > inline
bool isAliased( const Other* alias ) const noexcept;
273 inline
bool canSMPAssign() const noexcept;
281 inline
void resetUpper();
293 template< typename MT2,
bool SO2,
bool DF2 >
294 friend
bool isDefault( const LowerMatrix<MT2,SO2,DF2>& m );
296 template< typename MT2,
bool SO2,
bool DF2 >
297 friend MT2& derestrict( LowerMatrix<MT2,SO2,DF2>& m );
332 template< typename MT
334 inline LowerMatrix<MT,SO,false>::LowerMatrix()
351 template<
typename MT
353 inline LowerMatrix<MT,SO,false>::LowerMatrix(
size_t n )
373 template<
typename MT
375 inline LowerMatrix<MT,SO,false>::LowerMatrix(
size_t n,
size_t nonzeros )
376 : matrix_( n, n, nonzeros )
397 template<
typename MT
399 inline LowerMatrix<MT,SO,false>::LowerMatrix(
size_t n,
const std::vector<size_t>& nonzeros )
400 : matrix_( n, n, nonzeros )
416 template<
typename MT
418 inline LowerMatrix<MT,SO,false>::LowerMatrix(
const LowerMatrix& m )
419 : matrix_( m.matrix_ )
434 template<
typename MT
436 inline LowerMatrix<MT,SO,false>::LowerMatrix( LowerMatrix&& m ) noexcept
437 : matrix_(
std::move( m.matrix_ ) )
456 template<
typename MT
458 template<
typename MT2
460 inline LowerMatrix<MT,SO,false>::LowerMatrix(
const Matrix<MT2,SO2>& m )
463 if( !IsLower<MT2>::value && !
isLower( matrix_ ) ) {
467 if( !IsLower<MT2>::value )
501 template<
typename MT
504 LowerMatrix<MT,SO,false>::operator()(
size_t i,
size_t j )
531 template<
typename MT
534 LowerMatrix<MT,SO,false>::operator()(
size_t i,
size_t j )
const
562 template<
typename MT
565 LowerMatrix<MT,SO,false>::at(
size_t i,
size_t j )
596 template<
typename MT
599 LowerMatrix<MT,SO,false>::at(
size_t i,
size_t j )
const
625 template<
typename MT
630 return matrix_.begin(i);
648 template<
typename MT
653 return matrix_.begin(i);
671 template<
typename MT
676 return matrix_.cbegin(i);
694 template<
typename MT
699 return matrix_.end(i);
717 template<
typename MT
722 return matrix_.end(i);
740 template<
typename MT
745 return matrix_.cend(i);
769 template<
typename MT
771 inline LowerMatrix<MT,SO,false>&
772 LowerMatrix<MT,SO,false>::operator=(
const LowerMatrix& rhs )
774 matrix_ = rhs.matrix_;
792 template<
typename MT
794 inline LowerMatrix<MT,SO,false>&
795 LowerMatrix<MT,SO,false>::operator=( LowerMatrix&& rhs ) noexcept
797 matrix_ = std::move( rhs.matrix_ );
821 template<
typename MT
823 template<
typename MT2
825 inline DisableIf_< IsComputation<MT2>, LowerMatrix<MT,SO,false>& >
826 LowerMatrix<MT,SO,false>::operator=(
const Matrix<MT2,SO2>& rhs )
828 if( !IsLower<MT2>::value && !
isLower( ~rhs ) ) {
834 if( !IsLower<MT2>::value )
859 template<
typename MT
861 template<
typename MT2
863 inline EnableIf_< IsComputation<MT2>, LowerMatrix<MT,SO,false>& >
864 LowerMatrix<MT,SO,false>::operator=(
const Matrix<MT2,SO2>& rhs )
866 if( !IsSquare<MT2>::value && !
isSquare( ~rhs ) ) {
870 if( IsLower<MT2>::value ) {
880 matrix_ = std::move( tmp );
883 if( !IsLower<MT2>::value )
908 template<
typename MT
910 template<
typename MT2
912 inline DisableIf_< IsComputation<MT2>, LowerMatrix<MT,SO,false>& >
915 if( !IsLower<MT2>::value && !
isLower( ~rhs ) ) {
921 if( !IsLower<MT2>::value )
946 template<
typename MT
948 template<
typename MT2
950 inline EnableIf_< IsComputation<MT2>, LowerMatrix<MT,SO,false>& >
953 if( !IsSquare<MT2>::value && !
isSquare( ~rhs ) ) {
957 if( IsLower<MT2>::value ) {
961 const ResultType_<MT2> tmp( ~rhs );
970 if( !IsLower<MT2>::value )
995 template<
typename MT
997 template<
typename MT2
999 inline DisableIf_< IsComputation<MT2>, LowerMatrix<MT,SO,false>& >
1002 if( !IsLower<MT2>::value && !
isLower( ~rhs ) ) {
1008 if( !IsLower<MT2>::value )
1033 template<
typename MT
1035 template<
typename MT2
1037 inline EnableIf_< IsComputation<MT2>, LowerMatrix<MT,SO,false>& >
1040 if( !IsSquare<MT2>::value && !
isSquare( ~rhs ) ) {
1044 if( IsLower<MT2>::value ) {
1048 const ResultType_<MT2> tmp( ~rhs );
1057 if( !IsLower<MT2>::value )
1081 template<
typename MT
1083 template<
typename MT2
1085 inline LowerMatrix<MT,SO,false>&
1088 if( matrix_.rows() != (~rhs).
columns() ) {
1092 MT tmp( matrix_ * ~rhs );
1098 matrix_ = std::move( tmp );
1100 if( !IsLower<MT2>::value )
1120 template<
typename MT
1122 template<
typename Other >
1123 inline EnableIf_< IsNumeric<Other>, LowerMatrix<MT,SO,false> >&
1140 template<
typename MT
1142 template<
typename Other >
1143 inline EnableIf_< IsNumeric<Other>, LowerMatrix<MT,SO,false> >&
1169 template<
typename MT
1173 return matrix_.rows();
1185 template<
typename MT
1189 return matrix_.columns();
1201 template<
typename MT
1205 return matrix_.capacity();
1223 template<
typename MT
1227 return matrix_.capacity(i);
1239 template<
typename MT
1243 return matrix_.nonZeros();
1261 template<
typename MT
1265 return matrix_.nonZeros(i);
1277 template<
typename MT
1300 template<
typename MT
1318 template<
typename MT
1346 template<
typename MT
1355 return matrix_.set( i, j, value );
1378 template<
typename MT
1381 LowerMatrix<MT,SO,false>::insert(
size_t i,
size_t j,
const ElementType& value )
1387 return matrix_.insert( i, j, value );
1403 template<
typename MT
1405 inline void LowerMatrix<MT,SO,false>::erase(
size_t i,
size_t j )
1407 matrix_.erase( i, j );
1425 template<
typename MT
1428 LowerMatrix<MT,SO,false>::erase(
size_t i, Iterator pos )
1430 return matrix_.erase( i, pos );
1449 template<
typename MT
1452 LowerMatrix<MT,SO,false>::erase(
size_t i, Iterator first, Iterator last )
1454 return matrix_.erase( i, first, last );
1475 template<
typename MT
1483 matrix_.resize( n, n, preserve );
1500 template<
typename MT
1502 inline void LowerMatrix<MT,SO,false>::reserve(
size_t nonzeros )
1504 matrix_.reserve( nonzeros );
1524 template<
typename MT
1526 inline void LowerMatrix<MT,SO,false>::reserve(
size_t i,
size_t nonzeros )
1528 matrix_.reserve( i, nonzeros );
1545 template<
typename MT
1547 inline void LowerMatrix<MT,SO,false>::trim()
1567 template<
typename MT
1569 inline void LowerMatrix<MT,SO,false>::trim(
size_t i )
1584 template<
typename MT
1586 template<
typename Other >
1587 inline LowerMatrix<MT,SO,false>&
1588 LowerMatrix<MT,SO,false>::scale(
const Other& scalar )
1590 matrix_.scale( scalar );
1604 template<
typename MT
1606 template<
typename Other >
1607 inline LowerMatrix<MT,SO,false>&
1608 LowerMatrix<MT,SO,false>::scaleDiagonal( Other scalar )
1610 matrix_.scaleDiagonal( scalar );
1624 template<
typename MT
1630 swap( matrix_, m.matrix_ );
1647 template<
typename MT
1649 inline constexpr
size_t LowerMatrix<MT,SO,false>::maxNonZeros() noexcept
1653 return maxNonZeros( Rows<MT>::value );
1669 template<
typename MT
1671 inline constexpr
size_t LowerMatrix<MT,SO,false>::maxNonZeros(
size_t n ) noexcept
1673 return ( ( n + 1UL ) * n ) / 2UL;
1685 template<
typename MT
1687 inline void LowerMatrix<MT,SO,false>::resetUpper()
1690 for(
size_t j=1UL; j<
columns(); ++j )
1691 matrix_.erase( j, matrix_.begin( j ), matrix_.lowerBound( j, j ) );
1694 for(
size_t i=0UL; i<
rows(); ++i )
1695 matrix_.erase( i, matrix_.upperBound( i, i ), matrix_.end( i ) );
1726 template<
typename MT
1729 LowerMatrix<MT,SO,false>::find(
size_t i,
size_t j )
1731 return matrix_.find( i, j );
1753 template<
typename MT
1756 LowerMatrix<MT,SO,false>::find(
size_t i,
size_t j )
const
1758 return matrix_.find( i, j );
1780 template<
typename MT
1783 LowerMatrix<MT,SO,false>::lowerBound(
size_t i,
size_t j )
1785 return matrix_.lowerBound( i, j );
1807 template<
typename MT
1810 LowerMatrix<MT,SO,false>::lowerBound(
size_t i,
size_t j )
const
1812 return matrix_.lowerBound( i, j );
1834 template<
typename MT
1837 LowerMatrix<MT,SO,false>::upperBound(
size_t i,
size_t j )
1839 return matrix_.upperBound( i, j );
1861 template<
typename MT
1864 LowerMatrix<MT,SO,false>::upperBound(
size_t i,
size_t j )
const
1866 return matrix_.upperBound( i, j );
1930 template<
typename MT
1932 inline void LowerMatrix<MT,SO,false>::append(
size_t i,
size_t j,
const ElementType& value,
bool check )
1938 matrix_.append( i, j, value, check );
1958 template<
typename MT
1960 inline void LowerMatrix<MT,SO,false>::finalize(
size_t i )
1962 matrix_.finalize( i );
1986 template<
typename MT
2017 template<
typename MT
2019 template<
typename Other >
2020 inline bool LowerMatrix<MT,SO,false>::canAlias(
const Other* alias )
const noexcept
2022 return matrix_.canAlias( alias );
2039 template<
typename MT
2041 template<
typename Other >
2042 inline bool LowerMatrix<MT,SO,false>::isAliased(
const Other* alias )
const noexcept
2044 return matrix_.isAliased( alias );
2061 template<
typename MT
2063 inline bool LowerMatrix<MT,SO,false>::canSMPAssign() const noexcept
2065 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.
#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:346
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: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:188
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:2643
typename DisableIf< Condition, T >::Type DisableIf_
Auxiliary type for the DisableIf class template.The DisableIf_ alias declaration provides a convenien...
Definition: DisableIf.h:223
void clear(CompressedMatrix< Type, SO > &m)
Clearing the given compressed matrix.
Definition: CompressedMatrix.h:5077
CompressedMatrix< Type, true > This
Type of this CompressedMatrix instance.
Definition: CompressedMatrix.h:2636
#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:384
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.
CompressedMatrix< Type, false > OppositeType
Result type with opposite storage order for expression template evaluations.
Definition: CompressedMatrix.h:2639
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:298
bool isLower(const DenseMatrix< MT, SO > &dm)
Checks if the given dense matrix is a lower triangular matrix.
Definition: DenseMatrix.h:1036
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:232
bool isDefault(const DiagonalProxy< MT > &proxy)
Returns whether the represented element is in default state.
Definition: DiagonalProxy.h:573
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:5148
bool isIntact(const CompressedMatrix< Type, SO > &m)
Returns whether the invariants of the given compressed matrix are intact.
Definition: CompressedMatrix.h:5131
const Element * ConstIterator
Iterator over constant elements.
Definition: CompressedMatrix.h:2647
#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.
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:330
CompressedMatrix< Type, false > TransposeType
Transpose type for expression template evaluations.
Definition: CompressedMatrix.h:2640
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:538
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:254
Type ElementType
Type of the sparse matrix elements.
Definition: CompressedMatrix.h:2641
const Type & ConstReference
Reference to a constant matrix value.
Definition: CompressedMatrix.h:2645
Header file for the EnableIf class template.
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:2642
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:2646
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:258
Constraint on the data type.
Constraint on the data type.
#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
typename EnableIf< Condition, T >::Type EnableIf_
Auxiliary alias declaration for the EnableIf class template.The EnableIf_ alias declaration provides ...
Definition: EnableIf.h:223
BLAZE_ALWAYS_INLINE size_t rows(const Matrix< MT, SO > &matrix) noexcept
Returns the current number of rows of the matrix.
Definition: Matrix.h:314
SparseMatrix< This, true > BaseType
Base type of this CompressedMatrix instance.
Definition: CompressedMatrix.h:2637
#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 implementation of the base template of the LowerMatrix.
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:2638
bool isIntact(const DiagonalMatrix< MT, SO, DF > &m)
Returns whether the invariants of the given diagonal matrix are intact.
Definition: DiagonalMatrix.h:240
MatrixAccessProxy< This > Reference
Reference to a non-constant matrix value.
Definition: CompressedMatrix.h:2644
#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:609
#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