35 #ifndef _BLAZE_MATH_ADAPTORS_STRICTLYUPPERMATRIX_SPARSE_H_ 36 #define _BLAZE_MATH_ADAPTORS_STRICTLYUPPERMATRIX_SPARSE_H_ 100 class StrictlyUpperMatrix<MT,SO,false>
101 :
public SparseMatrix< StrictlyUpperMatrix<MT,SO,false>, SO >
105 typedef OppositeType_<MT> OT;
106 typedef TransposeType_<MT> TT;
107 typedef ElementType_<MT> ET;
112 typedef StrictlyUpperMatrix<MT,SO,false>
This;
113 typedef SparseMatrix<This,SO>
BaseType;
120 typedef StrictlyUpperProxy<MT>
Reference;
129 template<
typename NewType >
132 typedef StrictlyUpperMatrix< typename MT::template Rebind<NewType>::Other > Other;
139 template<
size_t NewM
143 typedef StrictlyUpperMatrix< typename MT::template Resize<NewM,NewN>::Other > Other;
149 enum :
bool { smpAssignable =
false };
155 explicit inline StrictlyUpperMatrix();
156 explicit inline StrictlyUpperMatrix(
size_t n );
157 explicit inline StrictlyUpperMatrix(
size_t n,
size_t nonzeros );
158 explicit inline StrictlyUpperMatrix(
size_t n,
const std::vector<size_t>& nonzeros );
160 inline StrictlyUpperMatrix(
const StrictlyUpperMatrix& m );
161 inline StrictlyUpperMatrix( StrictlyUpperMatrix&& m ) noexcept;
163 template<
typename MT2,
bool SO2 >
164 inline StrictlyUpperMatrix(
const Matrix<MT2,SO2>& m );
175 inline Reference operator()(
size_t i,
size_t j );
176 inline ConstReference operator()(
size_t i,
size_t j )
const;
177 inline Reference at(
size_t i,
size_t j );
178 inline ConstReference at(
size_t i,
size_t j )
const;
179 inline Iterator
begin (
size_t i );
180 inline ConstIterator
begin (
size_t i )
const;
181 inline ConstIterator
cbegin(
size_t i )
const;
182 inline Iterator
end (
size_t i );
183 inline ConstIterator
end (
size_t i )
const;
184 inline ConstIterator
cend (
size_t i )
const;
191 inline StrictlyUpperMatrix& operator=(
const StrictlyUpperMatrix& rhs );
192 inline StrictlyUpperMatrix& operator=( StrictlyUpperMatrix&& rhs ) noexcept;
194 template<
typename MT2,
bool SO2 >
195 inline DisableIf_< IsComputation<MT2>, StrictlyUpperMatrix& >
196 operator=(
const Matrix<MT2,SO2>& rhs );
198 template<
typename MT2,
bool SO2 >
199 inline EnableIf_< IsComputation<MT2>, StrictlyUpperMatrix& >
200 operator=(
const Matrix<MT2,SO2>& rhs );
202 template<
typename MT2,
bool SO2 >
203 inline DisableIf_< IsComputation<MT2>, StrictlyUpperMatrix& >
206 template<
typename MT2,
bool SO2 >
207 inline EnableIf_< IsComputation<MT2>, StrictlyUpperMatrix& >
210 template<
typename MT2,
bool SO2 >
211 inline DisableIf_< IsComputation<MT2>, StrictlyUpperMatrix& >
214 template<
typename MT2,
bool SO2 >
215 inline EnableIf_< IsComputation<MT2>, StrictlyUpperMatrix& >
218 template<
typename MT2,
bool SO2 >
219 inline StrictlyUpperMatrix&
operator*=(
const Matrix<MT2,SO2>& rhs );
221 template<
typename Other >
222 inline EnableIf_< IsNumeric<Other>, StrictlyUpperMatrix >&
operator*=( Other rhs );
224 template<
typename Other >
225 inline EnableIf_< IsNumeric<Other>, StrictlyUpperMatrix >&
operator/=( Other rhs );
232 inline size_t rows() const noexcept;
233 inline
size_t columns() const noexcept;
234 inline
size_t capacity() const noexcept;
235 inline
size_t capacity(
size_t i ) const noexcept;
237 inline
size_t nonZeros(
size_t i ) const;
239 inline
void reset(
size_t i );
241 inline
void resize (
size_t n,
bool preserve=true );
242 inline
void reserve(
size_t nonzeros );
243 inline
void reserve(
size_t i,
size_t nonzeros );
245 inline
void trim(
size_t i );
246 inline
void swap( StrictlyUpperMatrix& m ) noexcept;
248 static inline constexpr
size_t maxNonZeros() noexcept;
249 static inline constexpr
size_t maxNonZeros(
size_t n ) noexcept;
256 inline Iterator
set (
size_t i,
size_t j, const ElementType& value );
257 inline Iterator insert (
size_t i,
size_t j, const ElementType& value );
258 inline
void append (
size_t i,
size_t j, const ElementType& value,
bool check=false );
259 inline
void finalize(
size_t i );
266 inline
void erase(
size_t i,
size_t j );
267 inline Iterator erase(
size_t i, Iterator pos );
268 inline Iterator erase(
size_t i, Iterator first, Iterator last );
270 template< typename Pred >
271 inline
void erase( Pred predicate );
273 template< typename Pred >
274 inline
void erase(
size_t i, Iterator first, Iterator last, Pred predicate );
281 inline Iterator find (
size_t i,
size_t j );
282 inline ConstIterator find (
size_t i,
size_t j ) const;
283 inline Iterator lowerBound(
size_t i,
size_t j );
284 inline ConstIterator lowerBound(
size_t i,
size_t j ) const;
285 inline Iterator upperBound(
size_t i,
size_t j );
286 inline ConstIterator upperBound(
size_t i,
size_t j ) const;
293 template< typename Other > inline StrictlyUpperMatrix& scale( const Other& scalar );
294 template< typename Other > inline StrictlyUpperMatrix& scaleDiagonal( const Other& scale );
301 inline
bool isIntact() const noexcept;
308 template< typename Other > inline
bool canAlias ( const Other* alias ) const noexcept;
309 template< typename Other > inline
bool isAliased( const Other* alias ) const noexcept;
311 inline
bool canSMPAssign() const noexcept;
319 inline
void resetLower();
331 template< typename MT2,
bool SO2,
bool DF2 >
332 friend MT2& derestrict( StrictlyUpperMatrix<MT2,SO2,DF2>& m );
367 template< typename MT
369 inline StrictlyUpperMatrix<MT,SO,false>::StrictlyUpperMatrix()
386 template<
typename MT
388 inline StrictlyUpperMatrix<MT,SO,false>::StrictlyUpperMatrix(
size_t n )
409 template<
typename MT
411 inline StrictlyUpperMatrix<MT,SO,false>::StrictlyUpperMatrix(
size_t n,
size_t nonzeros )
412 : matrix_( n, n,
max( nonzeros, n ) )
436 template<
typename MT
438 inline StrictlyUpperMatrix<MT,SO,false>::StrictlyUpperMatrix(
size_t n,
const std::vector<size_t>& nonzeros )
439 : matrix_( n, n, nonzeros )
455 template<
typename MT
457 inline StrictlyUpperMatrix<MT,SO,false>::StrictlyUpperMatrix(
const StrictlyUpperMatrix& m )
458 : matrix_( m.matrix_ )
473 template<
typename MT
475 inline StrictlyUpperMatrix<MT,SO,false>::StrictlyUpperMatrix( StrictlyUpperMatrix&& m ) noexcept
476 : matrix_( std::move( m.matrix_ ) )
496 template<
typename MT
498 template<
typename MT2
500 inline StrictlyUpperMatrix<MT,SO,false>::StrictlyUpperMatrix(
const Matrix<MT2,SO2>& m )
503 if( IsUniTriangular<MT2>::value ||
508 if( !IsStrictlyUpper<MT2>::value )
542 template<
typename MT
545 StrictlyUpperMatrix<MT,SO,false>::operator()(
size_t i,
size_t j )
572 template<
typename MT
575 StrictlyUpperMatrix<MT,SO,false>::operator()(
size_t i,
size_t j )
const 603 template<
typename MT
606 StrictlyUpperMatrix<MT,SO,false>::at(
size_t i,
size_t j )
637 template<
typename MT
640 StrictlyUpperMatrix<MT,SO,false>::at(
size_t i,
size_t j )
const 666 template<
typename MT
671 return matrix_.begin(i);
689 template<
typename MT
694 return matrix_.begin(i);
712 template<
typename MT
717 return matrix_.cbegin(i);
735 template<
typename MT
740 return matrix_.end(i);
758 template<
typename MT
763 return matrix_.end(i);
781 template<
typename MT
786 return matrix_.cend(i);
810 template<
typename MT
812 inline StrictlyUpperMatrix<MT,SO,false>&
813 StrictlyUpperMatrix<MT,SO,false>::operator=(
const StrictlyUpperMatrix& rhs )
815 matrix_ = rhs.matrix_;
833 template<
typename MT
835 inline StrictlyUpperMatrix<MT,SO,false>&
836 StrictlyUpperMatrix<MT,SO,false>::operator=( StrictlyUpperMatrix&& rhs ) noexcept
838 matrix_ = std::move( rhs.matrix_ );
862 template<
typename MT
864 template<
typename MT2
866 inline DisableIf_< IsComputation<MT2>, StrictlyUpperMatrix<MT,SO,false>& >
867 StrictlyUpperMatrix<MT,SO,false>::operator=(
const Matrix<MT2,SO2>& rhs )
869 if( IsUniTriangular<MT2>::value ||
876 if( !IsStrictlyUpper<MT2>::value )
901 template<
typename MT
903 template<
typename MT2
905 inline EnableIf_< IsComputation<MT2>, StrictlyUpperMatrix<MT,SO,false>& >
906 StrictlyUpperMatrix<MT,SO,false>::operator=(
const Matrix<MT2,SO2>& rhs )
908 if( IsUniTriangular<MT2>::value || ( !IsSquare<MT2>::value && !
isSquare( ~rhs ) ) ) {
912 if( IsStrictlyUpper<MT2>::value ) {
922 matrix_ = std::move( tmp );
925 if( !IsStrictlyUpper<MT2>::value )
950 template<
typename MT
952 template<
typename MT2
954 inline DisableIf_< IsComputation<MT2>, StrictlyUpperMatrix<MT,SO,false>& >
957 if( IsUniTriangular<MT2>::value ||
964 if( !IsStrictlyUpper<MT2>::value )
989 template<
typename MT
991 template<
typename MT2
993 inline EnableIf_< IsComputation<MT2>, StrictlyUpperMatrix<MT,SO,false>& >
996 if( IsUniTriangular<MT2>::value || ( IsSquare<MT2>::value && !
isSquare( ~rhs ) ) ) {
1000 if( IsStrictlyUpper<MT2>::value ) {
1004 const ResultType_<MT2> tmp( ~rhs );
1013 if( !IsStrictlyUpper<MT2>::value )
1038 template<
typename MT
1040 template<
typename MT2
1042 inline DisableIf_< IsComputation<MT2>, StrictlyUpperMatrix<MT,SO,false>& >
1045 if( IsUniTriangular<MT2>::value ||
1052 if( !IsStrictlyUpper<MT2>::value )
1077 template<
typename MT
1079 template<
typename MT2
1081 inline EnableIf_< IsComputation<MT2>, StrictlyUpperMatrix<MT,SO,false>& >
1084 if( IsUniTriangular<MT2>::value || ( !IsSquare<MT2>::value && !
isSquare( ~rhs ) ) ) {
1088 if( IsStrictlyUpper<MT2>::value ) {
1092 const ResultType_<MT2> tmp( ~rhs );
1101 if( !IsStrictlyUpper<MT2>::value )
1125 template<
typename MT
1127 template<
typename MT2
1129 inline StrictlyUpperMatrix<MT,SO,false>&
1132 if( matrix_.rows() != (~rhs).
columns() ) {
1136 MT tmp( matrix_ * ~rhs );
1142 matrix_ = std::move( tmp );
1144 if( !IsStrictlyUpper<MT2>::value )
1164 template<
typename MT
1166 template<
typename Other >
1167 inline EnableIf_< IsNumeric<Other>, StrictlyUpperMatrix<MT,SO,false> >&
1184 template<
typename MT
1186 template<
typename Other >
1187 inline EnableIf_< IsNumeric<Other>, StrictlyUpperMatrix<MT,SO,false> >&
1213 template<
typename MT
1217 return matrix_.rows();
1229 template<
typename MT
1233 return matrix_.columns();
1245 template<
typename MT
1249 return matrix_.capacity();
1267 template<
typename MT
1271 return matrix_.capacity(i);
1283 template<
typename MT
1287 return matrix_.nonZeros();
1305 template<
typename MT
1309 return matrix_.nonZeros(i);
1321 template<
typename MT
1326 for(
size_t j=1UL; j<
columns(); ++j ) {
1327 matrix_.erase( j, matrix_.begin(j), matrix_.lowerBound(j,j) );
1331 for(
size_t i=0UL; i<
rows(); ++i ) {
1332 matrix_.erase( i, matrix_.lowerBound(i,i+1UL), matrix_.end(i) );
1353 template<
typename MT
1358 matrix_.erase( i, matrix_.begin(i), matrix_.lowerBound(i,i) );
1361 matrix_.erase( i, matrix_.lowerBound(i,i+1UL), matrix_.end(i) );
1376 template<
typename MT
1382 if( IsResizable<MT>::value ) {
1408 template<
typename MT
1416 matrix_.resize( n, n, preserve );
1433 template<
typename MT
1435 inline void StrictlyUpperMatrix<MT,SO,false>::reserve(
size_t nonzeros )
1437 matrix_.reserve( nonzeros );
1458 template<
typename MT
1460 inline void StrictlyUpperMatrix<MT,SO,false>::reserve(
size_t i,
size_t nonzeros )
1462 matrix_.reserve( i, nonzeros );
1479 template<
typename MT
1481 inline void StrictlyUpperMatrix<MT,SO,false>::trim()
1501 template<
typename MT
1503 inline void StrictlyUpperMatrix<MT,SO,false>::trim(
size_t i )
1518 template<
typename MT
1524 swap( matrix_, m.matrix_ );
1542 template<
typename MT
1544 inline constexpr
size_t StrictlyUpperMatrix<MT,SO,false>::maxNonZeros() noexcept
1548 return maxNonZeros( Rows<MT>::value );
1564 template<
typename MT
1566 inline constexpr
size_t StrictlyUpperMatrix<MT,SO,false>::maxNonZeros(
size_t n ) noexcept
1568 return ( ( n - 1UL ) * n ) / 2UL;
1580 template<
typename MT
1582 inline void StrictlyUpperMatrix<MT,SO,false>::resetLower()
1585 for(
size_t j=0UL; j<
columns(); ++j )
1586 matrix_.erase( j, matrix_.upperBound( j, j ), matrix_.end( j ) );
1589 for(
size_t i=1UL; i<
rows(); ++i )
1590 matrix_.erase( i, matrix_.begin( i ), matrix_.lowerBound( i, i ) );
1621 template<
typename MT
1630 return matrix_.set( i, j, value );
1653 template<
typename MT
1656 StrictlyUpperMatrix<MT,SO,false>::insert(
size_t i,
size_t j,
const ElementType& value )
1662 return matrix_.insert( i, j, value );
1718 template<
typename MT
1720 inline void StrictlyUpperMatrix<MT,SO,false>::append(
size_t i,
size_t j,
const ElementType& value,
bool check )
1726 matrix_.append( i, j, value, check );
1746 template<
typename MT
1748 inline void StrictlyUpperMatrix<MT,SO,false>::finalize(
size_t i )
1750 matrix_.finalize( i );
1774 template<
typename MT
1776 inline void StrictlyUpperMatrix<MT,SO,false>::erase(
size_t i,
size_t j )
1778 matrix_.erase( i, j );
1796 template<
typename MT
1799 StrictlyUpperMatrix<MT,SO,false>::erase(
size_t i, Iterator pos )
1801 return matrix_.erase( i, pos );
1821 template<
typename MT
1824 StrictlyUpperMatrix<MT,SO,false>::erase(
size_t i, Iterator first, Iterator last )
1826 return matrix_.erase( i, first, last );
1854 template<
typename MT
1856 template<
typename Pred >
1857 inline void StrictlyUpperMatrix<MT,SO,false>::erase( Pred predicate )
1859 matrix_.erase( predicate );
1895 template<
typename MT
1897 template<
typename Pred >
1898 inline void StrictlyUpperMatrix<MT,SO,false>::erase(
size_t i, Iterator first, Iterator last, Pred predicate )
1900 matrix_.erase( i, first, last, predicate );
1932 template<
typename MT
1935 StrictlyUpperMatrix<MT,SO,false>::find(
size_t i,
size_t j )
1937 return matrix_.find( i, j );
1959 template<
typename MT
1962 StrictlyUpperMatrix<MT,SO,false>::find(
size_t i,
size_t j )
const 1964 return matrix_.find( i, j );
1986 template<
typename MT
1989 StrictlyUpperMatrix<MT,SO,false>::lowerBound(
size_t i,
size_t j )
1991 return matrix_.lowerBound( i, j );
2013 template<
typename MT
2016 StrictlyUpperMatrix<MT,SO,false>::lowerBound(
size_t i,
size_t j )
const 2018 return matrix_.lowerBound( i, j );
2040 template<
typename MT
2043 StrictlyUpperMatrix<MT,SO,false>::upperBound(
size_t i,
size_t j )
2045 return matrix_.upperBound( i, j );
2067 template<
typename MT
2070 StrictlyUpperMatrix<MT,SO,false>::upperBound(
size_t i,
size_t j )
const 2072 return matrix_.upperBound( i, j );
2093 template<
typename MT
2095 template<
typename Other >
2096 inline StrictlyUpperMatrix<MT,SO,false>&
2097 StrictlyUpperMatrix<MT,SO,false>::scale(
const Other& scalar )
2099 matrix_.scale( scalar );
2113 template<
typename MT
2115 template<
typename Other >
2116 inline StrictlyUpperMatrix<MT,SO,false>&
2117 StrictlyUpperMatrix<MT,SO,false>::scaleDiagonal(
const Other& scalar )
2119 matrix_.scaleDiagonal( scalar );
2144 template<
typename MT
2175 template<
typename MT
2177 template<
typename Other >
2178 inline bool StrictlyUpperMatrix<MT,SO,false>::canAlias(
const Other* alias )
const noexcept
2180 return matrix_.canAlias( alias );
2197 template<
typename MT
2199 template<
typename Other >
2200 inline bool StrictlyUpperMatrix<MT,SO,false>::isAliased(
const Other* alias )
const noexcept
2202 return matrix_.isAliased( alias );
2219 template<
typename MT
2221 inline bool StrictlyUpperMatrix<MT,SO,false>::canSMPAssign() const noexcept
2223 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.
Header file for mathematical functions.
#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:352
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:1339
Constraint on the data type.
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:194
Constraint on the data type.
void reset(const DiagonalProxy< MT > &proxy)
Resetting the represented element to the default initial values.
Definition: DiagonalProxy.h:533
const This & CompositeType
Data type for composite expression templates.
Definition: CompressedMatrix.h:2935
void clear(CompressedMatrix< Type, SO > &m)
Clearing the given compressed matrix.
Definition: CompressedMatrix.h:5556
CompressedMatrix< Type, true > This
Type of this CompressedMatrix instance.
Definition: CompressedMatrix.h:2928
#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:390
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:1321
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:1802
CompressedMatrix< Type, false > OppositeType
Result type with opposite storage order for expression template evaluations.
Definition: CompressedMatrix.h:2931
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:304
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:238
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.
Header file for the IsStrictlyUpper type trait.
Header file for the clear shim.
Namespace of the Blaze C++ math library.
Definition: Blaze.h:57
void swap(CompressedMatrix< Type, SO > &a, CompressedMatrix< Type, SO > &b) noexcept
Swapping the contents of two compressed matrices.
Definition: CompressedMatrix.h:5635
bool isIntact(const CompressedMatrix< Type, SO > &m)
Returns whether the invariants of the given compressed matrix are intact.
Definition: CompressedMatrix.h:5618
const Element * ConstIterator
Iterator over constant elements.
Definition: CompressedMatrix.h:2939
#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
#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.
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:336
Header file for the IsUniTriangular type trait.
CompressedMatrix< Type, false > TransposeType
Transpose type for expression template evaluations.
Definition: CompressedMatrix.h:2932
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:544
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:260
Type ElementType
Type of the compressed matrix elements.
Definition: CompressedMatrix.h:2933
const Type & ConstReference
Reference to a constant matrix value.
Definition: CompressedMatrix.h:2937
Header file for the EnableIf class template.
void clear(const DiagonalProxy< MT > &proxy)
Clearing the represented element.
Definition: DiagonalProxy.h:553
Header file for the implementation of the base template of the StrictlyUpperMatrix.
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
bool isStrictlyUpper(const DenseMatrix< MT, SO > &dm)
Checks if the given dense matrix is a strictly upper triangular matrix.
Definition: DenseMatrix.h:1493
const Type & ReturnType
Return type for expression template evaluations.
Definition: CompressedMatrix.h:2934
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:1285
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
Element * Iterator
Iterator over non-constant elements.
Definition: CompressedMatrix.h:2938
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:267
Constraint on the data type.
Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_RESIZABLE(T)
Constraint on the data type.In case the given data type T is resizable, i.e. has a 'resize' member fu...
Definition: Resizable.h:81
BLAZE_ALWAYS_INLINE size_t rows(const Matrix< MT, SO > &matrix) noexcept
Returns the current number of rows of the matrix.
Definition: Matrix.h:320
SparseMatrix< This, true > BaseType
Base type of this CompressedMatrix instance.
Definition: CompressedMatrix.h:2929
#define BLAZE_CONSTRAINT_MUST_BE_RESIZABLE(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.
#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
This ResultType
Result type for expression template evaluations.
Definition: CompressedMatrix.h:2930
bool isIntact(const DiagonalMatrix< MT, SO, DF > &m)
Returns whether the invariants of the given diagonal matrix are intact.
Definition: DiagonalMatrix.h:249
MatrixAccessProxy< This > Reference
Reference to a non-constant matrix value.
Definition: CompressedMatrix.h:2936
#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:1303
#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:677
Header file for the IsResizable 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