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 >
112 typedef StrictlyUpperMatrix<MT,SO,false>
This;
119 typedef StrictlyUpperProxy<MT>
Reference;
128 template<
typename ET >
131 typedef StrictlyUpperMatrix< typename MT::template Rebind<ET>::Other > Other;
137 enum { smpAssignable = 0 };
143 explicit inline StrictlyUpperMatrix();
144 explicit inline StrictlyUpperMatrix(
size_t n );
145 explicit inline StrictlyUpperMatrix(
size_t n,
size_t nonzeros );
146 explicit inline StrictlyUpperMatrix(
size_t n,
const std::vector<size_t>& nonzeros );
148 inline StrictlyUpperMatrix(
const StrictlyUpperMatrix& m );
149 template<
typename MT2,
bool SO2 >
inline StrictlyUpperMatrix(
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 StrictlyUpperMatrix& operator=(
const StrictlyUpperMatrix& rhs );
178 template<
typename MT2,
bool SO2 >
179 inline typename DisableIf< IsComputation<MT2>, StrictlyUpperMatrix& >::Type
180 operator=(
const Matrix<MT2,SO2>& rhs );
182 template<
typename MT2,
bool SO2 >
183 inline typename EnableIf< IsComputation<MT2>, StrictlyUpperMatrix& >::Type
184 operator=(
const Matrix<MT2,SO2>& rhs );
186 template<
typename MT2,
bool SO2 >
187 inline typename DisableIf< IsComputation<MT2>, StrictlyUpperMatrix& >::Type
188 operator+=(
const Matrix<MT2,SO2>& rhs );
190 template<
typename MT2,
bool SO2 >
191 inline typename EnableIf< IsComputation<MT2>, StrictlyUpperMatrix& >::Type
192 operator+=(
const Matrix<MT2,SO2>& rhs );
194 template<
typename MT2,
bool SO2 >
195 inline typename DisableIf< IsComputation<MT2>, StrictlyUpperMatrix& >::Type
196 operator-=(
const Matrix<MT2,SO2>& rhs );
198 template<
typename MT2,
bool SO2 >
199 inline typename EnableIf< IsComputation<MT2>, StrictlyUpperMatrix& >::Type
200 operator-=(
const Matrix<MT2,SO2>& rhs );
202 template<
typename MT2,
bool SO2 >
203 inline StrictlyUpperMatrix& operator*=(
const Matrix<MT2,SO2>& rhs );
205 template<
typename Other >
206 inline typename EnableIf< IsNumeric<Other>, StrictlyUpperMatrix >::Type&
207 operator*=( Other rhs );
209 template<
typename Other >
210 inline typename EnableIf< IsNumeric<Other>, StrictlyUpperMatrix >::Type&
211 operator/=( Other rhs );
218 inline size_t rows()
const;
221 inline size_t capacity(
size_t i )
const;
223 inline size_t nonZeros(
size_t i )
const;
225 inline void reset(
size_t i );
227 inline Iterator
set(
size_t i,
size_t j,
const ElementType& value );
228 inline Iterator insert(
size_t i,
size_t j,
const ElementType& value );
229 inline void erase(
size_t i,
size_t j );
230 inline Iterator erase(
size_t i, Iterator pos );
231 inline Iterator erase(
size_t i, Iterator first, Iterator last );
232 inline void resize (
size_t n,
bool preserve=
true );
233 inline void reserve(
size_t nonzeros );
234 inline void reserve(
size_t i,
size_t nonzeros );
236 inline void trim(
size_t i );
238 template<
typename Other >
inline StrictlyUpperMatrix& scale(
const Other& scalar );
239 template<
typename Other >
inline StrictlyUpperMatrix& scaleDiagonal( Other scale );
241 inline void swap( StrictlyUpperMatrix& m ) ;
243 static inline size_t maxNonZeros();
244 static inline size_t maxNonZeros(
size_t n );
251 inline Iterator find (
size_t i,
size_t j );
252 inline ConstIterator find (
size_t i,
size_t j )
const;
253 inline Iterator lowerBound(
size_t i,
size_t j );
254 inline ConstIterator lowerBound(
size_t i,
size_t j )
const;
255 inline Iterator upperBound(
size_t i,
size_t j );
256 inline ConstIterator upperBound(
size_t i,
size_t j )
const;
263 inline void append (
size_t i,
size_t j,
const ElementType& value,
bool check=
false );
264 inline void finalize(
size_t i );
278 template<
typename Other >
inline bool canAlias (
const Other* alias )
const;
279 template<
typename Other >
inline bool isAliased(
const Other* alias )
const;
281 inline bool canSMPAssign()
const;
289 inline void resetLower();
301 template<
typename MT2,
bool SO2,
bool DF2 >
302 friend MT2& derestrict( StrictlyUpperMatrix<MT2,SO2,DF2>& m );
337 template<
typename MT
339 inline StrictlyUpperMatrix<MT,SO,false>::StrictlyUpperMatrix()
356 template<
typename MT
358 inline StrictlyUpperMatrix<MT,SO,false>::StrictlyUpperMatrix(
size_t n )
379 template<
typename MT
381 inline StrictlyUpperMatrix<MT,SO,false>::StrictlyUpperMatrix(
size_t n,
size_t nonzeros )
382 : matrix_( n, n,
max( nonzeros, n ) )
406 template<
typename MT
408 inline StrictlyUpperMatrix<MT,SO,false>::StrictlyUpperMatrix(
size_t n,
const std::vector<size_t>& nonzeros )
409 : matrix_( n, n, nonzeros )
425 template<
typename MT
427 inline StrictlyUpperMatrix<MT,SO,false>::StrictlyUpperMatrix(
const StrictlyUpperMatrix& m )
428 : matrix_( m.matrix_ )
448 template<
typename MT
450 template<
typename MT2
452 inline StrictlyUpperMatrix<MT,SO,false>::StrictlyUpperMatrix(
const Matrix<MT2,SO2>& m )
455 if( IsUniTriangular<MT2>::value ||
460 if( !IsStrictlyUpper<MT2>::value )
494 template<
typename MT
497 StrictlyUpperMatrix<MT,SO,false>::operator()(
size_t i,
size_t j )
524 template<
typename MT
527 StrictlyUpperMatrix<MT,SO,false>::operator()(
size_t i,
size_t j )
const
555 template<
typename MT
558 StrictlyUpperMatrix<MT,SO,false>::at(
size_t i,
size_t j )
589 template<
typename MT
592 StrictlyUpperMatrix<MT,SO,false>::at(
size_t i,
size_t j )
const
618 template<
typename MT
623 return matrix_.begin(i);
641 template<
typename MT
646 return matrix_.begin(i);
664 template<
typename MT
669 return matrix_.cbegin(i);
687 template<
typename MT
692 return matrix_.end(i);
710 template<
typename MT
715 return matrix_.end(i);
733 template<
typename MT
738 return matrix_.cend(i);
762 template<
typename MT
764 inline StrictlyUpperMatrix<MT,SO,false>&
765 StrictlyUpperMatrix<MT,SO,false>::operator=(
const StrictlyUpperMatrix& rhs )
767 matrix_ = rhs.matrix_;
791 template<
typename MT
793 template<
typename MT2
795 inline typename DisableIf< IsComputation<MT2>, StrictlyUpperMatrix<MT,SO,false>& >::Type
796 StrictlyUpperMatrix<MT,SO,false>::operator=(
const Matrix<MT2,SO2>& rhs )
798 if( IsUniTriangular<MT2>::value ||
805 if( !IsStrictlyUpper<MT2>::value )
830 template<
typename MT
832 template<
typename MT2
834 inline typename EnableIf< IsComputation<MT2>, StrictlyUpperMatrix<MT,SO,false>& >::Type
835 StrictlyUpperMatrix<MT,SO,false>::operator=(
const Matrix<MT2,SO2>& rhs )
837 if( IsUniTriangular<MT2>::value || ( !IsSquare<MT2>::value && !
isSquare( ~rhs ) ) ) {
841 if( IsStrictlyUpper<MT2>::value ) {
851 move( matrix_, tmp );
854 if( !IsStrictlyUpper<MT2>::value )
879 template<
typename MT
881 template<
typename MT2
883 inline typename DisableIf< IsComputation<MT2>, StrictlyUpperMatrix<MT,SO,false>& >::Type
884 StrictlyUpperMatrix<MT,SO,false>::operator+=(
const Matrix<MT2,SO2>& rhs )
886 if( IsUniTriangular<MT2>::value ||
893 if( !IsStrictlyUpper<MT2>::value )
918 template<
typename MT
920 template<
typename MT2
922 inline typename EnableIf< IsComputation<MT2>, StrictlyUpperMatrix<MT,SO,false>& >::Type
923 StrictlyUpperMatrix<MT,SO,false>::operator+=(
const Matrix<MT2,SO2>& rhs )
925 if( IsUniTriangular<MT2>::value || ( IsSquare<MT2>::value && !
isSquare( ~rhs ) ) ) {
929 if( IsStrictlyUpper<MT2>::value ) {
942 if( !IsStrictlyUpper<MT2>::value )
967 template<
typename MT
969 template<
typename MT2
971 inline typename DisableIf< IsComputation<MT2>, StrictlyUpperMatrix<MT,SO,false>& >::Type
972 StrictlyUpperMatrix<MT,SO,false>::operator-=(
const Matrix<MT2,SO2>& rhs )
974 if( IsUniTriangular<MT2>::value ||
981 if( !IsStrictlyUpper<MT2>::value )
1006 template<
typename MT
1008 template<
typename MT2
1010 inline typename EnableIf< IsComputation<MT2>, StrictlyUpperMatrix<MT,SO,false>& >::Type
1011 StrictlyUpperMatrix<MT,SO,false>::operator-=(
const Matrix<MT2,SO2>& rhs )
1013 if( IsUniTriangular<MT2>::value || ( !IsSquare<MT2>::value && !
isSquare( ~rhs ) ) ) {
1017 if( IsStrictlyUpper<MT2>::value ) {
1030 if( !IsStrictlyUpper<MT2>::value )
1054 template<
typename MT
1056 template<
typename MT2
1058 inline StrictlyUpperMatrix<MT,SO,false>&
1059 StrictlyUpperMatrix<MT,SO,false>::operator*=(
const Matrix<MT2,SO2>& rhs )
1061 if( matrix_.rows() != (~rhs).
columns() ) {
1065 MT tmp( matrix_ * ~rhs );
1071 move( matrix_, tmp );
1073 if( !IsStrictlyUpper<MT2>::value )
1093 template<
typename MT
1095 template<
typename Other >
1096 inline typename EnableIf< IsNumeric<Other>, StrictlyUpperMatrix<MT,SO,false> >::Type&
1097 StrictlyUpperMatrix<MT,SO,false>::operator*=( Other rhs )
1113 template<
typename MT
1115 template<
typename Other >
1116 inline typename EnableIf< IsNumeric<Other>, StrictlyUpperMatrix<MT,SO,false> >::Type&
1117 StrictlyUpperMatrix<MT,SO,false>::operator/=( Other rhs )
1142 template<
typename MT
1146 return matrix_.rows();
1158 template<
typename MT
1162 return matrix_.columns();
1174 template<
typename MT
1178 return matrix_.capacity();
1196 template<
typename MT
1200 return matrix_.capacity(i);
1212 template<
typename MT
1216 return matrix_.nonZeros();
1234 template<
typename MT
1238 return matrix_.nonZeros(i);
1250 template<
typename MT
1255 for(
size_t j=1UL; j<
columns(); ++j ) {
1256 matrix_.erase( j, matrix_.begin(j), matrix_.lowerBound(j,j) );
1260 for(
size_t i=0UL; i<
rows(); ++i ) {
1261 matrix_.erase( i, matrix_.lowerBound(i,i+1UL), matrix_.end(i) );
1282 template<
typename MT
1287 matrix_.erase( i, matrix_.begin(i), matrix_.lowerBound(i,i) );
1290 matrix_.erase( i, matrix_.lowerBound(i,i+1UL), matrix_.end(i) );
1305 template<
typename MT
1311 if( IsResizable<MT>::value ) {
1338 template<
typename MT
1347 return matrix_.set( i, j, value );
1370 template<
typename MT
1373 StrictlyUpperMatrix<MT,SO,false>::insert(
size_t i,
size_t j,
const ElementType& value )
1379 return matrix_.insert( i, j, value );
1395 template<
typename MT
1397 inline void StrictlyUpperMatrix<MT,SO,false>::erase(
size_t i,
size_t j )
1399 matrix_.erase( i, j );
1417 template<
typename MT
1420 StrictlyUpperMatrix<MT,SO,false>::erase(
size_t i,
Iterator pos )
1422 return matrix_.erase( i, pos );
1442 template<
typename MT
1445 StrictlyUpperMatrix<MT,SO,false>::erase(
size_t i,
Iterator first,
Iterator last )
1447 return matrix_.erase( i, first, last );
1468 template<
typename MT
1476 matrix_.resize( n, n, preserve );
1493 template<
typename MT
1495 inline void StrictlyUpperMatrix<MT,SO,false>::reserve(
size_t nonzeros )
1497 matrix_.reserve( nonzeros );
1518 template<
typename MT
1520 inline void StrictlyUpperMatrix<MT,SO,false>::reserve(
size_t i,
size_t nonzeros )
1522 matrix_.reserve( i, nonzeros );
1539 template<
typename MT
1541 inline void StrictlyUpperMatrix<MT,SO,false>::trim()
1561 template<
typename MT
1563 inline void StrictlyUpperMatrix<MT,SO,false>::trim(
size_t i )
1578 template<
typename MT
1580 template<
typename Other >
1581 inline StrictlyUpperMatrix<MT,SO,false>&
1582 StrictlyUpperMatrix<MT,SO,false>::scale(
const Other& scalar )
1584 matrix_.scale( scalar );
1598 template<
typename MT
1600 template<
typename Other >
1601 inline StrictlyUpperMatrix<MT,SO,false>&
1602 StrictlyUpperMatrix<MT,SO,false>::scaleDiagonal( Other scalar )
1604 matrix_.scaleDiagonal( scalar );
1619 template<
typename MT
1625 swap( matrix_, m.matrix_ );
1643 template<
typename MT
1645 inline size_t StrictlyUpperMatrix<MT,SO,false>::maxNonZeros()
1649 return maxNonZeros( Rows<MT>::value );
1665 template<
typename MT
1667 inline size_t StrictlyUpperMatrix<MT,SO,false>::maxNonZeros(
size_t n )
1669 return ( ( n - 1UL ) * n ) / 2UL;
1681 template<
typename MT
1683 inline void StrictlyUpperMatrix<MT,SO,false>::resetLower()
1686 for(
size_t j=0UL; j<
columns(); ++j )
1687 matrix_.erase( j, matrix_.upperBound( j, j ), matrix_.end( j ) );
1690 for(
size_t i=1UL; i<
rows(); ++i )
1691 matrix_.erase( i, matrix_.begin( i ), matrix_.lowerBound( i, i ) );
1722 template<
typename MT
1725 StrictlyUpperMatrix<MT,SO,false>::find(
size_t i,
size_t j )
1727 return matrix_.find( i, j );
1749 template<
typename MT
1752 StrictlyUpperMatrix<MT,SO,false>::find(
size_t i,
size_t j )
const
1754 return matrix_.find( i, j );
1776 template<
typename MT
1779 StrictlyUpperMatrix<MT,SO,false>::lowerBound(
size_t i,
size_t j )
1781 return matrix_.lowerBound( i, j );
1803 template<
typename MT
1806 StrictlyUpperMatrix<MT,SO,false>::lowerBound(
size_t i,
size_t j )
const
1808 return matrix_.lowerBound( i, j );
1830 template<
typename MT
1833 StrictlyUpperMatrix<MT,SO,false>::upperBound(
size_t i,
size_t j )
1835 return matrix_.upperBound( i, j );
1857 template<
typename MT
1860 StrictlyUpperMatrix<MT,SO,false>::upperBound(
size_t i,
size_t j )
const
1862 return matrix_.upperBound( i, j );
1926 template<
typename MT
1928 inline void StrictlyUpperMatrix<MT,SO,false>::append(
size_t i,
size_t j,
const ElementType& value,
bool check )
1934 matrix_.append( i, j, value, check );
1954 template<
typename MT
1956 inline void StrictlyUpperMatrix<MT,SO,false>::finalize(
size_t i )
1958 matrix_.finalize( i );
1982 template<
typename MT
2013 template<
typename MT
2015 template<
typename Other >
2016 inline bool StrictlyUpperMatrix<MT,SO,false>::canAlias(
const Other* alias )
const
2018 return matrix_.canAlias( alias );
2035 template<
typename MT
2037 template<
typename Other >
2038 inline bool StrictlyUpperMatrix<MT,SO,false>::isAliased(
const Other* alias )
const
2040 return matrix_.isAliased( alias );
2057 template<
typename MT
2059 inline bool StrictlyUpperMatrix<MT,SO,false>::canSMPAssign()
const
2061 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:116
#define BLAZE_THROW_INVALID_ARGUMENT(MESSAGE)
Macro for the emission of a std::invalid_argument exceptionThis macro encapsulates the default way of...
Definition: Exception.h:187
const MT::ElementType max(const DenseMatrix< MT, SO > &dm)
Returns the largest element of the dense matrix.
Definition: DenseMatrix.h:1729
BLAZE_ALWAYS_INLINE EnableIf< And< IsIntegral< T >, HasSize< T, 2UL > >, simd_int16_t >::Type set(T value)
Sets all values in the vector to the given 2-byte integral value.
Definition: Set.h:73
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.
Header file for basic type definitions.
BLAZE_ALWAYS_INLINE bool isSquare(const Matrix< MT, SO > &matrix)
Checks if the given matrix is a square matrix.
Definition: Matrix.h:603
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:229
void move(CompressedMatrix< Type, SO > &dst, CompressedMatrix< Type, SO > &src)
Moving the contents of one compressed matrix to another.
Definition: CompressedMatrix.h:5016
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:292
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:250
bool isStrictlyUpper(const DenseMatrix< MT, SO > &dm)
Checks if the given dense matrix is a strictly upper triangular matrix.
Definition: DenseMatrix.h:1434
#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:81
Constraint on the data type.
Constraint on the data type.
void reset(const DiagonalProxy< MT > &proxy)
Resetting the represented element to the default initial values.
Definition: DiagonalProxy.h:507
const This & CompositeType
Data type for composite expression templates.
Definition: CompressedMatrix.h:2588
BLAZE_ALWAYS_INLINE size_t capacity(const Matrix< MT, SO > &matrix)
Returns the maximum capacity of the matrix.
Definition: Matrix.h:340
BLAZE_ALWAYS_INLINE size_t rows(const Matrix< MT, SO > &matrix)
Returns the current number of rows of the matrix.
Definition: Matrix.h:308
void clear(CompressedMatrix< Type, SO > &m)
Clearing the given compressed matrix.
Definition: CompressedMatrix.h:4926
CompressedMatrix< Type, true > This
Type of this CompressedMatrix instance.
Definition: CompressedMatrix.h:2582
#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:116
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:378
Constraint on the data type.
CompressedMatrix< Type, false > OppositeType
Result type with opposite storage order for expression template evaluations.
Definition: CompressedMatrix.h:2584
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)
Swapping the contents of two compressed matrices.
Definition: CompressedMatrix.h:4998
bool isIntact(const CompressedMatrix< Type, SO > &m)
Returns whether the invariants of the given compressed matrix are intact.
Definition: CompressedMatrix.h:4980
const Element * ConstIterator
Iterator over constant elements.
Definition: CompressedMatrix.h:2592
#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:116
#define BLAZE_THROW_OUT_OF_RANGE(MESSAGE)
Macro for the emission of a std::out_of_range exceptionThis macro encapsulates the default way of Bla...
Definition: Exception.h:331
Header file for the Columns type trait.
Constraint on the data type.
Header file for the IsUniTriangular type trait.
CompressedMatrix< Type, false > TransposeType
Transpose type for expression template evaluations.
Definition: CompressedMatrix.h:2585
Constraints on the storage order of matrix types.
#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:118
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:187
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:532
Type ElementType
Type of the sparse matrix elements.
Definition: CompressedMatrix.h:2586
const Type & ConstReference
Reference to a constant matrix value.
Definition: CompressedMatrix.h:2590
Header file for the EnableIf class template.
void clear(const DiagonalProxy< MT > &proxy)
Clearing the represented element.
Definition: DiagonalProxy.h:527
Header file for the implementation of the base template of the StrictlyUpperMatrix.
Header file for the IsNumeric type trait.
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:116
const Type & ReturnType
Return type for expression template evaluations.
Definition: CompressedMatrix.h:2587
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:118
#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:116
Element * Iterator
Iterator over non-constant elements.
Definition: CompressedMatrix.h:2591
Header file for the isDefault shim.
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:118
void swap(DiagonalMatrix< MT, SO, DF > &a, DiagonalMatrix< MT, SO, DF > &b)
Swapping the contents of two matrices.
Definition: DiagonalMatrix.h:256
Header file for the move shim.
#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:79
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:118
This ResultType
Result type for expression template evaluations.
Definition: CompressedMatrix.h:2583
BLAZE_ALWAYS_INLINE size_t columns(const Matrix< MT, SO > &matrix)
Returns the current number of columns of the matrix.
Definition: Matrix.h:324
bool isIntact(const DiagonalMatrix< MT, SO, DF > &m)
Returns whether the invariants of the given diagonal matrix are intact.
Definition: DiagonalMatrix.h:237
MatrixAccessProxy< This > Reference
Reference to a non-constant matrix value.
Definition: CompressedMatrix.h:2589
#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:116
Header file for exception macros.
#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:143
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:79