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_<MT>;
108 using TT = TransposeType_<MT>;
109 using ET = ElementType_<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 >;
151 enum :
bool { smpAssignable =
false };
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 );
178 inline Reference operator()(
size_t i,
size_t j );
180 inline Reference at(
size_t i,
size_t j );
194 inline StrictlyLowerMatrix& operator=( initializer_list< initializer_list<ElementType> > list );
196 inline StrictlyLowerMatrix& operator=(
const StrictlyLowerMatrix& rhs );
197 inline StrictlyLowerMatrix& operator=( StrictlyLowerMatrix&& rhs ) noexcept;
199 template<
typename MT2,
bool SO2 >
200 inline DisableIf_< IsComputation<MT2>, StrictlyLowerMatrix& >
201 operator=(
const Matrix<MT2,SO2>& rhs );
203 template<
typename MT2,
bool SO2 >
204 inline EnableIf_< IsComputation<MT2>, StrictlyLowerMatrix& >
205 operator=(
const Matrix<MT2,SO2>& rhs );
207 template<
typename MT2,
bool SO2 >
208 inline DisableIf_< IsComputation<MT2>, StrictlyLowerMatrix& >
211 template<
typename MT2,
bool SO2 >
212 inline EnableIf_< IsComputation<MT2>, StrictlyLowerMatrix& >
215 template<
typename MT2,
bool SO2 >
216 inline DisableIf_< IsComputation<MT2>, StrictlyLowerMatrix& >
219 template<
typename MT2,
bool SO2 >
220 inline EnableIf_< IsComputation<MT2>, StrictlyLowerMatrix& >
223 template<
typename MT2,
bool SO2 >
224 inline StrictlyLowerMatrix& operator%=(
const Matrix<MT2,SO2>& rhs );
231 inline size_t rows() const noexcept;
232 inline
size_t columns() const noexcept;
233 inline
size_t capacity() const noexcept;
234 inline
size_t capacity(
size_t i ) const noexcept;
236 inline
size_t nonZeros(
size_t i ) const;
238 inline
void reset(
size_t i );
240 inline
void resize (
size_t n,
bool preserve=true );
241 inline
void reserve(
size_t nonzeros );
242 inline
void reserve(
size_t i,
size_t nonzeros );
244 inline
void trim(
size_t i );
246 inline
void swap( StrictlyLowerMatrix& m ) noexcept;
248 static inline constexpr
size_t maxNonZeros() noexcept;
249 static inline constexpr
size_t maxNonZeros(
size_t n ) noexcept;
258 inline
void append (
size_t i,
size_t j, const
ElementType& value,
bool check=false );
259 inline
void finalize(
size_t i );
266 inline
void erase(
size_t i,
size_t j );
270 template< typename Pred >
271 inline
void erase( Pred predicate );
273 template< typename Pred >
274 inline
void erase(
size_t i,
Iterator first,
Iterator last, Pred predicate );
281 inline
Iterator find (
size_t i,
size_t j );
283 inline
Iterator lowerBound(
size_t i,
size_t j );
285 inline
Iterator upperBound(
size_t i,
size_t j );
293 template< typename Other > inline StrictlyLowerMatrix& scale( const Other& scalar );
300 inline
bool isIntact() const noexcept;
307 template< typename Other > inline
bool canAlias ( const Other* alias ) const noexcept;
308 template< typename Other > inline
bool isAliased( const Other* alias ) const noexcept;
310 inline
bool canSMPAssign() const noexcept;
318 inline
void resetUpper();
330 template< typename MT2,
bool SO2,
bool DF2 >
331 friend MT2& derestrict( StrictlyLowerMatrix<MT2,SO2,DF2>& m );
366 template< typename MT
368 inline StrictlyLowerMatrix<MT,SO,false>::StrictlyLowerMatrix()
385 template<
typename MT
387 inline StrictlyLowerMatrix<MT,SO,false>::StrictlyLowerMatrix(
size_t n )
408 template<
typename MT
410 inline StrictlyLowerMatrix<MT,SO,false>::StrictlyLowerMatrix(
size_t n,
size_t nonzeros )
411 : matrix_( n, n,
max( nonzeros, n ) )
435 template<
typename MT
437 inline StrictlyLowerMatrix<MT,SO,false>::StrictlyLowerMatrix(
size_t n,
const std::vector<size_t>& nonzeros )
438 : matrix_( n, n, nonzeros )
472 template<
typename MT
474 inline StrictlyLowerMatrix<MT,SO,false>::StrictlyLowerMatrix( initializer_list< initializer_list<ElementType> > list )
493 template<
typename MT
495 inline StrictlyLowerMatrix<MT,SO,false>::StrictlyLowerMatrix(
const StrictlyLowerMatrix& m )
496 : matrix_( m.matrix_ )
511 template<
typename MT
513 inline StrictlyLowerMatrix<MT,SO,false>::StrictlyLowerMatrix( StrictlyLowerMatrix&& m ) noexcept
514 : matrix_( std::move( m.matrix_ ) )
534 template<
typename MT
536 template<
typename MT2
538 inline StrictlyLowerMatrix<MT,SO,false>::StrictlyLowerMatrix(
const Matrix<MT2,SO2>& m )
541 if( IsUniTriangular<MT2>::value ||
546 if( !IsStrictlyLower<MT2>::value )
580 template<
typename MT
583 StrictlyLowerMatrix<MT,SO,false>::operator()(
size_t i,
size_t j )
610 template<
typename MT
613 StrictlyLowerMatrix<MT,SO,false>::operator()(
size_t i,
size_t j )
const 641 template<
typename MT
644 StrictlyLowerMatrix<MT,SO,false>::at(
size_t i,
size_t j )
675 template<
typename MT
678 StrictlyLowerMatrix<MT,SO,false>::at(
size_t i,
size_t j )
const 704 template<
typename MT
709 return matrix_.begin(i);
727 template<
typename MT
732 return matrix_.begin(i);
750 template<
typename MT
755 return matrix_.cbegin(i);
773 template<
typename MT
778 return matrix_.end(i);
796 template<
typename MT
801 return matrix_.end(i);
819 template<
typename MT
824 return matrix_.cend(i);
863 template<
typename MT
865 inline StrictlyLowerMatrix<MT,SO,false>&
866 StrictlyLowerMatrix<MT,SO,false>::operator=( initializer_list< initializer_list<ElementType> > list )
868 const InitializerMatrix<ElementType> tmp( list, list.size() );
895 template<
typename MT
897 inline StrictlyLowerMatrix<MT,SO,false>&
898 StrictlyLowerMatrix<MT,SO,false>::operator=(
const StrictlyLowerMatrix& rhs )
900 matrix_ = rhs.matrix_;
918 template<
typename MT
920 inline StrictlyLowerMatrix<MT,SO,false>&
921 StrictlyLowerMatrix<MT,SO,false>::operator=( StrictlyLowerMatrix&& rhs ) noexcept
923 matrix_ = std::move( rhs.matrix_ );
947 template<
typename MT
949 template<
typename MT2
951 inline DisableIf_< IsComputation<MT2>, StrictlyLowerMatrix<MT,SO,false>& >
952 StrictlyLowerMatrix<MT,SO,false>::operator=(
const Matrix<MT2,SO2>& rhs )
954 if( IsUniTriangular<MT2>::value ||
961 if( !IsStrictlyLower<MT2>::value )
986 template<
typename MT
988 template<
typename MT2
990 inline EnableIf_< IsComputation<MT2>, StrictlyLowerMatrix<MT,SO,false>& >
991 StrictlyLowerMatrix<MT,SO,false>::operator=(
const Matrix<MT2,SO2>& rhs )
993 if( IsUniTriangular<MT2>::value || ( !IsSquare<MT2>::value && !
isSquare( ~rhs ) ) ) {
997 if( IsStrictlyLower<MT2>::value ) {
1007 matrix_ = std::move( tmp );
1010 if( !IsStrictlyLower<MT2>::value )
1035 template<
typename MT
1037 template<
typename MT2
1039 inline DisableIf_< IsComputation<MT2>, StrictlyLowerMatrix<MT,SO,false>& >
1042 if( IsUniTriangular<MT2>::value ||
1049 if( !IsStrictlyLower<MT2>::value )
1074 template<
typename MT
1076 template<
typename MT2
1078 inline EnableIf_< IsComputation<MT2>, StrictlyLowerMatrix<MT,SO,false>& >
1081 if( IsUniTriangular<MT2>::value || ( !IsSquare<MT2>::value && !
isSquare( ~rhs ) ) ) {
1085 if( IsStrictlyLower<MT2>::value ) {
1089 const ResultType_<MT2> tmp( ~rhs );
1098 if( !IsStrictlyLower<MT2>::value )
1123 template<
typename MT
1125 template<
typename MT2
1127 inline DisableIf_< IsComputation<MT2>, StrictlyLowerMatrix<MT,SO,false>& >
1130 if( IsUniTriangular<MT2>::value ||
1137 if( !IsStrictlyLower<MT2>::value )
1162 template<
typename MT
1164 template<
typename MT2
1166 inline EnableIf_< IsComputation<MT2>, StrictlyLowerMatrix<MT,SO,false>& >
1169 if( IsUniTriangular<MT2>::value || ( !IsSquare<MT2>::value && !
isSquare( ~rhs ) ) ) {
1173 if( IsStrictlyLower<MT2>::value ) {
1177 const ResultType_<MT2> tmp( ~rhs );
1186 if( !IsStrictlyLower<MT2>::value )
1210 template<
typename MT
1212 template<
typename MT2
1214 inline StrictlyLowerMatrix<MT,SO,false>&
1215 StrictlyLowerMatrix<MT,SO,false>::operator%=(
const Matrix<MT2,SO2>& rhs )
1217 if( !IsSquare<MT2>::value && !
isSquare( ~rhs ) ) {
1223 if( !IsStrictlyLower<MT2>::value )
1249 template<
typename MT
1253 return matrix_.rows();
1265 template<
typename MT
1269 return matrix_.columns();
1281 template<
typename MT
1285 return matrix_.capacity();
1303 template<
typename MT
1307 return matrix_.capacity(i);
1319 template<
typename MT
1323 return matrix_.nonZeros();
1341 template<
typename MT
1345 return matrix_.nonZeros(i);
1357 template<
typename MT
1362 for(
size_t j=0UL; j<
columns(); ++j ) {
1363 matrix_.erase( j, matrix_.lowerBound(j+1UL,j), matrix_.end(j) );
1367 for(
size_t i=1UL; i<
rows(); ++i ) {
1368 matrix_.erase( i, matrix_.begin(i), matrix_.lowerBound(i,i) );
1389 template<
typename MT
1394 matrix_.erase( i, matrix_.lowerBound(i+1UL,i), matrix_.end(i) );
1397 matrix_.erase( i, matrix_.begin(i), matrix_.lowerBound(i,i) );
1412 template<
typename MT
1418 if( IsResizable<MT>::value ) {
1444 template<
typename MT
1452 matrix_.resize( n, n, preserve );
1469 template<
typename MT
1471 inline void StrictlyLowerMatrix<MT,SO,false>::reserve(
size_t nonzeros )
1473 matrix_.reserve( nonzeros );
1494 template<
typename MT
1496 inline void StrictlyLowerMatrix<MT,SO,false>::reserve(
size_t i,
size_t nonzeros )
1498 matrix_.reserve( i, nonzeros );
1515 template<
typename MT
1517 inline void StrictlyLowerMatrix<MT,SO,false>::trim()
1537 template<
typename MT
1539 inline void StrictlyLowerMatrix<MT,SO,false>::trim(
size_t i )
1557 template<
typename MT
1561 matrix_.shrinkToFit();
1574 template<
typename MT
1580 swap( matrix_, m.matrix_ );
1598 template<
typename MT
1600 inline constexpr
size_t StrictlyLowerMatrix<MT,SO,false>::maxNonZeros() noexcept
1604 return maxNonZeros( Size<MT,0UL>::value );
1620 template<
typename MT
1622 inline constexpr
size_t StrictlyLowerMatrix<MT,SO,false>::maxNonZeros(
size_t n ) noexcept
1624 return ( ( n - 1UL ) * n ) / 2UL;
1636 template<
typename MT
1638 inline void StrictlyLowerMatrix<MT,SO,false>::resetUpper()
1641 for(
size_t j=1UL; j<
columns(); ++j )
1642 matrix_.erase( j, matrix_.begin( j ), matrix_.lowerBound( j, j ) );
1645 for(
size_t i=0UL; i<
rows(); ++i )
1646 matrix_.erase( i, matrix_.upperBound( i, i ), matrix_.end( i ) );
1677 template<
typename MT
1686 return matrix_.set( i, j, value );
1709 template<
typename MT
1712 StrictlyLowerMatrix<MT,SO,false>::insert(
size_t i,
size_t j,
const ElementType& value )
1718 return matrix_.insert( i, j, value );
1774 template<
typename MT
1776 inline void StrictlyLowerMatrix<MT,SO,false>::append(
size_t i,
size_t j,
const ElementType& value,
bool check )
1782 matrix_.append( i, j, value, check );
1802 template<
typename MT
1804 inline void StrictlyLowerMatrix<MT,SO,false>::finalize(
size_t i )
1806 matrix_.finalize( i );
1830 template<
typename MT
1832 inline void StrictlyLowerMatrix<MT,SO,false>::erase(
size_t i,
size_t j )
1834 matrix_.erase( i, j );
1852 template<
typename MT
1855 StrictlyLowerMatrix<MT,SO,false>::erase(
size_t i,
Iterator pos )
1857 return matrix_.erase( i, pos );
1877 template<
typename MT
1880 StrictlyLowerMatrix<MT,SO,false>::erase(
size_t i,
Iterator first,
Iterator last )
1882 return matrix_.erase( i, first, last );
1910 template<
typename MT
1912 template<
typename Pred >
1913 inline void StrictlyLowerMatrix<MT,SO,false>::erase( Pred predicate )
1915 matrix_.erase( predicate );
1951 template<
typename MT
1953 template<
typename Pred >
1954 inline void StrictlyLowerMatrix<MT,SO,false>::erase(
size_t i,
Iterator first,
Iterator last, Pred predicate )
1956 matrix_.erase( i, first, last, predicate );
1988 template<
typename MT
1991 StrictlyLowerMatrix<MT,SO,false>::find(
size_t i,
size_t j )
1993 return matrix_.find( i, j );
2015 template<
typename MT
2018 StrictlyLowerMatrix<MT,SO,false>::find(
size_t i,
size_t j )
const 2020 return matrix_.find( i, j );
2042 template<
typename MT
2045 StrictlyLowerMatrix<MT,SO,false>::lowerBound(
size_t i,
size_t j )
2047 return matrix_.lowerBound( i, j );
2069 template<
typename MT
2072 StrictlyLowerMatrix<MT,SO,false>::lowerBound(
size_t i,
size_t j )
const 2074 return matrix_.lowerBound( i, j );
2096 template<
typename MT
2099 StrictlyLowerMatrix<MT,SO,false>::upperBound(
size_t i,
size_t j )
2101 return matrix_.upperBound( i, j );
2123 template<
typename MT
2126 StrictlyLowerMatrix<MT,SO,false>::upperBound(
size_t i,
size_t j )
const 2128 return matrix_.upperBound( i, j );
2160 template<
typename MT
2162 template<
typename Other >
2163 inline StrictlyLowerMatrix<MT,SO,false>&
2164 StrictlyLowerMatrix<MT,SO,false>::scale(
const Other& scalar )
2166 matrix_.scale( scalar );
2191 template<
typename MT
2222 template<
typename MT
2224 template<
typename Other >
2225 inline bool StrictlyLowerMatrix<MT,SO,false>::canAlias(
const Other* alias )
const noexcept
2227 return matrix_.canAlias( alias );
2244 template<
typename MT
2246 template<
typename Other >
2247 inline bool StrictlyLowerMatrix<MT,SO,false>::isAliased(
const Other* alias )
const noexcept
2249 return matrix_.isAliased( alias );
2266 template<
typename MT
2268 inline bool StrictlyLowerMatrix<MT,SO,false>::canSMPAssign() const noexcept
2270 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:3077
bool isStrictlyLower(const DenseMatrix< MT, SO > &dm)
Checks if the given dense matrix is a strictly lower triangular matrix.
Definition: DenseMatrix.h:1386
#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
BLAZE_ALWAYS_INLINE size_t capacity(const Matrix< MT, SO > &matrix) noexcept
Returns the maximum capacity of the matrix.
Definition: Matrix.h:522
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:3076
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:364
CompressedMatrix< Type, true > This
Type of this CompressedMatrix instance.
Definition: CompressedMatrix.h:3074
Constraint on the data type.
void reset(const DiagonalProxy< MT > &proxy)
Resetting the represented element to the default initial values.
Definition: DiagonalProxy.h:588
BLAZE_ALWAYS_INLINE void shrinkToFit(Matrix< MT, SO > &matrix)
Requesting the removal of unused capacity.
Definition: Matrix.h:775
void clear(CompressedMatrix< Type, SO > &m)
Clearing the given compressed matrix.
Definition: CompressedMatrix.h:5829
CompressedMatrix< Type, false > TransposeType
Transpose type for expression template evaluations.
Definition: CompressedMatrix.h:3078
const Type & ConstReference
Reference to a constant matrix value.
Definition: CompressedMatrix.h:3083
#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:560
Element * Iterator
Iterator over non-constant elements.
Definition: CompressedMatrix.h:3084
Header file for the extended initializer_list functionality.
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:1950
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:474
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:408
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:3082
Header file for the clear shim.
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:5908
bool isIntact(const CompressedMatrix< Type, SO > &m)
Returns whether the invariants of the given compressed matrix are intact.
Definition: CompressedMatrix.h:5891
SparseMatrix< This, true > BaseType
Base type of this CompressedMatrix instance.
Definition: CompressedMatrix.h:3075
#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:3079
#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:3085
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:1026
BLAZE_ALWAYS_INLINE size_t columns(const Matrix< MT, SO > &matrix) noexcept
Returns the current number of columns of the matrix.
Definition: Matrix.h:506
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
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:714
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:430
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:608
BLAZE_ALWAYS_INLINE const EnableIf_< And< IsIntegral< T >, HasSize< T, 1UL > >, If_< IsSigned< T >, SIMDint8, SIMDuint8 > > set(T value) noexcept
Sets all values in the vector to the given 1-byte integral value.
Definition: Set.h:76
Header file for all adaptor forward declarations.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_SYMMETRIC_MATRIX_TYPE(T)
Constraint on the data type.In case the given data type T is a symmetric matrix type, a compilation error is created.
Definition: Symmetric.h:79
BLAZE_ALWAYS_INLINE T1 & operator+=(SIMDPack< T1 > &lhs, const SIMDPack< T2 > &rhs)
Addition assignment operator for the addition of two SIMD packs.
Definition: BasicTypes.h:1357
Header file for run time assertion macros.
Constraint on the data type.
Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_LOWER_MATRIX_TYPE(T)
Constraint on the data type.In case the given data type T is a lower triangular matrix type...
Definition: Lower.h:81
#define BLAZE_CONSTRAINT_MUST_NOT_BE_REFERENCE_TYPE(T)
Constraint on the data type.In case the given data type T is not a reference type, a compilation error is created.
Definition: Reference.h:79
Header file for the isDefault shim.
void swap(DiagonalMatrix< MT, SO, DF > &a, DiagonalMatrix< MT, SO, DF > &b) noexcept
Swapping the contents of two matrices.
Definition: DiagonalMatrix.h:272
Constraint on the data type.
Constraint on the data type.
Header file for the StrictlyLowerProxy class.
BLAZE_ALWAYS_INLINE size_t rows(const Matrix< MT, SO > &matrix) noexcept
Returns the current number of rows of the matrix.
Definition: Matrix.h:490
const Type & ReturnType
Return type for expression template evaluations.
Definition: CompressedMatrix.h:3080
#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:3081
#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:254
#define BLAZE_CONSTRAINT_MUST_NOT_BE_HERMITIAN_MATRIX_TYPE(T)
Constraint on the data type.In case the given data type T is an Hermitian matrix type, a compilation error is created.
Definition: Hermitian.h:79
BLAZE_ALWAYS_INLINE T1 & operator-=(SIMDPack< T1 > &lhs, const SIMDPack< T2 > &rhs)
Subtraction assignment operator for the subtraction of two SIMD packs.
Definition: BasicTypes.h:1375
#define BLAZE_STATIC_ASSERT(expr)
Compile time assertion macro.In case of an invalid compile time expression, a compilation error is cr...
Definition: StaticAssert.h:112
BLAZE_ALWAYS_INLINE bool isSquare(const Matrix< MT, SO > &matrix) noexcept
Checks if the given matrix is a square matrix.
Definition: Matrix.h:908
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