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 ET >
133 typedef StrictlyLowerMatrix< typename MT::template Rebind<ET>::Other > Other;
139 enum :
bool { smpAssignable =
false };
145 explicit inline StrictlyLowerMatrix();
146 explicit inline StrictlyLowerMatrix(
size_t n );
147 explicit inline StrictlyLowerMatrix(
size_t n,
size_t nonzeros );
148 explicit inline StrictlyLowerMatrix(
size_t n,
const std::vector<size_t>& nonzeros );
150 inline StrictlyLowerMatrix(
const StrictlyLowerMatrix& m );
151 inline StrictlyLowerMatrix( StrictlyLowerMatrix&& m ) noexcept;
153 template< typename MT2,
bool SO2 >
154 inline StrictlyLowerMatrix( const Matrix<MT2,SO2>& m );
165 inline Reference operator()(
size_t i,
size_t j );
166 inline ConstReference operator()(
size_t i,
size_t j ) const;
167 inline Reference at(
size_t i,
size_t j );
168 inline ConstReference at(
size_t i,
size_t j ) const;
169 inline Iterator
begin (
size_t i );
170 inline ConstIterator
begin (
size_t i ) const;
171 inline ConstIterator
cbegin(
size_t i ) const;
172 inline Iterator
end (
size_t i );
173 inline ConstIterator
end (
size_t i ) const;
174 inline ConstIterator
cend (
size_t i ) const;
181 inline StrictlyLowerMatrix& operator=( const StrictlyLowerMatrix& rhs );
182 inline StrictlyLowerMatrix& operator=( StrictlyLowerMatrix&& rhs ) noexcept;
184 template< typename MT2,
bool SO2 >
185 inline
DisableIf_< IsComputation<MT2>, StrictlyLowerMatrix& >
186 operator=( const Matrix<MT2,SO2>& rhs );
188 template< typename MT2,
bool SO2 >
189 inline
EnableIf_< IsComputation<MT2>, StrictlyLowerMatrix& >
190 operator=( const Matrix<MT2,SO2>& rhs );
192 template< typename MT2,
bool SO2 >
193 inline
DisableIf_< IsComputation<MT2>, StrictlyLowerMatrix& >
194 operator+=( const Matrix<MT2,SO2>& rhs );
196 template< typename MT2,
bool SO2 >
197 inline
EnableIf_< IsComputation<MT2>, StrictlyLowerMatrix& >
198 operator+=( const Matrix<MT2,SO2>& rhs );
200 template< typename MT2,
bool SO2 >
201 inline
DisableIf_< IsComputation<MT2>, StrictlyLowerMatrix& >
202 operator-=( const Matrix<MT2,SO2>& rhs );
204 template< typename MT2,
bool SO2 >
205 inline
EnableIf_< IsComputation<MT2>, StrictlyLowerMatrix& >
206 operator-=( const Matrix<MT2,SO2>& rhs );
208 template< typename MT2,
bool SO2 >
209 inline StrictlyLowerMatrix& operator*=( const Matrix<MT2,SO2>& rhs );
211 template< typename Other >
212 inline
EnableIf_< IsNumeric<Other>, StrictlyLowerMatrix >& operator*=( Other rhs );
214 template< typename Other >
215 inline
EnableIf_< IsNumeric<Other>, StrictlyLowerMatrix >& operator/=( Other rhs );
222 inline
size_t rows() const noexcept;
223 inline
size_t columns() const noexcept;
224 inline
size_t capacity() const noexcept;
225 inline
size_t capacity(
size_t i ) const noexcept;
227 inline
size_t nonZeros(
size_t i ) const;
229 inline
void reset(
size_t i );
231 inline Iterator
set(
size_t i,
size_t j, const ElementType& value );
232 inline Iterator insert(
size_t i,
size_t j, const ElementType& value );
233 inline
void erase(
size_t i,
size_t j );
234 inline Iterator erase(
size_t i, Iterator pos );
235 inline Iterator erase(
size_t i, Iterator first, Iterator last );
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 template< typename Other > inline StrictlyLowerMatrix& scale( const Other& scalar );
243 template< typename Other > inline StrictlyLowerMatrix& scaleDiagonal( Other scale );
245 inline
void swap( StrictlyLowerMatrix& m ) noexcept;
247 static inline constexpr
size_t maxNonZeros() noexcept;
248 static inline constexpr
size_t maxNonZeros(
size_t n ) noexcept;
255 inline Iterator find (
size_t i,
size_t j );
256 inline ConstIterator find (
size_t i,
size_t j ) const;
257 inline Iterator lowerBound(
size_t i,
size_t j );
258 inline ConstIterator lowerBound(
size_t i,
size_t j ) const;
259 inline Iterator upperBound(
size_t i,
size_t j );
260 inline ConstIterator upperBound(
size_t i,
size_t j ) const;
267 inline
void append (
size_t i,
size_t j, const ElementType& value,
bool check=false );
268 inline
void finalize(
size_t i );
275 inline
bool isIntact() const noexcept;
282 template< typename Other > inline
bool canAlias ( const Other* alias ) const noexcept;
283 template< typename Other > inline
bool isAliased( const Other* alias ) const noexcept;
285 inline
bool canSMPAssign() const noexcept;
293 inline
void resetUpper();
305 template< typename MT2,
bool SO2,
bool DF2 >
306 friend MT2& derestrict( StrictlyLowerMatrix<MT2,SO2,DF2>& m );
341 template< typename MT
343 inline StrictlyLowerMatrix<MT,SO,false>::StrictlyLowerMatrix()
360 template<
typename MT
362 inline StrictlyLowerMatrix<MT,SO,false>::StrictlyLowerMatrix(
size_t n )
383 template<
typename MT
385 inline StrictlyLowerMatrix<MT,SO,false>::StrictlyLowerMatrix(
size_t n,
size_t nonzeros )
386 : matrix_( n, n,
max( nonzeros, n ) )
410 template<
typename MT
412 inline StrictlyLowerMatrix<MT,SO,false>::StrictlyLowerMatrix(
size_t n,
const std::vector<size_t>& nonzeros )
413 : matrix_( n, n, nonzeros )
429 template<
typename MT
431 inline StrictlyLowerMatrix<MT,SO,false>::StrictlyLowerMatrix(
const StrictlyLowerMatrix& m )
432 : matrix_( m.matrix_ )
447 template<
typename MT
449 inline StrictlyLowerMatrix<MT,SO,false>::StrictlyLowerMatrix( StrictlyLowerMatrix&& m ) noexcept
450 : matrix_(
std::move( m.matrix_ ) )
470 template<
typename MT
472 template<
typename MT2
474 inline StrictlyLowerMatrix<MT,SO,false>::StrictlyLowerMatrix(
const Matrix<MT2,SO2>& m )
477 if( IsUniTriangular<MT2>::value ||
482 if( !IsStrictlyLower<MT2>::value )
516 template<
typename MT
519 StrictlyLowerMatrix<MT,SO,false>::operator()(
size_t i,
size_t j )
546 template<
typename MT
549 StrictlyLowerMatrix<MT,SO,false>::operator()(
size_t i,
size_t j )
const
577 template<
typename MT
580 StrictlyLowerMatrix<MT,SO,false>::at(
size_t i,
size_t j )
611 template<
typename MT
614 StrictlyLowerMatrix<MT,SO,false>::at(
size_t i,
size_t j )
const
640 template<
typename MT
645 return matrix_.begin(i);
663 template<
typename MT
668 return matrix_.begin(i);
686 template<
typename MT
691 return matrix_.cbegin(i);
709 template<
typename MT
714 return matrix_.end(i);
732 template<
typename MT
737 return matrix_.end(i);
755 template<
typename MT
760 return matrix_.cend(i);
784 template<
typename MT
786 inline StrictlyLowerMatrix<MT,SO,false>&
787 StrictlyLowerMatrix<MT,SO,false>::operator=(
const StrictlyLowerMatrix& rhs )
789 matrix_ = rhs.matrix_;
807 template<
typename MT
809 inline StrictlyLowerMatrix<MT,SO,false>&
810 StrictlyLowerMatrix<MT,SO,false>::operator=( StrictlyLowerMatrix&& rhs ) noexcept
812 matrix_ = std::move( rhs.matrix_ );
836 template<
typename MT
838 template<
typename MT2
840 inline DisableIf_< IsComputation<MT2>, StrictlyLowerMatrix<MT,SO,false>& >
841 StrictlyLowerMatrix<MT,SO,false>::operator=(
const Matrix<MT2,SO2>& rhs )
843 if( IsUniTriangular<MT2>::value ||
850 if( !IsStrictlyLower<MT2>::value )
875 template<
typename MT
877 template<
typename MT2
879 inline EnableIf_< IsComputation<MT2>, StrictlyLowerMatrix<MT,SO,false>& >
880 StrictlyLowerMatrix<MT,SO,false>::operator=(
const Matrix<MT2,SO2>& rhs )
882 if( IsUniTriangular<MT2>::value || ( !IsSquare<MT2>::value && !
isSquare( ~rhs ) ) ) {
886 if( IsStrictlyLower<MT2>::value ) {
896 matrix_ = std::move( tmp );
899 if( !IsStrictlyLower<MT2>::value )
924 template<
typename MT
926 template<
typename MT2
928 inline DisableIf_< IsComputation<MT2>, StrictlyLowerMatrix<MT,SO,false>& >
931 if( IsUniTriangular<MT2>::value ||
938 if( !IsStrictlyLower<MT2>::value )
963 template<
typename MT
965 template<
typename MT2
967 inline EnableIf_< IsComputation<MT2>, StrictlyLowerMatrix<MT,SO,false>& >
970 if( IsUniTriangular<MT2>::value || ( !IsSquare<MT2>::value && !
isSquare( ~rhs ) ) ) {
974 if( IsStrictlyLower<MT2>::value ) {
978 const ResultType_<MT2> tmp( ~rhs );
987 if( !IsStrictlyLower<MT2>::value )
1012 template<
typename MT
1014 template<
typename MT2
1016 inline DisableIf_< IsComputation<MT2>, StrictlyLowerMatrix<MT,SO,false>& >
1019 if( IsUniTriangular<MT2>::value ||
1026 if( !IsStrictlyLower<MT2>::value )
1051 template<
typename MT
1053 template<
typename MT2
1055 inline EnableIf_< IsComputation<MT2>, StrictlyLowerMatrix<MT,SO,false>& >
1058 if( IsUniTriangular<MT2>::value || ( !IsSquare<MT2>::value && !
isSquare( ~rhs ) ) ) {
1062 if( IsStrictlyLower<MT2>::value ) {
1066 const ResultType_<MT2> tmp( ~rhs );
1075 if( !IsStrictlyLower<MT2>::value )
1099 template<
typename MT
1101 template<
typename MT2
1103 inline StrictlyLowerMatrix<MT,SO,false>&
1106 if( matrix_.rows() != (~rhs).
columns() ) {
1110 MT tmp( matrix_ * ~rhs );
1116 matrix_ = std::move( tmp );
1118 if( !IsStrictlyLower<MT2>::value )
1138 template<
typename MT
1140 template<
typename Other >
1141 inline EnableIf_< IsNumeric<Other>, StrictlyLowerMatrix<MT,SO,false> >&
1158 template<
typename MT
1160 template<
typename Other >
1161 inline EnableIf_< IsNumeric<Other>, StrictlyLowerMatrix<MT,SO,false> >&
1187 template<
typename MT
1191 return matrix_.rows();
1203 template<
typename MT
1207 return matrix_.columns();
1219 template<
typename MT
1223 return matrix_.capacity();
1241 template<
typename MT
1245 return matrix_.capacity(i);
1257 template<
typename MT
1261 return matrix_.nonZeros();
1279 template<
typename MT
1283 return matrix_.nonZeros(i);
1295 template<
typename MT
1300 for(
size_t j=0UL; j<
columns(); ++j ) {
1301 matrix_.erase( j, matrix_.lowerBound(j+1UL,j), matrix_.end(j) );
1305 for(
size_t i=1UL; i<
rows(); ++i ) {
1306 matrix_.erase( i, matrix_.begin(i), matrix_.lowerBound(i,i) );
1327 template<
typename MT
1332 matrix_.erase( i, matrix_.lowerBound(i+1UL,i), matrix_.end(i) );
1335 matrix_.erase( i, matrix_.begin(i), matrix_.lowerBound(i,i) );
1350 template<
typename MT
1356 if( IsResizable<MT>::value ) {
1383 template<
typename MT
1392 return matrix_.set( i, j, value );
1415 template<
typename MT
1418 StrictlyLowerMatrix<MT,SO,false>::insert(
size_t i,
size_t j,
const ElementType& value )
1424 return matrix_.insert( i, j, value );
1440 template<
typename MT
1442 inline void StrictlyLowerMatrix<MT,SO,false>::erase(
size_t i,
size_t j )
1444 matrix_.erase( i, j );
1462 template<
typename MT
1465 StrictlyLowerMatrix<MT,SO,false>::erase(
size_t i, Iterator pos )
1467 return matrix_.erase( i, pos );
1487 template<
typename MT
1490 StrictlyLowerMatrix<MT,SO,false>::erase(
size_t i, Iterator first, Iterator last )
1492 return matrix_.erase( i, first, last );
1513 template<
typename MT
1521 matrix_.resize( n, n, preserve );
1538 template<
typename MT
1540 inline void StrictlyLowerMatrix<MT,SO,false>::reserve(
size_t nonzeros )
1542 matrix_.reserve( nonzeros );
1563 template<
typename MT
1565 inline void StrictlyLowerMatrix<MT,SO,false>::reserve(
size_t i,
size_t nonzeros )
1567 matrix_.reserve( i, nonzeros );
1584 template<
typename MT
1586 inline void StrictlyLowerMatrix<MT,SO,false>::trim()
1606 template<
typename MT
1608 inline void StrictlyLowerMatrix<MT,SO,false>::trim(
size_t i )
1623 template<
typename MT
1625 template<
typename Other >
1626 inline StrictlyLowerMatrix<MT,SO,false>&
1627 StrictlyLowerMatrix<MT,SO,false>::scale(
const Other& scalar )
1629 matrix_.scale( scalar );
1643 template<
typename MT
1645 template<
typename Other >
1646 inline StrictlyLowerMatrix<MT,SO,false>&
1647 StrictlyLowerMatrix<MT,SO,false>::scaleDiagonal( Other scalar )
1649 matrix_.scaleDiagonal( scalar );
1663 template<
typename MT
1669 swap( matrix_, m.matrix_ );
1687 template<
typename MT
1689 inline constexpr
size_t StrictlyLowerMatrix<MT,SO,false>::maxNonZeros() noexcept
1693 return maxNonZeros( Rows<MT>::value );
1709 template<
typename MT
1711 inline constexpr
size_t StrictlyLowerMatrix<MT,SO,false>::maxNonZeros(
size_t n ) noexcept
1713 return ( ( n - 1UL ) * n ) / 2UL;
1725 template<
typename MT
1727 inline void StrictlyLowerMatrix<MT,SO,false>::resetUpper()
1730 for(
size_t j=1UL; j<
columns(); ++j )
1731 matrix_.erase( j, matrix_.begin( j ), matrix_.lowerBound( j, j ) );
1734 for(
size_t i=0UL; i<
rows(); ++i )
1735 matrix_.erase( i, matrix_.upperBound( i, i ), matrix_.end( i ) );
1766 template<
typename MT
1769 StrictlyLowerMatrix<MT,SO,false>::find(
size_t i,
size_t j )
1771 return matrix_.find( i, j );
1793 template<
typename MT
1796 StrictlyLowerMatrix<MT,SO,false>::find(
size_t i,
size_t j )
const
1798 return matrix_.find( i, j );
1820 template<
typename MT
1823 StrictlyLowerMatrix<MT,SO,false>::lowerBound(
size_t i,
size_t j )
1825 return matrix_.lowerBound( i, j );
1847 template<
typename MT
1850 StrictlyLowerMatrix<MT,SO,false>::lowerBound(
size_t i,
size_t j )
const
1852 return matrix_.lowerBound( i, j );
1874 template<
typename MT
1877 StrictlyLowerMatrix<MT,SO,false>::upperBound(
size_t i,
size_t j )
1879 return matrix_.upperBound( i, j );
1901 template<
typename MT
1904 StrictlyLowerMatrix<MT,SO,false>::upperBound(
size_t i,
size_t j )
const
1906 return matrix_.upperBound( i, j );
1970 template<
typename MT
1972 inline void StrictlyLowerMatrix<MT,SO,false>::append(
size_t i,
size_t j,
const ElementType& value,
bool check )
1978 matrix_.append( i, j, value, check );
1998 template<
typename MT
2000 inline void StrictlyLowerMatrix<MT,SO,false>::finalize(
size_t i )
2002 matrix_.finalize( i );
2026 template<
typename MT
2057 template<
typename MT
2059 template<
typename Other >
2060 inline bool StrictlyLowerMatrix<MT,SO,false>::canAlias(
const Other* alias )
const noexcept
2062 return matrix_.canAlias( alias );
2079 template<
typename MT
2081 template<
typename Other >
2082 inline bool StrictlyLowerMatrix<MT,SO,false>::isAliased(
const Other* alias )
const noexcept
2084 return matrix_.isAliased( alias );
2101 template<
typename MT
2103 inline bool StrictlyLowerMatrix<MT,SO,false>::canSMPAssign() const noexcept
2105 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.
#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.
Header file for the implementation of the base template of the StrictlyLowerMatrix.
bool isStrictlyLower(const DenseMatrix< MT, SO > &dm)
Checks if the given dense matrix is a strictly lower triangular matrix.
Definition: DenseMatrix.h:1192
#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.
const ElementType_< MT > max(const DenseMatrix< MT, SO > &dm)
Returns the largest element of the dense matrix.
Definition: DenseMatrix.h:1716
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
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
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.
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
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: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.
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: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.
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
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 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
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