35 #ifndef _BLAZE_MATH_ADAPTORS_STRICTLYLOWERMATRIX_DENSE_H_
36 #define _BLAZE_MATH_ADAPTORS_STRICTLYLOWERMATRIX_DENSE_H_
101 template<
typename MT
103 class StrictlyLowerMatrix<MT,SO,true>
104 :
public DenseMatrix< StrictlyLowerMatrix<MT,SO,true>, SO >
111 typedef IntrinsicTrait<ET> IT;
116 typedef StrictlyLowerMatrix<MT,SO,true>
This;
121 typedef typename MT::IntrinsicType IntrinsicType;
124 typedef StrictlyLowerProxy<MT>
Reference;
126 typedef typename MT::Pointer Pointer;
127 typedef typename MT::ConstPointer ConstPointer;
134 template<
typename ET >
137 typedef StrictlyLowerMatrix< typename MT::template Rebind<ET>::Other > Other;
148 typedef std::random_access_iterator_tag IteratorCategory;
150 typedef StrictlyLowerProxy<MT> PointerType;
151 typedef StrictlyLowerProxy<MT> ReferenceType;
152 typedef ptrdiff_t DifferenceType;
155 typedef IteratorCategory iterator_category;
156 typedef ValueType value_type;
157 typedef PointerType pointer;
158 typedef ReferenceType reference;
159 typedef DifferenceType difference_type;
192 inline Iterator& operator+=(
size_t inc ) {
193 ( SO )?( row_ += inc ):( column_ += inc );
204 inline Iterator& operator-=(
size_t dec ) {
205 ( SO )?( row_ -= dec ):( column_ -= dec );
216 ( SO )?( ++row_ ):( ++column_ );
226 inline const Iterator operator++(
int ) {
239 ( SO )?( --row_ ):( --column_ );
249 inline const Iterator operator--(
int ) {
262 return ReferenceType( *matrix_, row_, column_ );
271 inline PointerType operator->()
const {
272 return PointerType( *matrix_, row_, column_ );
283 return matrix_->begin( column_ ) + row_;
285 return matrix_->begin( row_ ) + column_;
297 return ( SO )?( lhs.row_ == rhs.row_ ):( lhs.column_ == rhs.column_ );
333 return ( SO )?( lhs.row_ != rhs.row_ ):( lhs.column_ != rhs.column_ );
369 return ( SO )?( lhs.row_ < rhs.row_ ):( lhs.column_ < rhs.column_ );
405 return ( SO )?( lhs.row_ > rhs.row_ ):( lhs.column_ > rhs.column_ );
441 return ( SO )?( lhs.row_ <= rhs.row_ ):( lhs.column_ <= rhs.column_ );
477 return ( SO )?( lhs.row_ >= rhs.row_ ):( lhs.column_ >= rhs.column_ );
512 return ( SO )?( row_ - rhs.row_ ):( column_ - rhs.column_ );
525 return Iterator( *it.matrix_, it.row_ + inc, it.column_ );
527 return Iterator( *it.matrix_, it.row_, it.column_ + inc );
540 return Iterator( *it.matrix_, it.row_ + inc, it.column_ );
542 return Iterator( *it.matrix_, it.row_, it.column_ + inc );
555 return Iterator( *it.matrix_, it.row_ - dec, it.column_ );
557 return Iterator( *it.matrix_, it.row_, it.column_ - dec );
572 enum { vectorizable = MT::vectorizable };
575 enum { smpAssignable = MT::smpAssignable };
581 explicit inline StrictlyLowerMatrix();
582 template<
typename A1 >
explicit inline StrictlyLowerMatrix(
const A1& a1 );
583 explicit inline StrictlyLowerMatrix(
size_t n,
const ElementType& init );
584 inline StrictlyLowerMatrix(
const StrictlyLowerMatrix& m );
595 inline Reference operator()(
size_t i,
size_t j );
596 inline ConstReference operator()(
size_t i,
size_t j )
const;
597 inline ConstPointer data ()
const;
598 inline ConstPointer data (
size_t i )
const;
600 inline ConstIterator
begin (
size_t i )
const;
601 inline ConstIterator
cbegin(
size_t i )
const;
603 inline ConstIterator
end (
size_t i )
const;
604 inline ConstIterator
cend (
size_t i )
const;
611 inline StrictlyLowerMatrix& operator=(
const ElementType& rhs );
612 inline StrictlyLowerMatrix& operator=(
const StrictlyLowerMatrix& rhs );
614 template<
typename MT2,
bool SO2 >
615 inline typename DisableIf< IsComputation<MT2>, StrictlyLowerMatrix& >::Type
616 operator=(
const Matrix<MT2,SO2>& rhs );
618 template<
typename MT2,
bool SO2 >
619 inline typename EnableIf< IsComputation<MT2>, StrictlyLowerMatrix& >::Type
620 operator=(
const Matrix<MT2,SO2>& rhs );
622 template<
typename MT2,
bool SO2 >
623 inline typename DisableIf< IsComputation<MT2>, StrictlyLowerMatrix& >::Type
624 operator+=(
const Matrix<MT2,SO2>& rhs );
626 template<
typename MT2,
bool SO2 >
627 inline typename EnableIf< IsComputation<MT2>, StrictlyLowerMatrix& >::Type
628 operator+=(
const Matrix<MT2,SO2>& rhs );
630 template<
typename MT2,
bool SO2 >
631 inline typename DisableIf< IsComputation<MT2>, StrictlyLowerMatrix& >::Type
632 operator-=(
const Matrix<MT2,SO2>& rhs );
634 template<
typename MT2,
bool SO2 >
635 inline typename EnableIf< IsComputation<MT2>, StrictlyLowerMatrix& >::Type
636 operator-=(
const Matrix<MT2,SO2>& rhs );
638 template<
typename MT2,
bool SO2 >
639 inline StrictlyLowerMatrix& operator*=(
const Matrix<MT2,SO2>& rhs );
641 template<
typename Other >
642 inline typename EnableIf< IsNumeric<Other>, StrictlyLowerMatrix >::Type&
643 operator*=( Other rhs );
645 template<
typename Other >
646 inline typename EnableIf< IsNumeric<Other>, StrictlyLowerMatrix >::Type&
647 operator/=( Other rhs );
654 inline size_t rows()
const;
658 inline size_t capacity(
size_t i )
const;
660 inline size_t nonZeros(
size_t i )
const;
662 inline void reset(
size_t i );
664 void resize (
size_t n,
bool preserve=
true );
665 inline void extend (
size_t n,
bool preserve=
true );
666 inline void reserve(
size_t elements );
668 template<
typename Other >
inline StrictlyLowerMatrix& scale(
const Other& scalar );
670 inline void swap( StrictlyLowerMatrix& m ) ;
672 static inline size_t maxNonZeros();
673 static inline size_t maxNonZeros(
size_t n );
680 template<
typename Other >
inline bool canAlias (
const Other* alias )
const;
681 template<
typename Other >
inline bool isAliased(
const Other* alias )
const;
683 inline bool isAligned ()
const;
684 inline bool canSMPAssign()
const;
695 inline const MT construct(
size_t n ,
TrueType );
696 inline const MT construct(
const ElementType& value,
FalseType );
698 template<
typename MT2,
bool SO2,
typename T >
699 inline const MT construct(
const Matrix<MT2,SO2>& m, T );
711 template<
typename MT2,
bool SO2,
bool DF2 >
712 friend MT2& derestrict( StrictlyLowerMatrix<MT2,SO2,DF2>& m );
746 template<
typename MT
748 inline StrictlyLowerMatrix<MT,SO,true>::StrictlyLowerMatrix()
775 template<
typename MT
777 template<
typename A1 >
778 inline StrictlyLowerMatrix<MT,SO,true>::StrictlyLowerMatrix(
const A1& a1 )
779 : matrix_( construct( a1, typename IsResizable<MT>::Type() ) )
794 template<
typename MT
796 inline StrictlyLowerMatrix<MT,SO,true>::StrictlyLowerMatrix(
size_t n,
const ElementType& init )
797 : matrix_( n, n, ElementType() )
802 for(
size_t j=0UL; j<
columns(); ++j ) {
803 for(
size_t i=j+1UL; i<
rows(); ++i )
808 for(
size_t i=0UL; i<
rows(); ++i ) {
809 for(
size_t j=0UL; j<i; ++j )
826 template<
typename MT
828 inline StrictlyLowerMatrix<MT,SO,true>::StrictlyLowerMatrix(
const StrictlyLowerMatrix& m )
829 : matrix_( m.matrix_ )
858 template<
typename MT
861 StrictlyLowerMatrix<MT,SO,true>::operator()(
size_t i,
size_t j )
885 template<
typename MT
888 StrictlyLowerMatrix<MT,SO,true>::operator()(
size_t i,
size_t j )
const
912 template<
typename MT
914 inline typename StrictlyLowerMatrix<MT,SO,true>::ConstPointer
915 StrictlyLowerMatrix<MT,SO,true>::data()
const
917 return matrix_.data();
932 template<
typename MT
934 inline typename StrictlyLowerMatrix<MT,SO,true>::ConstPointer
935 StrictlyLowerMatrix<MT,SO,true>::data(
size_t i )
const
937 return matrix_.data(i);
955 template<
typename MT
981 template<
typename MT
986 return matrix_.begin(i);
1004 template<
typename MT
1009 return matrix_.cbegin(i);
1027 template<
typename MT
1053 template<
typename MT
1058 return matrix_.end(i);
1076 template<
typename MT
1081 return matrix_.cend(i);
1102 template<
typename MT
1104 inline StrictlyLowerMatrix<MT,SO,true>&
1105 StrictlyLowerMatrix<MT,SO,true>::operator=(
const ElementType& rhs )
1108 for(
size_t j=0UL; j<
columns(); ++j )
1109 for(
size_t i=j+1UL; i<
rows(); ++i )
1113 for(
size_t i=1UL; i<
rows(); ++i )
1114 for(
size_t j=0UL; j<i; ++j )
1134 template<
typename MT
1136 inline StrictlyLowerMatrix<MT,SO,true>&
1137 StrictlyLowerMatrix<MT,SO,true>::operator=(
const StrictlyLowerMatrix& rhs )
1139 matrix_ = rhs.matrix_;
1160 template<
typename MT
1162 template<
typename MT2
1164 inline typename DisableIf< IsComputation<MT2>, StrictlyLowerMatrix<MT,SO,true>& >::Type
1165 StrictlyLowerMatrix<MT,SO,true>::operator=(
const Matrix<MT2,SO2>& rhs )
1167 if( IsUniTriangular<MT2>::value ||
1169 throw std::invalid_argument(
"Invalid assignment to strictly lower matrix" );
1192 template<
typename MT
1194 template<
typename MT2
1196 inline typename EnableIf< IsComputation<MT2>, StrictlyLowerMatrix<MT,SO,true>& >::Type
1197 StrictlyLowerMatrix<MT,SO,true>::operator=(
const Matrix<MT2,SO2>& rhs )
1199 if( IsUniTriangular<MT2>::value || ( !IsSquare<MT2>::value && !
isSquare( ~rhs ) ) )
1200 throw std::invalid_argument(
"Invalid assignment to strictly lower matrix" );
1202 if( IsStrictlyLower<MT2>::value ) {
1209 throw std::invalid_argument(
"Invalid assignment to strictly lower matrix" );
1211 move( matrix_, tmp );
1233 template<
typename MT
1235 template<
typename MT2
1237 inline typename DisableIf< IsComputation<MT2>, StrictlyLowerMatrix<MT,SO,true>& >::Type
1238 StrictlyLowerMatrix<MT,SO,true>::operator+=(
const Matrix<MT2,SO2>& rhs )
1240 if( IsUniTriangular<MT2>::value ||
1242 throw std::invalid_argument(
"Invalid assignment to strictly lower matrix" );
1265 template<
typename MT
1267 template<
typename MT2
1269 inline typename EnableIf< IsComputation<MT2>, StrictlyLowerMatrix<MT,SO,true>& >::Type
1270 StrictlyLowerMatrix<MT,SO,true>::operator+=(
const Matrix<MT2,SO2>& rhs )
1272 if( IsUniTriangular<MT2>::value || ( !IsSquare<MT2>::value && !
isSquare( ~rhs ) ) )
1273 throw std::invalid_argument(
"Invalid assignment to strictly lower matrix" );
1275 if( IsStrictlyLower<MT2>::value ) {
1282 throw std::invalid_argument(
"Invalid assignment to strictly lower matrix" );
1306 template<
typename MT
1308 template<
typename MT2
1310 inline typename DisableIf< IsComputation<MT2>, StrictlyLowerMatrix<MT,SO,true>& >::Type
1311 StrictlyLowerMatrix<MT,SO,true>::operator-=(
const Matrix<MT2,SO2>& rhs )
1313 if( IsUniTriangular<MT2>::value ||
1315 throw std::invalid_argument(
"Invalid assignment to strictly lower matrix" );
1338 template<
typename MT
1340 template<
typename MT2
1342 inline typename EnableIf< IsComputation<MT2>, StrictlyLowerMatrix<MT,SO,true>& >::Type
1343 StrictlyLowerMatrix<MT,SO,true>::operator-=(
const Matrix<MT2,SO2>& rhs )
1345 if( IsUniTriangular<MT2>::value || ( !IsSquare<MT2>::value && !
isSquare( ~rhs ) ) )
1346 throw std::invalid_argument(
"Invalid assignment to strictly lower matrix" );
1348 if( IsStrictlyLower<MT2>::value ) {
1355 throw std::invalid_argument(
"Invalid assignment to strictly lower matrix" );
1378 template<
typename MT
1380 template<
typename MT2
1382 inline StrictlyLowerMatrix<MT,SO,true>&
1383 StrictlyLowerMatrix<MT,SO,true>::operator*=(
const Matrix<MT2,SO2>& rhs )
1385 if( matrix_.rows() != (~rhs).
columns() )
1386 throw std::invalid_argument(
"Invalid assignment to strictly lower matrix" );
1388 MT tmp( matrix_ * ~rhs );
1391 throw std::invalid_argument(
"Invalid assignment to strictly lower matrix" );
1393 move( matrix_, tmp );
1409 template<
typename MT
1411 template<
typename Other >
1412 inline typename EnableIf< IsNumeric<Other>, StrictlyLowerMatrix<MT,SO,true> >::Type&
1413 StrictlyLowerMatrix<MT,SO,true>::operator*=( Other rhs )
1429 template<
typename MT
1431 template<
typename Other >
1432 inline typename EnableIf< IsNumeric<Other>, StrictlyLowerMatrix<MT,SO,true> >::Type&
1433 StrictlyLowerMatrix<MT,SO,true>::operator/=( Other rhs )
1458 template<
typename MT
1462 return matrix_.rows();
1474 template<
typename MT
1478 return matrix_.columns();
1495 template<
typename MT
1499 return matrix_.spacing();
1511 template<
typename MT
1515 return matrix_.capacity();
1533 template<
typename MT
1537 return matrix_.capacity(i);
1549 template<
typename MT
1553 return matrix_.nonZeros();
1571 template<
typename MT
1575 return matrix_.nonZeros(i);
1587 template<
typename MT
1594 for(
size_t j=0UL; j<
columns(); ++j )
1595 for(
size_t i=j+1UL; i<
rows(); ++i )
1596 clear( matrix_(i,j) );
1599 for(
size_t i=1UL; i<
rows(); ++i )
1600 for(
size_t j=0UL; j<i; ++j )
1601 clear( matrix_(i,j) );
1621 template<
typename MT
1628 for(
size_t j=i+1UL; j<
rows(); ++j )
1629 clear( matrix_(j,i) );
1632 for(
size_t j=0UL; j<i; ++j )
1633 clear( matrix_(i,j) );
1652 template<
typename MT
1658 if( IsResizable<MT>::value ) {
1705 template<
typename MT
1715 const size_t oldsize( matrix_.rows() );
1717 matrix_.resize( n, n,
true );
1721 const size_t increment( n - oldsize );
1722 submatrix( matrix_, 0UL, oldsize, n, increment ).reset();
1742 template<
typename MT
1744 inline void StrictlyLowerMatrix<MT,SO,true>::extend(
size_t n,
bool preserve )
1765 template<
typename MT
1767 inline void StrictlyLowerMatrix<MT,SO,true>::reserve(
size_t elements )
1769 matrix_.reserve( elements );
1782 template<
typename MT
1784 template<
typename Other >
1785 inline StrictlyLowerMatrix<MT,SO,true>&
1786 StrictlyLowerMatrix<MT,SO,true>::scale(
const Other& scalar )
1788 matrix_.scale( scalar );
1803 template<
typename MT
1809 swap( matrix_, m.matrix_ );
1827 template<
typename MT
1829 inline size_t StrictlyLowerMatrix<MT,SO,true>::maxNonZeros()
1833 return maxNonZeros( Rows<MT>::value );
1849 template<
typename MT
1851 inline size_t StrictlyLowerMatrix<MT,SO,true>::maxNonZeros(
size_t n )
1853 return ( ( n - 1UL ) * n ) / 2UL;
1878 template<
typename MT
1880 template<
typename Other >
1881 inline bool StrictlyLowerMatrix<MT,SO,true>::canAlias(
const Other* alias )
const
1883 return matrix_.canAlias( alias );
1900 template<
typename MT
1902 template<
typename Other >
1903 inline bool StrictlyLowerMatrix<MT,SO,true>::isAliased(
const Other* alias )
const
1905 return matrix_.isAliased( alias );
1921 template<
typename MT
1923 inline bool StrictlyLowerMatrix<MT,SO,true>::isAligned()
const
1925 return matrix_.isAligned();
1942 template<
typename MT
1944 inline bool StrictlyLowerMatrix<MT,SO,true>::canSMPAssign()
const
1946 return matrix_.canSMPAssign();
1968 template<
typename MT
1973 return matrix_.load( i, j );
1995 template<
typename MT
2000 return matrix_.loadu( i, j );
2021 template<
typename MT
2023 inline const MT StrictlyLowerMatrix<MT,SO,true>::construct(
size_t n,
TrueType )
2040 template<
typename MT
2042 inline const MT StrictlyLowerMatrix<MT,SO,true>::construct(
const ElementType& init,
FalseType )
2050 for(
size_t j=0UL; j<tmp.columns(); ++j ) {
2051 for(
size_t i=j+1UL; i<tmp.rows(); ++i )
2056 for(
size_t i=0UL; i<tmp.rows(); ++i ) {
2057 for(
size_t j=0UL; j<i; ++j )
2079 template<
typename MT
2081 template<
typename MT2
2084 inline const MT StrictlyLowerMatrix<MT,SO,true>::construct(
const Matrix<MT2,SO2>& m, T )
2088 if( IsUniTriangular<MT2>::value ||
2090 throw std::invalid_argument(
"Invalid setup of strictly lower 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
#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.
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.
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
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
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_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.
Header file for the StrictlyLowerProxy class.
#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
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.
Header file for the implementation of the base template of the StrictlyLowerMatrix.
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.