35 #ifndef _BLAZE_MATH_ADAPTORS_STRICTLYUPPERMATRIX_SPARSE_H_ 36 #define _BLAZE_MATH_ADAPTORS_STRICTLYUPPERMATRIX_SPARSE_H_ 101 class StrictlyUpperMatrix<MT,SO,false>
102 :
public SparseMatrix< StrictlyUpperMatrix<MT,SO,false>, SO >
106 using OT = OppositeType_<MT>;
107 using TT = TransposeType_<MT>;
108 using ET = ElementType_<MT>;
113 using This = StrictlyUpperMatrix<MT,SO,false>;
114 using BaseType = SparseMatrix<This,SO>;
121 using Reference = StrictlyUpperProxy<MT>;
130 template<
typename NewType >
133 using Other = StrictlyUpperMatrix< typename MT::template Rebind<NewType>::Other >;
140 template<
size_t NewM
144 using Other = StrictlyUpperMatrix< typename MT::template Resize<NewM,NewN>::Other >;
150 enum :
bool { smpAssignable =
false };
156 explicit inline StrictlyUpperMatrix();
157 explicit inline StrictlyUpperMatrix(
size_t n );
158 explicit inline StrictlyUpperMatrix(
size_t n,
size_t nonzeros );
159 explicit inline StrictlyUpperMatrix(
size_t n,
const std::vector<size_t>& nonzeros );
160 explicit inline StrictlyUpperMatrix( initializer_list< initializer_list<ElementType> > list );
162 inline StrictlyUpperMatrix(
const StrictlyUpperMatrix& m );
163 inline StrictlyUpperMatrix( StrictlyUpperMatrix&& m ) noexcept;
165 template<
typename MT2,
bool SO2 >
166 inline StrictlyUpperMatrix(
const Matrix<MT2,SO2>& m );
177 inline Reference operator()(
size_t i,
size_t j );
179 inline Reference at(
size_t i,
size_t j );
193 inline StrictlyUpperMatrix& operator=( initializer_list< initializer_list<ElementType> > list );
195 inline StrictlyUpperMatrix& operator=(
const StrictlyUpperMatrix& rhs );
196 inline StrictlyUpperMatrix& operator=( StrictlyUpperMatrix&& rhs ) noexcept;
198 template<
typename MT2,
bool SO2 >
199 inline DisableIf_< IsComputation<MT2>, StrictlyUpperMatrix& >
200 operator=(
const Matrix<MT2,SO2>& rhs );
202 template<
typename MT2,
bool SO2 >
203 inline EnableIf_< IsComputation<MT2>, StrictlyUpperMatrix& >
204 operator=(
const Matrix<MT2,SO2>& rhs );
206 template<
typename MT2,
bool SO2 >
207 inline DisableIf_< IsComputation<MT2>, StrictlyUpperMatrix& >
210 template<
typename MT2,
bool SO2 >
211 inline EnableIf_< IsComputation<MT2>, StrictlyUpperMatrix& >
214 template<
typename MT2,
bool SO2 >
215 inline DisableIf_< IsComputation<MT2>, StrictlyUpperMatrix& >
218 template<
typename MT2,
bool SO2 >
219 inline EnableIf_< IsComputation<MT2>, StrictlyUpperMatrix& >
222 template<
typename MT2,
bool SO2 >
223 inline StrictlyUpperMatrix& operator%=(
const Matrix<MT2,SO2>& rhs );
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( StrictlyUpperMatrix& 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 StrictlyUpperMatrix& 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< typename MT2,
bool SO2,
bool DF2 >
330 friend MT2& derestrict( StrictlyUpperMatrix<MT2,SO2,DF2>& m );
365 template< typename MT
367 inline StrictlyUpperMatrix<MT,SO,false>::StrictlyUpperMatrix()
384 template<
typename MT
386 inline StrictlyUpperMatrix<MT,SO,false>::StrictlyUpperMatrix(
size_t n )
407 template<
typename MT
409 inline StrictlyUpperMatrix<MT,SO,false>::StrictlyUpperMatrix(
size_t n,
size_t nonzeros )
410 : matrix_( n, n,
max( nonzeros, n ) )
434 template<
typename MT
436 inline StrictlyUpperMatrix<MT,SO,false>::StrictlyUpperMatrix(
size_t n,
const std::vector<size_t>& nonzeros )
437 : matrix_( n, n, nonzeros )
471 template<
typename MT
473 inline StrictlyUpperMatrix<MT,SO,false>::StrictlyUpperMatrix( initializer_list< initializer_list<ElementType> > list )
492 template<
typename MT
494 inline StrictlyUpperMatrix<MT,SO,false>::StrictlyUpperMatrix(
const StrictlyUpperMatrix& m )
495 : matrix_( m.matrix_ )
510 template<
typename MT
512 inline StrictlyUpperMatrix<MT,SO,false>::StrictlyUpperMatrix( StrictlyUpperMatrix&& m ) noexcept
513 : matrix_( std::move( m.matrix_ ) )
533 template<
typename MT
535 template<
typename MT2
537 inline StrictlyUpperMatrix<MT,SO,false>::StrictlyUpperMatrix(
const Matrix<MT2,SO2>& m )
540 if( IsUniTriangular<MT2>::value ||
545 if( !IsStrictlyUpper<MT2>::value )
579 template<
typename MT
582 StrictlyUpperMatrix<MT,SO,false>::operator()(
size_t i,
size_t j )
609 template<
typename MT
612 StrictlyUpperMatrix<MT,SO,false>::operator()(
size_t i,
size_t j )
const 640 template<
typename MT
643 StrictlyUpperMatrix<MT,SO,false>::at(
size_t i,
size_t j )
674 template<
typename MT
677 StrictlyUpperMatrix<MT,SO,false>::at(
size_t i,
size_t j )
const 703 template<
typename MT
708 return matrix_.begin(i);
726 template<
typename MT
731 return matrix_.begin(i);
749 template<
typename MT
754 return matrix_.cbegin(i);
772 template<
typename MT
777 return matrix_.end(i);
795 template<
typename MT
800 return matrix_.end(i);
818 template<
typename MT
823 return matrix_.cend(i);
862 template<
typename MT
864 inline StrictlyUpperMatrix<MT,SO,false>&
865 StrictlyUpperMatrix<MT,SO,false>::operator=( initializer_list< initializer_list<ElementType> > list )
867 const InitializerMatrix<ElementType> tmp( list, list.size() );
894 template<
typename MT
896 inline StrictlyUpperMatrix<MT,SO,false>&
897 StrictlyUpperMatrix<MT,SO,false>::operator=(
const StrictlyUpperMatrix& rhs )
899 matrix_ = rhs.matrix_;
917 template<
typename MT
919 inline StrictlyUpperMatrix<MT,SO,false>&
920 StrictlyUpperMatrix<MT,SO,false>::operator=( StrictlyUpperMatrix&& rhs ) noexcept
922 matrix_ = std::move( rhs.matrix_ );
946 template<
typename MT
948 template<
typename MT2
950 inline DisableIf_< IsComputation<MT2>, StrictlyUpperMatrix<MT,SO,false>& >
951 StrictlyUpperMatrix<MT,SO,false>::operator=(
const Matrix<MT2,SO2>& rhs )
953 if( IsUniTriangular<MT2>::value ||
960 if( !IsStrictlyUpper<MT2>::value )
985 template<
typename MT
987 template<
typename MT2
989 inline EnableIf_< IsComputation<MT2>, StrictlyUpperMatrix<MT,SO,false>& >
990 StrictlyUpperMatrix<MT,SO,false>::operator=(
const Matrix<MT2,SO2>& rhs )
992 if( IsUniTriangular<MT2>::value || ( !IsSquare<MT2>::value && !
isSquare( ~rhs ) ) ) {
996 if( IsStrictlyUpper<MT2>::value ) {
1006 matrix_ = std::move( tmp );
1009 if( !IsStrictlyUpper<MT2>::value )
1034 template<
typename MT
1036 template<
typename MT2
1038 inline DisableIf_< IsComputation<MT2>, StrictlyUpperMatrix<MT,SO,false>& >
1041 if( IsUniTriangular<MT2>::value ||
1048 if( !IsStrictlyUpper<MT2>::value )
1073 template<
typename MT
1075 template<
typename MT2
1077 inline EnableIf_< IsComputation<MT2>, StrictlyUpperMatrix<MT,SO,false>& >
1080 if( IsUniTriangular<MT2>::value || ( IsSquare<MT2>::value && !
isSquare( ~rhs ) ) ) {
1084 if( IsStrictlyUpper<MT2>::value ) {
1088 const ResultType_<MT2> tmp( ~rhs );
1097 if( !IsStrictlyUpper<MT2>::value )
1122 template<
typename MT
1124 template<
typename MT2
1126 inline DisableIf_< IsComputation<MT2>, StrictlyUpperMatrix<MT,SO,false>& >
1129 if( IsUniTriangular<MT2>::value ||
1136 if( !IsStrictlyUpper<MT2>::value )
1161 template<
typename MT
1163 template<
typename MT2
1165 inline EnableIf_< IsComputation<MT2>, StrictlyUpperMatrix<MT,SO,false>& >
1168 if( IsUniTriangular<MT2>::value || ( !IsSquare<MT2>::value && !
isSquare( ~rhs ) ) ) {
1172 if( IsStrictlyUpper<MT2>::value ) {
1176 const ResultType_<MT2> tmp( ~rhs );
1185 if( !IsStrictlyUpper<MT2>::value )
1208 template<
typename MT
1210 template<
typename MT2
1212 inline StrictlyUpperMatrix<MT,SO,false>&
1213 StrictlyUpperMatrix<MT,SO,false>::operator%=(
const Matrix<MT2,SO2>& rhs )
1215 if( !IsSquare<MT2>::value && !
isSquare( ~rhs ) ) {
1221 if( !IsStrictlyUpper<MT2>::value )
1247 template<
typename MT
1251 return matrix_.rows();
1263 template<
typename MT
1267 return matrix_.columns();
1279 template<
typename MT
1283 return matrix_.capacity();
1301 template<
typename MT
1305 return matrix_.capacity(i);
1317 template<
typename MT
1321 return matrix_.nonZeros();
1339 template<
typename MT
1343 return matrix_.nonZeros(i);
1355 template<
typename MT
1360 for(
size_t j=1UL; j<
columns(); ++j ) {
1361 matrix_.erase( j, matrix_.begin(j), matrix_.lowerBound(j,j) );
1365 for(
size_t i=0UL; i<
rows(); ++i ) {
1366 matrix_.erase( i, matrix_.lowerBound(i,i+1UL), matrix_.end(i) );
1387 template<
typename MT
1392 matrix_.erase( i, matrix_.begin(i), matrix_.lowerBound(i,i) );
1395 matrix_.erase( i, matrix_.lowerBound(i,i+1UL), matrix_.end(i) );
1410 template<
typename MT
1416 if( IsResizable<MT>::value ) {
1442 template<
typename MT
1450 matrix_.resize( n, n, preserve );
1467 template<
typename MT
1469 inline void StrictlyUpperMatrix<MT,SO,false>::reserve(
size_t nonzeros )
1471 matrix_.reserve( nonzeros );
1492 template<
typename MT
1494 inline void StrictlyUpperMatrix<MT,SO,false>::reserve(
size_t i,
size_t nonzeros )
1496 matrix_.reserve( i, nonzeros );
1513 template<
typename MT
1515 inline void StrictlyUpperMatrix<MT,SO,false>::trim()
1535 template<
typename MT
1537 inline void StrictlyUpperMatrix<MT,SO,false>::trim(
size_t i )
1555 template<
typename MT
1559 matrix_.shrinkToFit();
1572 template<
typename MT
1578 swap( matrix_, m.matrix_ );
1596 template<
typename MT
1598 inline constexpr
size_t StrictlyUpperMatrix<MT,SO,false>::maxNonZeros() noexcept
1602 return maxNonZeros( Size<MT,0UL>::value );
1618 template<
typename MT
1620 inline constexpr
size_t StrictlyUpperMatrix<MT,SO,false>::maxNonZeros(
size_t n ) noexcept
1622 return ( ( n - 1UL ) * n ) / 2UL;
1634 template<
typename MT
1636 inline void StrictlyUpperMatrix<MT,SO,false>::resetLower()
1639 for(
size_t j=0UL; j<
columns(); ++j )
1640 matrix_.erase( j, matrix_.upperBound( j, j ), matrix_.end( j ) );
1643 for(
size_t i=1UL; i<
rows(); ++i )
1644 matrix_.erase( i, matrix_.begin( i ), matrix_.lowerBound( i, i ) );
1675 template<
typename MT
1684 return matrix_.set( i, j, value );
1707 template<
typename MT
1710 StrictlyUpperMatrix<MT,SO,false>::insert(
size_t i,
size_t j,
const ElementType& value )
1716 return matrix_.insert( i, j, value );
1772 template<
typename MT
1774 inline void StrictlyUpperMatrix<MT,SO,false>::append(
size_t i,
size_t j,
const ElementType& value,
bool check )
1780 matrix_.append( i, j, value, check );
1800 template<
typename MT
1802 inline void StrictlyUpperMatrix<MT,SO,false>::finalize(
size_t i )
1804 matrix_.finalize( i );
1828 template<
typename MT
1830 inline void StrictlyUpperMatrix<MT,SO,false>::erase(
size_t i,
size_t j )
1832 matrix_.erase( i, j );
1850 template<
typename MT
1853 StrictlyUpperMatrix<MT,SO,false>::erase(
size_t i,
Iterator pos )
1855 return matrix_.erase( i, pos );
1875 template<
typename MT
1878 StrictlyUpperMatrix<MT,SO,false>::erase(
size_t i,
Iterator first,
Iterator last )
1880 return matrix_.erase( i, first, last );
1908 template<
typename MT
1910 template<
typename Pred >
1911 inline void StrictlyUpperMatrix<MT,SO,false>::erase( Pred predicate )
1913 matrix_.erase( predicate );
1949 template<
typename MT
1951 template<
typename Pred >
1952 inline void StrictlyUpperMatrix<MT,SO,false>::erase(
size_t i,
Iterator first,
Iterator last, Pred predicate )
1954 matrix_.erase( i, first, last, predicate );
1986 template<
typename MT
1989 StrictlyUpperMatrix<MT,SO,false>::find(
size_t i,
size_t j )
1991 return matrix_.find( i, j );
2013 template<
typename MT
2016 StrictlyUpperMatrix<MT,SO,false>::find(
size_t i,
size_t j )
const 2018 return matrix_.find( i, j );
2040 template<
typename MT
2043 StrictlyUpperMatrix<MT,SO,false>::lowerBound(
size_t i,
size_t j )
2045 return matrix_.lowerBound( i, j );
2067 template<
typename MT
2070 StrictlyUpperMatrix<MT,SO,false>::lowerBound(
size_t i,
size_t j )
const 2072 return matrix_.lowerBound( i, j );
2094 template<
typename MT
2097 StrictlyUpperMatrix<MT,SO,false>::upperBound(
size_t i,
size_t j )
2099 return matrix_.upperBound( i, j );
2121 template<
typename MT
2124 StrictlyUpperMatrix<MT,SO,false>::upperBound(
size_t i,
size_t j )
const 2126 return matrix_.upperBound( i, j );
2158 template<
typename MT
2160 template<
typename Other >
2161 inline StrictlyUpperMatrix<MT,SO,false>&
2162 StrictlyUpperMatrix<MT,SO,false>::scale(
const Other& scalar )
2164 matrix_.scale( scalar );
2189 template<
typename MT
2220 template<
typename MT
2222 template<
typename Other >
2223 inline bool StrictlyUpperMatrix<MT,SO,false>::canAlias(
const Other* alias )
const noexcept
2225 return matrix_.canAlias( alias );
2242 template<
typename MT
2244 template<
typename Other >
2245 inline bool StrictlyUpperMatrix<MT,SO,false>::isAliased(
const Other* alias )
const noexcept
2247 return matrix_.isAliased( alias );
2264 template<
typename MT
2266 inline bool StrictlyUpperMatrix<MT,SO,false>::canSMPAssign() const noexcept
2268 return matrix_.canSMPAssign();
Header file for the StrictlyUpperProxy class.
#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
#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
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
decltype(auto) declupp(const DenseMatrix< MT, SO > &dm)
Declares the given dense matrix expression dm as upper.
Definition: DMatDeclUppExpr.h:1026
#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.
Header file for the IsStrictlyUpper type trait.
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.
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 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.
void clear(const DiagonalProxy< MT > &proxy)
Clearing the represented element.
Definition: DiagonalProxy.h:608
Header file for the implementation of the base template of the StrictlyUpperMatrix.
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
bool isStrictlyUpper(const DenseMatrix< MT, SO > &dm)
Checks if the given dense matrix is a strictly upper triangular matrix.
Definition: DenseMatrix.h:1641
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
#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