35 #ifndef _BLAZE_MATH_ADAPTORS_UNIUPPERMATRIX_SPARSE_H_
36 #define _BLAZE_MATH_ADAPTORS_UNIUPPERMATRIX_SPARSE_H_
104 template<
typename MT
106 class UniUpperMatrix<MT,SO,false>
107 :
public SparseMatrix< UniUpperMatrix<MT,SO,false>, SO >
118 typedef UniUpperMatrix<MT,SO,false>
This;
133 template<
typename ET >
136 typedef UniUpperMatrix< typename MT::template Rebind<ET>::Other > Other;
149 typedef std::forward_iterator_tag IteratorCategory;
150 typedef UniUpperElement<MT> ValueType;
151 typedef ValueType PointerType;
152 typedef ValueType ReferenceType;
153 typedef ptrdiff_t DifferenceType;
156 typedef IteratorCategory iterator_category;
157 typedef ValueType value_type;
158 typedef PointerType pointer;
159 typedef ReferenceType reference;
160 typedef DifferenceType difference_type;
178 inline Iterator( IteratorType pos,
size_t index )
200 inline const Iterator operator++(
int ) {
213 return ReferenceType( pos_, pos_->index() == index_ );
222 inline PointerType operator->()
const {
223 return PointerType( pos_, pos_->index() == index_ );
244 return pos_ == rhs.pos_;
255 return !( *
this == rhs );
266 return pos_ - rhs.pos_;
275 inline IteratorType base()
const {
290 enum { smpAssignable = 0 };
296 explicit inline UniUpperMatrix();
297 explicit inline UniUpperMatrix(
size_t n );
298 explicit inline UniUpperMatrix(
size_t n,
size_t nonzeros );
299 explicit inline UniUpperMatrix(
size_t n,
const std::vector<size_t>& nonzeros );
301 inline UniUpperMatrix(
const UniUpperMatrix& m );
302 template<
typename MT2,
bool SO2 >
inline UniUpperMatrix(
const Matrix<MT2,SO2>& m );
313 inline Reference operator()(
size_t i,
size_t j );
314 inline ConstReference operator()(
size_t i,
size_t j )
const;
315 inline Reference at(
size_t i,
size_t j );
316 inline ConstReference at(
size_t i,
size_t j )
const;
318 inline ConstIterator
begin (
size_t i )
const;
319 inline ConstIterator
cbegin(
size_t i )
const;
321 inline ConstIterator
end (
size_t i )
const;
322 inline ConstIterator
cend (
size_t i )
const;
329 inline UniUpperMatrix& operator=(
const UniUpperMatrix& rhs );
331 template<
typename MT2,
bool SO2 >
332 inline typename DisableIf< IsComputation<MT2>, UniUpperMatrix& >::Type
333 operator=(
const Matrix<MT2,SO2>& rhs );
335 template<
typename MT2,
bool SO2 >
336 inline typename EnableIf< IsComputation<MT2>, UniUpperMatrix& >::Type
337 operator=(
const Matrix<MT2,SO2>& rhs );
339 template<
typename MT2,
bool SO2 >
340 inline typename DisableIf< IsComputation<MT2>, UniUpperMatrix& >::Type
341 operator+=(
const Matrix<MT2,SO2>& rhs );
343 template<
typename MT2,
bool SO2 >
344 inline typename EnableIf< IsComputation<MT2>, UniUpperMatrix& >::Type
345 operator+=(
const Matrix<MT2,SO2>& rhs );
347 template<
typename MT2,
bool SO2 >
348 inline typename DisableIf< IsComputation<MT2>, UniUpperMatrix& >::Type
349 operator-=(
const Matrix<MT2,SO2>& rhs );
351 template<
typename MT2,
bool SO2 >
352 inline typename EnableIf< IsComputation<MT2>, UniUpperMatrix& >::Type
353 operator-=(
const Matrix<MT2,SO2>& rhs );
355 template<
typename MT2,
bool SO2 >
356 inline UniUpperMatrix& operator*=(
const Matrix<MT2,SO2>& rhs );
363 inline size_t rows()
const;
366 inline size_t capacity(
size_t i )
const;
368 inline size_t nonZeros(
size_t i )
const;
370 inline void reset(
size_t i );
372 inline Iterator set(
size_t i,
size_t j,
const ElementType& value );
373 inline Iterator insert(
size_t i,
size_t j,
const ElementType& value );
374 inline void erase(
size_t i,
size_t j );
377 inline void resize (
size_t n,
bool preserve=
true );
378 inline void reserve(
size_t nonzeros );
379 inline void reserve(
size_t i,
size_t nonzeros );
381 inline void trim(
size_t i );
382 inline void swap( UniUpperMatrix& m ) ;
384 static inline size_t maxNonZeros();
385 static inline size_t maxNonZeros(
size_t n );
392 inline Iterator find (
size_t i,
size_t j );
393 inline ConstIterator find (
size_t i,
size_t j )
const;
394 inline Iterator lowerBound(
size_t i,
size_t j );
395 inline ConstIterator lowerBound(
size_t i,
size_t j )
const;
396 inline Iterator upperBound(
size_t i,
size_t j );
397 inline ConstIterator upperBound(
size_t i,
size_t j )
const;
404 inline void append (
size_t i,
size_t j,
const ElementType& value,
bool check=
false );
405 inline void finalize(
size_t i );
419 template<
typename Other >
inline bool canAlias (
const Other* alias )
const;
420 template<
typename Other >
inline bool isAliased(
const Other* alias )
const;
422 inline bool canSMPAssign()
const;
430 inline void resetLower();
442 template<
typename MT2,
bool SO2,
bool DF2 >
443 friend MT2& derestrict( UniUpperMatrix<MT2,SO2,DF2>& m );
479 template<
typename MT
481 inline UniUpperMatrix<MT,SO,false>::UniUpperMatrix()
498 template<
typename MT
500 inline UniUpperMatrix<MT,SO,false>::UniUpperMatrix(
size_t n )
505 for(
size_t i=0UL; i<n; ++i ) {
507 matrix_.finalize( i );
526 template<
typename MT
528 inline UniUpperMatrix<MT,SO,false>::UniUpperMatrix(
size_t n,
size_t nonzeros )
529 : matrix_( n, n,
max( nonzeros, n ) )
533 for(
size_t i=0UL; i<n; ++i ) {
535 matrix_.finalize( i );
558 template<
typename MT
560 inline UniUpperMatrix<MT,SO,false>::UniUpperMatrix(
size_t n,
const std::vector<size_t>& nonzeros )
561 : matrix_( n, n, nonzeros )
565 for(
size_t i=0UL; i<n; ++i )
567 if( nonzeros[i] == 0UL ) {
572 matrix_.finalize( i );
587 template<
typename MT
589 inline UniUpperMatrix<MT,SO,false>::UniUpperMatrix(
const UniUpperMatrix& m )
590 : matrix_( m.matrix_ )
609 template<
typename MT
611 template<
typename MT2
613 inline UniUpperMatrix<MT,SO,false>::UniUpperMatrix(
const Matrix<MT2,SO2>& m )
616 if( !IsUniUpper<MT2>::value && !
isUniUpper( matrix_ ) ) {
620 if( !IsUniUpper<MT2>::value )
654 template<
typename MT
657 UniUpperMatrix<MT,SO,false>::operator()(
size_t i,
size_t j )
684 template<
typename MT
687 UniUpperMatrix<MT,SO,false>::operator()(
size_t i,
size_t j )
const
715 template<
typename MT
718 UniUpperMatrix<MT,SO,false>::at(
size_t i,
size_t j )
749 template<
typename MT
752 UniUpperMatrix<MT,SO,false>::at(
size_t i,
size_t j )
const
778 template<
typename MT
783 return Iterator( matrix_.begin(i), i );
801 template<
typename MT
806 return matrix_.begin(i);
824 template<
typename MT
829 return matrix_.cbegin(i);
847 template<
typename MT
852 return Iterator( matrix_.end(i), i );
870 template<
typename MT
875 return matrix_.end(i);
893 template<
typename MT
898 return matrix_.cend(i);
922 template<
typename MT
924 inline UniUpperMatrix<MT,SO,false>&
925 UniUpperMatrix<MT,SO,false>::operator=(
const UniUpperMatrix& rhs )
927 matrix_ = rhs.matrix_;
951 template<
typename MT
953 template<
typename MT2
955 inline typename DisableIf< IsComputation<MT2>, UniUpperMatrix<MT,SO,false>& >::Type
956 UniUpperMatrix<MT,SO,false>::operator=(
const Matrix<MT2,SO2>& rhs )
958 if( IsStrictlyTriangular<MT2>::value || ( !IsUniUpper<MT2>::value && !
isUniUpper( ~rhs ) ) ) {
964 if( !IsUniUpper<MT2>::value )
989 template<
typename MT
991 template<
typename MT2
993 inline typename EnableIf< IsComputation<MT2>, UniUpperMatrix<MT,SO,false>& >::Type
994 UniUpperMatrix<MT,SO,false>::operator=(
const Matrix<MT2,SO2>& rhs )
996 if( IsStrictlyTriangular<MT2>::value || ( !IsSquare<MT2>::value && !
isSquare( ~rhs ) ) ) {
1000 if( IsUniUpper<MT2>::value ) {
1010 move( matrix_, tmp );
1013 if( !IsUniUpper<MT2>::value )
1038 template<
typename MT
1040 template<
typename MT2
1042 inline typename DisableIf< IsComputation<MT2>, UniUpperMatrix<MT,SO,false>& >::Type
1043 UniUpperMatrix<MT,SO,false>::operator+=(
const Matrix<MT2,SO2>& rhs )
1045 if( IsLower<MT2>::value || IsUniTriangular<MT2>::value ||
1052 if( !IsStrictlyUpper<MT2>::value )
1077 template<
typename MT
1079 template<
typename MT2
1081 inline typename EnableIf< IsComputation<MT2>, UniUpperMatrix<MT,SO,false>& >::Type
1082 UniUpperMatrix<MT,SO,false>::operator+=(
const Matrix<MT2,SO2>& rhs )
1084 if( IsLower<MT2>::value || IsUniTriangular<MT2>::value ||
1085 ( IsSquare<MT2>::value && !
isSquare( ~rhs ) ) ) {
1089 if( IsStrictlyUpper<MT2>::value ) {
1102 if( !IsStrictlyUpper<MT2>::value )
1127 template<
typename MT
1129 template<
typename MT2
1131 inline typename DisableIf< IsComputation<MT2>, UniUpperMatrix<MT,SO,false>& >::Type
1132 UniUpperMatrix<MT,SO,false>::operator-=(
const Matrix<MT2,SO2>& rhs )
1134 if( IsLower<MT2>::value || IsUniTriangular<MT2>::value ||
1141 if( !IsStrictlyUpper<MT2>::value )
1166 template<
typename MT
1168 template<
typename MT2
1170 inline typename EnableIf< IsComputation<MT2>, UniUpperMatrix<MT,SO,false>& >::Type
1171 UniUpperMatrix<MT,SO,false>::operator-=(
const Matrix<MT2,SO2>& rhs )
1173 if( IsLower<MT2>::value || IsUniTriangular<MT2>::value ||
1174 ( !IsSquare<MT2>::value && !
isSquare( ~rhs ) ) ) {
1178 if( IsStrictlyUpper<MT2>::value ) {
1191 if( !IsStrictlyUpper<MT2>::value )
1215 template<
typename MT
1217 template<
typename MT2
1219 inline UniUpperMatrix<MT,SO,false>&
1220 UniUpperMatrix<MT,SO,false>::operator*=(
const Matrix<MT2,SO2>& rhs )
1222 if( matrix_.rows() != (~rhs).
columns() ) {
1226 MT tmp( matrix_ * ~rhs );
1232 move( matrix_, tmp );
1234 if( !IsUniUpper<MT2>::value )
1260 template<
typename MT
1264 return matrix_.rows();
1276 template<
typename MT
1280 return matrix_.columns();
1292 template<
typename MT
1296 return matrix_.capacity();
1314 template<
typename MT
1318 return matrix_.capacity(i);
1330 template<
typename MT
1334 return matrix_.nonZeros();
1352 template<
typename MT
1356 return matrix_.nonZeros(i);
1368 template<
typename MT
1373 for(
size_t j=1UL; j<
columns(); ++j ) {
1374 matrix_.erase( j, matrix_.begin(j), matrix_.lowerBound(j,j) );
1378 for(
size_t i=0UL; i<
rows(); ++i ) {
1379 matrix_.erase( i, matrix_.lowerBound(i,i+1UL), matrix_.end(i) );
1400 template<
typename MT
1405 matrix_.erase( i, matrix_.begin(i), matrix_.lowerBound(i,i) );
1408 matrix_.erase( i, matrix_.lowerBound(i,i+1UL), matrix_.end(i) );
1423 template<
typename MT
1429 if( IsResizable<MT>::value ) {
1456 template<
typename MT
1465 return Iterator( matrix_.set( i, j, value ), ( SO ? j : i ) );
1488 template<
typename MT
1491 UniUpperMatrix<MT,SO,false>::insert(
size_t i,
size_t j,
const ElementType& value )
1497 return Iterator( matrix_.insert( i, j, value ), ( SO ? j : i ) );
1515 template<
typename MT
1517 inline void UniUpperMatrix<MT,SO,false>::erase(
size_t i,
size_t j )
1523 matrix_.erase( i, j );
1543 template<
typename MT
1546 UniUpperMatrix<MT,SO,false>::erase(
size_t i,
Iterator pos )
1548 if( pos != matrix_.end(i) && pos->index() == i ) {
1552 return Iterator( matrix_.erase( i, pos.base() ), i );
1573 template<
typename MT
1576 UniUpperMatrix<MT,SO,false>::erase(
size_t i,
Iterator first,
Iterator last )
1578 for(
Iterator element=first; element!=last; ++element ) {
1579 if( element->index() == i ) {
1584 return Iterator( matrix_.erase( i, first.base(), last.base() ), i );
1605 template<
typename MT
1613 const size_t oldsize( matrix_.rows() );
1615 matrix_.resize( n, n, preserve );
1618 for(
size_t i=oldsize; i<n; ++i )
1619 matrix_.insert( i, i, ElementType(1) );
1637 template<
typename MT
1639 inline void UniUpperMatrix<MT,SO,false>::reserve(
size_t nonzeros )
1641 matrix_.reserve( nonzeros );
1661 template<
typename MT
1663 inline void UniUpperMatrix<MT,SO,false>::reserve(
size_t i,
size_t nonzeros )
1665 matrix_.reserve( i, nonzeros );
1682 template<
typename MT
1684 inline void UniUpperMatrix<MT,SO,false>::trim()
1704 template<
typename MT
1706 inline void UniUpperMatrix<MT,SO,false>::trim(
size_t i )
1722 template<
typename MT
1728 swap( matrix_, m.matrix_ );
1745 template<
typename MT
1747 inline size_t UniUpperMatrix<MT,SO,false>::maxNonZeros()
1751 return maxNonZeros( Rows<MT>::value );
1767 template<
typename MT
1769 inline size_t UniUpperMatrix<MT,SO,false>::maxNonZeros(
size_t n )
1771 return ( ( n + 1UL ) * n ) / 2UL;
1783 template<
typename MT
1785 inline void UniUpperMatrix<MT,SO,false>::resetLower()
1788 for(
size_t j=0UL; j<
columns(); ++j )
1789 matrix_.erase( j, matrix_.upperBound( j, j ), matrix_.end( j ) );
1792 for(
size_t i=1UL; i<
rows(); ++i )
1793 matrix_.erase( i, matrix_.begin( i ), matrix_.lowerBound( i, i ) );
1824 template<
typename MT
1827 UniUpperMatrix<MT,SO,false>::find(
size_t i,
size_t j )
1829 return Iterator( matrix_.find( i, j ), ( SO ? j : i ) );
1851 template<
typename MT
1854 UniUpperMatrix<MT,SO,false>::find(
size_t i,
size_t j )
const
1856 return matrix_.find( i, j );
1878 template<
typename MT
1881 UniUpperMatrix<MT,SO,false>::lowerBound(
size_t i,
size_t j )
1883 return Iterator( matrix_.lowerBound( i, j ), ( SO ? j : i ) );
1905 template<
typename MT
1908 UniUpperMatrix<MT,SO,false>::lowerBound(
size_t i,
size_t j )
const
1910 return matrix_.lowerBound( i, j );
1932 template<
typename MT
1935 UniUpperMatrix<MT,SO,false>::upperBound(
size_t i,
size_t j )
1937 return Iterator( matrix_.upperBound( i, j ), ( SO ? j : i ) );
1959 template<
typename MT
1962 UniUpperMatrix<MT,SO,false>::upperBound(
size_t i,
size_t j )
const
1964 return matrix_.upperBound( i, j );
2028 template<
typename MT
2030 inline void UniUpperMatrix<MT,SO,false>::append(
size_t i,
size_t j,
const ElementType& value,
bool check )
2037 matrix_.insert( i, j, value );
2057 template<
typename MT
2059 inline void UniUpperMatrix<MT,SO,false>::finalize(
size_t i )
2085 template<
typename MT
2116 template<
typename MT
2118 template<
typename Other >
2119 inline bool UniUpperMatrix<MT,SO,false>::canAlias(
const Other* alias )
const
2121 return matrix_.canAlias( alias );
2138 template<
typename MT
2140 template<
typename Other >
2141 inline bool UniUpperMatrix<MT,SO,false>::isAliased(
const Other* alias )
const
2143 return matrix_.isAliased( alias );
2160 template<
typename MT
2162 inline bool UniUpperMatrix<MT,SO,false>::canSMPAssign()
const
2164 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: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
Constraint on the data type.
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 the IsUniUpper type trait.
const DMatDMatMultExpr< T1, T2 > operator*(const DenseMatrix< T1, false > &lhs, const DenseMatrix< T2, false > &rhs)
Multiplication operator for the multiplication of two row-major dense matrices ( ).
Definition: DMatDMatMultExpr.h:7820
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
Header file for the implementation of the base template of the UniUpperMatrix.
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.
bool isDefault(const CompressedMatrix< Type, SO > &m)
Returns whether the given compressed matrix is in default state.
Definition: CompressedMatrix.h:4953
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 IsLower type trait.
Header file for the UniUpperProxy class.
const DenseIterator< Type, AF > operator-(const DenseIterator< Type, AF > &it, ptrdiff_t inc)
Subtraction between a DenseIterator and an integral value.
Definition: DenseIterator.h:642
Header file for the IsUniTriangular type trait.
Header file for the IsStrictlyTriangular 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 IsNumeric type trait.
Header file for all adaptor forward declarations.
Header file for the UniUpperValue class.
#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_BE_NUMERIC_TYPE(T)
Constraint on the data type.In case the given data type T is not a numeric (integral or floating poin...
Definition: Numeric.h:79
#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.
Header file for the UniUpperElement class.
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
bool operator==(const NegativeAccuracy< A > &lhs, const T &rhs)
Equality comparison between a NegativeAccuracy object and a floating point value. ...
Definition: Accuracy.h:249
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 operator!=(const NegativeAccuracy< A > &lhs, const T &rhs)
Inequality comparison between a NegativeAccuracy object and a floating point value.
Definition: Accuracy.h:289
bool isIntact(const DiagonalMatrix< MT, SO, DF > &m)
Returns whether the invariants of the given diagonal matrix are intact.
Definition: DiagonalMatrix.h:237
bool isUniUpper(const DenseMatrix< MT, SO > &dm)
Checks if the given dense matrix is an upper unitriangular matrix.
Definition: DenseMatrix.h:1354
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