35 #ifndef _BLAZE_MATH_ADAPTORS_UPPERMATRIX_SPARSE_H_
36 #define _BLAZE_MATH_ADAPTORS_UPPERMATRIX_SPARSE_H_
96 class UpperMatrix<MT,SO,false>
97 :
public SparseMatrix< UpperMatrix<MT,SO,false>, SO >
101 typedef OppositeType_<MT> OT;
102 typedef TransposeType_<MT> TT;
103 typedef ElementType_<MT> ET;
108 typedef UpperMatrix<MT,SO,false>
This;
109 typedef SparseMatrix<This,SO>
BaseType;
125 template<
typename ET >
128 typedef UpperMatrix< typename MT::template Rebind<ET>::Other > Other;
134 enum :
bool { smpAssignable =
false };
140 explicit inline UpperMatrix();
141 explicit inline UpperMatrix(
size_t n );
142 explicit inline UpperMatrix(
size_t n,
size_t nonzeros );
143 explicit inline UpperMatrix(
size_t n,
const std::vector<size_t>& nonzeros );
145 inline UpperMatrix(
const UpperMatrix& m );
146 inline UpperMatrix( UpperMatrix&& m ) noexcept;
148 template< typename MT2,
bool SO2 >
149 inline UpperMatrix( const Matrix<MT2,SO2>& m );
160 inline Reference operator()(
size_t i,
size_t j );
161 inline ConstReference operator()(
size_t i,
size_t j ) const;
162 inline Reference at(
size_t i,
size_t j );
163 inline ConstReference at(
size_t i,
size_t j ) const;
164 inline Iterator
begin (
size_t i );
165 inline ConstIterator
begin (
size_t i ) const;
166 inline ConstIterator
cbegin(
size_t i ) const;
167 inline Iterator
end (
size_t i );
168 inline ConstIterator
end (
size_t i ) const;
169 inline ConstIterator
cend (
size_t i ) const;
176 inline UpperMatrix& operator=( const UpperMatrix& rhs );
177 inline UpperMatrix& operator=( UpperMatrix&& rhs ) noexcept;
179 template< typename MT2,
bool SO2 >
180 inline
DisableIf_< IsComputation<MT2>, UpperMatrix& > operator=( const Matrix<MT2,SO2>& rhs );
182 template< typename MT2,
bool SO2 >
183 inline
EnableIf_< IsComputation<MT2>, UpperMatrix& > operator=( const Matrix<MT2,SO2>& rhs );
185 template< typename MT2,
bool SO2 >
186 inline
DisableIf_< IsComputation<MT2>, UpperMatrix& > operator+=( const Matrix<MT2,SO2>& rhs );
188 template< typename MT2,
bool SO2 >
189 inline
EnableIf_< IsComputation<MT2>, UpperMatrix& > operator+=( const Matrix<MT2,SO2>& rhs );
191 template< typename MT2,
bool SO2 >
192 inline
DisableIf_< IsComputation<MT2>, UpperMatrix& > operator-=( const Matrix<MT2,SO2>& rhs );
194 template< typename MT2,
bool SO2 >
195 inline
EnableIf_< IsComputation<MT2>, UpperMatrix& > operator-=( const Matrix<MT2,SO2>& rhs );
197 template< typename MT2,
bool SO2 >
198 inline UpperMatrix& operator*=( const Matrix<MT2,SO2>& rhs );
200 template< typename Other >
201 inline
EnableIf_< IsNumeric<Other>, UpperMatrix >& operator*=( Other rhs );
203 template< typename Other >
204 inline
EnableIf_< IsNumeric<Other>, UpperMatrix >& operator/=( Other rhs );
211 inline
size_t rows() const noexcept;
212 inline
size_t columns() const noexcept;
213 inline
size_t capacity() const noexcept;
214 inline
size_t capacity(
size_t i ) const noexcept;
216 inline
size_t nonZeros(
size_t i ) const;
218 inline
void reset(
size_t i );
220 inline Iterator
set(
size_t i,
size_t j, const ElementType& value );
221 inline Iterator insert(
size_t i,
size_t j, const ElementType& value );
222 inline
void erase(
size_t i,
size_t j );
223 inline Iterator erase(
size_t i, Iterator pos );
224 inline Iterator erase(
size_t i, Iterator first, Iterator last );
225 inline
void resize (
size_t n,
bool preserve=true );
226 inline
void reserve(
size_t nonzeros );
227 inline
void reserve(
size_t i,
size_t nonzeros );
229 inline
void trim(
size_t i );
230 template< typename Other > inline UpperMatrix& scale( const Other& scalar );
231 template< typename Other > inline UpperMatrix& scaleDiagonal( Other scale );
232 inline
void swap( UpperMatrix& m ) noexcept;
234 static inline constexpr
size_t maxNonZeros() noexcept;
235 static inline constexpr
size_t maxNonZeros(
size_t n ) noexcept;
242 inline Iterator find (
size_t i,
size_t j );
243 inline ConstIterator find (
size_t i,
size_t j ) const;
244 inline Iterator lowerBound(
size_t i,
size_t j );
245 inline ConstIterator lowerBound(
size_t i,
size_t j ) const;
246 inline Iterator upperBound(
size_t i,
size_t j );
247 inline ConstIterator upperBound(
size_t i,
size_t j ) const;
254 inline
void append (
size_t i,
size_t j, const ElementType& value,
bool check=false );
255 inline
void finalize(
size_t i );
262 inline
bool isIntact() const noexcept;
269 template< typename Other > inline
bool canAlias ( const Other* alias ) const noexcept;
270 template< typename Other > inline
bool isAliased( const Other* alias ) const noexcept;
272 inline
bool canSMPAssign() const noexcept;
280 inline
void resetLower();
292 template< typename MT2,
bool SO2,
bool DF2 >
293 friend
bool isDefault( const UpperMatrix<MT2,SO2,DF2>& m );
295 template< typename MT2,
bool SO2,
bool DF2 >
296 friend MT2& derestrict( UpperMatrix<MT2,SO2,DF2>& m );
331 template< typename MT
333 inline UpperMatrix<MT,SO,false>::UpperMatrix()
350 template<
typename MT
352 inline UpperMatrix<MT,SO,false>::UpperMatrix(
size_t n )
372 template<
typename MT
374 inline UpperMatrix<MT,SO,false>::UpperMatrix(
size_t n,
size_t nonzeros )
375 : matrix_( n, n, nonzeros )
396 template<
typename MT
398 inline UpperMatrix<MT,SO,false>::UpperMatrix(
size_t n,
const std::vector<size_t>& nonzeros )
399 : matrix_( n, n, nonzeros )
415 template<
typename MT
417 inline UpperMatrix<MT,SO,false>::UpperMatrix(
const UpperMatrix& m )
418 : matrix_( m.matrix_ )
433 template<
typename MT
435 inline UpperMatrix<MT,SO,false>::UpperMatrix( UpperMatrix&& m ) noexcept
436 : matrix_(
std::move( m.matrix_ ) )
455 template<
typename MT
457 template<
typename MT2
459 inline UpperMatrix<MT,SO,false>::UpperMatrix(
const Matrix<MT2,SO2>& m )
462 if( !IsUpper<MT2>::value && !
isUpper( matrix_ ) ) {
466 if( !IsUpper<MT2>::value )
500 template<
typename MT
503 UpperMatrix<MT,SO,false>::operator()(
size_t i,
size_t j )
530 template<
typename MT
533 UpperMatrix<MT,SO,false>::operator()(
size_t i,
size_t j )
const
561 template<
typename MT
564 UpperMatrix<MT,SO,false>::at(
size_t i,
size_t j )
595 template<
typename MT
598 UpperMatrix<MT,SO,false>::at(
size_t i,
size_t j )
const
624 template<
typename MT
629 return matrix_.begin(i);
647 template<
typename MT
652 return matrix_.begin(i);
670 template<
typename MT
675 return matrix_.cbegin(i);
693 template<
typename MT
698 return matrix_.end(i);
716 template<
typename MT
721 return matrix_.end(i);
739 template<
typename MT
744 return matrix_.cend(i);
768 template<
typename MT
770 inline UpperMatrix<MT,SO,false>&
771 UpperMatrix<MT,SO,false>::operator=(
const UpperMatrix& rhs )
773 matrix_ = rhs.matrix_;
791 template<
typename MT
793 inline UpperMatrix<MT,SO,false>&
794 UpperMatrix<MT,SO,false>::operator=( UpperMatrix&& rhs ) noexcept
796 matrix_ = std::move( rhs.matrix_ );
820 template<
typename MT
822 template<
typename MT2
824 inline DisableIf_< IsComputation<MT2>, UpperMatrix<MT,SO,false>& >
825 UpperMatrix<MT,SO,false>::operator=(
const Matrix<MT2,SO2>& rhs )
827 if( !IsUpper<MT2>::value && !
isUpper( ~rhs ) ) {
833 if( !IsUpper<MT2>::value )
858 template<
typename MT
860 template<
typename MT2
862 inline EnableIf_< IsComputation<MT2>, UpperMatrix<MT,SO,false>& >
863 UpperMatrix<MT,SO,false>::operator=(
const Matrix<MT2,SO2>& rhs )
865 if( !IsSquare<MT2>::value && !
isSquare( ~rhs ) ) {
869 if( IsUpper<MT2>::value ) {
879 matrix_ = std::move( tmp );
882 if( !IsUpper<MT2>::value )
907 template<
typename MT
909 template<
typename MT2
911 inline DisableIf_< IsComputation<MT2>, UpperMatrix<MT,SO,false>& >
914 if( !IsUpper<MT2>::value && !
isUpper( ~rhs ) ) {
920 if( !IsUpper<MT2>::value )
945 template<
typename MT
947 template<
typename MT2
949 inline EnableIf_< IsComputation<MT2>, UpperMatrix<MT,SO,false>& >
952 if( IsSquare<MT2>::value && !
isSquare( ~rhs ) ) {
956 if( IsUpper<MT2>::value ) {
960 const ResultType_<MT2> tmp( ~rhs );
969 if( !IsUpper<MT2>::value )
994 template<
typename MT
996 template<
typename MT2
998 inline DisableIf_< IsComputation<MT2>, UpperMatrix<MT,SO,false>& >
1001 if( !IsUpper<MT2>::value && !
isUpper( ~rhs ) ) {
1007 if( !IsUpper<MT2>::value )
1032 template<
typename MT
1034 template<
typename MT2
1036 inline EnableIf_< IsComputation<MT2>, UpperMatrix<MT,SO,false>& >
1039 if( !IsSquare<MT2>::value && !
isSquare( ~rhs ) ) {
1043 if( IsUpper<MT2>::value ) {
1047 const ResultType_<MT2> tmp( ~rhs );
1056 if( !IsUpper<MT2>::value )
1080 template<
typename MT
1082 template<
typename MT2
1084 inline UpperMatrix<MT,SO,false>&
1087 if( matrix_.rows() != (~rhs).
columns() ) {
1091 MT tmp( matrix_ * ~rhs );
1097 matrix_ = std::move( tmp );
1099 if( !IsUpper<MT2>::value )
1119 template<
typename MT
1121 template<
typename Other >
1122 inline EnableIf_< IsNumeric<Other>, UpperMatrix<MT,SO,false> >&
1139 template<
typename MT
1141 template<
typename Other >
1142 inline EnableIf_< IsNumeric<Other>, UpperMatrix<MT,SO,false> >&
1168 template<
typename MT
1172 return matrix_.rows();
1184 template<
typename MT
1188 return matrix_.columns();
1200 template<
typename MT
1204 return matrix_.capacity();
1222 template<
typename MT
1226 return matrix_.capacity(i);
1238 template<
typename MT
1242 return matrix_.nonZeros();
1260 template<
typename MT
1264 return matrix_.nonZeros(i);
1276 template<
typename MT
1299 template<
typename MT
1317 template<
typename MT
1345 template<
typename MT
1354 return matrix_.set( i, j, value );
1377 template<
typename MT
1380 UpperMatrix<MT,SO,false>::insert(
size_t i,
size_t j,
const ElementType& value )
1386 return matrix_.insert( i, j, value );
1402 template<
typename MT
1404 inline void UpperMatrix<MT,SO,false>::erase(
size_t i,
size_t j )
1406 matrix_.erase( i, j );
1424 template<
typename MT
1427 UpperMatrix<MT,SO,false>::erase(
size_t i, Iterator pos )
1429 return matrix_.erase( i, pos );
1448 template<
typename MT
1451 UpperMatrix<MT,SO,false>::erase(
size_t i, Iterator first, Iterator last )
1453 return matrix_.erase( i, first, last );
1474 template<
typename MT
1482 matrix_.resize( n, n, preserve );
1499 template<
typename MT
1501 inline void UpperMatrix<MT,SO,false>::reserve(
size_t nonzeros )
1503 matrix_.reserve( nonzeros );
1523 template<
typename MT
1525 inline void UpperMatrix<MT,SO,false>::reserve(
size_t i,
size_t nonzeros )
1527 matrix_.reserve( i, nonzeros );
1544 template<
typename MT
1546 inline void UpperMatrix<MT,SO,false>::trim()
1566 template<
typename MT
1568 inline void UpperMatrix<MT,SO,false>::trim(
size_t i )
1583 template<
typename MT
1585 template<
typename Other >
1586 inline UpperMatrix<MT,SO,false>&
1587 UpperMatrix<MT,SO,false>::scale(
const Other& scalar )
1589 matrix_.scale( scalar );
1603 template<
typename MT
1605 template<
typename Other >
1606 inline UpperMatrix<MT,SO,false>&
1607 UpperMatrix<MT,SO,false>::scaleDiagonal( Other scalar )
1609 matrix_.scaleDiagonal( scalar );
1623 template<
typename MT
1629 swap( matrix_, m.matrix_ );
1646 template<
typename MT
1648 inline constexpr
size_t UpperMatrix<MT,SO,false>::maxNonZeros() noexcept
1652 return maxNonZeros( Rows<MT>::value );
1668 template<
typename MT
1670 inline constexpr
size_t UpperMatrix<MT,SO,false>::maxNonZeros(
size_t n ) noexcept
1672 return ( ( n + 1UL ) * n ) / 2UL;
1684 template<
typename MT
1686 inline void UpperMatrix<MT,SO,false>::resetLower()
1689 for(
size_t j=0UL; j<
columns(); ++j )
1690 matrix_.erase( j, matrix_.upperBound( j, j ), matrix_.end( j ) );
1693 for(
size_t i=1UL; i<
rows(); ++i )
1694 matrix_.erase( i, matrix_.begin( i ), matrix_.lowerBound( i, i ) );
1725 template<
typename MT
1728 UpperMatrix<MT,SO,false>::find(
size_t i,
size_t j )
1730 return matrix_.find( i, j );
1752 template<
typename MT
1755 UpperMatrix<MT,SO,false>::find(
size_t i,
size_t j )
const
1757 return matrix_.find( i, j );
1779 template<
typename MT
1782 UpperMatrix<MT,SO,false>::lowerBound(
size_t i,
size_t j )
1784 return matrix_.lowerBound( i, j );
1806 template<
typename MT
1809 UpperMatrix<MT,SO,false>::lowerBound(
size_t i,
size_t j )
const
1811 return matrix_.lowerBound( i, j );
1833 template<
typename MT
1836 UpperMatrix<MT,SO,false>::upperBound(
size_t i,
size_t j )
1838 return matrix_.upperBound( i, j );
1860 template<
typename MT
1863 UpperMatrix<MT,SO,false>::upperBound(
size_t i,
size_t j )
const
1865 return matrix_.upperBound( i, j );
1929 template<
typename MT
1931 inline void UpperMatrix<MT,SO,false>::append(
size_t i,
size_t j,
const ElementType& value,
bool check )
1937 matrix_.append( i, j, value, check );
1957 template<
typename MT
1959 inline void UpperMatrix<MT,SO,false>::finalize(
size_t i )
1961 matrix_.finalize( i );
1985 template<
typename MT
2016 template<
typename MT
2018 template<
typename Other >
2019 inline bool UpperMatrix<MT,SO,false>::canAlias(
const Other* alias )
const noexcept
2021 return matrix_.canAlias( alias );
2038 template<
typename MT
2040 template<
typename Other >
2041 inline bool UpperMatrix<MT,SO,false>::isAliased(
const Other* alias )
const noexcept
2043 return matrix_.isAliased( alias );
2060 template<
typename MT
2062 inline bool UpperMatrix<MT,SO,false>::canSMPAssign() const noexcept
2064 return matrix_.canSMPAssign();
#define BLAZE_CONSTRAINT_MUST_NOT_BE_CONST(T)
Constraint on the data type.In case the given data type is a const-qualified type, a compilation error is created.
Definition: Const.h:79
#define BLAZE_THROW_INVALID_ARGUMENT(MESSAGE)
Macro for the emission of a std::invalid_argument exception.This macro encapsulates the default way o...
Definition: Exception.h:235
#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.
#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.
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
bool isDefault(const DiagonalProxy< MT > &proxy)
Returns whether the represented element is in default state.
Definition: DiagonalProxy.h:573
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 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
CompressedMatrix< Type, false > TransposeType
Transpose type for expression template evaluations.
Definition: CompressedMatrix.h:2640
bool isUpper(const DenseMatrix< MT, SO > &dm)
Checks if the given dense matrix is an upper triangular matrix.
Definition: DenseMatrix.h:1267
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
Header file for the UpperProxy class.
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 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
Header file for the IsUpper type trait.
#define BLAZE_STATIC_ASSERT(expr)
Compile time assertion macro.In case of an invalid compile time expression, a compilation error is cr...
Definition: StaticAssert.h:112
Header file for the implementation of the base template of the UpperMatrix.
BLAZE_ALWAYS_INLINE bool isSquare(const Matrix< MT, SO > &matrix) noexcept
Checks if the given matrix is a square matrix.
Definition: Matrix.h:609
#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