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_<MT>;
104 using TT = TransposeType_<MT>;
105 using ET = ElementType_<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 >;
147 enum :
bool { smpAssignable =
false };
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 );
158 inline UpperMatrix(
const UpperMatrix& m );
159 inline UpperMatrix( UpperMatrix&& m ) noexcept;
161 template<
typename MT2,
bool SO2 >
162 inline UpperMatrix(
const Matrix<MT2,SO2>& m );
173 inline Reference operator()(
size_t i,
size_t j );
175 inline Reference at(
size_t i,
size_t j );
189 inline UpperMatrix& operator=(
const UpperMatrix& rhs );
190 inline UpperMatrix& operator=( UpperMatrix&& rhs ) noexcept;
192 template<
typename MT2,
bool SO2 >
193 inline DisableIf_< IsComputation<MT2>, UpperMatrix& > operator=(
const Matrix<MT2,SO2>& rhs );
195 template<
typename MT2,
bool SO2 >
196 inline EnableIf_< IsComputation<MT2>, UpperMatrix& > operator=(
const Matrix<MT2,SO2>& rhs );
198 template<
typename MT2,
bool SO2 >
199 inline DisableIf_< IsComputation<MT2>, UpperMatrix& >
operator+=(
const Matrix<MT2,SO2>& rhs );
201 template<
typename MT2,
bool SO2 >
202 inline EnableIf_< IsComputation<MT2>, UpperMatrix& >
operator+=(
const Matrix<MT2,SO2>& rhs );
204 template<
typename MT2,
bool SO2 >
205 inline DisableIf_< IsComputation<MT2>, UpperMatrix& >
operator-=(
const Matrix<MT2,SO2>& rhs );
207 template<
typename MT2,
bool SO2 >
208 inline EnableIf_< IsComputation<MT2>, UpperMatrix& >
operator-=(
const Matrix<MT2,SO2>& rhs );
210 template<
typename MT2,
bool SO2 >
211 inline UpperMatrix& operator%=(
const Matrix<MT2,SO2>& rhs );
213 template<
typename MT2,
bool SO2 >
214 inline UpperMatrix&
operator*=(
const Matrix<MT2,SO2>& rhs );
216 template<
typename Other >
217 inline EnableIf_< IsNumeric<Other>, UpperMatrix >&
operator*=( Other rhs );
219 template<
typename Other >
220 inline EnableIf_< IsNumeric<Other>, UpperMatrix >&
operator/=( Other rhs );
227 inline size_t rows() const noexcept;
228 inline
size_t columns() const noexcept;
229 inline
size_t capacity() const noexcept;
230 inline
size_t capacity(
size_t i ) const noexcept;
232 inline
size_t nonZeros(
size_t i ) const;
234 inline
void reset(
size_t i );
236 inline
void resize (
size_t n,
bool preserve=true );
237 inline
void reserve(
size_t nonzeros );
238 inline
void reserve(
size_t i,
size_t nonzeros );
240 inline
void trim(
size_t i );
242 inline
void swap( UpperMatrix& m ) noexcept;
244 static inline constexpr
size_t maxNonZeros() noexcept;
245 static inline constexpr
size_t maxNonZeros(
size_t n ) noexcept;
254 inline
void append (
size_t i,
size_t j, const
ElementType& value,
bool check=false );
255 inline
void finalize(
size_t i );
262 inline
void erase(
size_t i,
size_t j );
266 template< typename Pred >
267 inline
void erase( Pred predicate );
269 template< typename Pred >
270 inline
void erase(
size_t i,
Iterator first,
Iterator last, Pred predicate );
277 inline
Iterator find (
size_t i,
size_t j );
279 inline
Iterator lowerBound(
size_t i,
size_t j );
281 inline
Iterator upperBound(
size_t i,
size_t j );
289 template< typename Other > inline UpperMatrix& scale( const Other& scalar );
290 template< typename Other > inline UpperMatrix& scaleDiagonal( const Other& scale );
297 inline
bool isIntact() const noexcept;
304 template< typename Other > inline
bool canAlias ( const Other* alias ) const noexcept;
305 template< typename Other > inline
bool isAliased( const Other* alias ) const noexcept;
307 inline
bool canSMPAssign() const noexcept;
315 inline
void resetLower();
327 template<
bool RF, typename MT2,
bool SO2,
bool DF2 >
328 friend
bool isDefault( const UpperMatrix<MT2,SO2,DF2>& m );
330 template< typename MT2,
bool SO2,
bool DF2 >
331 friend MT2& derestrict( UpperMatrix<MT2,SO2,DF2>& m );
366 template< typename MT
368 inline UpperMatrix<MT,SO,false>::UpperMatrix()
385 template<
typename MT
387 inline UpperMatrix<MT,SO,false>::UpperMatrix(
size_t n )
407 template<
typename MT
409 inline UpperMatrix<MT,SO,false>::UpperMatrix(
size_t n,
size_t nonzeros )
410 : matrix_( n, n, nonzeros )
431 template<
typename MT
433 inline UpperMatrix<MT,SO,false>::UpperMatrix(
size_t n,
const std::vector<size_t>& nonzeros )
434 : matrix_( n, n, nonzeros )
450 template<
typename MT
452 inline UpperMatrix<MT,SO,false>::UpperMatrix(
const UpperMatrix& m )
453 : matrix_( m.matrix_ )
468 template<
typename MT
470 inline UpperMatrix<MT,SO,false>::UpperMatrix( UpperMatrix&& m ) noexcept
471 : matrix_( std::move( m.matrix_ ) )
490 template<
typename MT
492 template<
typename MT2
494 inline UpperMatrix<MT,SO,false>::UpperMatrix(
const Matrix<MT2,SO2>& m )
497 if( !IsUpper<MT2>::value && !
isUpper( matrix_ ) ) {
501 if( !IsUpper<MT2>::value )
535 template<
typename MT
538 UpperMatrix<MT,SO,false>::operator()(
size_t i,
size_t j )
565 template<
typename MT
568 UpperMatrix<MT,SO,false>::operator()(
size_t i,
size_t j )
const 596 template<
typename MT
599 UpperMatrix<MT,SO,false>::at(
size_t i,
size_t j )
630 template<
typename MT
633 UpperMatrix<MT,SO,false>::at(
size_t i,
size_t j )
const 659 template<
typename MT
664 return matrix_.begin(i);
682 template<
typename MT
687 return matrix_.begin(i);
705 template<
typename MT
710 return matrix_.cbegin(i);
728 template<
typename MT
733 return matrix_.end(i);
751 template<
typename MT
756 return matrix_.end(i);
774 template<
typename MT
779 return matrix_.cend(i);
803 template<
typename MT
805 inline UpperMatrix<MT,SO,false>&
806 UpperMatrix<MT,SO,false>::operator=(
const UpperMatrix& rhs )
808 matrix_ = rhs.matrix_;
826 template<
typename MT
828 inline UpperMatrix<MT,SO,false>&
829 UpperMatrix<MT,SO,false>::operator=( UpperMatrix&& rhs ) noexcept
831 matrix_ = std::move( rhs.matrix_ );
855 template<
typename MT
857 template<
typename MT2
859 inline DisableIf_< IsComputation<MT2>, UpperMatrix<MT,SO,false>& >
860 UpperMatrix<MT,SO,false>::operator=(
const Matrix<MT2,SO2>& rhs )
862 if( !IsUpper<MT2>::value && !
isUpper( ~rhs ) ) {
868 if( !IsUpper<MT2>::value )
893 template<
typename MT
895 template<
typename MT2
897 inline EnableIf_< IsComputation<MT2>, UpperMatrix<MT,SO,false>& >
898 UpperMatrix<MT,SO,false>::operator=(
const Matrix<MT2,SO2>& rhs )
900 if( !IsSquare<MT2>::value && !
isSquare( ~rhs ) ) {
904 if( IsUpper<MT2>::value ) {
914 matrix_ = std::move( tmp );
917 if( !IsUpper<MT2>::value )
942 template<
typename MT
944 template<
typename MT2
946 inline DisableIf_< IsComputation<MT2>, UpperMatrix<MT,SO,false>& >
949 if( !IsUpper<MT2>::value && !
isUpper( ~rhs ) ) {
955 if( !IsUpper<MT2>::value )
980 template<
typename MT
982 template<
typename MT2
984 inline EnableIf_< IsComputation<MT2>, UpperMatrix<MT,SO,false>& >
987 if( IsSquare<MT2>::value && !
isSquare( ~rhs ) ) {
991 if( IsUpper<MT2>::value ) {
995 const ResultType_<MT2> tmp( ~rhs );
1004 if( !IsUpper<MT2>::value )
1029 template<
typename MT
1031 template<
typename MT2
1033 inline DisableIf_< IsComputation<MT2>, UpperMatrix<MT,SO,false>& >
1036 if( !IsUpper<MT2>::value && !
isUpper( ~rhs ) ) {
1042 if( !IsUpper<MT2>::value )
1067 template<
typename MT
1069 template<
typename MT2
1071 inline EnableIf_< IsComputation<MT2>, UpperMatrix<MT,SO,false>& >
1074 if( !IsSquare<MT2>::value && !
isSquare( ~rhs ) ) {
1078 if( IsUpper<MT2>::value ) {
1082 const ResultType_<MT2> tmp( ~rhs );
1091 if( !IsUpper<MT2>::value )
1114 template<
typename MT
1116 template<
typename MT2
1118 inline UpperMatrix<MT,SO,false>&
1119 UpperMatrix<MT,SO,false>::operator%=(
const Matrix<MT2,SO2>& rhs )
1121 if( !IsSquare<MT2>::value && !
isSquare( ~rhs ) ) {
1127 if( !IsUpper<MT2>::value )
1151 template<
typename MT
1153 template<
typename MT2
1155 inline UpperMatrix<MT,SO,false>&
1158 if( matrix_.rows() != (~rhs).
columns() ) {
1162 MT tmp( matrix_ * ~rhs );
1168 matrix_ = std::move( tmp );
1170 if( !IsUpper<MT2>::value )
1190 template<
typename MT
1192 template<
typename Other >
1193 inline EnableIf_< IsNumeric<Other>, UpperMatrix<MT,SO,false> >&
1210 template<
typename MT
1212 template<
typename Other >
1213 inline EnableIf_< IsNumeric<Other>, UpperMatrix<MT,SO,false> >&
1239 template<
typename MT
1243 return matrix_.rows();
1255 template<
typename MT
1259 return matrix_.columns();
1271 template<
typename MT
1275 return matrix_.capacity();
1293 template<
typename MT
1297 return matrix_.capacity(i);
1309 template<
typename MT
1313 return matrix_.nonZeros();
1331 template<
typename MT
1335 return matrix_.nonZeros(i);
1347 template<
typename MT
1370 template<
typename MT
1388 template<
typename MT
1415 template<
typename MT
1423 matrix_.resize( n, n, preserve );
1440 template<
typename MT
1442 inline void UpperMatrix<MT,SO,false>::reserve(
size_t nonzeros )
1444 matrix_.reserve( nonzeros );
1464 template<
typename MT
1466 inline void UpperMatrix<MT,SO,false>::reserve(
size_t i,
size_t nonzeros )
1468 matrix_.reserve( i, nonzeros );
1485 template<
typename MT
1487 inline void UpperMatrix<MT,SO,false>::trim()
1507 template<
typename MT
1509 inline void UpperMatrix<MT,SO,false>::trim(
size_t i )
1527 template<
typename MT
1531 matrix_.shrinkToFit();
1544 template<
typename MT
1550 swap( matrix_, m.matrix_ );
1567 template<
typename MT
1569 inline constexpr
size_t UpperMatrix<MT,SO,false>::maxNonZeros() noexcept
1573 return maxNonZeros( Rows<MT>::value );
1589 template<
typename MT
1591 inline constexpr
size_t UpperMatrix<MT,SO,false>::maxNonZeros(
size_t n ) noexcept
1593 return ( ( n + 1UL ) * n ) / 2UL;
1605 template<
typename MT
1607 inline void UpperMatrix<MT,SO,false>::resetLower()
1610 for(
size_t j=0UL; j<
columns(); ++j )
1611 matrix_.erase( j, matrix_.upperBound( j, j ), matrix_.end( j ) );
1614 for(
size_t i=1UL; i<
rows(); ++i )
1615 matrix_.erase( i, matrix_.begin( i ), matrix_.lowerBound( i, i ) );
1646 template<
typename MT
1655 return matrix_.set( i, j, value );
1678 template<
typename MT
1681 UpperMatrix<MT,SO,false>::insert(
size_t i,
size_t j,
const ElementType& value )
1687 return matrix_.insert( i, j, value );
1743 template<
typename MT
1745 inline void UpperMatrix<MT,SO,false>::append(
size_t i,
size_t j,
const ElementType& value,
bool check )
1751 matrix_.append( i, j, value, check );
1771 template<
typename MT
1773 inline void UpperMatrix<MT,SO,false>::finalize(
size_t i )
1775 matrix_.finalize( i );
1799 template<
typename MT
1801 inline void UpperMatrix<MT,SO,false>::erase(
size_t i,
size_t j )
1803 matrix_.erase( i, j );
1821 template<
typename MT
1824 UpperMatrix<MT,SO,false>::erase(
size_t i,
Iterator pos )
1826 return matrix_.erase( i, pos );
1845 template<
typename MT
1850 return matrix_.erase( i, first, last );
1878 template<
typename MT
1880 template<
typename Pred >
1881 inline void UpperMatrix<MT,SO,false>::erase( Pred predicate )
1883 matrix_.erase( predicate );
1919 template<
typename MT
1921 template<
typename Pred >
1922 inline void UpperMatrix<MT,SO,false>::erase(
size_t i,
Iterator first,
Iterator last, Pred predicate )
1924 matrix_.erase( i, first, last, predicate );
1956 template<
typename MT
1959 UpperMatrix<MT,SO,false>::find(
size_t i,
size_t j )
1961 return matrix_.find( i, j );
1983 template<
typename MT
1986 UpperMatrix<MT,SO,false>::find(
size_t i,
size_t j )
const 1988 return matrix_.find( i, j );
2010 template<
typename MT
2013 UpperMatrix<MT,SO,false>::lowerBound(
size_t i,
size_t j )
2015 return matrix_.lowerBound( i, j );
2037 template<
typename MT
2040 UpperMatrix<MT,SO,false>::lowerBound(
size_t i,
size_t j )
const 2042 return matrix_.lowerBound( i, j );
2064 template<
typename MT
2067 UpperMatrix<MT,SO,false>::upperBound(
size_t i,
size_t j )
2069 return matrix_.upperBound( i, j );
2091 template<
typename MT
2094 UpperMatrix<MT,SO,false>::upperBound(
size_t i,
size_t j )
const 2096 return matrix_.upperBound( i, j );
2128 template<
typename MT
2130 template<
typename Other >
2131 inline UpperMatrix<MT,SO,false>&
2132 UpperMatrix<MT,SO,false>::scale(
const Other& scalar )
2134 matrix_.scale( scalar );
2151 template<
typename MT
2153 template<
typename Other >
2154 inline UpperMatrix<MT,SO,false>&
2155 UpperMatrix<MT,SO,false>::scaleDiagonal(
const Other& scalar )
2157 matrix_.scaleDiagonal( scalar );
2182 template<
typename MT
2213 template<
typename MT
2215 template<
typename Other >
2216 inline bool UpperMatrix<MT,SO,false>::canAlias(
const Other* alias )
const noexcept
2218 return matrix_.canAlias( alias );
2235 template<
typename MT
2237 template<
typename Other >
2238 inline bool UpperMatrix<MT,SO,false>::isAliased(
const Other* alias )
const noexcept
2240 return matrix_.isAliased( alias );
2257 template<
typename MT
2259 inline bool UpperMatrix<MT,SO,false>::canSMPAssign() const noexcept
2261 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:3079
bool isUpper(const DenseMatrix< MT, SO > &dm)
Checks if the given dense matrix is an upper triangular matrix.
Definition: DenseMatrix.h:1328
#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
Header file for the Rows type trait.
BLAZE_ALWAYS_INLINE size_t capacity(const Matrix< MT, SO > &matrix) noexcept
Returns the maximum capacity of the matrix.
Definition: Matrix.h:356
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
BLAZE_ALWAYS_INLINE T1 & operator/=(SIMDPack< T1 > &lhs, const SIMDPack< T2 > &rhs)
Division assignment operator for the division of two SIMD packs.
Definition: BasicTypes.h:1411
Constraint on the data type.
This ResultType
Result type for expression template evaluations.
Definition: CompressedMatrix.h:3078
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:198
CompressedMatrix< Type, true > This
Type of this CompressedMatrix instance.
Definition: CompressedMatrix.h:3076
Constraint on the data type.
void reset(const DiagonalProxy< MT > &proxy)
Resetting the represented element to the default initial values.
Definition: DiagonalProxy.h:560
BLAZE_ALWAYS_INLINE void shrinkToFit(Matrix< MT, SO > &matrix)
Requesting the removal of unused capacity.
Definition: Matrix.h:609
void clear(CompressedMatrix< Type, SO > &m)
Clearing the given compressed matrix.
Definition: CompressedMatrix.h:5845
CompressedMatrix< Type, false > TransposeType
Transpose type for expression template evaluations.
Definition: CompressedMatrix.h:3080
const Type & ConstReference
Reference to a constant matrix value.
Definition: CompressedMatrix.h:3085
decltype(auto) declupp(const DenseMatrix< MT, SO > &dm)
Declares the given dense matrix expression dm as upper.
Definition: DMatDeclUppExpr.h:1027
#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:394
Element * Iterator
Iterator over non-constant elements.
Definition: CompressedMatrix.h:3086
BLAZE_ALWAYS_INLINE T1 & operator*=(SIMDPack< T1 > &lhs, const SIMDPack< T2 > &rhs)
Multiplication assignment operator for the multiplication of two SIMD packs.
Definition: BasicTypes.h:1393
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:308
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:242
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 DisableIf class template.
MatrixAccessProxy< This > Reference
Reference to a non-constant matrix value.
Definition: CompressedMatrix.h:3084
Header file for the clear shim.
Namespace of the Blaze C++ math library.
Definition: Blaze.h:57
#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:5924
bool isIntact(const CompressedMatrix< Type, SO > &m)
Returns whether the invariants of the given compressed matrix are intact.
Definition: CompressedMatrix.h:5907
SparseMatrix< This, true > BaseType
Base type of this CompressedMatrix instance.
Definition: CompressedMatrix.h:3077
#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:3081
#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
Header file for the Columns type trait.
const Element * ConstIterator
Iterator over constant elements.
Definition: CompressedMatrix.h:3087
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:340
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:548
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:264
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:580
Header file for the IsNumeric type trait.
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:270
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:324
const Type & ReturnType
Return type for expression template evaluations.
Definition: CompressedMatrix.h:3082
#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:3083
#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:252
bool isDefault(const DiagonalProxy< MT > &proxy)
Returns whether the represented element is in default state.
Definition: DiagonalProxy.h:600
#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.
BLAZE_ALWAYS_INLINE bool isSquare(const Matrix< MT, SO > &matrix) noexcept
Checks if the given matrix is a square matrix.
Definition: Matrix.h:742
#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