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_t<MT>;
107 using TT = TransposeType_t<MT>;
108 using ET = ElementType_t<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 >;
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 );
173 ~StrictlyUpperMatrix() =
default;
180 inline Reference operator()(
size_t i,
size_t j );
182 inline Reference at(
size_t i,
size_t j );
196 inline StrictlyUpperMatrix& operator=( initializer_list< initializer_list<ElementType> > list );
198 inline StrictlyUpperMatrix& operator=(
const StrictlyUpperMatrix& rhs );
199 inline StrictlyUpperMatrix& operator=( StrictlyUpperMatrix&& rhs ) noexcept;
201 template<
typename MT2,
bool SO2 >
202 inline auto operator=(
const Matrix<MT2,SO2>& rhs )
203 -> DisableIf_t< IsComputation_v<MT2>, StrictlyUpperMatrix& >;
205 template<
typename MT2,
bool SO2 >
206 inline auto operator=(
const Matrix<MT2,SO2>& rhs )
207 -> EnableIf_t< IsComputation_v<MT2>, StrictlyUpperMatrix& >;
209 template<
typename MT2,
bool SO2 >
210 inline auto operator+=(
const Matrix<MT2,SO2>& rhs )
211 -> DisableIf_t< IsComputation_v<MT2>, StrictlyUpperMatrix& >;
213 template<
typename MT2,
bool SO2 >
214 inline auto operator+=(
const Matrix<MT2,SO2>& rhs )
215 -> EnableIf_t< IsComputation_v<MT2>, StrictlyUpperMatrix& >;
217 template<
typename MT2,
bool SO2 >
218 inline auto operator-=(
const Matrix<MT2,SO2>& rhs )
219 -> DisableIf_t< IsComputation_v<MT2>, StrictlyUpperMatrix& >;
221 template<
typename MT2,
bool SO2 >
222 inline auto operator-=(
const Matrix<MT2,SO2>& rhs )
223 -> EnableIf_t< IsComputation_v<MT2>, StrictlyUpperMatrix& >;
225 template<
typename MT2,
bool SO2 >
226 inline auto operator%=(
const Matrix<MT2,SO2>& rhs ) -> StrictlyUpperMatrix&;
233 inline size_t rows() const noexcept;
234 inline
size_t columns() const noexcept;
235 inline
size_t capacity() const noexcept;
236 inline
size_t capacity(
size_t i ) const noexcept;
238 inline
size_t nonZeros(
size_t i ) const;
240 inline
void reset(
size_t i );
242 inline
void resize (
size_t n,
bool preserve=true );
243 inline
void reserve(
size_t nonzeros );
244 inline
void reserve(
size_t i,
size_t nonzeros );
246 inline
void trim(
size_t i );
248 inline
void swap( StrictlyUpperMatrix& m ) noexcept;
250 static inline constexpr
size_t maxNonZeros() noexcept;
251 static inline constexpr
size_t maxNonZeros(
size_t n ) noexcept;
260 inline
void append (
size_t i,
size_t j, const
ElementType& value,
bool check=false );
261 inline
void finalize(
size_t i );
268 inline
void erase(
size_t i,
size_t j );
272 template< typename Pred >
273 inline
void erase( Pred predicate );
275 template< typename Pred >
276 inline
void erase(
size_t i,
Iterator first,
Iterator last, Pred predicate );
283 inline
Iterator find (
size_t i,
size_t j );
285 inline
Iterator lowerBound(
size_t i,
size_t j );
287 inline
Iterator upperBound(
size_t i,
size_t j );
295 template< typename Other > inline StrictlyUpperMatrix& scale( const Other& scalar );
302 inline
bool isIntact() const noexcept;
309 template< typename Other > inline
bool canAlias ( const Other* alias ) const noexcept;
310 template< typename Other > inline
bool isAliased( const Other* alias ) const noexcept;
312 inline
bool canSMPAssign() const noexcept;
320 inline
void resetLower();
332 template< typename MT2,
bool SO2,
bool DF2 >
333 friend MT2& derestrict( StrictlyUpperMatrix<MT2,SO2,DF2>& m );
368 template< typename MT
370 inline StrictlyUpperMatrix<MT,SO,false>::StrictlyUpperMatrix()
387 template<
typename MT
389 inline StrictlyUpperMatrix<MT,SO,false>::StrictlyUpperMatrix(
size_t n )
410 template<
typename MT
412 inline StrictlyUpperMatrix<MT,SO,false>::StrictlyUpperMatrix(
size_t n,
size_t nonzeros )
413 : matrix_( n, n,
max( nonzeros, n ) )
437 template<
typename MT
439 inline StrictlyUpperMatrix<MT,SO,false>::StrictlyUpperMatrix(
size_t n,
const std::vector<size_t>& nonzeros )
440 : matrix_( n, n, nonzeros )
474 template<
typename MT
476 inline StrictlyUpperMatrix<MT,SO,false>::StrictlyUpperMatrix( initializer_list< initializer_list<ElementType> > list )
495 template<
typename MT
497 inline StrictlyUpperMatrix<MT,SO,false>::StrictlyUpperMatrix(
const StrictlyUpperMatrix& m )
498 : matrix_( m.matrix_ )
513 template<
typename MT
515 inline StrictlyUpperMatrix<MT,SO,false>::StrictlyUpperMatrix( StrictlyUpperMatrix&& m ) noexcept
516 : matrix_( std::move( m.matrix_ ) )
536 template<
typename MT
538 template<
typename MT2
540 inline StrictlyUpperMatrix<MT,SO,false>::StrictlyUpperMatrix(
const Matrix<MT2,SO2>& m )
543 if( IsUniTriangular_v<MT2> ||
548 if( !IsStrictlyUpper_v<MT2> )
582 template<
typename MT
585 StrictlyUpperMatrix<MT,SO,false>::operator()(
size_t i,
size_t j )
612 template<
typename MT
615 StrictlyUpperMatrix<MT,SO,false>::operator()(
size_t i,
size_t j )
const 643 template<
typename MT
646 StrictlyUpperMatrix<MT,SO,false>::at(
size_t i,
size_t j )
677 template<
typename MT
680 StrictlyUpperMatrix<MT,SO,false>::at(
size_t i,
size_t j )
const 706 template<
typename MT
711 return matrix_.begin(i);
729 template<
typename MT
734 return matrix_.begin(i);
752 template<
typename MT
757 return matrix_.cbegin(i);
775 template<
typename MT
780 return matrix_.end(i);
798 template<
typename MT
803 return matrix_.end(i);
821 template<
typename MT
826 return matrix_.cend(i);
865 template<
typename MT
867 inline StrictlyUpperMatrix<MT,SO,false>&
868 StrictlyUpperMatrix<MT,SO,false>::operator=( initializer_list< initializer_list<ElementType> > list )
870 const InitializerMatrix<ElementType> tmp( list, list.size() );
897 template<
typename MT
899 inline StrictlyUpperMatrix<MT,SO,false>&
900 StrictlyUpperMatrix<MT,SO,false>::operator=(
const StrictlyUpperMatrix& rhs )
902 matrix_ = rhs.matrix_;
920 template<
typename MT
922 inline StrictlyUpperMatrix<MT,SO,false>&
923 StrictlyUpperMatrix<MT,SO,false>::operator=( StrictlyUpperMatrix&& rhs ) noexcept
925 matrix_ = std::move( rhs.matrix_ );
949 template<
typename MT
951 template<
typename MT2
953 inline auto StrictlyUpperMatrix<MT,SO,false>::operator=(
const Matrix<MT2,SO2>& rhs )
954 -> DisableIf_t< IsComputation_v<MT2>, StrictlyUpperMatrix& >
956 if( IsUniTriangular_v<MT2> ||
963 if( !IsStrictlyUpper_v<MT2> )
988 template<
typename MT
990 template<
typename MT2
992 inline auto StrictlyUpperMatrix<MT,SO,false>::operator=(
const Matrix<MT2,SO2>& rhs )
993 -> EnableIf_t< IsComputation_v<MT2>, StrictlyUpperMatrix& >
995 if( IsUniTriangular_v<MT2> || ( !IsSquare_v<MT2> && !
isSquare( ~rhs ) ) ) {
999 if( IsStrictlyUpper_v<MT2> ) {
1009 matrix_ = std::move( tmp );
1012 if( !IsStrictlyUpper_v<MT2> )
1037 template<
typename MT
1039 template<
typename MT2
1042 -> DisableIf_t< IsComputation_v<MT2>, StrictlyUpperMatrix& >
1044 if( IsUniTriangular_v<MT2> ||
1051 if( !IsStrictlyUpper_v<MT2> )
1076 template<
typename MT
1078 template<
typename MT2
1081 -> EnableIf_t< IsComputation_v<MT2>, StrictlyUpperMatrix& >
1083 if( IsUniTriangular_v<MT2> || ( IsSquare_v<MT2> && !
isSquare( ~rhs ) ) ) {
1087 if( IsStrictlyUpper_v<MT2> ) {
1091 const ResultType_t<MT2> tmp( ~rhs );
1100 if( !IsStrictlyUpper_v<MT2> )
1125 template<
typename MT
1127 template<
typename MT2
1130 -> DisableIf_t< IsComputation_v<MT2>, StrictlyUpperMatrix& >
1132 if( IsUniTriangular_v<MT2> ||
1139 if( !IsStrictlyUpper_v<MT2> )
1164 template<
typename MT
1166 template<
typename MT2
1169 -> EnableIf_t< IsComputation_v<MT2>, StrictlyUpperMatrix& >
1171 if( IsUniTriangular_v<MT2> || ( !IsSquare_v<MT2> && !
isSquare( ~rhs ) ) ) {
1175 if( IsStrictlyUpper_v<MT2> ) {
1179 const ResultType_t<MT2> tmp( ~rhs );
1188 if( !IsStrictlyUpper_v<MT2> )
1211 template<
typename MT
1213 template<
typename MT2
1215 inline auto StrictlyUpperMatrix<MT,SO,false>::operator%=(
const Matrix<MT2,SO2>& rhs )
1216 -> StrictlyUpperMatrix&
1218 if( !IsSquare_v<MT2> && !
isSquare( ~rhs ) ) {
1224 if( !IsStrictlyUpper_v<MT2> )
1250 template<
typename MT
1254 return matrix_.rows();
1266 template<
typename MT
1270 return matrix_.columns();
1282 template<
typename MT
1286 return matrix_.capacity();
1304 template<
typename MT
1308 return matrix_.capacity(i);
1320 template<
typename MT
1324 return matrix_.nonZeros();
1342 template<
typename MT
1346 return matrix_.nonZeros(i);
1358 template<
typename MT
1365 for(
size_t j=1UL; j<
columns(); ++j ) {
1366 erase( matrix_, j, matrix_.begin(j), matrix_.lowerBound(j,j) );
1370 for(
size_t i=0UL; i<
rows(); ++i ) {
1371 erase( matrix_, i, matrix_.lowerBound(i,i+1UL), matrix_.end(i) );
1392 template<
typename MT
1399 erase( matrix_, i, matrix_.begin(i), matrix_.lowerBound(i,i) );
1402 erase( matrix_, i, matrix_.lowerBound(i,i+1UL), matrix_.end(i) );
1417 template<
typename MT
1423 if( IsResizable_v<MT> ) {
1449 template<
typename MT
1457 matrix_.resize( n, n, preserve );
1474 template<
typename MT
1476 inline void StrictlyUpperMatrix<MT,SO,false>::reserve(
size_t nonzeros )
1478 matrix_.reserve( nonzeros );
1499 template<
typename MT
1501 inline void StrictlyUpperMatrix<MT,SO,false>::reserve(
size_t i,
size_t nonzeros )
1503 matrix_.reserve( i, nonzeros );
1520 template<
typename MT
1522 inline void StrictlyUpperMatrix<MT,SO,false>::trim()
1542 template<
typename MT
1544 inline void StrictlyUpperMatrix<MT,SO,false>::trim(
size_t i )
1562 template<
typename MT
1566 matrix_.shrinkToFit();
1579 template<
typename MT
1585 swap( matrix_, m.matrix_ );
1603 template<
typename MT
1605 inline constexpr
size_t StrictlyUpperMatrix<MT,SO,false>::maxNonZeros() noexcept
1609 return maxNonZeros( Size_v<MT,0UL> );
1625 template<
typename MT
1627 inline constexpr
size_t StrictlyUpperMatrix<MT,SO,false>::maxNonZeros(
size_t n ) noexcept
1629 return ( ( n - 1UL ) * n ) / 2UL;
1641 template<
typename MT
1643 inline void StrictlyUpperMatrix<MT,SO,false>::resetLower()
1648 for(
size_t j=0UL; j<
columns(); ++j )
1649 erase( matrix_, j, matrix_.upperBound( j, j ), matrix_.end( j ) );
1652 for(
size_t i=1UL; i<
rows(); ++i )
1653 erase( matrix_, i, matrix_.begin( i ), matrix_.lowerBound( i, i ) );
1684 template<
typename MT
1693 return matrix_.set( i, j, value );
1716 template<
typename MT
1719 StrictlyUpperMatrix<MT,SO,false>::insert(
size_t i,
size_t j,
const ElementType& value )
1725 return matrix_.insert( i, j, value );
1781 template<
typename MT
1783 inline void StrictlyUpperMatrix<MT,SO,false>::append(
size_t i,
size_t j,
const ElementType& value,
bool check )
1789 matrix_.append( i, j, value, check );
1809 template<
typename MT
1811 inline void StrictlyUpperMatrix<MT,SO,false>::finalize(
size_t i )
1813 matrix_.finalize( i );
1837 template<
typename MT
1839 inline void StrictlyUpperMatrix<MT,SO,false>::erase(
size_t i,
size_t j )
1843 erase( matrix_, i, j );
1861 template<
typename MT
1864 StrictlyUpperMatrix<MT,SO,false>::erase(
size_t i,
Iterator pos )
1868 return erase( matrix_, i, pos );
1888 template<
typename MT
1891 StrictlyUpperMatrix<MT,SO,false>::erase(
size_t i,
Iterator first,
Iterator last )
1895 return erase( matrix_, i, first, last );
1923 template<
typename MT
1925 template<
typename Pred >
1926 inline void StrictlyUpperMatrix<MT,SO,false>::erase( Pred predicate )
1930 erase( matrix_, predicate );
1966 template<
typename MT
1968 template<
typename Pred >
1969 inline void StrictlyUpperMatrix<MT,SO,false>::erase(
size_t i,
Iterator first,
Iterator last, Pred predicate )
1973 erase( matrix_, i, first, last, predicate );
2005 template<
typename MT
2008 StrictlyUpperMatrix<MT,SO,false>::find(
size_t i,
size_t j )
2010 return matrix_.find( i, j );
2032 template<
typename MT
2035 StrictlyUpperMatrix<MT,SO,false>::find(
size_t i,
size_t j )
const 2037 return matrix_.find( i, j );
2059 template<
typename MT
2062 StrictlyUpperMatrix<MT,SO,false>::lowerBound(
size_t i,
size_t j )
2064 return matrix_.lowerBound( i, j );
2086 template<
typename MT
2089 StrictlyUpperMatrix<MT,SO,false>::lowerBound(
size_t i,
size_t j )
const 2091 return matrix_.lowerBound( i, j );
2113 template<
typename MT
2116 StrictlyUpperMatrix<MT,SO,false>::upperBound(
size_t i,
size_t j )
2118 return matrix_.upperBound( i, j );
2140 template<
typename MT
2143 StrictlyUpperMatrix<MT,SO,false>::upperBound(
size_t i,
size_t j )
const 2145 return matrix_.upperBound( i, j );
2177 template<
typename MT
2179 template<
typename Other >
2180 inline StrictlyUpperMatrix<MT,SO,false>&
2181 StrictlyUpperMatrix<MT,SO,false>::scale(
const Other& scalar )
2183 matrix_.scale( scalar );
2208 template<
typename MT
2239 template<
typename MT
2241 template<
typename Other >
2242 inline bool StrictlyUpperMatrix<MT,SO,false>::canAlias(
const Other* alias )
const noexcept
2244 return matrix_.canAlias( alias );
2261 template<
typename MT
2263 template<
typename Other >
2264 inline bool StrictlyUpperMatrix<MT,SO,false>::isAliased(
const Other* alias )
const noexcept
2266 return matrix_.isAliased( alias );
2283 template<
typename MT
2285 inline bool StrictlyUpperMatrix<MT,SO,false>::canSMPAssign() const noexcept
2287 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:3078
#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.
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: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.
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
decltype(auto) max(const DenseMatrix< MT1, SO1 > &lhs, const DenseMatrix< MT2, SO2 > &rhs)
Computes the componentwise maximum of the dense matrices lhs and rhs.
Definition: DMatDMatMapExpr.h:1179
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
Header file for the implementation of the base template of the StrictlyUpperMatrix.
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:1446
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
#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 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
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.