35 #ifndef _BLAZE_MATH_ADAPTORS_UPPERMATRIX_SPARSE_H_ 36 #define _BLAZE_MATH_ADAPTORS_UPPERMATRIX_SPARSE_H_ 98 class UpperMatrix<MT,SO,false>
99 :
public SparseMatrix< UpperMatrix<MT,SO,false>, SO >
103 using OT = OppositeType_t<MT>;
104 using TT = TransposeType_t<MT>;
105 using ET = ElementType_t<MT>;
110 using This = UpperMatrix<MT,SO,false>;
111 using BaseType = SparseMatrix<This,SO>;
127 template<
typename NewType >
130 using Other = UpperMatrix< typename MT::template Rebind<NewType>::Other >;
137 template<
size_t NewM
141 using Other = UpperMatrix< typename MT::template Resize<NewM,NewN>::Other >;
153 explicit inline UpperMatrix();
154 explicit inline UpperMatrix(
size_t n );
155 explicit inline UpperMatrix(
size_t n,
size_t nonzeros );
156 explicit inline UpperMatrix(
size_t n,
const std::vector<size_t>& nonzeros );
157 explicit inline UpperMatrix( initializer_list< initializer_list<ElementType> > list );
159 inline UpperMatrix(
const UpperMatrix& m );
160 inline UpperMatrix( UpperMatrix&& m ) noexcept;
162 template<
typename MT2,
bool SO2 >
163 inline UpperMatrix(
const Matrix<MT2,SO2>& m );
170 ~UpperMatrix() =
default;
177 inline Reference operator()(
size_t i,
size_t j );
179 inline Reference at(
size_t i,
size_t j );
193 inline UpperMatrix& operator=( initializer_list< initializer_list<ElementType> > list );
195 inline UpperMatrix& operator=(
const UpperMatrix& rhs );
196 inline UpperMatrix& operator=( UpperMatrix&& rhs ) noexcept;
198 template<
typename MT2,
bool SO2 >
199 inline auto operator=(
const Matrix<MT2,SO2>& rhs )
200 -> DisableIf_t< IsComputation_v<MT2>, UpperMatrix& >;
202 template<
typename MT2,
bool SO2 >
203 inline auto operator=(
const Matrix<MT2,SO2>& rhs )
204 -> EnableIf_t< IsComputation_v<MT2>, UpperMatrix& >;
206 template<
typename MT2,
bool SO2 >
207 inline auto operator+=(
const Matrix<MT2,SO2>& rhs )
208 -> DisableIf_t< IsComputation_v<MT2>, UpperMatrix& >;
210 template<
typename MT2,
bool SO2 >
211 inline auto operator+=(
const Matrix<MT2,SO2>& rhs )
212 -> EnableIf_t< IsComputation_v<MT2>, UpperMatrix& >;
214 template<
typename MT2,
bool SO2 >
215 inline auto operator-=(
const Matrix<MT2,SO2>& rhs )
216 -> DisableIf_t< IsComputation_v<MT2>, UpperMatrix& >;
218 template<
typename MT2,
bool SO2 >
219 inline auto operator-=(
const Matrix<MT2,SO2>& rhs )
220 -> EnableIf_t< IsComputation_v<MT2>, UpperMatrix& >;
222 template<
typename MT2,
bool SO2 >
223 inline auto operator%=(
const Matrix<MT2,SO2>& rhs ) -> UpperMatrix&;
230 inline size_t rows() const noexcept;
231 inline
size_t columns() const noexcept;
232 inline
size_t capacity() const noexcept;
233 inline
size_t capacity(
size_t i ) const noexcept;
235 inline
size_t nonZeros(
size_t i ) const;
237 inline
void reset(
size_t i );
239 inline
void resize (
size_t n,
bool preserve=true );
240 inline
void reserve(
size_t nonzeros );
241 inline
void reserve(
size_t i,
size_t nonzeros );
243 inline
void trim(
size_t i );
245 inline
void swap( UpperMatrix& m ) noexcept;
247 static inline constexpr
size_t maxNonZeros() noexcept;
248 static inline constexpr
size_t maxNonZeros(
size_t n ) noexcept;
257 inline
void append (
size_t i,
size_t j, const
ElementType& value,
bool check=false );
258 inline
void finalize(
size_t i );
265 inline
void erase(
size_t i,
size_t j );
269 template< typename Pred >
270 inline
void erase( Pred predicate );
272 template< typename Pred >
273 inline
void erase(
size_t i,
Iterator first,
Iterator last, Pred predicate );
280 inline
Iterator find (
size_t i,
size_t j );
282 inline
Iterator lowerBound(
size_t i,
size_t j );
284 inline
Iterator upperBound(
size_t i,
size_t j );
292 template< typename Other > inline UpperMatrix& scale( const Other& scalar );
299 inline
bool isIntact() const noexcept;
306 template< typename Other > inline
bool canAlias ( const Other* alias ) const noexcept;
307 template< typename Other > inline
bool isAliased( const Other* alias ) const noexcept;
309 inline
bool canSMPAssign() const noexcept;
317 inline
void resetLower();
329 template<
bool RF, typename MT2,
bool SO2,
bool DF2 >
330 friend
bool isDefault( const UpperMatrix<MT2,SO2,DF2>& m );
332 template< typename MT2,
bool SO2,
bool DF2 >
333 friend MT2& derestrict( UpperMatrix<MT2,SO2,DF2>& m );
368 template< typename MT
370 inline UpperMatrix<MT,SO,false>::UpperMatrix()
387 template<
typename MT
389 inline UpperMatrix<MT,SO,false>::UpperMatrix(
size_t n )
409 template<
typename MT
411 inline UpperMatrix<MT,SO,false>::UpperMatrix(
size_t n,
size_t nonzeros )
412 : matrix_( n, n, nonzeros )
433 template<
typename MT
435 inline UpperMatrix<MT,SO,false>::UpperMatrix(
size_t n,
const std::vector<size_t>& nonzeros )
436 : matrix_( n, n, nonzeros )
470 template<
typename MT
472 inline UpperMatrix<MT,SO,false>::UpperMatrix( initializer_list< initializer_list<ElementType> > list )
491 template<
typename MT
493 inline UpperMatrix<MT,SO,false>::UpperMatrix(
const UpperMatrix& m )
494 : matrix_( m.matrix_ )
509 template<
typename MT
511 inline UpperMatrix<MT,SO,false>::UpperMatrix( UpperMatrix&& m ) noexcept
512 : matrix_( std::move( m.matrix_ ) )
531 template<
typename MT
533 template<
typename MT2
535 inline UpperMatrix<MT,SO,false>::UpperMatrix(
const Matrix<MT2,SO2>& m )
538 if( !IsUpper_v<MT2> && !
isUpper( matrix_ ) ) {
542 if( !IsUpper_v<MT2> )
576 template<
typename MT
579 UpperMatrix<MT,SO,false>::operator()(
size_t i,
size_t j )
606 template<
typename MT
609 UpperMatrix<MT,SO,false>::operator()(
size_t i,
size_t j )
const 637 template<
typename MT
640 UpperMatrix<MT,SO,false>::at(
size_t i,
size_t j )
671 template<
typename MT
674 UpperMatrix<MT,SO,false>::at(
size_t i,
size_t j )
const 700 template<
typename MT
705 return matrix_.begin(i);
723 template<
typename MT
728 return matrix_.begin(i);
746 template<
typename MT
751 return matrix_.cbegin(i);
769 template<
typename MT
774 return matrix_.end(i);
792 template<
typename MT
797 return matrix_.end(i);
815 template<
typename MT
820 return matrix_.cend(i);
859 template<
typename MT
861 inline UpperMatrix<MT,SO,false>&
862 UpperMatrix<MT,SO,false>::operator=( initializer_list< initializer_list<ElementType> > list )
864 const InitializerMatrix<ElementType> tmp( list, list.size() );
891 template<
typename MT
893 inline UpperMatrix<MT,SO,false>&
894 UpperMatrix<MT,SO,false>::operator=(
const UpperMatrix& rhs )
896 matrix_ = rhs.matrix_;
914 template<
typename MT
916 inline UpperMatrix<MT,SO,false>&
917 UpperMatrix<MT,SO,false>::operator=( UpperMatrix&& rhs ) noexcept
919 matrix_ = std::move( rhs.matrix_ );
943 template<
typename MT
945 template<
typename MT2
947 inline auto UpperMatrix<MT,SO,false>::operator=(
const Matrix<MT2,SO2>& rhs )
948 -> DisableIf_t< IsComputation_v<MT2>, UpperMatrix& >
950 if( !IsUpper_v<MT2> && !
isUpper( ~rhs ) ) {
956 if( !IsUpper_v<MT2> )
981 template<
typename MT
983 template<
typename MT2
985 inline auto UpperMatrix<MT,SO,false>::operator=(
const Matrix<MT2,SO2>& rhs )
986 -> EnableIf_t< IsComputation_v<MT2>, UpperMatrix& >
988 if( !IsSquare_v<MT2> && !
isSquare( ~rhs ) ) {
992 if( IsUpper_v<MT2> ) {
1002 matrix_ = std::move( tmp );
1005 if( !IsUpper_v<MT2> )
1030 template<
typename MT
1032 template<
typename MT2
1035 -> DisableIf_t< IsComputation_v<MT2>, UpperMatrix& >
1037 if( !IsUpper_v<MT2> && !
isUpper( ~rhs ) ) {
1043 if( !IsUpper_v<MT2> )
1068 template<
typename MT
1070 template<
typename MT2
1073 -> EnableIf_t< IsComputation_v<MT2>, UpperMatrix& >
1075 if( IsSquare_v<MT2> && !
isSquare( ~rhs ) ) {
1079 if( IsUpper_v<MT2> ) {
1083 const ResultType_t<MT2> tmp( ~rhs );
1092 if( !IsUpper_v<MT2> )
1117 template<
typename MT
1119 template<
typename MT2
1122 -> DisableIf_t< IsComputation_v<MT2>, UpperMatrix& >
1124 if( !IsUpper_v<MT2> && !
isUpper( ~rhs ) ) {
1130 if( !IsUpper_v<MT2> )
1155 template<
typename MT
1157 template<
typename MT2
1160 -> EnableIf_t< IsComputation_v<MT2>, UpperMatrix& >
1162 if( !IsSquare_v<MT2> && !
isSquare( ~rhs ) ) {
1166 if( IsUpper_v<MT2> ) {
1170 const ResultType_t<MT2> tmp( ~rhs );
1179 if( !IsUpper_v<MT2> )
1202 template<
typename MT
1204 template<
typename MT2
1206 inline auto UpperMatrix<MT,SO,false>::operator%=(
const Matrix<MT2,SO2>& rhs )
1209 if( !IsSquare_v<MT2> && !
isSquare( ~rhs ) ) {
1215 if( !IsUpper_v<MT2> )
1241 template<
typename MT
1245 return matrix_.rows();
1257 template<
typename MT
1261 return matrix_.columns();
1273 template<
typename MT
1277 return matrix_.capacity();
1295 template<
typename MT
1299 return matrix_.capacity(i);
1311 template<
typename MT
1315 return matrix_.nonZeros();
1333 template<
typename MT
1337 return matrix_.nonZeros(i);
1349 template<
typename MT
1372 template<
typename MT
1390 template<
typename MT
1417 template<
typename MT
1425 matrix_.resize( n, n, preserve );
1442 template<
typename MT
1444 inline void UpperMatrix<MT,SO,false>::reserve(
size_t nonzeros )
1446 matrix_.reserve( nonzeros );
1466 template<
typename MT
1468 inline void UpperMatrix<MT,SO,false>::reserve(
size_t i,
size_t nonzeros )
1470 matrix_.reserve( i, nonzeros );
1487 template<
typename MT
1489 inline void UpperMatrix<MT,SO,false>::trim()
1509 template<
typename MT
1511 inline void UpperMatrix<MT,SO,false>::trim(
size_t i )
1529 template<
typename MT
1533 matrix_.shrinkToFit();
1546 template<
typename MT
1552 swap( matrix_, m.matrix_ );
1569 template<
typename MT
1571 inline constexpr
size_t UpperMatrix<MT,SO,false>::maxNonZeros() noexcept
1575 return maxNonZeros( Size_v<MT,0UL> );
1591 template<
typename MT
1593 inline constexpr
size_t UpperMatrix<MT,SO,false>::maxNonZeros(
size_t n ) noexcept
1595 return ( ( n + 1UL ) * n ) / 2UL;
1607 template<
typename MT
1609 inline void UpperMatrix<MT,SO,false>::resetLower()
1614 for(
size_t j=0UL; j<
columns(); ++j )
1615 erase( matrix_, j, matrix_.upperBound( j, j ), matrix_.end( j ) );
1618 for(
size_t i=1UL; i<
rows(); ++i )
1619 erase( matrix_, i, matrix_.begin( i ), matrix_.lowerBound( i, i ) );
1650 template<
typename MT
1659 return matrix_.set( i, j, value );
1682 template<
typename MT
1685 UpperMatrix<MT,SO,false>::insert(
size_t i,
size_t j,
const ElementType& value )
1691 return matrix_.insert( i, j, value );
1747 template<
typename MT
1749 inline void UpperMatrix<MT,SO,false>::append(
size_t i,
size_t j,
const ElementType& value,
bool check )
1755 matrix_.append( i, j, value, check );
1775 template<
typename MT
1777 inline void UpperMatrix<MT,SO,false>::finalize(
size_t i )
1779 matrix_.finalize( i );
1803 template<
typename MT
1805 inline void UpperMatrix<MT,SO,false>::erase(
size_t i,
size_t j )
1809 erase( matrix_, i, j );
1827 template<
typename MT
1830 UpperMatrix<MT,SO,false>::erase(
size_t i,
Iterator pos )
1834 return erase( matrix_, i, pos );
1853 template<
typename MT
1860 return erase( matrix_, i, first, last );
1888 template<
typename MT
1890 template<
typename Pred >
1891 inline void UpperMatrix<MT,SO,false>::erase( Pred predicate )
1895 erase( matrix_, predicate );
1931 template<
typename MT
1933 template<
typename Pred >
1934 inline void UpperMatrix<MT,SO,false>::erase(
size_t i,
Iterator first,
Iterator last, Pred predicate )
1938 erase( matrix_, i, first, last, predicate );
1970 template<
typename MT
1973 UpperMatrix<MT,SO,false>::find(
size_t i,
size_t j )
1975 return matrix_.find( i, j );
1997 template<
typename MT
2000 UpperMatrix<MT,SO,false>::find(
size_t i,
size_t j )
const 2002 return matrix_.find( i, j );
2024 template<
typename MT
2027 UpperMatrix<MT,SO,false>::lowerBound(
size_t i,
size_t j )
2029 return matrix_.lowerBound( i, j );
2051 template<
typename MT
2054 UpperMatrix<MT,SO,false>::lowerBound(
size_t i,
size_t j )
const 2056 return matrix_.lowerBound( i, j );
2078 template<
typename MT
2081 UpperMatrix<MT,SO,false>::upperBound(
size_t i,
size_t j )
2083 return matrix_.upperBound( i, j );
2105 template<
typename MT
2108 UpperMatrix<MT,SO,false>::upperBound(
size_t i,
size_t j )
const 2110 return matrix_.upperBound( i, j );
2142 template<
typename MT
2144 template<
typename Other >
2145 inline UpperMatrix<MT,SO,false>&
2146 UpperMatrix<MT,SO,false>::scale(
const Other& scalar )
2148 matrix_.scale( scalar );
2173 template<
typename MT
2204 template<
typename MT
2206 template<
typename Other >
2207 inline bool UpperMatrix<MT,SO,false>::canAlias(
const Other* alias )
const noexcept
2209 return matrix_.canAlias( alias );
2226 template<
typename MT
2228 template<
typename Other >
2229 inline bool UpperMatrix<MT,SO,false>::isAliased(
const Other* alias )
const noexcept
2231 return matrix_.isAliased( alias );
2248 template<
typename MT
2250 inline bool UpperMatrix<MT,SO,false>::canSMPAssign() const noexcept
2252 return matrix_.canSMPAssign();
#define BLAZE_CONSTRAINT_MUST_NOT_BE_CONST(T)
Constraint on the data type.In case the given data type is a const-qualified type, a compilation error is created.
Definition: Const.h:79
#define BLAZE_THROW_INVALID_ARGUMENT(MESSAGE)
Macro for the emission of a std::invalid_argument exception.This macro encapsulates the default way o...
Definition: Exception.h:235
Header file for auxiliary alias declarations.
CompressedMatrix< Type, false > OppositeType
Result type with opposite storage order for expression template evaluations.
Definition: CompressedMatrix.h:3078
bool isUpper(const DenseMatrix< MT, SO > &dm)
Checks if the given dense matrix is an upper triangular matrix.
Definition: DenseMatrix.h:1271
#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
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
decltype(auto) declupp(const DenseMatrix< MT, SO > &dm)
Declares the given dense matrix expression dm as upper.
Definition: DMatDeclUppExpr.h:1002
#define BLAZE_CONSTRAINT_MUST_NOT_BE_VOLATILE(T)
Constraint on the data type.In case the given data type is a volatile-qualified type, a compilation error is created.
Definition: Volatile.h:79
size_t nonZeros(const Matrix< MT, SO > &matrix)
Returns the total number of non-zero elements in the matrix.
Definition: Matrix.h:584
Element * Iterator
Iterator over non-constant elements.
Definition: CompressedMatrix.h:3085
Header file for the extended initializer_list functionality.
Constraint on the data type.
constexpr size_t columns(const Matrix< MT, SO > &matrix) noexcept
Returns the current number of columns of the matrix.
Definition: Matrix.h:514
MT::ConstIterator cend(const Matrix< MT, SO > &matrix, size_t i)
Returns an iterator just past the last element of row/column i.
Definition: Matrix.h:482
MT::ConstIterator cbegin(const Matrix< MT, SO > &matrix, size_t i)
Returns an iterator to the first element of row/column i.
Definition: Matrix.h:416
Constraint on the data type.
Constraint on the data type.
Constraint on the data type.
Header file for the SparseMatrix base class.
Header file for utility functions for sparse matrices.
Header file for the IsSquare type trait.
Constraint on the data type.
Header file for the implementation of a matrix representation of an initializer list.
Header file for the DisableIf class template.
MatrixAccessProxy< This > Reference
Reference to a non-constant matrix value.
Definition: CompressedMatrix.h:3083
Namespace of the Blaze C++ math library.
Definition: Blaze.h:58
#define BLAZE_CONSTRAINT_MUST_BE_STATIC_TYPE(T)
Constraint on the data type.In case the given data type T is not a static data type, i.e. a vector or matrix with dimensions fixed at compile time, a compilation error is created.
Definition: Static.h:61
void swap(CompressedMatrix< Type, SO > &a, CompressedMatrix< Type, SO > &b) noexcept
Swapping the contents of two compressed matrices.
Definition: CompressedMatrix.h:5907
bool isIntact(const CompressedMatrix< Type, SO > &m)
Returns whether the invariants of the given compressed matrix are intact.
Definition: CompressedMatrix.h:5890
SparseMatrix< This, true > BaseType
Base type of this CompressedMatrix instance.
Definition: CompressedMatrix.h:3076
#define BLAZE_CONSTRAINT_MUST_NOT_BE_POINTER_TYPE(T)
Constraint on the data type.In case the given data type T is not a pointer type, a compilation error ...
Definition: Pointer.h:79
Type ElementType
Type of the compressed matrix elements.
Definition: CompressedMatrix.h:3080
#define BLAZE_THROW_OUT_OF_RANGE(MESSAGE)
Macro for the emission of a std::out_of_range exception.This macro encapsulates the default way of Bl...
Definition: Exception.h:331
const Element * ConstIterator
Iterator over constant elements.
Definition: CompressedMatrix.h:3086
Constraint on the data type.
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 UpperProxy class.
Header file for the EnableIf class template.
void clear(const DiagonalProxy< MT > &proxy)
Clearing the represented element.
Definition: DiagonalProxy.h:611
Header file for all adaptor forward declarations.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_SYMMETRIC_MATRIX_TYPE(T)
Constraint on the data type.In case the given data type T is a symmetric matrix type, a compilation error is created.
Definition: Symmetric.h:79
BLAZE_ALWAYS_INLINE T1 & operator+=(SIMDPack< T1 > &lhs, const SIMDPack< T2 > &rhs)
Addition assignment operator for the addition of two SIMD packs.
Definition: BasicTypes.h:1357
Header file for run time assertion macros.
Constraint on the data type.
Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_LOWER_MATRIX_TYPE(T)
Constraint on the data type.In case the given data type T is a lower triangular matrix type...
Definition: Lower.h:81
#define BLAZE_CONSTRAINT_MUST_NOT_BE_REFERENCE_TYPE(T)
Constraint on the data type.In case the given data type T is not a reference type, a compilation error is created.
Definition: Reference.h:79
Header file for the isDefault shim.
void swap(DiagonalMatrix< MT, SO, DF > &a, DiagonalMatrix< MT, SO, DF > &b) noexcept
Swapping the contents of two matrices.
Definition: DiagonalMatrix.h:281
BLAZE_ALWAYS_INLINE const EnableIf_t< IsIntegral_v< T > &&HasSize_v< T, 1UL >, If_t< IsSigned_v< T >, SIMDint8, SIMDuint8 > > set(T value) noexcept
Sets all values in the vector to the given 1-byte integral value.
Definition: Set.h:75
Constraint on the data type.
Constraint on the data type.
constexpr size_t rows(const Matrix< MT, SO > &matrix) noexcept
Returns the current number of rows of the matrix.
Definition: Matrix.h:498
const Type & ReturnType
Return type for expression template evaluations.
Definition: CompressedMatrix.h:3081
#define BLAZE_CONSTRAINT_MUST_BE_RESIZABLE_TYPE(T)
Constraint on the data type.In case the given data type T is not resizable, i.e. does not have a 'res...
Definition: Resizable.h:61
Header file for the IsComputation type trait class.
const This & CompositeType
Data type for composite expression templates.
Definition: CompressedMatrix.h:3082
#define BLAZE_CONSTRAINT_MUST_NOT_BE_EXPRESSION_TYPE(T)
Constraint on the data type.In case the given data type T is an expression (i.e. a type derived from ...
Definition: Expression.h:81
bool isIntact(const DiagonalMatrix< MT, SO, DF > &m)
Returns whether the invariants of the given diagonal matrix are intact.
Definition: DiagonalMatrix.h:263
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
Header file for the IsUpper type trait.
#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
Header file for the implementation of the base template of the UpperMatrix.
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.