35 #ifndef _BLAZE_MATH_ADAPTORS_DIAGONALMATRIX_SPARSE_H_ 36 #define _BLAZE_MATH_ADAPTORS_DIAGONALMATRIX_SPARSE_H_ 96 class DiagonalMatrix<MT,SO,false>
97 :
public SparseMatrix< DiagonalMatrix<MT,SO,false>, SO >
101 using OT = OppositeType_<MT>;
102 using TT = TransposeType_<MT>;
103 using ET = ElementType_<MT>;
108 using This = DiagonalMatrix<MT,SO,false>;
109 using BaseType = SparseMatrix<This,SO>;
125 template<
typename NewType >
128 using Other = DiagonalMatrix< typename MT::template Rebind<NewType>::Other >;
135 template<
size_t NewM
139 using Other = DiagonalMatrix< typename MT::template Resize<NewM,NewN>::Other >;
145 enum :
bool { smpAssignable =
false };
151 explicit inline DiagonalMatrix();
152 explicit inline DiagonalMatrix(
size_t n );
153 explicit inline DiagonalMatrix(
size_t n,
size_t nonzeros );
154 explicit inline DiagonalMatrix(
size_t n,
const std::vector<size_t>& nonzeros );
155 explicit inline DiagonalMatrix( initializer_list< initializer_list<ElementType> > list );
157 inline DiagonalMatrix(
const DiagonalMatrix& m );
158 inline DiagonalMatrix( DiagonalMatrix&& m ) noexcept;
160 template<
typename MT2,
bool SO2 >
161 inline DiagonalMatrix(
const Matrix<MT2,SO2>& m );
172 inline Reference operator()(
size_t i,
size_t j );
174 inline Reference at(
size_t i,
size_t j );
188 inline DiagonalMatrix& operator=( initializer_list< initializer_list<ElementType> > list );
190 inline DiagonalMatrix& operator=(
const DiagonalMatrix& rhs );
191 inline DiagonalMatrix& operator=( DiagonalMatrix&& rhs ) noexcept;
193 template<
typename MT2,
bool SO2 >
194 inline DisableIf_< IsComputation<MT2>, DiagonalMatrix& > operator=(
const Matrix<MT2,SO2>& rhs );
196 template<
typename MT2,
bool SO2 >
197 inline EnableIf_< IsComputation<MT2>, DiagonalMatrix& > operator=(
const Matrix<MT2,SO2>& rhs );
199 template<
typename MT2,
bool SO2 >
200 inline DisableIf_< IsComputation<MT2>, DiagonalMatrix& >
operator+=(
const Matrix<MT2,SO2>& rhs );
202 template<
typename MT2,
bool SO2 >
203 inline EnableIf_< IsComputation<MT2>, DiagonalMatrix& >
operator+=(
const Matrix<MT2,SO2>& rhs );
205 template<
typename MT2,
bool SO2 >
206 inline DisableIf_< IsComputation<MT2>, DiagonalMatrix& >
operator-=(
const Matrix<MT2,SO2>& rhs );
208 template<
typename MT2,
bool SO2 >
209 inline EnableIf_< IsComputation<MT2>, DiagonalMatrix& >
operator-=(
const Matrix<MT2,SO2>& rhs );
211 template<
typename MT2,
bool SO2 >
212 inline DiagonalMatrix& operator%=(
const Matrix<MT2,SO2>& rhs );
219 inline size_t rows() const noexcept;
220 inline
size_t columns() const noexcept;
221 inline
size_t capacity() const noexcept;
222 inline
size_t capacity(
size_t i ) const noexcept;
224 inline
size_t nonZeros(
size_t i ) const;
226 inline
void reset(
size_t i );
228 inline
void resize (
size_t n,
bool preserve=true );
229 inline
void reserve(
size_t nonzeros );
230 inline
void reserve(
size_t i,
size_t nonzeros );
232 inline
void trim(
size_t i );
234 inline
void swap( DiagonalMatrix& m ) noexcept;
243 inline
void append (
size_t i,
size_t j, const
ElementType& value,
bool check=false );
244 inline
void finalize(
size_t i );
251 inline
void erase(
size_t i,
size_t j );
255 template< typename Pred >
256 inline
void erase( Pred predicate );
258 template< typename Pred >
259 inline
void erase(
size_t i,
Iterator first,
Iterator last, Pred predicate );
266 inline
Iterator find (
size_t i,
size_t j );
268 inline
Iterator lowerBound(
size_t i,
size_t j );
270 inline
Iterator upperBound(
size_t i,
size_t j );
278 template< typename Other > inline DiagonalMatrix& scale( const Other& scalar );
285 inline
bool isIntact() const noexcept;
292 template< typename Other > inline
bool canAlias ( const Other* alias ) const noexcept;
293 template< typename Other > inline
bool isAliased( const Other* alias ) const noexcept;
295 inline
bool canSMPAssign() const noexcept;
303 inline
void resetNonDiagonal();
315 template<
bool RF, typename MT2,
bool SO2,
bool DF2 >
316 friend
bool isDefault( const DiagonalMatrix<MT2,SO2,DF2>& m );
318 template< typename MT2,
bool SO2,
bool DF2 >
319 friend MT2& derestrict( DiagonalMatrix<MT2,SO2,DF2>& m );
354 template< typename MT
356 inline DiagonalMatrix<MT,SO,false>::DiagonalMatrix()
373 template<
typename MT
375 inline DiagonalMatrix<MT,SO,false>::DiagonalMatrix(
size_t n )
395 template<
typename MT
397 inline DiagonalMatrix<MT,SO,false>::DiagonalMatrix(
size_t n,
size_t nonzeros )
398 : matrix_( n, n, nonzeros )
419 template<
typename MT
421 inline DiagonalMatrix<MT,SO,false>::DiagonalMatrix(
size_t n,
const std::vector<size_t>& nonzeros )
422 : matrix_( n, n, nonzeros )
456 template<
typename MT
458 inline DiagonalMatrix<MT,SO,false>::DiagonalMatrix( initializer_list< initializer_list<ElementType> > list )
477 template<
typename MT
479 inline DiagonalMatrix<MT,SO,false>::DiagonalMatrix(
const DiagonalMatrix& m )
480 : matrix_( m.matrix_ )
495 template<
typename MT
497 inline DiagonalMatrix<MT,SO,false>::DiagonalMatrix( DiagonalMatrix&& m ) noexcept
498 : matrix_( std::move( m.matrix_ ) )
517 template<
typename MT
519 template<
typename MT2
521 inline DiagonalMatrix<MT,SO,false>::DiagonalMatrix(
const Matrix<MT2,SO2>& m )
524 if( !IsDiagonal<MT2>::value && !
isDiagonal( matrix_ ) ) {
528 if( !IsDiagonal<MT2>::value )
562 template<
typename MT
565 DiagonalMatrix<MT,SO,false>::operator()(
size_t i,
size_t j )
592 template<
typename MT
595 DiagonalMatrix<MT,SO,false>::operator()(
size_t i,
size_t j )
const 623 template<
typename MT
626 DiagonalMatrix<MT,SO,false>::at(
size_t i,
size_t j )
657 template<
typename MT
660 DiagonalMatrix<MT,SO,false>::at(
size_t i,
size_t j )
const 686 template<
typename MT
691 return matrix_.begin(i);
709 template<
typename MT
714 return matrix_.begin(i);
732 template<
typename MT
737 return matrix_.cbegin(i);
755 template<
typename MT
760 return matrix_.end(i);
778 template<
typename MT
783 return matrix_.end(i);
801 template<
typename MT
806 return matrix_.cend(i);
845 template<
typename MT
847 inline DiagonalMatrix<MT,SO,false>&
848 DiagonalMatrix<MT,SO,false>::operator=( initializer_list< initializer_list<ElementType> > list )
850 const InitializerMatrix<ElementType> tmp( list, list.size() );
877 template<
typename MT
879 inline DiagonalMatrix<MT,SO,false>&
880 DiagonalMatrix<MT,SO,false>::operator=(
const DiagonalMatrix& rhs )
882 matrix_ = rhs.matrix_;
900 template<
typename MT
902 inline DiagonalMatrix<MT,SO,false>&
903 DiagonalMatrix<MT,SO,false>::operator=( DiagonalMatrix&& rhs ) noexcept
905 matrix_ = std::move( rhs.matrix_ );
929 template<
typename MT
931 template<
typename MT2
933 inline DisableIf_< IsComputation<MT2>, DiagonalMatrix<MT,SO,false>& >
934 DiagonalMatrix<MT,SO,false>::operator=(
const Matrix<MT2,SO2>& rhs )
936 if( !IsDiagonal<MT2>::value && !
isDiagonal( ~rhs ) ) {
942 if( !IsDiagonal<MT2>::value )
967 template<
typename MT
969 template<
typename MT2
971 inline EnableIf_< IsComputation<MT2>, DiagonalMatrix<MT,SO,false>& >
972 DiagonalMatrix<MT,SO,false>::operator=(
const Matrix<MT2,SO2>& rhs )
974 if( !IsSquare<MT2>::value && !
isSquare( ~rhs ) ) {
978 if( IsDiagonal<MT2>::value ) {
988 matrix_ = std::move( tmp );
991 if( !IsDiagonal<MT2>::value )
1016 template<
typename MT
1018 template<
typename MT2
1020 inline DisableIf_< IsComputation<MT2>, DiagonalMatrix<MT,SO,false>& >
1023 if( !IsDiagonal<MT2>::value && !
isDiagonal( ~rhs ) ) {
1029 if( !IsDiagonal<MT2>::value )
1054 template<
typename MT
1056 template<
typename MT2
1058 inline EnableIf_< IsComputation<MT2>, DiagonalMatrix<MT,SO,false>& >
1061 if( !IsSquare<MT2>::value && !
isSquare( ~rhs ) ) {
1065 if( IsDiagonal<MT2>::value ) {
1069 const ResultType_<MT2> tmp( ~rhs );
1078 if( !IsDiagonal<MT2>::value )
1103 template<
typename MT
1105 template<
typename MT2
1107 inline DisableIf_< IsComputation<MT2>, DiagonalMatrix<MT,SO,false>& >
1110 if( !IsDiagonal<MT2>::value && !
isDiagonal( ~rhs ) ) {
1116 if( !IsDiagonal<MT2>::value )
1141 template<
typename MT
1143 template<
typename MT2
1145 inline EnableIf_< IsComputation<MT2>, DiagonalMatrix<MT,SO,false>& >
1148 if( !IsSquare<MT2>::value && !
isSquare( ~rhs ) ) {
1152 if( IsDiagonal<MT2>::value ) {
1156 const ResultType_<MT2> tmp( ~rhs );
1165 if( !IsDiagonal<MT2>::value )
1188 template<
typename MT
1190 template<
typename MT2
1192 inline DiagonalMatrix<MT,SO,false>&
1193 DiagonalMatrix<MT,SO,false>::operator%=(
const Matrix<MT2,SO2>& rhs )
1195 if( !IsSquare<MT2>::value && !
isSquare( ~rhs ) ) {
1201 if( !IsDiagonal<MT2>::value )
1227 template<
typename MT
1231 return matrix_.rows();
1243 template<
typename MT
1247 return matrix_.columns();
1259 template<
typename MT
1263 return matrix_.capacity();
1281 template<
typename MT
1285 return matrix_.capacity(i);
1297 template<
typename MT
1301 return matrix_.nonZeros();
1319 template<
typename MT
1323 return matrix_.nonZeros(i);
1335 template<
typename MT
1358 template<
typename MT
1376 template<
typename MT
1403 template<
typename MT
1411 matrix_.resize( n, n, preserve );
1428 template<
typename MT
1430 inline void DiagonalMatrix<MT,SO,false>::reserve(
size_t nonzeros )
1432 matrix_.reserve( nonzeros );
1452 template<
typename MT
1454 inline void DiagonalMatrix<MT,SO,false>::reserve(
size_t i,
size_t nonzeros )
1456 matrix_.reserve( i, nonzeros );
1473 template<
typename MT
1475 inline void DiagonalMatrix<MT,SO,false>::trim()
1495 template<
typename MT
1497 inline void DiagonalMatrix<MT,SO,false>::trim(
size_t i )
1515 template<
typename MT
1519 matrix_.shrinkToFit();
1532 template<
typename MT
1538 swap( matrix_, m.matrix_ );
1550 template<
typename MT
1552 inline void DiagonalMatrix<MT,SO,false>::resetNonDiagonal()
1554 for(
size_t i=0UL; i<
rows(); ++i ) {
1555 matrix_.erase( i, matrix_.begin( i ), matrix_.lowerBound( i, i ) );
1556 matrix_.erase( i, matrix_.upperBound( i, i ), matrix_.end( i ) );
1587 template<
typename MT
1596 return matrix_.set( i, j, value );
1619 template<
typename MT
1622 DiagonalMatrix<MT,SO,false>::insert(
size_t i,
size_t j,
const ElementType& value )
1628 return matrix_.insert( i, j, value );
1684 template<
typename MT
1686 inline void DiagonalMatrix<MT,SO,false>::append(
size_t i,
size_t j,
const ElementType& value,
bool check )
1692 matrix_.append( i, j, value, check );
1712 template<
typename MT
1714 inline void DiagonalMatrix<MT,SO,false>::finalize(
size_t i )
1716 matrix_.finalize( i );
1740 template<
typename MT
1742 inline void DiagonalMatrix<MT,SO,false>::erase(
size_t i,
size_t j )
1744 matrix_.erase( i, j );
1762 template<
typename MT
1765 DiagonalMatrix<MT,SO,false>::erase(
size_t i,
Iterator pos )
1767 return matrix_.erase( i, pos );
1787 template<
typename MT
1790 DiagonalMatrix<MT,SO,false>::erase(
size_t i,
Iterator first,
Iterator last )
1792 return matrix_.erase( i, first, last );
1820 template<
typename MT
1822 template<
typename Pred >
1823 inline void DiagonalMatrix<MT,SO,false>::erase( Pred predicate )
1825 matrix_.erase( predicate );
1861 template<
typename MT
1863 template<
typename Pred >
1864 inline void DiagonalMatrix<MT,SO,false>::erase(
size_t i,
Iterator first,
Iterator last, Pred predicate )
1866 matrix_.erase( i, first, last, predicate );
1898 template<
typename MT
1901 DiagonalMatrix<MT,SO,false>::find(
size_t i,
size_t j )
1903 return matrix_.find( i, j );
1925 template<
typename MT
1928 DiagonalMatrix<MT,SO,false>::find(
size_t i,
size_t j )
const 1930 return matrix_.find( i, j );
1952 template<
typename MT
1955 DiagonalMatrix<MT,SO,false>::lowerBound(
size_t i,
size_t j )
1957 return matrix_.lowerBound( i, j );
1979 template<
typename MT
1982 DiagonalMatrix<MT,SO,false>::lowerBound(
size_t i,
size_t j )
const 1984 return matrix_.lowerBound( i, j );
2006 template<
typename MT
2009 DiagonalMatrix<MT,SO,false>::upperBound(
size_t i,
size_t j )
2011 return matrix_.upperBound( i, j );
2033 template<
typename MT
2036 DiagonalMatrix<MT,SO,false>::upperBound(
size_t i,
size_t j )
const 2038 return matrix_.upperBound( i, j );
2070 template<
typename MT
2072 template<
typename Other >
2073 inline DiagonalMatrix<MT,SO,false>&
2074 DiagonalMatrix<MT,SO,false>::scale(
const Other& scalar )
2076 matrix_.scale( scalar );
2101 template<
typename MT
2132 template<
typename MT
2134 template<
typename Other >
2135 inline bool DiagonalMatrix<MT,SO,false>::canAlias(
const Other* alias )
const noexcept
2137 return matrix_.canAlias( alias );
2154 template<
typename MT
2156 template<
typename Other >
2157 inline bool DiagonalMatrix<MT,SO,false>::isAliased(
const Other* alias )
const noexcept
2159 return matrix_.isAliased( alias );
2176 template<
typename MT
2178 inline bool DiagonalMatrix<MT,SO,false>::canSMPAssign() const noexcept
2180 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
decltype(auto) decldiag(const DenseMatrix< MT, SO > &dm)
Declares the given dense matrix expression dm as diagonal.
Definition: DMatDeclDiagExpr.h:996
#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.
#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
Header file for the IsDiagonal type trait.
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
bool isDiagonal(const DenseMatrix< MT, SO > &dm)
Checks if the give dense matrix is diagonal.
Definition: DenseMatrix.h:1725
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.
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.
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.
MatrixAccessProxy< This > Reference
Reference to a non-constant matrix value.
Definition: CompressedMatrix.h:3082
Header file for the DiagonalProxy class.
Header file for the clear shim.
Namespace of the Blaze C++ math library.
Definition: Blaze.h:58
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.
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
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.
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
#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.
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
Header file for the implementation of the base template of the DiagonalMatrix.
#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
bool isDefault(const DiagonalProxy< MT > &proxy)
Returns whether the represented element is in default state.
Definition: DiagonalProxy.h:628
#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 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