35 #ifndef _BLAZE_MATH_ADAPTORS_UNILOWERMATRIX_DENSE_H_
36 #define _BLAZE_MATH_ADAPTORS_UNILOWERMATRIX_DENSE_H_
105 template<
typename MT
107 class UniLowerMatrix<MT,SO,true>
108 :
public DenseMatrix< UniLowerMatrix<MT,SO,true>, SO >
115 typedef IntrinsicTrait<ET> IT;
120 typedef UniLowerMatrix<MT,SO,true>
This;
125 typedef typename MT::IntrinsicType IntrinsicType;
130 typedef typename MT::Pointer Pointer;
131 typedef typename MT::ConstPointer ConstPointer;
138 template<
typename ET >
141 typedef UniLowerMatrix< typename MT::template Rebind<ET>::Other > Other;
152 typedef std::random_access_iterator_tag IteratorCategory;
154 typedef UniLowerProxy<MT> PointerType;
155 typedef UniLowerProxy<MT> ReferenceType;
156 typedef ptrdiff_t DifferenceType;
159 typedef IteratorCategory iterator_category;
160 typedef ValueType value_type;
161 typedef PointerType pointer;
162 typedef ReferenceType reference;
163 typedef DifferenceType difference_type;
196 inline Iterator& operator+=(
size_t inc ) {
197 ( SO )?( row_ += inc ):( column_ += inc );
208 inline Iterator& operator-=(
size_t dec ) {
209 ( SO )?( row_ -= dec ):( column_ -= dec );
220 ( SO )?( ++row_ ):( ++column_ );
230 inline const Iterator operator++(
int ) {
243 ( SO )?( --row_ ):( --column_ );
253 inline const Iterator operator--(
int ) {
266 return ReferenceType( *matrix_, row_, column_ );
275 inline PointerType operator->()
const {
276 return PointerType( *matrix_, row_, column_ );
287 return matrix_->begin( column_ ) + row_;
289 return matrix_->begin( row_ ) + column_;
301 return ( SO )?( lhs.row_ == rhs.row_ ):( lhs.column_ == rhs.column_ );
337 return ( SO )?( lhs.row_ != rhs.row_ ):( lhs.column_ != rhs.column_ );
373 return ( SO )?( lhs.row_ < rhs.row_ ):( lhs.column_ < rhs.column_ );
409 return ( SO )?( lhs.row_ > rhs.row_ ):( lhs.column_ > rhs.column_ );
445 return ( SO )?( lhs.row_ <= rhs.row_ ):( lhs.column_ <= rhs.column_ );
481 return ( SO )?( lhs.row_ >= rhs.row_ ):( lhs.column_ >= rhs.column_ );
516 return ( SO )?( row_ - rhs.row_ ):( column_ - rhs.column_ );
529 return Iterator( *it.matrix_, it.row_ + inc, it.column_ );
531 return Iterator( *it.matrix_, it.row_, it.column_ + inc );
544 return Iterator( *it.matrix_, it.row_ + inc, it.column_ );
546 return Iterator( *it.matrix_, it.row_, it.column_ + inc );
559 return Iterator( *it.matrix_, it.row_ - dec, it.column_ );
561 return Iterator( *it.matrix_, it.row_, it.column_ - dec );
576 enum { vectorizable = MT::vectorizable };
579 enum { smpAssignable = MT::smpAssignable };
585 explicit inline UniLowerMatrix();
586 template<
typename A1 >
explicit inline UniLowerMatrix(
const A1& a1 );
587 explicit inline UniLowerMatrix(
size_t n,
const ElementType& init );
588 inline UniLowerMatrix(
const UniLowerMatrix& m );
599 inline Reference operator()(
size_t i,
size_t j );
600 inline ConstReference operator()(
size_t i,
size_t j )
const;
601 inline ConstPointer data ()
const;
602 inline ConstPointer data (
size_t i )
const;
604 inline ConstIterator
begin (
size_t i )
const;
605 inline ConstIterator
cbegin(
size_t i )
const;
607 inline ConstIterator
end (
size_t i )
const;
608 inline ConstIterator
cend (
size_t i )
const;
615 inline UniLowerMatrix& operator=(
const ElementType& rhs );
616 inline UniLowerMatrix& operator=(
const UniLowerMatrix& rhs );
618 template<
typename MT2,
bool SO2 >
619 inline typename DisableIf< IsComputation<MT2>, UniLowerMatrix& >::Type
620 operator=(
const Matrix<MT2,SO2>& rhs );
622 template<
typename MT2,
bool SO2 >
623 inline typename EnableIf< IsComputation<MT2>, UniLowerMatrix& >::Type
624 operator=(
const Matrix<MT2,SO2>& rhs );
626 template<
typename MT2,
bool SO2 >
627 inline typename DisableIf< IsComputation<MT2>, UniLowerMatrix& >::Type
628 operator+=(
const Matrix<MT2,SO2>& rhs );
630 template<
typename MT2,
bool SO2 >
631 inline typename EnableIf< IsComputation<MT2>, UniLowerMatrix& >::Type
632 operator+=(
const Matrix<MT2,SO2>& rhs );
634 template<
typename MT2,
bool SO2 >
635 inline typename DisableIf< IsComputation<MT2>, UniLowerMatrix& >::Type
636 operator-=(
const Matrix<MT2,SO2>& rhs );
638 template<
typename MT2,
bool SO2 >
639 inline typename EnableIf< IsComputation<MT2>, UniLowerMatrix& >::Type
640 operator-=(
const Matrix<MT2,SO2>& rhs );
642 template<
typename MT2,
bool SO2 >
643 inline UniLowerMatrix& operator*=(
const Matrix<MT2,SO2>& rhs );
650 inline size_t rows()
const;
654 inline size_t capacity(
size_t i )
const;
656 inline size_t nonZeros(
size_t i )
const;
658 inline void reset(
size_t i );
660 void resize (
size_t n,
bool preserve=
true );
661 inline void extend (
size_t n,
bool preserve=
true );
662 inline void reserve(
size_t elements );
663 inline void swap( UniLowerMatrix& m ) ;
665 static inline size_t maxNonZeros();
666 static inline size_t maxNonZeros(
size_t n );
673 template<
typename Other >
inline bool canAlias (
const Other* alias )
const;
674 template<
typename Other >
inline bool isAliased(
const Other* alias )
const;
676 inline bool isAligned ()
const;
677 inline bool canSMPAssign()
const;
688 inline const MT construct(
size_t n ,
TrueType );
689 inline const MT construct(
const ElementType& value,
FalseType );
691 template<
typename MT2,
bool SO2,
typename T >
692 inline const MT construct(
const Matrix<MT2,SO2>& m, T );
704 template<
typename MT2,
bool SO2,
bool DF2 >
705 friend MT2& derestrict( UniLowerMatrix<MT2,SO2,DF2>& m );
740 template<
typename MT
742 inline UniLowerMatrix<MT,SO,true>::UniLowerMatrix()
745 for(
size_t i=0UL; i<Rows<MT>::value; ++i )
772 template<
typename MT
774 template<
typename A1 >
775 inline UniLowerMatrix<MT,SO,true>::UniLowerMatrix(
const A1& a1 )
776 : matrix_( construct( a1, typename IsResizable<MT>::Type() ) )
791 template<
typename MT
793 inline UniLowerMatrix<MT,SO,true>::UniLowerMatrix(
size_t n,
const ElementType& init )
794 : matrix_( n, n, ElementType() )
799 for(
size_t j=0UL; j<
columns(); ++j ) {
801 for(
size_t i=j+1UL; i<
rows(); ++i )
806 for(
size_t i=0UL; i<
rows(); ++i ) {
807 for(
size_t j=0UL; j<i; ++j )
825 template<
typename MT
827 inline UniLowerMatrix<MT,SO,true>::UniLowerMatrix(
const UniLowerMatrix& m )
828 : matrix_( m.matrix_ )
857 template<
typename MT
860 UniLowerMatrix<MT,SO,true>::operator()(
size_t i,
size_t j )
884 template<
typename MT
887 UniLowerMatrix<MT,SO,true>::operator()(
size_t i,
size_t j )
const
911 template<
typename MT
913 inline typename UniLowerMatrix<MT,SO,true>::ConstPointer
914 UniLowerMatrix<MT,SO,true>::data()
const
916 return matrix_.data();
931 template<
typename MT
933 inline typename UniLowerMatrix<MT,SO,true>::ConstPointer
934 UniLowerMatrix<MT,SO,true>::data(
size_t i )
const
936 return matrix_.data(i);
954 template<
typename MT
980 template<
typename MT
985 return matrix_.begin(i);
1003 template<
typename MT
1008 return matrix_.cbegin(i);
1026 template<
typename MT
1052 template<
typename MT
1057 return matrix_.end(i);
1075 template<
typename MT
1080 return matrix_.cend(i);
1101 template<
typename MT
1103 inline UniLowerMatrix<MT,SO,true>&
1104 UniLowerMatrix<MT,SO,true>::operator=(
const ElementType& rhs )
1107 for(
size_t j=0UL; j<
columns(); ++j )
1108 for(
size_t i=j+1UL; i<
rows(); ++i )
1112 for(
size_t i=1UL; i<
rows(); ++i )
1113 for(
size_t j=0UL; j<i; ++j )
1133 template<
typename MT
1135 inline UniLowerMatrix<MT,SO,true>&
1136 UniLowerMatrix<MT,SO,true>::operator=(
const UniLowerMatrix& rhs )
1138 matrix_ = rhs.matrix_;
1159 template<
typename MT
1161 template<
typename MT2
1163 inline typename DisableIf< IsComputation<MT2>, UniLowerMatrix<MT,SO,true>& >::Type
1164 UniLowerMatrix<MT,SO,true>::operator=(
const Matrix<MT2,SO2>& rhs )
1166 if( IsStrictlyTriangular<MT2>::value || ( !IsUniLower<MT2>::value && !
isUniLower( ~rhs ) ) )
1167 throw std::invalid_argument(
"Invalid assignment to unilower matrix" );
1190 template<
typename MT
1192 template<
typename MT2
1194 inline typename EnableIf< IsComputation<MT2>, UniLowerMatrix<MT,SO,true>& >::Type
1195 UniLowerMatrix<MT,SO,true>::operator=(
const Matrix<MT2,SO2>& rhs )
1197 if( IsStrictlyTriangular<MT2>::value || ( !IsSquare<MT2>::value && !
isSquare( ~rhs ) ) )
1198 throw std::invalid_argument(
"Invalid assignment to unilower matrix" );
1200 if( IsUniLower<MT2>::value ) {
1207 throw std::invalid_argument(
"Invalid assignment to unilower matrix" );
1209 move( matrix_, tmp );
1231 template<
typename MT
1233 template<
typename MT2
1235 inline typename DisableIf< IsComputation<MT2>, UniLowerMatrix<MT,SO,true>& >::Type
1236 UniLowerMatrix<MT,SO,true>::operator+=(
const Matrix<MT2,SO2>& rhs )
1238 if( IsUpper<MT2>::value || IsUniTriangular<MT2>::value ||
1240 throw std::invalid_argument(
"Invalid assignment to unilower matrix" );
1263 template<
typename MT
1265 template<
typename MT2
1267 inline typename EnableIf< IsComputation<MT2>, UniLowerMatrix<MT,SO,true>& >::Type
1268 UniLowerMatrix<MT,SO,true>::operator+=(
const Matrix<MT2,SO2>& rhs )
1270 if( IsUpper<MT2>::value || IsUniTriangular<MT2>::value ||
1271 ( !IsSquare<MT2>::value && !
isSquare( ~rhs ) ) )
1272 throw std::invalid_argument(
"Invalid assignment to unilower matrix" );
1274 if( IsStrictlyLower<MT2>::value ) {
1281 throw std::invalid_argument(
"Invalid assignment to unilower matrix" );
1305 template<
typename MT
1307 template<
typename MT2
1309 inline typename DisableIf< IsComputation<MT2>, UniLowerMatrix<MT,SO,true>& >::Type
1310 UniLowerMatrix<MT,SO,true>::operator-=(
const Matrix<MT2,SO2>& rhs )
1312 if( IsUpper<MT2>::value || IsUniTriangular<MT2>::value ||
1314 throw std::invalid_argument(
"Invalid assignment to unilower matrix" );
1337 template<
typename MT
1339 template<
typename MT2
1341 inline typename EnableIf< IsComputation<MT2>, UniLowerMatrix<MT,SO,true>& >::Type
1342 UniLowerMatrix<MT,SO,true>::operator-=(
const Matrix<MT2,SO2>& rhs )
1344 if( IsUpper<MT2>::value || IsUniTriangular<MT2>::value ||
1345 ( !IsSquare<MT2>::value && !
isSquare( ~rhs ) ) )
1346 throw std::invalid_argument(
"Invalid assignment to unilower matrix" );
1348 if( IsStrictlyLower<MT2>::value ) {
1355 throw std::invalid_argument(
"Invalid assignment to unilower matrix" );
1378 template<
typename MT
1380 template<
typename MT2
1382 inline UniLowerMatrix<MT,SO,true>&
1383 UniLowerMatrix<MT,SO,true>::operator*=(
const Matrix<MT2,SO2>& rhs )
1385 if( matrix_.rows() != (~rhs).
columns() )
1386 throw std::invalid_argument(
"Invalid assignment to unilower matrix" );
1388 MT tmp( matrix_ * ~rhs );
1391 throw std::invalid_argument(
"Invalid assignment to unilower matrix" );
1393 move( matrix_, tmp );
1415 template<
typename MT
1419 return matrix_.rows();
1431 template<
typename MT
1435 return matrix_.columns();
1452 template<
typename MT
1456 return matrix_.spacing();
1468 template<
typename MT
1472 return matrix_.capacity();
1490 template<
typename MT
1494 return matrix_.capacity(i);
1506 template<
typename MT
1510 return matrix_.nonZeros();
1528 template<
typename MT
1532 return matrix_.nonZeros(i);
1544 template<
typename MT
1551 for(
size_t j=0UL; j<
columns(); ++j )
1552 for(
size_t i=j+1UL; i<
rows(); ++i )
1553 clear( matrix_(i,j) );
1556 for(
size_t i=1UL; i<
rows(); ++i )
1557 for(
size_t j=0UL; j<i; ++j )
1558 clear( matrix_(i,j) );
1578 template<
typename MT
1585 for(
size_t j=i+1UL; j<
rows(); ++j )
1586 clear( matrix_(j,i) );
1589 for(
size_t j=0UL; j<i; ++j )
1590 clear( matrix_(i,j) );
1609 template<
typename MT
1615 if( IsResizable<MT>::value ) {
1662 template<
typename MT
1672 const size_t oldsize( matrix_.rows() );
1674 matrix_.resize( n, n,
true );
1678 const size_t increment( n - oldsize );
1679 submatrix( matrix_, 0UL, oldsize, n-1UL, increment ).reset();
1681 for(
size_t i=oldsize; i<n; ++i )
1702 template<
typename MT
1704 inline void UniLowerMatrix<MT,SO,true>::extend(
size_t n,
bool preserve )
1725 template<
typename MT
1727 inline void UniLowerMatrix<MT,SO,true>::reserve(
size_t elements )
1729 matrix_.reserve( elements );
1743 template<
typename MT
1749 swap( matrix_, m.matrix_ );
1767 template<
typename MT
1769 inline size_t UniLowerMatrix<MT,SO,true>::maxNonZeros()
1773 return maxNonZeros( Rows<MT>::value );
1789 template<
typename MT
1791 inline size_t UniLowerMatrix<MT,SO,true>::maxNonZeros(
size_t n )
1793 return ( ( n + 1UL ) * n ) / 2UL;
1818 template<
typename MT
1820 template<
typename Other >
1821 inline bool UniLowerMatrix<MT,SO,true>::canAlias(
const Other* alias )
const
1823 return matrix_.canAlias( alias );
1840 template<
typename MT
1842 template<
typename Other >
1843 inline bool UniLowerMatrix<MT,SO,true>::isAliased(
const Other* alias )
const
1845 return matrix_.isAliased( alias );
1861 template<
typename MT
1863 inline bool UniLowerMatrix<MT,SO,true>::isAligned()
const
1865 return matrix_.isAligned();
1882 template<
typename MT
1884 inline bool UniLowerMatrix<MT,SO,true>::canSMPAssign()
const
1886 return matrix_.canSMPAssign();
1908 template<
typename MT
1913 return matrix_.load( i, j );
1935 template<
typename MT
1940 return matrix_.loadu( i, j );
1961 template<
typename MT
1963 inline const MT UniLowerMatrix<MT,SO,true>::construct(
size_t n,
TrueType )
1969 for(
size_t i=0UL; i<n; ++i )
1985 template<
typename MT
1987 inline const MT UniLowerMatrix<MT,SO,true>::construct(
const ElementType& init,
FalseType )
1995 for(
size_t j=0UL; j<tmp.columns(); ++j ) {
1997 for(
size_t i=j+1UL; i<tmp.rows(); ++i )
2002 for(
size_t i=0UL; i<tmp.rows(); ++i ) {
2003 for(
size_t j=0UL; j<i; ++j )
2026 template<
typename MT
2028 template<
typename MT2
2031 inline const MT UniLowerMatrix<MT,SO,true>::construct(
const Matrix<MT2,SO2>& m, T )
2035 if( IsStrictlyTriangular<MT2>::value || ( !IsUniLower<MT2>::value && !
isUniLower( tmp ) ) )
2036 throw std::invalid_argument(
"Invalid setup of unilower matrix" );
Constraint on the data type.
Header file for all restructuring submatrix functions.
#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
Constraint on the data type.
#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 UNUSED_PARAMETER function template.
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:8247
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:902
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:237
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:300
bool operator<=(const NegativeAccuracy< A > &, const T &rhs)
Less-or-equal-than comparison between a NegativeAccuracy object and a floating point value...
Definition: Accuracy.h:404
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:258
bool isStrictlyLower(const DenseMatrix< MT, SO > &dm)
Checks if the given dense matrix is a strictly lower triangular matrix.
Definition: DenseMatrix.h:1121
Header file for the FalseType type/value trait base class.
#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:242
#define BLAZE_CONSTRAINT_MUST_BE_DENSE_MATRIX_TYPE(T)
Constraint on the data type.In case the given data type T is not a dense, N-dimensional matrix type...
Definition: DenseMatrix.h:79
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:821
const This & CompositeType
Data type for composite expression templates.
Definition: CompressedMatrix.h:2507
BLAZE_ALWAYS_INLINE size_t capacity(const Matrix< MT, SO > &matrix)
Returns the maximum capacity of the matrix.
Definition: Matrix.h:348
BLAZE_ALWAYS_INLINE size_t rows(const Matrix< MT, SO > &matrix)
Returns the current number of rows of the matrix.
Definition: Matrix.h:316
void clear(CompressedMatrix< Type, SO > &m)
Clearing the given compressed matrix.
Definition: CompressedMatrix.h:4762
DisableIf< Or< IsComputation< MT >, IsTransExpr< MT > >, typename ColumnExprTrait< MT >::Type >::Type column(Matrix< MT, SO > &matrix, size_t index)
Creating a view on a specific column of the given matrix.
Definition: Column.h:103
void UNUSED_PARAMETER(const T1 &)
Suppression of unused parameter warnings.
Definition: Unused.h:81
bool operator>(const NegativeAccuracy< A > &lhs, const T &rhs)
Greater-than comparison between a NegativeAccuracy object and a floating point value.
Definition: Accuracy.h:366
CompressedMatrix< Type, true > This
Type of this CompressedMatrix instance.
Definition: CompressedMatrix.h:2501
bool operator>=(const NegativeAccuracy< A > &, const T &rhs)
Greater-or-equal-than comparison between a NegativeAccuracy object and a floating point value...
Definition: Accuracy.h:442
#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:386
#define BLAZE_CONSTRAINT_MUST_BE_SQUARE(T)
Constraint on the data type.In case the given data type T is not a square matrix type, a compilation error is created.
Definition: Square.h:78
Constraint on the data type.
Header file for the IsUniLower type trait.
CompressedMatrix< Type, false > OppositeType
Result type with opposite storage order for expression template evaluations.
Definition: CompressedMatrix.h:2503
Constraint on the data type.
Header file for the IsSquare type trait.
Constraint on the data type.
Constraint on the data type.
Header file for the DenseSubmatrix class template.
Header file for the DisableIf class template.
Header file for the clear shim.
Namespace of the Blaze C++ math library.
Definition: Blaze.h:57
#define BLAZE_ALWAYS_INLINE
Platform dependent setup of an enforced inline keyword.
Definition: Inline.h:85
BLAZE_ALWAYS_INLINE EnableIf< And< IsIntegral< T >, HasSize< T, 2UL > >, sse_int16_t >::Type loadu(const T *address)
Loads a vector of 2-byte integral values.
Definition: Loadu.h:76
void swap(CompressedMatrix< Type, SO > &a, CompressedMatrix< Type, SO > &b)
Swapping the contents of two compressed matrices.
Definition: CompressedMatrix.h:4807
const Element * ConstIterator
Iterator over constant elements.
Definition: CompressedMatrix.h:2511
#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
Header file for the DenseMatrix base class.
Constraint on the data type.
const DenseIterator< Type > operator+(const DenseIterator< Type > &it, ptrdiff_t inc)
Addition between a DenseIterator and an integral value.
Definition: DenseIterator.h:556
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:2504
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:195
bool isUniLower(const DenseMatrix< MT, SO > &dm)
Checks if the given dense matrix is a lower unitriangular matrix.
Definition: DenseMatrix.h:1041
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:535
Type ElementType
Type of the sparse matrix elements.
Definition: CompressedMatrix.h:2505
const Type & ConstReference
Reference to a constant matrix value.
Definition: CompressedMatrix.h:2509
Header file for the EnableIf class template.
Header file for the IsStrictlyLower type trait.
Header file for utility functions for dense matrices.
void clear(const DiagonalProxy< MT > &proxy)
Clearing the represented element.
Definition: DiagonalProxy.h:841
Header file for the UniLowerProxy class.
BLAZE_ALWAYS_INLINE EnableIf< And< IsIntegral< T >, HasSize< T, 2UL > >, sse_int16_t >::Type load(const T *address)
Loads a vector of 2-byte integral values.
Definition: Load.h:79
Header file for all adaptor forward declarations.
const bool spacing
Adding an additional spacing line between two log messages.This setting gives the opportunity to add ...
Definition: Logging.h:70
DisableIf< Or< IsComputation< MT >, IsTransExpr< MT > >, typename RowExprTrait< MT >::Type >::Type row(Matrix< MT, SO > &matrix, size_t index)
Creating a view on a specific row of the given matrix.
Definition: Row.h:103
#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:2506
Header file for run time assertion macros.
Constraint on the data type.
Constraint on the data type.
const DenseIterator< Type > operator-(const DenseIterator< Type > &it, ptrdiff_t inc)
Subtraction between a DenseIterator and an integral value.
Definition: DenseIterator.h:585
#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
void move(DynamicMatrix< Type, SO > &dst, DynamicMatrix< Type, SO > &src)
Moving the contents of one dynamic matrix to another.
Definition: DynamicMatrix.h:4934
#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:2510
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:200
Header file for all intrinsic functionality.
Header file for the move shim.
SubmatrixExprTrait< MT, unaligned >::Type submatrix(Matrix< MT, SO > &matrix, size_t row, size_t column, size_t m, size_t n)
Creating a view on a specific submatrix of the given matrix.
Definition: Submatrix.h:143
bool operator<(const NegativeAccuracy< A > &lhs, const T &rhs)
Less-than comparison between a NegativeAccuracy object and a floating point value.
Definition: Accuracy.h:328
#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.
boost::false_type FalseType
Type/value traits base class.The FalseType class is used as base class for type traits and value trai...
Definition: FalseType.h:61
#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:2502
BLAZE_ALWAYS_INLINE size_t columns(const Matrix< MT, SO > &matrix)
Returns the current number of columns of the matrix.
Definition: Matrix.h:332
bool operator!=(const NegativeAccuracy< A > &lhs, const T &rhs)
Inequality comparison between a NegativeAccuracy object and a floating point value.
Definition: Accuracy.h:289
MatrixAccessProxy< This > Reference
Reference to a non-constant matrix value.
Definition: CompressedMatrix.h:2508
Header file for the IsUpper type trait.
boost::true_type TrueType
Type traits base class.The TrueType class is used as base class for type traits and value traits that...
Definition: TrueType.h:61
#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.
System settings for the inline keywords.
#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
Header file for the TrueType type/value trait base class.
Header file for the implementation of the base template of the UniLowerMatrix.