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 ET >
132 typedef StrictlyUpperMatrix< typename MT::template Rebind<ET>::Other > Other;
138 enum :
bool { smpAssignable =
false };
144 explicit inline StrictlyUpperMatrix();
145 explicit inline StrictlyUpperMatrix(
size_t n );
146 explicit inline StrictlyUpperMatrix(
size_t n,
size_t nonzeros );
147 explicit inline StrictlyUpperMatrix(
size_t n,
const std::vector<size_t>& nonzeros );
149 inline StrictlyUpperMatrix(
const StrictlyUpperMatrix& m );
150 inline StrictlyUpperMatrix( StrictlyUpperMatrix&& m ) noexcept;
152 template< typename MT2,
bool SO2 >
153 inline StrictlyUpperMatrix( const Matrix<MT2,SO2>& m );
164 inline Reference operator()(
size_t i,
size_t j );
165 inline ConstReference operator()(
size_t i,
size_t j ) const;
166 inline Reference at(
size_t i,
size_t j );
167 inline ConstReference at(
size_t i,
size_t j ) const;
168 inline Iterator
begin (
size_t i );
169 inline ConstIterator
begin (
size_t i ) const;
170 inline ConstIterator
cbegin(
size_t i ) const;
171 inline Iterator
end (
size_t i );
172 inline ConstIterator
end (
size_t i ) const;
173 inline ConstIterator
cend (
size_t i ) const;
180 inline StrictlyUpperMatrix& operator=( const StrictlyUpperMatrix& rhs );
181 inline StrictlyUpperMatrix& operator=( StrictlyUpperMatrix&& rhs ) noexcept;
183 template< typename MT2,
bool SO2 >
184 inline
DisableIf_< IsComputation<MT2>, StrictlyUpperMatrix& >
185 operator=( const Matrix<MT2,SO2>& rhs );
187 template< typename MT2,
bool SO2 >
188 inline
EnableIf_< IsComputation<MT2>, StrictlyUpperMatrix& >
189 operator=( const Matrix<MT2,SO2>& rhs );
191 template< typename MT2,
bool SO2 >
192 inline
DisableIf_< IsComputation<MT2>, StrictlyUpperMatrix& >
193 operator+=( const Matrix<MT2,SO2>& rhs );
195 template< typename MT2,
bool SO2 >
196 inline
EnableIf_< IsComputation<MT2>, StrictlyUpperMatrix& >
197 operator+=( const Matrix<MT2,SO2>& rhs );
199 template< typename MT2,
bool SO2 >
200 inline
DisableIf_< IsComputation<MT2>, StrictlyUpperMatrix& >
201 operator-=( const Matrix<MT2,SO2>& rhs );
203 template< typename MT2,
bool SO2 >
204 inline
EnableIf_< IsComputation<MT2>, StrictlyUpperMatrix& >
205 operator-=( const Matrix<MT2,SO2>& rhs );
207 template< typename MT2,
bool SO2 >
208 inline StrictlyUpperMatrix& operator*=( const Matrix<MT2,SO2>& rhs );
210 template< typename Other >
211 inline
EnableIf_< IsNumeric<Other>, StrictlyUpperMatrix >& operator*=( Other rhs );
213 template< typename Other >
214 inline
EnableIf_< IsNumeric<Other>, StrictlyUpperMatrix >& operator/=( Other rhs );
221 inline
size_t rows() const noexcept;
222 inline
size_t columns() const noexcept;
223 inline
size_t capacity() const noexcept;
224 inline
size_t capacity(
size_t i ) const noexcept;
226 inline
size_t nonZeros(
size_t i ) const;
228 inline
void reset(
size_t i );
230 inline Iterator
set(
size_t i,
size_t j, const ElementType& value );
231 inline Iterator insert(
size_t i,
size_t j, const ElementType& value );
232 inline
void erase(
size_t i,
size_t j );
233 inline Iterator erase(
size_t i, Iterator pos );
234 inline Iterator erase(
size_t i, Iterator first, Iterator last );
235 inline
void resize (
size_t n,
bool preserve=true );
236 inline
void reserve(
size_t nonzeros );
237 inline
void reserve(
size_t i,
size_t nonzeros );
239 inline
void trim(
size_t i );
241 template< typename Other > inline StrictlyUpperMatrix& scale( const Other& scalar );
242 template< typename Other > inline StrictlyUpperMatrix& scaleDiagonal( Other scale );
244 inline
void swap( StrictlyUpperMatrix& m ) noexcept;
246 static inline constexpr
size_t maxNonZeros() noexcept;
247 static inline constexpr
size_t maxNonZeros(
size_t n ) noexcept;
254 inline Iterator find (
size_t i,
size_t j );
255 inline ConstIterator find (
size_t i,
size_t j ) const;
256 inline Iterator lowerBound(
size_t i,
size_t j );
257 inline ConstIterator lowerBound(
size_t i,
size_t j ) const;
258 inline Iterator upperBound(
size_t i,
size_t j );
259 inline ConstIterator upperBound(
size_t i,
size_t j ) const;
266 inline
void append (
size_t i,
size_t j, const ElementType& value,
bool check=false );
267 inline
void finalize(
size_t i );
274 inline
bool isIntact() const noexcept;
281 template< typename Other > inline
bool canAlias ( const Other* alias ) const noexcept;
282 template< typename Other > inline
bool isAliased( const Other* alias ) const noexcept;
284 inline
bool canSMPAssign() const noexcept;
292 inline
void resetLower();
304 template< typename MT2,
bool SO2,
bool DF2 >
305 friend MT2& derestrict( StrictlyUpperMatrix<MT2,SO2,DF2>& m );
340 template< typename MT
342 inline StrictlyUpperMatrix<MT,SO,false>::StrictlyUpperMatrix()
359 template<
typename MT
361 inline StrictlyUpperMatrix<MT,SO,false>::StrictlyUpperMatrix(
size_t n )
382 template<
typename MT
384 inline StrictlyUpperMatrix<MT,SO,false>::StrictlyUpperMatrix(
size_t n,
size_t nonzeros )
385 : matrix_( n, n,
max( nonzeros, n ) )
409 template<
typename MT
411 inline StrictlyUpperMatrix<MT,SO,false>::StrictlyUpperMatrix(
size_t n,
const std::vector<size_t>& nonzeros )
412 : matrix_( n, n, nonzeros )
428 template<
typename MT
430 inline StrictlyUpperMatrix<MT,SO,false>::StrictlyUpperMatrix(
const StrictlyUpperMatrix& m )
431 : matrix_( m.matrix_ )
446 template<
typename MT
448 inline StrictlyUpperMatrix<MT,SO,false>::StrictlyUpperMatrix( StrictlyUpperMatrix&& m ) noexcept
449 : matrix_(
std::move( m.matrix_ ) )
469 template<
typename MT
471 template<
typename MT2
473 inline StrictlyUpperMatrix<MT,SO,false>::StrictlyUpperMatrix(
const Matrix<MT2,SO2>& m )
476 if( IsUniTriangular<MT2>::value ||
481 if( !IsStrictlyUpper<MT2>::value )
515 template<
typename MT
518 StrictlyUpperMatrix<MT,SO,false>::operator()(
size_t i,
size_t j )
545 template<
typename MT
548 StrictlyUpperMatrix<MT,SO,false>::operator()(
size_t i,
size_t j )
const
576 template<
typename MT
579 StrictlyUpperMatrix<MT,SO,false>::at(
size_t i,
size_t j )
610 template<
typename MT
613 StrictlyUpperMatrix<MT,SO,false>::at(
size_t i,
size_t j )
const
639 template<
typename MT
644 return matrix_.begin(i);
662 template<
typename MT
667 return matrix_.begin(i);
685 template<
typename MT
690 return matrix_.cbegin(i);
708 template<
typename MT
713 return matrix_.end(i);
731 template<
typename MT
736 return matrix_.end(i);
754 template<
typename MT
759 return matrix_.cend(i);
783 template<
typename MT
785 inline StrictlyUpperMatrix<MT,SO,false>&
786 StrictlyUpperMatrix<MT,SO,false>::operator=(
const StrictlyUpperMatrix& rhs )
788 matrix_ = rhs.matrix_;
806 template<
typename MT
808 inline StrictlyUpperMatrix<MT,SO,false>&
809 StrictlyUpperMatrix<MT,SO,false>::operator=( StrictlyUpperMatrix&& rhs ) noexcept
811 matrix_ = std::move( rhs.matrix_ );
835 template<
typename MT
837 template<
typename MT2
839 inline DisableIf_< IsComputation<MT2>, StrictlyUpperMatrix<MT,SO,false>& >
840 StrictlyUpperMatrix<MT,SO,false>::operator=(
const Matrix<MT2,SO2>& rhs )
842 if( IsUniTriangular<MT2>::value ||
849 if( !IsStrictlyUpper<MT2>::value )
874 template<
typename MT
876 template<
typename MT2
878 inline EnableIf_< IsComputation<MT2>, StrictlyUpperMatrix<MT,SO,false>& >
879 StrictlyUpperMatrix<MT,SO,false>::operator=(
const Matrix<MT2,SO2>& rhs )
881 if( IsUniTriangular<MT2>::value || ( !IsSquare<MT2>::value && !
isSquare( ~rhs ) ) ) {
885 if( IsStrictlyUpper<MT2>::value ) {
895 matrix_ = std::move( tmp );
898 if( !IsStrictlyUpper<MT2>::value )
923 template<
typename MT
925 template<
typename MT2
927 inline DisableIf_< IsComputation<MT2>, StrictlyUpperMatrix<MT,SO,false>& >
930 if( IsUniTriangular<MT2>::value ||
937 if( !IsStrictlyUpper<MT2>::value )
962 template<
typename MT
964 template<
typename MT2
966 inline EnableIf_< IsComputation<MT2>, StrictlyUpperMatrix<MT,SO,false>& >
969 if( IsUniTriangular<MT2>::value || ( IsSquare<MT2>::value && !
isSquare( ~rhs ) ) ) {
973 if( IsStrictlyUpper<MT2>::value ) {
977 const ResultType_<MT2> tmp( ~rhs );
986 if( !IsStrictlyUpper<MT2>::value )
1011 template<
typename MT
1013 template<
typename MT2
1015 inline DisableIf_< IsComputation<MT2>, StrictlyUpperMatrix<MT,SO,false>& >
1018 if( IsUniTriangular<MT2>::value ||
1025 if( !IsStrictlyUpper<MT2>::value )
1050 template<
typename MT
1052 template<
typename MT2
1054 inline EnableIf_< IsComputation<MT2>, StrictlyUpperMatrix<MT,SO,false>& >
1057 if( IsUniTriangular<MT2>::value || ( !IsSquare<MT2>::value && !
isSquare( ~rhs ) ) ) {
1061 if( IsStrictlyUpper<MT2>::value ) {
1065 const ResultType_<MT2> tmp( ~rhs );
1074 if( !IsStrictlyUpper<MT2>::value )
1098 template<
typename MT
1100 template<
typename MT2
1102 inline StrictlyUpperMatrix<MT,SO,false>&
1105 if( matrix_.rows() != (~rhs).
columns() ) {
1109 MT tmp( matrix_ * ~rhs );
1115 matrix_ = std::move( tmp );
1117 if( !IsStrictlyUpper<MT2>::value )
1137 template<
typename MT
1139 template<
typename Other >
1140 inline EnableIf_< IsNumeric<Other>, StrictlyUpperMatrix<MT,SO,false> >&
1157 template<
typename MT
1159 template<
typename Other >
1160 inline EnableIf_< IsNumeric<Other>, StrictlyUpperMatrix<MT,SO,false> >&
1186 template<
typename MT
1190 return matrix_.rows();
1202 template<
typename MT
1206 return matrix_.columns();
1218 template<
typename MT
1222 return matrix_.capacity();
1240 template<
typename MT
1244 return matrix_.capacity(i);
1256 template<
typename MT
1260 return matrix_.nonZeros();
1278 template<
typename MT
1282 return matrix_.nonZeros(i);
1294 template<
typename MT
1299 for(
size_t j=1UL; j<
columns(); ++j ) {
1300 matrix_.erase( j, matrix_.begin(j), matrix_.lowerBound(j,j) );
1304 for(
size_t i=0UL; i<
rows(); ++i ) {
1305 matrix_.erase( i, matrix_.lowerBound(i,i+1UL), matrix_.end(i) );
1326 template<
typename MT
1331 matrix_.erase( i, matrix_.begin(i), matrix_.lowerBound(i,i) );
1334 matrix_.erase( i, matrix_.lowerBound(i,i+1UL), matrix_.end(i) );
1349 template<
typename MT
1355 if( IsResizable<MT>::value ) {
1382 template<
typename MT
1391 return matrix_.set( i, j, value );
1414 template<
typename MT
1417 StrictlyUpperMatrix<MT,SO,false>::insert(
size_t i,
size_t j,
const ElementType& value )
1423 return matrix_.insert( i, j, value );
1439 template<
typename MT
1441 inline void StrictlyUpperMatrix<MT,SO,false>::erase(
size_t i,
size_t j )
1443 matrix_.erase( i, j );
1461 template<
typename MT
1464 StrictlyUpperMatrix<MT,SO,false>::erase(
size_t i, Iterator pos )
1466 return matrix_.erase( i, pos );
1486 template<
typename MT
1489 StrictlyUpperMatrix<MT,SO,false>::erase(
size_t i, Iterator first, Iterator last )
1491 return matrix_.erase( i, first, last );
1512 template<
typename MT
1520 matrix_.resize( n, n, preserve );
1537 template<
typename MT
1539 inline void StrictlyUpperMatrix<MT,SO,false>::reserve(
size_t nonzeros )
1541 matrix_.reserve( nonzeros );
1562 template<
typename MT
1564 inline void StrictlyUpperMatrix<MT,SO,false>::reserve(
size_t i,
size_t nonzeros )
1566 matrix_.reserve( i, nonzeros );
1583 template<
typename MT
1585 inline void StrictlyUpperMatrix<MT,SO,false>::trim()
1605 template<
typename MT
1607 inline void StrictlyUpperMatrix<MT,SO,false>::trim(
size_t i )
1622 template<
typename MT
1624 template<
typename Other >
1625 inline StrictlyUpperMatrix<MT,SO,false>&
1626 StrictlyUpperMatrix<MT,SO,false>::scale(
const Other& scalar )
1628 matrix_.scale( scalar );
1642 template<
typename MT
1644 template<
typename Other >
1645 inline StrictlyUpperMatrix<MT,SO,false>&
1646 StrictlyUpperMatrix<MT,SO,false>::scaleDiagonal( Other scalar )
1648 matrix_.scaleDiagonal( scalar );
1662 template<
typename MT
1668 swap( matrix_, m.matrix_ );
1686 template<
typename MT
1688 inline constexpr
size_t StrictlyUpperMatrix<MT,SO,false>::maxNonZeros() noexcept
1692 return maxNonZeros( Rows<MT>::value );
1708 template<
typename MT
1710 inline constexpr
size_t StrictlyUpperMatrix<MT,SO,false>::maxNonZeros(
size_t n ) noexcept
1712 return ( ( n - 1UL ) * n ) / 2UL;
1724 template<
typename MT
1726 inline void StrictlyUpperMatrix<MT,SO,false>::resetLower()
1729 for(
size_t j=0UL; j<
columns(); ++j )
1730 matrix_.erase( j, matrix_.upperBound( j, j ), matrix_.end( j ) );
1733 for(
size_t i=1UL; i<
rows(); ++i )
1734 matrix_.erase( i, matrix_.begin( i ), matrix_.lowerBound( i, i ) );
1765 template<
typename MT
1768 StrictlyUpperMatrix<MT,SO,false>::find(
size_t i,
size_t j )
1770 return matrix_.find( i, j );
1792 template<
typename MT
1795 StrictlyUpperMatrix<MT,SO,false>::find(
size_t i,
size_t j )
const
1797 return matrix_.find( i, j );
1819 template<
typename MT
1822 StrictlyUpperMatrix<MT,SO,false>::lowerBound(
size_t i,
size_t j )
1824 return matrix_.lowerBound( i, j );
1846 template<
typename MT
1849 StrictlyUpperMatrix<MT,SO,false>::lowerBound(
size_t i,
size_t j )
const
1851 return matrix_.lowerBound( i, j );
1873 template<
typename MT
1876 StrictlyUpperMatrix<MT,SO,false>::upperBound(
size_t i,
size_t j )
1878 return matrix_.upperBound( i, j );
1900 template<
typename MT
1903 StrictlyUpperMatrix<MT,SO,false>::upperBound(
size_t i,
size_t j )
const
1905 return matrix_.upperBound( i, j );
1969 template<
typename MT
1971 inline void StrictlyUpperMatrix<MT,SO,false>::append(
size_t i,
size_t j,
const ElementType& value,
bool check )
1977 matrix_.append( i, j, value, check );
1997 template<
typename MT
1999 inline void StrictlyUpperMatrix<MT,SO,false>::finalize(
size_t i )
2001 matrix_.finalize( i );
2025 template<
typename MT
2056 template<
typename MT
2058 template<
typename Other >
2059 inline bool StrictlyUpperMatrix<MT,SO,false>::canAlias(
const Other* alias )
const noexcept
2061 return matrix_.canAlias( alias );
2078 template<
typename MT
2080 template<
typename Other >
2081 inline bool StrictlyUpperMatrix<MT,SO,false>::isAliased(
const Other* alias )
const noexcept
2083 return matrix_.isAliased( alias );
2100 template<
typename MT
2102 inline bool StrictlyUpperMatrix<MT,SO,false>::canSMPAssign() const noexcept
2104 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:346
Header file for basic type definitions.
bool isStrictlyUpper(const DenseMatrix< MT, SO > &dm)
Checks if the given dense matrix is a strictly upper triangular matrix.
Definition: DenseMatrix.h:1423
#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:188
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:2643
typename DisableIf< Condition, T >::Type DisableIf_
Auxiliary type for the DisableIf class template.The DisableIf_ alias declaration provides a convenien...
Definition: DisableIf.h:223
void clear(CompressedMatrix< Type, SO > &m)
Clearing the given compressed matrix.
Definition: CompressedMatrix.h:5077
CompressedMatrix< Type, true > This
Type of this CompressedMatrix instance.
Definition: CompressedMatrix.h:2636
#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:384
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:1716
CompressedMatrix< Type, false > OppositeType
Result type with opposite storage order for expression template evaluations.
Definition: CompressedMatrix.h:2639
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:298
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:232
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:5148
bool isIntact(const CompressedMatrix< Type, SO > &m)
Returns whether the invariants of the given compressed matrix are intact.
Definition: CompressedMatrix.h:5131
const Element * ConstIterator
Iterator over constant elements.
Definition: CompressedMatrix.h:2647
#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:330
Header file for the IsUniTriangular type trait.
CompressedMatrix< Type, false > TransposeType
Transpose type for expression template evaluations.
Definition: CompressedMatrix.h:2640
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:538
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:254
Type ElementType
Type of the sparse matrix elements.
Definition: CompressedMatrix.h:2641
const Type & ConstReference
Reference to a constant matrix value.
Definition: CompressedMatrix.h:2645
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
const Type & ReturnType
Return type for expression template evaluations.
Definition: CompressedMatrix.h:2642
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:2646
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:258
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
typename EnableIf< Condition, T >::Type EnableIf_
Auxiliary alias declaration for the EnableIf class template.The EnableIf_ alias declaration provides ...
Definition: EnableIf.h:223
BLAZE_ALWAYS_INLINE size_t rows(const Matrix< MT, SO > &matrix) noexcept
Returns the current number of rows of the matrix.
Definition: Matrix.h:314
SparseMatrix< This, true > BaseType
Base type of this CompressedMatrix instance.
Definition: CompressedMatrix.h:2637
#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:2638
bool isIntact(const DiagonalMatrix< MT, SO, DF > &m)
Returns whether the invariants of the given diagonal matrix are intact.
Definition: DiagonalMatrix.h:240
MatrixAccessProxy< This > Reference
Reference to a non-constant matrix value.
Definition: CompressedMatrix.h:2644
#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:609
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