35 #ifndef _BLAZE_MATH_ADAPTORS_STRICTLYLOWERMATRIX_SPARSE_H_ 36 #define _BLAZE_MATH_ADAPTORS_STRICTLYLOWERMATRIX_SPARSE_H_ 100 template<
typename MT
102 class StrictlyLowerMatrix<MT,SO,false>
103 :
public SparseMatrix< StrictlyLowerMatrix<MT,SO,false>, SO >
107 using OT = OppositeType_t<MT>;
108 using TT = TransposeType_t<MT>;
109 using ET = ElementType_t<MT>;
114 using This = StrictlyLowerMatrix<MT,SO,false>;
115 using BaseType = SparseMatrix<This,SO>;
122 using Reference = StrictlyLowerProxy<MT>;
131 template<
typename NewType >
134 using Other = StrictlyLowerMatrix< typename MT::template Rebind<NewType>::Other >;
141 template<
size_t NewM
145 using Other = StrictlyLowerMatrix< typename MT::template Resize<NewM,NewN>::Other >;
157 explicit inline StrictlyLowerMatrix();
158 explicit inline StrictlyLowerMatrix(
size_t n );
159 explicit inline StrictlyLowerMatrix(
size_t n,
size_t nonzeros );
160 explicit inline StrictlyLowerMatrix(
size_t n,
const std::vector<size_t>& nonzeros );
161 explicit inline StrictlyLowerMatrix( initializer_list< initializer_list<ElementType> > list );
163 inline StrictlyLowerMatrix(
const StrictlyLowerMatrix& m );
164 inline StrictlyLowerMatrix( StrictlyLowerMatrix&& m ) noexcept;
166 template<
typename MT2,
bool SO2 >
167 inline StrictlyLowerMatrix(
const Matrix<MT2,SO2>& m );
174 ~StrictlyLowerMatrix() =
default;
181 inline Reference operator()(
size_t i,
size_t j );
183 inline Reference at(
size_t i,
size_t j );
197 inline StrictlyLowerMatrix& operator=( initializer_list< initializer_list<ElementType> > list );
199 inline StrictlyLowerMatrix& operator=(
const StrictlyLowerMatrix& rhs );
200 inline StrictlyLowerMatrix& operator=( StrictlyLowerMatrix&& rhs ) noexcept;
202 template<
typename MT2,
bool SO2 >
203 inline auto operator=(
const Matrix<MT2,SO2>& rhs )
204 -> DisableIf_t< IsComputation_v<MT2>, StrictlyLowerMatrix& >;
206 template<
typename MT2,
bool SO2 >
207 inline auto operator=(
const Matrix<MT2,SO2>& rhs )
208 -> EnableIf_t< IsComputation_v<MT2>, StrictlyLowerMatrix& >;
210 template<
typename MT2,
bool SO2 >
211 inline auto operator+=(
const Matrix<MT2,SO2>& rhs )
212 -> DisableIf_t< IsComputation_v<MT2>, StrictlyLowerMatrix& >;
214 template<
typename MT2,
bool SO2 >
215 inline auto operator+=(
const Matrix<MT2,SO2>& rhs )
216 -> EnableIf_t< IsComputation_v<MT2>, StrictlyLowerMatrix& >;
218 template<
typename MT2,
bool SO2 >
219 inline auto operator-=(
const Matrix<MT2,SO2>& rhs )
220 -> DisableIf_t< IsComputation_v<MT2>, StrictlyLowerMatrix& >;
222 template<
typename MT2,
bool SO2 >
223 inline auto operator-=(
const Matrix<MT2,SO2>& rhs )
224 -> EnableIf_t< IsComputation_v<MT2>, StrictlyLowerMatrix& >;
226 template<
typename MT2,
bool SO2 >
227 inline auto operator%=(
const Matrix<MT2,SO2>& rhs ) -> StrictlyLowerMatrix&;
234 inline size_t rows() const noexcept;
235 inline
size_t columns() const noexcept;
236 inline
size_t capacity() const noexcept;
237 inline
size_t capacity(
size_t i ) const noexcept;
239 inline
size_t nonZeros(
size_t i ) const;
241 inline
void reset(
size_t i );
243 inline
void resize (
size_t n,
bool preserve=true );
244 inline
void reserve(
size_t nonzeros );
245 inline
void reserve(
size_t i,
size_t nonzeros );
247 inline
void trim(
size_t i );
249 inline
void swap( StrictlyLowerMatrix& m ) noexcept;
251 static inline constexpr
size_t maxNonZeros() noexcept;
252 static inline constexpr
size_t maxNonZeros(
size_t n ) noexcept;
261 inline
void append (
size_t i,
size_t j, const
ElementType& value,
bool check=false );
262 inline
void finalize(
size_t i );
269 inline
void erase(
size_t i,
size_t j );
273 template< typename Pred >
274 inline
void erase( Pred predicate );
276 template< typename Pred >
277 inline
void erase(
size_t i,
Iterator first,
Iterator last, Pred predicate );
284 inline
Iterator find (
size_t i,
size_t j );
286 inline
Iterator lowerBound(
size_t i,
size_t j );
288 inline
Iterator upperBound(
size_t i,
size_t j );
296 template< typename Other > inline StrictlyLowerMatrix& scale( const Other& scalar );
303 inline
bool isIntact() const noexcept;
310 template< typename Other > inline
bool canAlias ( const Other* alias ) const noexcept;
311 template< typename Other > inline
bool isAliased( const Other* alias ) const noexcept;
313 inline
bool canSMPAssign() const noexcept;
321 inline
void resetUpper();
333 template< typename MT2,
bool SO2,
bool DF2 >
334 friend MT2& derestrict( StrictlyLowerMatrix<MT2,SO2,DF2>& m );
369 template< typename MT
371 inline StrictlyLowerMatrix<MT,SO,false>::StrictlyLowerMatrix()
388 template<
typename MT
390 inline StrictlyLowerMatrix<MT,SO,false>::StrictlyLowerMatrix(
size_t n )
411 template<
typename MT
413 inline StrictlyLowerMatrix<MT,SO,false>::StrictlyLowerMatrix(
size_t n,
size_t nonzeros )
414 : matrix_( n, n,
max( nonzeros, n ) )
438 template<
typename MT
440 inline StrictlyLowerMatrix<MT,SO,false>::StrictlyLowerMatrix(
size_t n,
const std::vector<size_t>& nonzeros )
441 : matrix_( n, n, nonzeros )
475 template<
typename MT
477 inline StrictlyLowerMatrix<MT,SO,false>::StrictlyLowerMatrix( initializer_list< initializer_list<ElementType> > list )
496 template<
typename MT
498 inline StrictlyLowerMatrix<MT,SO,false>::StrictlyLowerMatrix(
const StrictlyLowerMatrix& m )
499 : matrix_( m.matrix_ )
514 template<
typename MT
516 inline StrictlyLowerMatrix<MT,SO,false>::StrictlyLowerMatrix( StrictlyLowerMatrix&& m ) noexcept
517 : matrix_( std::move( m.matrix_ ) )
537 template<
typename MT
539 template<
typename MT2
541 inline StrictlyLowerMatrix<MT,SO,false>::StrictlyLowerMatrix(
const Matrix<MT2,SO2>& m )
544 if( IsUniTriangular_v<MT2> ||
549 if( !IsStrictlyLower_v<MT2> )
583 template<
typename MT
586 StrictlyLowerMatrix<MT,SO,false>::operator()(
size_t i,
size_t j )
613 template<
typename MT
616 StrictlyLowerMatrix<MT,SO,false>::operator()(
size_t i,
size_t j )
const 644 template<
typename MT
647 StrictlyLowerMatrix<MT,SO,false>::at(
size_t i,
size_t j )
678 template<
typename MT
681 StrictlyLowerMatrix<MT,SO,false>::at(
size_t i,
size_t j )
const 707 template<
typename MT
712 return matrix_.begin(i);
730 template<
typename MT
735 return matrix_.begin(i);
753 template<
typename MT
758 return matrix_.cbegin(i);
776 template<
typename MT
781 return matrix_.end(i);
799 template<
typename MT
804 return matrix_.end(i);
822 template<
typename MT
827 return matrix_.cend(i);
866 template<
typename MT
868 inline StrictlyLowerMatrix<MT,SO,false>&
869 StrictlyLowerMatrix<MT,SO,false>::operator=( initializer_list< initializer_list<ElementType> > list )
871 const InitializerMatrix<ElementType> tmp( list, list.size() );
898 template<
typename MT
900 inline StrictlyLowerMatrix<MT,SO,false>&
901 StrictlyLowerMatrix<MT,SO,false>::operator=(
const StrictlyLowerMatrix& rhs )
903 matrix_ = rhs.matrix_;
921 template<
typename MT
923 inline StrictlyLowerMatrix<MT,SO,false>&
924 StrictlyLowerMatrix<MT,SO,false>::operator=( StrictlyLowerMatrix&& rhs ) noexcept
926 matrix_ = std::move( rhs.matrix_ );
950 template<
typename MT
952 template<
typename MT2
954 inline auto StrictlyLowerMatrix<MT,SO,false>::operator=(
const Matrix<MT2,SO2>& rhs )
955 -> DisableIf_t< IsComputation_v<MT2>, StrictlyLowerMatrix& >
957 if( IsUniTriangular_v<MT2> ||
964 if( !IsStrictlyLower_v<MT2> )
989 template<
typename MT
991 template<
typename MT2
993 inline auto StrictlyLowerMatrix<MT,SO,false>::operator=(
const Matrix<MT2,SO2>& rhs )
994 -> EnableIf_t< IsComputation_v<MT2>, StrictlyLowerMatrix& >
996 if( IsUniTriangular_v<MT2> || ( !IsSquare_v<MT2> && !
isSquare( ~rhs ) ) ) {
1000 if( IsStrictlyLower_v<MT2> ) {
1010 matrix_ = std::move( tmp );
1013 if( !IsStrictlyLower_v<MT2> )
1038 template<
typename MT
1040 template<
typename MT2
1043 -> DisableIf_t< IsComputation_v<MT2>, StrictlyLowerMatrix& >
1045 if( IsUniTriangular_v<MT2> ||
1052 if( !IsStrictlyLower_v<MT2> )
1077 template<
typename MT
1079 template<
typename MT2
1082 -> EnableIf_t< IsComputation_v<MT2>, StrictlyLowerMatrix& >
1084 if( IsUniTriangular_v<MT2> || ( !IsSquare_v<MT2> && !
isSquare( ~rhs ) ) ) {
1088 if( IsStrictlyLower_v<MT2> ) {
1092 const ResultType_t<MT2> tmp( ~rhs );
1101 if( !IsStrictlyLower_v<MT2> )
1126 template<
typename MT
1128 template<
typename MT2
1131 -> DisableIf_t< IsComputation_v<MT2>, StrictlyLowerMatrix& >
1133 if( IsUniTriangular_v<MT2> ||
1140 if( !IsStrictlyLower_v<MT2> )
1165 template<
typename MT
1167 template<
typename MT2
1170 -> EnableIf_t< IsComputation_v<MT2>, StrictlyLowerMatrix& >
1172 if( IsUniTriangular_v<MT2> || ( !IsSquare_v<MT2> && !
isSquare( ~rhs ) ) ) {
1176 if( IsStrictlyLower_v<MT2> ) {
1180 const ResultType_t<MT2> tmp( ~rhs );
1189 if( !IsStrictlyLower_v<MT2> )
1213 template<
typename MT
1215 template<
typename MT2
1217 inline auto StrictlyLowerMatrix<MT,SO,false>::operator%=(
const Matrix<MT2,SO2>& rhs )
1218 -> StrictlyLowerMatrix&
1220 if( !IsSquare_v<MT2> && !
isSquare( ~rhs ) ) {
1226 if( !IsStrictlyLower_v<MT2> )
1252 template<
typename MT
1256 return matrix_.rows();
1268 template<
typename MT
1272 return matrix_.columns();
1284 template<
typename MT
1288 return matrix_.capacity();
1306 template<
typename MT
1310 return matrix_.capacity(i);
1322 template<
typename MT
1326 return matrix_.nonZeros();
1344 template<
typename MT
1348 return matrix_.nonZeros(i);
1360 template<
typename MT
1367 for(
size_t j=0UL; j<
columns(); ++j ) {
1368 erase( matrix_, j, matrix_.lowerBound(j+1UL,j), matrix_.end(j) );
1372 for(
size_t i=1UL; i<
rows(); ++i ) {
1373 erase( matrix_, i, matrix_.begin(i), matrix_.lowerBound(i,i) );
1394 template<
typename MT
1401 erase( matrix_, i, matrix_.lowerBound(i+1UL,i), matrix_.end(i) );
1404 erase( matrix_, i, matrix_.begin(i), matrix_.lowerBound(i,i) );
1419 template<
typename MT
1425 if( IsResizable_v<MT> ) {
1451 template<
typename MT
1459 matrix_.resize( n, n, preserve );
1476 template<
typename MT
1478 inline void StrictlyLowerMatrix<MT,SO,false>::reserve(
size_t nonzeros )
1480 matrix_.reserve( nonzeros );
1501 template<
typename MT
1503 inline void StrictlyLowerMatrix<MT,SO,false>::reserve(
size_t i,
size_t nonzeros )
1505 matrix_.reserve( i, nonzeros );
1522 template<
typename MT
1524 inline void StrictlyLowerMatrix<MT,SO,false>::trim()
1544 template<
typename MT
1546 inline void StrictlyLowerMatrix<MT,SO,false>::trim(
size_t i )
1564 template<
typename MT
1568 matrix_.shrinkToFit();
1581 template<
typename MT
1587 swap( matrix_, m.matrix_ );
1605 template<
typename MT
1607 inline constexpr
size_t StrictlyLowerMatrix<MT,SO,false>::maxNonZeros() noexcept
1611 return maxNonZeros( Size_v<MT,0UL> );
1627 template<
typename MT
1629 inline constexpr
size_t StrictlyLowerMatrix<MT,SO,false>::maxNonZeros(
size_t n ) noexcept
1631 return ( ( n - 1UL ) * n ) / 2UL;
1643 template<
typename MT
1645 inline void StrictlyLowerMatrix<MT,SO,false>::resetUpper()
1650 for(
size_t j=1UL; j<
columns(); ++j )
1651 erase( matrix_, j, matrix_.begin( j ), matrix_.lowerBound( j, j ) );
1654 for(
size_t i=0UL; i<
rows(); ++i )
1655 erase( matrix_, i, matrix_.upperBound( i, i ), matrix_.end( i ) );
1686 template<
typename MT
1695 return matrix_.set( i, j, value );
1718 template<
typename MT
1721 StrictlyLowerMatrix<MT,SO,false>::insert(
size_t i,
size_t j,
const ElementType& value )
1727 return matrix_.insert( i, j, value );
1783 template<
typename MT
1785 inline void StrictlyLowerMatrix<MT,SO,false>::append(
size_t i,
size_t j,
const ElementType& value,
bool check )
1791 matrix_.append( i, j, value, check );
1811 template<
typename MT
1813 inline void StrictlyLowerMatrix<MT,SO,false>::finalize(
size_t i )
1815 matrix_.finalize( i );
1839 template<
typename MT
1841 inline void StrictlyLowerMatrix<MT,SO,false>::erase(
size_t i,
size_t j )
1845 erase( matrix_, i, j );
1863 template<
typename MT
1866 StrictlyLowerMatrix<MT,SO,false>::erase(
size_t i,
Iterator pos )
1870 return erase( matrix_, i, pos );
1890 template<
typename MT
1893 StrictlyLowerMatrix<MT,SO,false>::erase(
size_t i,
Iterator first,
Iterator last )
1897 return erase( matrix_, i, first, last );
1925 template<
typename MT
1927 template<
typename Pred >
1928 inline void StrictlyLowerMatrix<MT,SO,false>::erase( Pred predicate )
1932 erase( matrix_, predicate );
1968 template<
typename MT
1970 template<
typename Pred >
1971 inline void StrictlyLowerMatrix<MT,SO,false>::erase(
size_t i,
Iterator first,
Iterator last, Pred predicate )
1975 erase( matrix_, i, first, last, predicate );
2007 template<
typename MT
2010 StrictlyLowerMatrix<MT,SO,false>::find(
size_t i,
size_t j )
2012 return matrix_.find( i, j );
2034 template<
typename MT
2037 StrictlyLowerMatrix<MT,SO,false>::find(
size_t i,
size_t j )
const 2039 return matrix_.find( i, j );
2061 template<
typename MT
2064 StrictlyLowerMatrix<MT,SO,false>::lowerBound(
size_t i,
size_t j )
2066 return matrix_.lowerBound( i, j );
2088 template<
typename MT
2091 StrictlyLowerMatrix<MT,SO,false>::lowerBound(
size_t i,
size_t j )
const 2093 return matrix_.lowerBound( i, j );
2115 template<
typename MT
2118 StrictlyLowerMatrix<MT,SO,false>::upperBound(
size_t i,
size_t j )
2120 return matrix_.upperBound( i, j );
2142 template<
typename MT
2145 StrictlyLowerMatrix<MT,SO,false>::upperBound(
size_t i,
size_t j )
const 2147 return matrix_.upperBound( i, j );
2179 template<
typename MT
2181 template<
typename Other >
2182 inline StrictlyLowerMatrix<MT,SO,false>&
2183 StrictlyLowerMatrix<MT,SO,false>::scale(
const Other& scalar )
2185 matrix_.scale( scalar );
2210 template<
typename MT
2241 template<
typename MT
2243 template<
typename Other >
2244 inline bool StrictlyLowerMatrix<MT,SO,false>::canAlias(
const Other* alias )
const noexcept
2246 return matrix_.canAlias( alias );
2263 template<
typename MT
2265 template<
typename Other >
2266 inline bool StrictlyLowerMatrix<MT,SO,false>::isAliased(
const Other* alias )
const noexcept
2268 return matrix_.isAliased( alias );
2285 template<
typename MT
2287 inline bool StrictlyLowerMatrix<MT,SO,false>::canSMPAssign() const noexcept
2289 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:3078
bool isStrictlyLower(const DenseMatrix< MT, SO > &dm)
Checks if the given dense matrix is a strictly lower triangular matrix.
Definition: DenseMatrix.h:1179
#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
size_t capacity(const Matrix< MT, SO > &matrix) noexcept
Returns the maximum capacity of the matrix.
Definition: Matrix.h:546
Header file for basic type definitions.
Header file for the implementation of the base template of the StrictlyLowerMatrix.
#define BLAZE_CONSTRAINT_MUST_BE_MATRIX_WITH_STORAGE_ORDER(T, SO)
Constraint on the data type.In case the given data type T is not a dense or sparse matrix type and in...
Definition: StorageOrder.h:63
Constraint on the data type.
This ResultType
Result type for expression template evaluations.
Definition: CompressedMatrix.h:3077
MT::Iterator begin(Matrix< MT, SO > &matrix, size_t i)
Returns an iterator to the first element of row/column i.
Definition: Matrix.h:372
CompressedMatrix< Type, true > This
Type of this CompressedMatrix instance.
Definition: CompressedMatrix.h:3075
Constraint on the data type.
void reset(const DiagonalProxy< MT > &proxy)
Resetting the represented element to the default initial values.
Definition: DiagonalProxy.h:591
static constexpr bool smpAssignable
Compilation flag for SMP assignments.
Definition: CompressedMatrix.h:3113
void shrinkToFit(Matrix< MT, SO > &matrix)
Requesting the removal of unused capacity.
Definition: Matrix.h:799
void clear(CompressedMatrix< Type, SO > &m)
Clearing the given compressed matrix.
Definition: CompressedMatrix.h:5828
CompressedMatrix< Type, false > TransposeType
Transpose type for expression template evaluations.
Definition: CompressedMatrix.h:3079
const Type & ConstReference
Reference to a constant matrix value.
Definition: CompressedMatrix.h:3084
#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
size_t nonZeros(const Matrix< MT, SO > &matrix)
Returns the total number of non-zero elements in the matrix.
Definition: Matrix.h:584
Element * Iterator
Iterator over non-constant elements.
Definition: CompressedMatrix.h:3085
Header file for the extended initializer_list functionality.
Constraint on the data type.
constexpr size_t columns(const Matrix< MT, SO > &matrix) noexcept
Returns the current number of columns of the matrix.
Definition: Matrix.h:514
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:482
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:416
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.
Headerfile for the generic max algorithm.
Header file for the DisableIf class template.
MatrixAccessProxy< This > Reference
Reference to a non-constant matrix value.
Definition: CompressedMatrix.h:3083
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:5907
bool isIntact(const CompressedMatrix< Type, SO > &m)
Returns whether the invariants of the given compressed matrix are intact.
Definition: CompressedMatrix.h:5890
SparseMatrix< This, true > BaseType
Base type of this CompressedMatrix instance.
Definition: CompressedMatrix.h:3076
#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:3080
#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:3086
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:1002
Header file for the SparseElement base class.
Header file for the IsUniTriangular type trait.
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
decltype(auto) max(const DenseMatrix< MT1, SO1 > &lhs, const DenseMatrix< MT2, SO2 > &rhs)
Computes the componentwise maximum of the dense matrices lhs and rhs.
Definition: DMatDMatMapExpr.h:1179
void resize(Matrix< MT, SO > &matrix, size_t rows, size_t columns, bool preserve=true)
Changing the size of the matrix.
Definition: Matrix.h:738
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:438
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:611
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:281
BLAZE_ALWAYS_INLINE const EnableIf_t< IsIntegral_v< T > &&HasSize_v< T, 1UL >, If_t< IsSigned_v< T >, SIMDint8, SIMDuint8 > > set(T value) noexcept
Sets all values in the vector to the given 1-byte integral value.
Definition: Set.h:75
Constraint on the data type.
Constraint on the data type.
Header file for the StrictlyLowerProxy class.
constexpr size_t rows(const Matrix< MT, SO > &matrix) noexcept
Returns the current number of rows of the matrix.
Definition: Matrix.h:498
const Type & ReturnType
Return type for expression template evaluations.
Definition: CompressedMatrix.h:3081
#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 IsComputation type trait class.
const This & CompositeType
Data type for composite expression templates.
Definition: CompressedMatrix.h:3082
#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:263
#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
bool isSquare(const Matrix< MT, SO > &matrix) noexcept
Checks if the given matrix is a square matrix.
Definition: Matrix.h:951
Header file for the IsResizable type trait.
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
constexpr ptrdiff_t Size_v
Auxiliary variable template for the Size type trait.The Size_v variable template provides a convenien...
Definition: Size.h:176
Header file for the clear shim.