35 #ifndef _BLAZE_MATH_ADAPTORS_LOWERMATRIX_SPARSE_H_ 36 #define _BLAZE_MATH_ADAPTORS_LOWERMATRIX_SPARSE_H_ 100 class LowerMatrix<MT,SO,false>
101 :
public SparseMatrix< LowerMatrix<MT,SO,false>, SO >
105 using OT = OppositeType_t<MT>;
106 using TT = TransposeType_t<MT>;
107 using ET = ElementType_t<MT>;
112 using This = LowerMatrix<MT,SO,false>;
113 using BaseType = SparseMatrix<This,SO>;
114 using ResultType = This;
115 using OppositeType = LowerMatrix<OT,!SO,false>;
116 using TransposeType = UpperMatrix<TT,!SO,false>;
117 using ElementType = ET;
118 using ReturnType = ReturnType_t<MT>;
119 using CompositeType =
const This&;
120 using Reference = LowerProxy<MT>;
121 using ConstReference = ConstReference_t<MT>;
122 using Iterator = Iterator_t<MT>;
123 using ConstIterator = ConstIterator_t<MT>;
129 template<
typename NewType >
132 using Other = LowerMatrix< typename MT::template Rebind<NewType>::Other >;
139 template<
size_t NewM
143 using Other = LowerMatrix< typename MT::template Resize<NewM,NewN>::Other >;
149 static constexpr
bool smpAssignable =
false;
155 explicit inline LowerMatrix();
156 explicit inline LowerMatrix(
size_t n );
157 explicit inline LowerMatrix(
size_t n,
size_t nonzeros );
158 explicit inline LowerMatrix(
size_t n,
const std::vector<size_t>& nonzeros );
159 inline LowerMatrix( initializer_list< initializer_list<ElementType> > list );
161 inline LowerMatrix(
const LowerMatrix& m );
162 inline LowerMatrix( LowerMatrix&& m ) noexcept;
164 template<
typename MT2,
bool SO2 >
165 inline LowerMatrix(
const Matrix<MT2,SO2>& m );
172 ~LowerMatrix() =
default;
179 inline Reference operator()(
size_t i,
size_t j );
180 inline ConstReference operator()(
size_t i,
size_t j )
const;
181 inline Reference at(
size_t i,
size_t j );
182 inline ConstReference at(
size_t i,
size_t j )
const;
183 inline Iterator
begin (
size_t i );
184 inline ConstIterator
begin (
size_t i )
const;
185 inline ConstIterator
cbegin(
size_t i )
const;
186 inline Iterator
end (
size_t i );
187 inline ConstIterator
end (
size_t i )
const;
188 inline ConstIterator
cend (
size_t i )
const;
195 inline LowerMatrix& operator=( initializer_list< initializer_list<ElementType> > list );
197 inline LowerMatrix& operator=(
const LowerMatrix& rhs );
198 inline LowerMatrix& operator=( LowerMatrix&& rhs ) noexcept;
200 template<
typename MT2,
bool SO2 >
201 inline auto operator=(
const Matrix<MT2,SO2>& rhs )
202 -> DisableIf_t< IsComputation_v<MT2>, LowerMatrix& >;
204 template<
typename MT2,
bool SO2 >
205 inline auto operator=(
const Matrix<MT2,SO2>& rhs )
206 -> EnableIf_t< IsComputation_v<MT2>, LowerMatrix& >;
208 template<
typename MT2,
bool SO2 >
209 inline auto operator+=(
const Matrix<MT2,SO2>& rhs )
210 -> DisableIf_t< IsComputation_v<MT2>, LowerMatrix& >;
212 template<
typename MT2,
bool SO2 >
213 inline auto operator+=(
const Matrix<MT2,SO2>& rhs )
214 -> EnableIf_t< IsComputation_v<MT2>, LowerMatrix& >;
216 template<
typename MT2,
bool SO2 >
217 inline auto operator-=(
const Matrix<MT2,SO2>& rhs )
218 -> DisableIf_t< IsComputation_v<MT2>, LowerMatrix& >;
220 template<
typename MT2,
bool SO2 >
221 inline auto operator-=(
const Matrix<MT2,SO2>& rhs )
222 -> EnableIf_t< IsComputation_v<MT2>, LowerMatrix& >;
224 template<
typename MT2,
bool SO2 >
225 inline auto operator%=(
const Matrix<MT2,SO2>& rhs ) -> LowerMatrix&;
232 inline size_t rows() const noexcept;
233 inline
size_t columns() const noexcept;
234 inline
size_t capacity() const noexcept;
235 inline
size_t capacity(
size_t i ) const noexcept;
237 inline
size_t nonZeros(
size_t i ) const;
239 inline
void reset(
size_t i );
241 inline
void resize (
size_t n,
bool preserve=true );
242 inline
void reserve(
size_t nonzeros );
243 inline
void reserve(
size_t i,
size_t nonzeros );
245 inline
void trim(
size_t i );
247 inline
void swap( LowerMatrix& m ) noexcept;
249 static inline constexpr
size_t maxNonZeros() noexcept;
250 static inline constexpr
size_t maxNonZeros(
size_t n ) noexcept;
257 inline Iterator
set (
size_t i,
size_t j, const ElementType& value );
258 inline Iterator insert (
size_t i,
size_t j, const ElementType& value );
259 inline
void append (
size_t i,
size_t j, const ElementType& value,
bool check=false );
260 inline
void finalize(
size_t i );
267 inline
void erase(
size_t i,
size_t j );
268 inline Iterator erase(
size_t i, Iterator pos );
269 inline Iterator erase(
size_t i, Iterator first, Iterator last );
271 template< typename Pred >
272 inline
void erase( Pred predicate );
274 template< typename Pred >
275 inline
void erase(
size_t i, Iterator first, Iterator last, Pred predicate );
282 inline Iterator find (
size_t i,
size_t j );
283 inline ConstIterator find (
size_t i,
size_t j ) const;
284 inline Iterator lowerBound(
size_t i,
size_t j );
285 inline ConstIterator lowerBound(
size_t i,
size_t j ) const;
286 inline Iterator upperBound(
size_t i,
size_t j );
287 inline ConstIterator upperBound(
size_t i,
size_t j ) const;
294 template< typename Other > inline LowerMatrix& scale( const Other& scalar );
301 inline
bool isIntact() const noexcept;
308 template< typename Other > inline
bool canAlias ( const Other* alias ) const noexcept;
309 template< typename Other > inline
bool isAliased( const Other* alias ) const noexcept;
311 inline
bool canSMPAssign() const noexcept;
319 inline
void resetUpper();
331 template<
bool RF, typename MT2,
bool SO2,
bool DF2 >
332 friend
bool isDefault( const LowerMatrix<MT2,SO2,DF2>& m );
334 template< typename MT2,
bool SO2,
bool DF2 >
335 friend MT2& derestrict( LowerMatrix<MT2,SO2,DF2>& m );
372 template< typename MT
374 inline LowerMatrix<MT,SO,false>::LowerMatrix()
391 template<
typename MT
393 inline LowerMatrix<MT,SO,false>::LowerMatrix(
size_t n )
413 template<
typename MT
415 inline LowerMatrix<MT,SO,false>::LowerMatrix(
size_t n,
size_t nonzeros )
416 : matrix_( n, n, nonzeros )
437 template<
typename MT
439 inline LowerMatrix<MT,SO,false>::LowerMatrix(
size_t n,
const std::vector<size_t>& nonzeros )
440 : matrix_( n, n, nonzeros )
474 template<
typename MT
476 inline LowerMatrix<MT,SO,false>::LowerMatrix( initializer_list< initializer_list<ElementType> > list )
495 template<
typename MT
497 inline LowerMatrix<MT,SO,false>::LowerMatrix(
const LowerMatrix& m )
498 : matrix_( m.matrix_ )
513 template<
typename MT
515 inline LowerMatrix<MT,SO,false>::LowerMatrix( LowerMatrix&& m ) noexcept
516 : matrix_( std::move( m.matrix_ ) )
535 template<
typename MT
537 template<
typename MT2
539 inline LowerMatrix<MT,SO,false>::LowerMatrix(
const Matrix<MT2,SO2>& m )
542 if( !IsLower_v<MT2> && !
isLower( matrix_ ) ) {
546 if( !IsLower_v<MT2> )
580 template<
typename MT
582 inline typename LowerMatrix<MT,SO,false>::Reference
583 LowerMatrix<MT,SO,false>::operator()(
size_t i,
size_t j )
588 return Reference( matrix_, i, j );
610 template<
typename MT
612 inline typename LowerMatrix<MT,SO,false>::ConstReference
613 LowerMatrix<MT,SO,false>::operator()(
size_t i,
size_t j )
const 641 template<
typename MT
643 inline typename LowerMatrix<MT,SO,false>::Reference
644 LowerMatrix<MT,SO,false>::at(
size_t i,
size_t j )
675 template<
typename MT
677 inline typename LowerMatrix<MT,SO,false>::ConstReference
678 LowerMatrix<MT,SO,false>::at(
size_t i,
size_t j )
const 704 template<
typename MT
706 inline typename LowerMatrix<MT,SO,false>::Iterator
709 return matrix_.begin(i);
727 template<
typename MT
729 inline typename LowerMatrix<MT,SO,false>::ConstIterator
732 return matrix_.begin(i);
750 template<
typename MT
752 inline typename LowerMatrix<MT,SO,false>::ConstIterator
755 return matrix_.cbegin(i);
773 template<
typename MT
775 inline typename LowerMatrix<MT,SO,false>::Iterator
778 return matrix_.end(i);
796 template<
typename MT
798 inline typename LowerMatrix<MT,SO,false>::ConstIterator
801 return matrix_.end(i);
819 template<
typename MT
821 inline typename LowerMatrix<MT,SO,false>::ConstIterator
824 return matrix_.cend(i);
863 template<
typename MT
865 inline LowerMatrix<MT,SO,false>&
866 LowerMatrix<MT,SO,false>::operator=( initializer_list< initializer_list<ElementType> > list )
868 const InitializerMatrix<ElementType> tmp( list, list.size() );
895 template<
typename MT
897 inline LowerMatrix<MT,SO,false>&
898 LowerMatrix<MT,SO,false>::operator=(
const LowerMatrix& rhs )
900 matrix_ = rhs.matrix_;
918 template<
typename MT
920 inline LowerMatrix<MT,SO,false>&
921 LowerMatrix<MT,SO,false>::operator=( LowerMatrix&& rhs ) noexcept
923 matrix_ = std::move( rhs.matrix_ );
947 template<
typename MT
949 template<
typename MT2
951 inline auto LowerMatrix<MT,SO,false>::operator=(
const Matrix<MT2,SO2>& rhs )
952 -> DisableIf_t< IsComputation_v<MT2>, LowerMatrix& >
954 if( !IsLower_v<MT2> && !
isLower( ~rhs ) ) {
960 if( !IsLower_v<MT2> )
985 template<
typename MT
987 template<
typename MT2
989 inline auto LowerMatrix<MT,SO,false>::operator=(
const Matrix<MT2,SO2>& rhs )
990 -> EnableIf_t< IsComputation_v<MT2>, LowerMatrix& >
992 if( !IsSquare_v<MT2> && !
isSquare( ~rhs ) ) {
996 if( IsLower_v<MT2> ) {
1006 matrix_ = std::move( tmp );
1009 if( !IsLower_v<MT2> )
1034 template<
typename MT
1036 template<
typename MT2
1039 -> DisableIf_t< IsComputation_v<MT2>, LowerMatrix& >
1041 if( !IsLower_v<MT2> && !
isLower( ~rhs ) ) {
1047 if( !IsLower_v<MT2> )
1072 template<
typename MT
1074 template<
typename MT2
1077 -> EnableIf_t< IsComputation_v<MT2>, LowerMatrix& >
1079 if( !IsSquare_v<MT2> && !
isSquare( ~rhs ) ) {
1083 if( IsLower_v<MT2> ) {
1087 const ResultType_t<MT2> tmp( ~rhs );
1096 if( !IsLower_v<MT2> )
1121 template<
typename MT
1123 template<
typename MT2
1126 -> DisableIf_t< IsComputation_v<MT2>, LowerMatrix& >
1128 if( !IsLower_v<MT2> && !
isLower( ~rhs ) ) {
1134 if( !IsLower_v<MT2> )
1159 template<
typename MT
1161 template<
typename MT2
1164 -> EnableIf_t< IsComputation_v<MT2>, LowerMatrix& >
1166 if( !IsSquare_v<MT2> && !
isSquare( ~rhs ) ) {
1170 if( IsLower_v<MT2> ) {
1174 const ResultType_t<MT2> tmp( ~rhs );
1183 if( !IsLower_v<MT2> )
1206 template<
typename MT
1208 template<
typename MT2
1210 inline auto LowerMatrix<MT,SO,false>::operator%=(
const Matrix<MT2,SO2>& rhs )
1213 if( !IsSquare_v<MT2> && !
isSquare( ~rhs ) ) {
1219 if( !IsLower_v<MT2> )
1245 template<
typename MT
1249 return matrix_.rows();
1261 template<
typename MT
1265 return matrix_.columns();
1277 template<
typename MT
1281 return matrix_.capacity();
1299 template<
typename MT
1303 return matrix_.capacity(i);
1315 template<
typename MT
1319 return matrix_.nonZeros();
1337 template<
typename MT
1341 return matrix_.nonZeros(i);
1353 template<
typename MT
1376 template<
typename MT
1394 template<
typename MT
1421 template<
typename MT
1429 matrix_.resize( n, n, preserve );
1446 template<
typename MT
1448 inline void LowerMatrix<MT,SO,false>::reserve(
size_t nonzeros )
1450 matrix_.reserve( nonzeros );
1470 template<
typename MT
1472 inline void LowerMatrix<MT,SO,false>::reserve(
size_t i,
size_t nonzeros )
1474 matrix_.reserve( i, nonzeros );
1491 template<
typename MT
1493 inline void LowerMatrix<MT,SO,false>::trim()
1513 template<
typename MT
1515 inline void LowerMatrix<MT,SO,false>::trim(
size_t i )
1533 template<
typename MT
1537 matrix_.shrinkToFit();
1550 template<
typename MT
1556 swap( matrix_, m.matrix_ );
1573 template<
typename MT
1575 inline constexpr
size_t LowerMatrix<MT,SO,false>::maxNonZeros() noexcept
1579 return maxNonZeros( Size_v<MT,0UL> );
1595 template<
typename MT
1597 inline constexpr
size_t LowerMatrix<MT,SO,false>::maxNonZeros(
size_t n ) noexcept
1599 return ( ( n + 1UL ) * n ) / 2UL;
1611 template<
typename MT
1613 inline void LowerMatrix<MT,SO,false>::resetUpper()
1618 for(
size_t j=1UL; j<
columns(); ++j )
1619 erase( matrix_, j, matrix_.begin( j ), matrix_.lowerBound( j, j ) );
1622 for(
size_t i=0UL; i<
rows(); ++i )
1623 erase( matrix_, i, matrix_.upperBound( i, i ), matrix_.end( i ) );
1654 template<
typename MT
1656 inline typename LowerMatrix<MT,SO,false>::Iterator
1663 return matrix_.set( i, j, value );
1686 template<
typename MT
1688 inline typename LowerMatrix<MT,SO,false>::Iterator
1689 LowerMatrix<MT,SO,false>::insert(
size_t i,
size_t j,
const ElementType& value )
1695 return matrix_.insert( i, j, value );
1751 template<
typename MT
1753 inline void LowerMatrix<MT,SO,false>::append(
size_t i,
size_t j,
const ElementType& value,
bool check )
1759 matrix_.append( i, j, value, check );
1779 template<
typename MT
1781 inline void LowerMatrix<MT,SO,false>::finalize(
size_t i )
1783 matrix_.finalize( i );
1807 template<
typename MT
1809 inline void LowerMatrix<MT,SO,false>::erase(
size_t i,
size_t j )
1813 erase( matrix_, i, j );
1831 template<
typename MT
1833 inline typename LowerMatrix<MT,SO,false>::Iterator
1834 LowerMatrix<MT,SO,false>::erase(
size_t i, Iterator pos )
1838 return erase( matrix_, i, pos );
1857 template<
typename MT
1859 inline typename LowerMatrix<MT,SO,false>::Iterator
1860 LowerMatrix<MT,SO,false>::erase(
size_t i, Iterator first, Iterator last )
1864 return erase( matrix_, i, first, last );
1892 template<
typename MT
1894 template<
typename Pred >
1895 inline void LowerMatrix<MT,SO,false>::erase( Pred predicate )
1899 erase( matrix_, predicate );
1935 template<
typename MT
1937 template<
typename Pred >
1938 inline void LowerMatrix<MT,SO,false>::erase(
size_t i, Iterator first, Iterator last, Pred predicate )
1942 erase( matrix_, i, first, last, predicate );
1974 template<
typename MT
1976 inline typename LowerMatrix<MT,SO,false>::Iterator
1977 LowerMatrix<MT,SO,false>::find(
size_t i,
size_t j )
1979 return matrix_.find( i, j );
2001 template<
typename MT
2003 inline typename LowerMatrix<MT,SO,false>::ConstIterator
2004 LowerMatrix<MT,SO,false>::find(
size_t i,
size_t j )
const 2006 return matrix_.find( i, j );
2028 template<
typename MT
2030 inline typename LowerMatrix<MT,SO,false>::Iterator
2031 LowerMatrix<MT,SO,false>::lowerBound(
size_t i,
size_t j )
2033 return matrix_.lowerBound( i, j );
2055 template<
typename MT
2057 inline typename LowerMatrix<MT,SO,false>::ConstIterator
2058 LowerMatrix<MT,SO,false>::lowerBound(
size_t i,
size_t j )
const 2060 return matrix_.lowerBound( i, j );
2082 template<
typename MT
2084 inline typename LowerMatrix<MT,SO,false>::Iterator
2085 LowerMatrix<MT,SO,false>::upperBound(
size_t i,
size_t j )
2087 return matrix_.upperBound( i, j );
2109 template<
typename MT
2111 inline typename LowerMatrix<MT,SO,false>::ConstIterator
2112 LowerMatrix<MT,SO,false>::upperBound(
size_t i,
size_t j )
const 2114 return matrix_.upperBound( i, j );
2146 template<
typename MT
2148 template<
typename Other >
2149 inline LowerMatrix<MT,SO,false>&
2150 LowerMatrix<MT,SO,false>::scale(
const Other& scalar )
2152 matrix_.scale( scalar );
2177 template<
typename MT
2208 template<
typename MT
2210 template<
typename Other >
2211 inline bool LowerMatrix<MT,SO,false>::canAlias(
const Other* alias )
const noexcept
2213 return matrix_.canAlias( alias );
2230 template<
typename MT
2232 template<
typename Other >
2233 inline bool LowerMatrix<MT,SO,false>::isAliased(
const Other* alias )
const noexcept
2235 return matrix_.isAliased( alias );
2252 template<
typename MT
2254 inline bool LowerMatrix<MT,SO,false>::canSMPAssign() const noexcept
2256 return matrix_.canSMPAssign();
#define BLAZE_CONSTRAINT_MUST_NOT_BE_TRANSFORMATION_TYPE(T)
Constraint on the data type.In case the given data type T is a transformation expression (i....
Definition: Transformation.h:81
#define BLAZE_CONSTRAINT_MUST_NOT_BE_CONST(T)
Constraint on the data type.In case the given data type is a const-qualified type,...
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
Constraint on the data type.
Header file for auxiliary alias declarations.
auto operator-=(DenseMatrix< MT, SO > &mat, ST scalar) -> EnableIf_t< IsNumeric_v< ST >, MT & >
Subtraction assignment operator for the subtraction of a dense matrix and a scalar value ( ).
Definition: DenseMatrix.h:432
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
bool isLower(const DenseMatrix< MT, SO > &dm)
Checks if the given dense matrix is a lower triangular matrix.
Definition: DenseMatrix.h:1793
Constraint on the data type.
#define BLAZE_USER_ASSERT(expr, msg)
Run time assertion macro for user checks.In case of an invalid run time expression,...
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.
#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
#define BLAZE_CONSTRAINT_MUST_NOT_BE_COMPUTATION_TYPE(T)
Constraint on the data type.In case the given data type T is a computational expression (i....
Definition: Computation.h:81
Constraint on the data type.
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
void reset(const DiagonalProxy< MT > &proxy)
Resetting the represented element to the default initial values.
Definition: DiagonalProxy.h:595
void shrinkToFit(Matrix< MT, SO > &matrix)
Requesting the removal of unused capacity.
Definition: Matrix.h:799
Header file for all adaptor forward declarations.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_VOLATILE(T)
Constraint on the data type.In case the given data type is a volatile-qualified type,...
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
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.
Header file for the DisableIf class template.
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,...
Definition: Static.h:61
#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
auto operator+=(DenseMatrix< MT, SO > &mat, ST scalar) -> EnableIf_t< IsNumeric_v< ST >, MT & >
Addition assignment operator for the addition of a dense matrix and a scalar value ( ).
Definition: DenseMatrix.h:370
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:1001
Header file for the IsLower type trait.
Header file for the LowerProxy class.
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
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.
void clear(const DiagonalProxy< MT > &proxy)
Clearing the represented element.
Definition: DiagonalProxy.h:615
#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,...
Definition: Symmetric.h:79
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,...
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:282
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.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_VIEW_TYPE(T)
Constraint on the data type.In case the given data type T is a view type (i.e. a subvector,...
Definition: View.h:81
constexpr size_t rows(const Matrix< MT, SO > &matrix) noexcept
Returns the current number of rows of the matrix.
Definition: Matrix.h:498
#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.
bool isIntact(const DiagonalMatrix< MT, SO, DF > &m)
Returns whether the invariants of the given diagonal matrix are intact.
Definition: DiagonalMatrix.h:264
bool isDefault(const DiagonalProxy< MT > &proxy)
Returns whether the represented element is in default state.
Definition: DiagonalProxy.h:635
#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,...
Definition: Hermitian.h:79
#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 Size type trait.
#define BLAZE_INTERNAL_ASSERT(expr, msg)
Run time assertion macro for internal checks.In case of an invalid run time expression,...
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
Header file for the clear shim.