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_t<MT>;
102 using TT = TransposeType_t<MT>;
103 using ET = ElementType_t<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 >;
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 );
168 ~DiagonalMatrix() =
default;
175 inline Reference operator()(
size_t i,
size_t j );
177 inline Reference at(
size_t i,
size_t j );
191 inline DiagonalMatrix& operator=( initializer_list< initializer_list<ElementType> > list );
193 inline DiagonalMatrix& operator=(
const DiagonalMatrix& rhs );
194 inline DiagonalMatrix& operator=( DiagonalMatrix&& rhs ) noexcept;
196 template<
typename MT2,
bool SO2 >
197 inline auto operator=(
const Matrix<MT2,SO2>& rhs )
198 -> DisableIf_t< IsComputation_v<MT2>, DiagonalMatrix& >;
200 template<
typename MT2,
bool SO2 >
201 inline auto operator=(
const Matrix<MT2,SO2>& rhs )
202 -> EnableIf_t< IsComputation_v<MT2>, DiagonalMatrix& >;
204 template<
typename MT2,
bool SO2 >
205 inline auto operator+=(
const Matrix<MT2,SO2>& rhs )
206 -> DisableIf_t< IsComputation_v<MT2>, DiagonalMatrix& >;
208 template<
typename MT2,
bool SO2 >
209 inline auto operator+=(
const Matrix<MT2,SO2>& rhs )
210 -> EnableIf_t< IsComputation_v<MT2>, DiagonalMatrix& >;
212 template<
typename MT2,
bool SO2 >
213 inline auto operator-=(
const Matrix<MT2,SO2>& rhs )
214 -> DisableIf_t< IsComputation_v<MT2>, DiagonalMatrix& >;
216 template<
typename MT2,
bool SO2 >
217 inline auto operator-=(
const Matrix<MT2,SO2>& rhs )
218 -> EnableIf_t< IsComputation_v<MT2>, DiagonalMatrix& >;
220 template<
typename MT2,
bool SO2 >
221 inline auto operator%=(
const Matrix<MT2,SO2>& rhs ) -> DiagonalMatrix&;
228 inline size_t rows() const noexcept;
229 inline
size_t columns() const noexcept;
230 inline
size_t capacity() const noexcept;
231 inline
size_t capacity(
size_t i ) const noexcept;
233 inline
size_t nonZeros(
size_t i ) const;
235 inline
void reset(
size_t i );
237 inline
void resize (
size_t n,
bool preserve=true );
238 inline
void reserve(
size_t nonzeros );
239 inline
void reserve(
size_t i,
size_t nonzeros );
241 inline
void trim(
size_t i );
243 inline
void swap( DiagonalMatrix& m ) noexcept;
252 inline
void append (
size_t i,
size_t j, const
ElementType& value,
bool check=false );
253 inline
void finalize(
size_t i );
260 inline
void erase(
size_t i,
size_t j );
264 template< typename Pred >
265 inline
void erase( Pred predicate );
267 template< typename Pred >
268 inline
void erase(
size_t i,
Iterator first,
Iterator last, Pred predicate );
275 inline
Iterator find (
size_t i,
size_t j );
277 inline
Iterator lowerBound(
size_t i,
size_t j );
279 inline
Iterator upperBound(
size_t i,
size_t j );
287 template< typename Other > inline DiagonalMatrix& scale( const Other& scalar );
294 inline
bool isIntact() const noexcept;
301 template< typename Other > inline
bool canAlias ( const Other* alias ) const noexcept;
302 template< typename Other > inline
bool isAliased( const Other* alias ) const noexcept;
304 inline
bool canSMPAssign() const noexcept;
312 inline
void resetNonDiagonal();
324 template<
bool RF, typename MT2,
bool SO2,
bool DF2 >
325 friend
bool isDefault( const DiagonalMatrix<MT2,SO2,DF2>& m );
327 template< typename MT2,
bool SO2,
bool DF2 >
328 friend MT2& derestrict( DiagonalMatrix<MT2,SO2,DF2>& m );
363 template< typename MT
365 inline DiagonalMatrix<MT,SO,false>::DiagonalMatrix()
382 template<
typename MT
384 inline DiagonalMatrix<MT,SO,false>::DiagonalMatrix(
size_t n )
404 template<
typename MT
406 inline DiagonalMatrix<MT,SO,false>::DiagonalMatrix(
size_t n,
size_t nonzeros )
407 : matrix_( n, n, nonzeros )
428 template<
typename MT
430 inline DiagonalMatrix<MT,SO,false>::DiagonalMatrix(
size_t n,
const std::vector<size_t>& nonzeros )
431 : matrix_( n, n, nonzeros )
465 template<
typename MT
467 inline DiagonalMatrix<MT,SO,false>::DiagonalMatrix( initializer_list< initializer_list<ElementType> > list )
486 template<
typename MT
488 inline DiagonalMatrix<MT,SO,false>::DiagonalMatrix(
const DiagonalMatrix& m )
489 : matrix_( m.matrix_ )
504 template<
typename MT
506 inline DiagonalMatrix<MT,SO,false>::DiagonalMatrix( DiagonalMatrix&& m ) noexcept
507 : matrix_( std::move( m.matrix_ ) )
526 template<
typename MT
528 template<
typename MT2
530 inline DiagonalMatrix<MT,SO,false>::DiagonalMatrix(
const Matrix<MT2,SO2>& m )
533 if( !IsDiagonal_v<MT2> && !
isDiagonal( matrix_ ) ) {
537 if( !IsDiagonal_v<MT2> )
571 template<
typename MT
574 DiagonalMatrix<MT,SO,false>::operator()(
size_t i,
size_t j )
601 template<
typename MT
604 DiagonalMatrix<MT,SO,false>::operator()(
size_t i,
size_t j )
const 632 template<
typename MT
635 DiagonalMatrix<MT,SO,false>::at(
size_t i,
size_t j )
666 template<
typename MT
669 DiagonalMatrix<MT,SO,false>::at(
size_t i,
size_t j )
const 695 template<
typename MT
700 return matrix_.begin(i);
718 template<
typename MT
723 return matrix_.begin(i);
741 template<
typename MT
746 return matrix_.cbegin(i);
764 template<
typename MT
769 return matrix_.end(i);
787 template<
typename MT
792 return matrix_.end(i);
810 template<
typename MT
815 return matrix_.cend(i);
854 template<
typename MT
856 inline DiagonalMatrix<MT,SO,false>&
857 DiagonalMatrix<MT,SO,false>::operator=( initializer_list< initializer_list<ElementType> > list )
859 const InitializerMatrix<ElementType> tmp( list, list.size() );
886 template<
typename MT
888 inline DiagonalMatrix<MT,SO,false>&
889 DiagonalMatrix<MT,SO,false>::operator=(
const DiagonalMatrix& rhs )
891 matrix_ = rhs.matrix_;
909 template<
typename MT
911 inline DiagonalMatrix<MT,SO,false>&
912 DiagonalMatrix<MT,SO,false>::operator=( DiagonalMatrix&& rhs ) noexcept
914 matrix_ = std::move( rhs.matrix_ );
938 template<
typename MT
940 template<
typename MT2
942 inline auto DiagonalMatrix<MT,SO,false>::operator=(
const Matrix<MT2,SO2>& rhs )
943 -> DisableIf_t< IsComputation_v<MT2>, DiagonalMatrix& >
945 if( !IsDiagonal_v<MT2> && !
isDiagonal( ~rhs ) ) {
951 if( !IsDiagonal_v<MT2> )
976 template<
typename MT
978 template<
typename MT2
980 inline auto DiagonalMatrix<MT,SO,false>::operator=(
const Matrix<MT2,SO2>& rhs )
981 -> EnableIf_t< IsComputation_v<MT2>, DiagonalMatrix& >
983 if( !IsSquare_v<MT2> && !
isSquare( ~rhs ) ) {
987 if( IsDiagonal_v<MT2> ) {
997 matrix_ = std::move( tmp );
1000 if( !IsDiagonal_v<MT2> )
1025 template<
typename MT
1027 template<
typename MT2
1030 -> DisableIf_t< IsComputation_v<MT2>, DiagonalMatrix& >
1032 if( !IsDiagonal_v<MT2> && !
isDiagonal( ~rhs ) ) {
1038 if( !IsDiagonal_v<MT2> )
1063 template<
typename MT
1065 template<
typename MT2
1068 -> EnableIf_t< IsComputation_v<MT2>, DiagonalMatrix& >
1070 if( !IsSquare_v<MT2> && !
isSquare( ~rhs ) ) {
1074 if( IsDiagonal_v<MT2> ) {
1078 const ResultType_t<MT2> tmp( ~rhs );
1087 if( !IsDiagonal_v<MT2> )
1112 template<
typename MT
1114 template<
typename MT2
1117 -> DisableIf_t< IsComputation_v<MT2>, DiagonalMatrix& >
1119 if( !IsDiagonal_v<MT2> && !
isDiagonal( ~rhs ) ) {
1125 if( !IsDiagonal_v<MT2> )
1150 template<
typename MT
1152 template<
typename MT2
1155 -> EnableIf_t< IsComputation_v<MT2>, DiagonalMatrix& >
1157 if( !IsSquare_v<MT2> && !
isSquare( ~rhs ) ) {
1161 if( IsDiagonal_v<MT2> ) {
1165 const ResultType_t<MT2> tmp( ~rhs );
1174 if( !IsDiagonal_v<MT2> )
1197 template<
typename MT
1199 template<
typename MT2
1201 inline auto DiagonalMatrix<MT,SO,false>::operator%=(
const Matrix<MT2,SO2>& rhs )
1204 if( !IsSquare_v<MT2> && !
isSquare( ~rhs ) ) {
1210 if( !IsDiagonal_v<MT2> )
1236 template<
typename MT
1240 return matrix_.rows();
1252 template<
typename MT
1256 return matrix_.columns();
1268 template<
typename MT
1272 return matrix_.capacity();
1290 template<
typename MT
1294 return matrix_.capacity(i);
1306 template<
typename MT
1310 return matrix_.nonZeros();
1328 template<
typename MT
1332 return matrix_.nonZeros(i);
1344 template<
typename MT
1367 template<
typename MT
1385 template<
typename MT
1412 template<
typename MT
1420 matrix_.resize( n, n, preserve );
1437 template<
typename MT
1439 inline void DiagonalMatrix<MT,SO,false>::reserve(
size_t nonzeros )
1441 matrix_.reserve( nonzeros );
1461 template<
typename MT
1463 inline void DiagonalMatrix<MT,SO,false>::reserve(
size_t i,
size_t nonzeros )
1465 matrix_.reserve( i, nonzeros );
1482 template<
typename MT
1484 inline void DiagonalMatrix<MT,SO,false>::trim()
1504 template<
typename MT
1506 inline void DiagonalMatrix<MT,SO,false>::trim(
size_t i )
1524 template<
typename MT
1528 matrix_.shrinkToFit();
1541 template<
typename MT
1547 swap( matrix_, m.matrix_ );
1559 template<
typename MT
1561 inline void DiagonalMatrix<MT,SO,false>::resetNonDiagonal()
1565 for(
size_t i=0UL; i<
rows(); ++i ) {
1566 erase( matrix_, i, matrix_.begin( i ), matrix_.lowerBound( i, i ) );
1567 erase( matrix_, i, matrix_.upperBound( i, i ), matrix_.end( i ) );
1598 template<
typename MT
1607 return matrix_.set( i, j, value );
1630 template<
typename MT
1633 DiagonalMatrix<MT,SO,false>::insert(
size_t i,
size_t j,
const ElementType& value )
1639 return matrix_.insert( i, j, value );
1695 template<
typename MT
1697 inline void DiagonalMatrix<MT,SO,false>::append(
size_t i,
size_t j,
const ElementType& value,
bool check )
1703 matrix_.append( i, j, value, check );
1723 template<
typename MT
1725 inline void DiagonalMatrix<MT,SO,false>::finalize(
size_t i )
1727 matrix_.finalize( i );
1751 template<
typename MT
1753 inline void DiagonalMatrix<MT,SO,false>::erase(
size_t i,
size_t j )
1757 erase( matrix_, i, j );
1775 template<
typename MT
1778 DiagonalMatrix<MT,SO,false>::erase(
size_t i,
Iterator pos )
1782 return erase( matrix_, i, pos );
1802 template<
typename MT
1805 DiagonalMatrix<MT,SO,false>::erase(
size_t i,
Iterator first,
Iterator last )
1809 return erase( matrix_, i, first, last );
1837 template<
typename MT
1839 template<
typename Pred >
1840 inline void DiagonalMatrix<MT,SO,false>::erase( Pred predicate )
1844 erase( matrix_, predicate );
1880 template<
typename MT
1882 template<
typename Pred >
1883 inline void DiagonalMatrix<MT,SO,false>::erase(
size_t i,
Iterator first,
Iterator last, Pred predicate )
1887 erase( matrix_, i, first, last, predicate );
1919 template<
typename MT
1922 DiagonalMatrix<MT,SO,false>::find(
size_t i,
size_t j )
1924 return matrix_.find( i, j );
1946 template<
typename MT
1949 DiagonalMatrix<MT,SO,false>::find(
size_t i,
size_t j )
const 1951 return matrix_.find( i, j );
1973 template<
typename MT
1976 DiagonalMatrix<MT,SO,false>::lowerBound(
size_t i,
size_t j )
1978 return matrix_.lowerBound( i, j );
2000 template<
typename MT
2003 DiagonalMatrix<MT,SO,false>::lowerBound(
size_t i,
size_t j )
const 2005 return matrix_.lowerBound( i, j );
2027 template<
typename MT
2030 DiagonalMatrix<MT,SO,false>::upperBound(
size_t i,
size_t j )
2032 return matrix_.upperBound( i, j );
2054 template<
typename MT
2057 DiagonalMatrix<MT,SO,false>::upperBound(
size_t i,
size_t j )
const 2059 return matrix_.upperBound( i, j );
2091 template<
typename MT
2093 template<
typename Other >
2094 inline DiagonalMatrix<MT,SO,false>&
2095 DiagonalMatrix<MT,SO,false>::scale(
const Other& scalar )
2097 matrix_.scale( scalar );
2122 template<
typename MT
2153 template<
typename MT
2155 template<
typename Other >
2156 inline bool DiagonalMatrix<MT,SO,false>::canAlias(
const Other* alias )
const noexcept
2158 return matrix_.canAlias( alias );
2175 template<
typename MT
2177 template<
typename Other >
2178 inline bool DiagonalMatrix<MT,SO,false>::isAliased(
const Other* alias )
const noexcept
2180 return matrix_.isAliased( alias );
2197 template<
typename MT
2199 inline bool DiagonalMatrix<MT,SO,false>::canSMPAssign() const noexcept
2201 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
decltype(auto) decldiag(const DenseMatrix< MT, SO > &dm)
Declares the given dense matrix expression dm as diagonal.
Definition: DMatDeclDiagExpr.h:975
#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.
#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: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
bool isDiagonal(const DenseMatrix< MT, SO > &dm)
Checks if the give dense matrix is diagonal.
Definition: DenseMatrix.h:1539
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.
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:3083
Header file for the DiagonalProxy class.
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: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.
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:611
#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.
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
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: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
bool isDefault(const DiagonalProxy< MT > &proxy)
Returns whether the represented element is in default state.
Definition: DiagonalProxy.h:631
#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 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.