35 #ifndef _BLAZE_MATH_ADAPTORS_LOWERMATRIX_DENSE_H_
36 #define _BLAZE_MATH_ADAPTORS_LOWERMATRIX_DENSE_H_
104 template<
typename MT
106 class LowerMatrix<MT,SO,true>
107 :
public DenseMatrix< LowerMatrix<MT,SO,true>, SO >
111 typedef OppositeType_<MT> OT;
112 typedef TransposeType_<MT> TT;
113 typedef ElementType_<MT> ET;
118 typedef LowerMatrix<MT,SO,true>
This;
119 typedef DenseMatrix<This,SO>
BaseType;
124 typedef SIMDType_<MT> SIMDType;
129 typedef Pointer_<MT> Pointer;
130 typedef ConstPointer_<MT> ConstPointer;
137 template<
typename ET >
140 typedef LowerMatrix< typename MT::template Rebind<ET>::Other > Other;
151 typedef std::random_access_iterator_tag IteratorCategory;
152 typedef ElementType_<MT> ValueType;
153 typedef LowerProxy<MT> PointerType;
154 typedef LowerProxy<MT> ReferenceType;
155 typedef ptrdiff_t DifferenceType;
158 typedef IteratorCategory iterator_category;
159 typedef ValueType value_type;
160 typedef PointerType pointer;
161 typedef ReferenceType reference;
162 typedef DifferenceType difference_type;
196 ( SO )?( row_ += inc ):( column_ += inc );
208 ( SO )?( row_ -= dec ):( column_ -= dec );
218 inline Iterator& operator++() noexcept {
219 ( SO )?( ++row_ ):( ++column_ );
229 inline const Iterator operator++(
int ) noexcept {
241 inline Iterator& operator--() noexcept {
242 ( SO )?( --row_ ):( --column_ );
252 inline const Iterator operator--(
int ) noexcept {
265 return ReferenceType( *matrix_, row_, column_ );
274 inline PointerType operator->()
const {
275 return PointerType( *matrix_, row_, column_ );
289 inline SIMDType load()
const {
290 return (*matrix_).load(row_,column_);
304 inline SIMDType
loada()
const {
305 return (*matrix_).loada(row_,column_);
319 inline SIMDType
loadu()
const {
320 return (*matrix_).loadu(row_,column_);
331 return matrix_->begin( column_ ) + row_;
333 return matrix_->begin( row_ ) + column_;
345 return ( SO )?( lhs.row_ == rhs.row_ ):( lhs.column_ == rhs.column_ );
381 return ( SO )?( lhs.row_ != rhs.row_ ):( lhs.column_ != rhs.column_ );
417 return ( SO )?( lhs.row_ < rhs.row_ ):( lhs.column_ < rhs.column_ );
453 return ( SO )?( lhs.row_ > rhs.row_ ):( lhs.column_ > rhs.column_ );
489 return ( SO )?( lhs.row_ <= rhs.row_ ):( lhs.column_ <= rhs.column_ );
525 return ( SO )?( lhs.row_ >= rhs.row_ ):( lhs.column_ >= rhs.column_ );
560 return ( SO )?( row_ - rhs.row_ ):( column_ - rhs.column_ );
573 return Iterator( *it.matrix_, it.row_ + inc, it.column_ );
575 return Iterator( *it.matrix_, it.row_, it.column_ + inc );
588 return Iterator( *it.matrix_, it.row_ + inc, it.column_ );
590 return Iterator( *it.matrix_, it.row_, it.column_ + inc );
603 return Iterator( *it.matrix_, it.row_ - dec, it.column_ );
605 return Iterator( *it.matrix_, it.row_, it.column_ - dec );
620 enum :
bool { simdEnabled = MT::simdEnabled };
623 enum :
bool { smpAssignable = MT::smpAssignable };
629 explicit inline LowerMatrix();
630 template<
typename A1 >
explicit inline LowerMatrix(
const A1& a1 );
631 explicit inline LowerMatrix(
size_t n,
const ElementType& init );
633 explicit inline LowerMatrix( initializer_list< initializer_list<ElementType> > list );
635 template<
typename Other >
636 explicit inline LowerMatrix(
size_t n,
const Other* array );
638 template<
typename Other,
size_t N >
639 explicit inline LowerMatrix(
const Other (&array)[N][N] );
641 explicit inline LowerMatrix( ElementType* ptr,
size_t n );
642 explicit inline LowerMatrix( ElementType* ptr,
size_t n,
size_t nn );
644 template<
typename Deleter >
645 explicit inline LowerMatrix( ElementType* ptr,
size_t n, Deleter d );
647 template<
typename Deleter >
648 explicit inline LowerMatrix( ElementType* ptr,
size_t n,
size_t nn, Deleter d );
650 inline LowerMatrix(
const LowerMatrix& m );
651 inline LowerMatrix( LowerMatrix&& m ) noexcept;
662 inline Reference operator()(
size_t i,
size_t j );
663 inline ConstReference operator()(
size_t i,
size_t j ) const;
664 inline Reference at(
size_t i,
size_t j );
665 inline ConstReference at(
size_t i,
size_t j ) const;
666 inline ConstPointer data () const noexcept;
667 inline ConstPointer data (
size_t i ) const noexcept;
669 inline ConstIterator
begin (
size_t i ) const;
670 inline ConstIterator
cbegin(
size_t i ) const;
672 inline ConstIterator
end (
size_t i ) const;
673 inline ConstIterator
cend (
size_t i ) const;
680 inline LowerMatrix& operator=( const ElementType& rhs );
681 inline LowerMatrix& operator=( initializer_list< initializer_list<ElementType> > list );
683 template< typename Other,
size_t N >
684 inline LowerMatrix& operator=( const Other (&array)[N][N] );
686 inline LowerMatrix& operator=( const LowerMatrix& rhs );
687 inline LowerMatrix& operator=( LowerMatrix&& rhs ) noexcept;
689 template< typename MT2,
bool SO2 >
690 inline
DisableIf_< IsComputation<MT2>, LowerMatrix& > operator=( const Matrix<MT2,SO2>& rhs );
692 template< typename MT2,
bool SO2 >
693 inline
EnableIf_< IsComputation<MT2>, LowerMatrix& > operator=( const Matrix<MT2,SO2>& rhs );
695 template< typename MT2,
bool SO2 >
696 inline
DisableIf_< IsComputation<MT2>, LowerMatrix& > operator+=( const Matrix<MT2,SO2>& rhs );
698 template< typename MT2,
bool SO2 >
699 inline
EnableIf_< IsComputation<MT2>, LowerMatrix& > operator+=( const Matrix<MT2,SO2>& rhs );
701 template< typename MT2,
bool SO2 >
702 inline
DisableIf_< IsComputation<MT2>, LowerMatrix& > operator-=( const Matrix<MT2,SO2>& rhs );
704 template< typename MT2,
bool SO2 >
705 inline
EnableIf_< IsComputation<MT2>, LowerMatrix& > operator-=( const Matrix<MT2,SO2>& rhs );
707 template< typename MT2,
bool SO2 >
708 inline LowerMatrix& operator*=( const Matrix<MT2,SO2>& rhs );
710 template< typename Other >
711 inline
EnableIf_< IsNumeric<Other>, LowerMatrix >& operator*=( Other rhs );
713 template< typename Other >
714 inline
EnableIf_< IsNumeric<Other>, LowerMatrix >& operator/=( Other rhs );
721 inline
size_t rows() const noexcept;
722 inline
size_t columns() const noexcept;
723 inline
size_t spacing() const noexcept;
724 inline
size_t capacity() const noexcept;
725 inline
size_t capacity(
size_t i ) const noexcept;
727 inline
size_t nonZeros(
size_t i ) const;
729 inline
void reset(
size_t i );
731 void resize (
size_t n,
bool preserve=true );
732 inline
void extend (
size_t n,
bool preserve=true );
733 inline
void reserve(
size_t elements );
734 template< typename Other > inline LowerMatrix& scale( const Other& scalar );
735 inline
void swap( LowerMatrix& m ) noexcept;
737 static inline constexpr
size_t maxNonZeros() noexcept;
738 static inline constexpr
size_t maxNonZeros(
size_t n ) noexcept;
745 inline
bool isIntact() const noexcept;
752 template< typename Other > inline
bool canAlias ( const Other* alias ) const noexcept;
753 template< typename Other > inline
bool isAliased( const Other* alias ) const noexcept;
755 inline
bool isAligned () const noexcept;
756 inline
bool canSMPAssign() const noexcept;
768 inline const MT construct(
size_t n ,
TrueType );
769 inline const MT construct( const ElementType& value,
FalseType );
771 template< typename MT2,
bool SO2, typename T >
772 inline const MT construct( const Matrix<MT2,SO2>& m, T );
784 template< typename MT2,
bool SO2,
bool DF2 >
785 friend
bool isDefault( const LowerMatrix<MT2,SO2,DF2>& m );
787 template< typename MT2,
bool SO2,
bool DF2 >
788 friend MT2& derestrict( LowerMatrix<MT2,SO2,DF2>& m );
823 template< typename MT
825 inline LowerMatrix<MT,SO,true>::LowerMatrix()
853 template<
typename MT
855 template<
typename A1 >
856 inline LowerMatrix<MT,SO,true>::LowerMatrix(
const A1& a1 )
857 : matrix_( construct( a1, typename IsResizable<MT>::Type() ) )
873 template<
typename MT
875 inline LowerMatrix<MT,SO,true>::LowerMatrix(
size_t n,
const ElementType& init )
876 : matrix_( n, n, ElementType() )
881 for(
size_t j=0UL; j<
columns(); ++j )
882 for(
size_t i=j; i<
rows(); ++i )
886 for(
size_t i=0UL; i<
rows(); ++i )
887 for(
size_t j=0UL; j<=i; ++j )
921 template<
typename MT
923 inline LowerMatrix<MT,SO,true>::LowerMatrix( initializer_list< initializer_list<ElementType> > list )
962 template<
typename MT
964 template<
typename Other >
965 inline LowerMatrix<MT,SO,true>::LowerMatrix(
size_t n,
const Other* array )
966 : matrix_( n, n, array )
1001 template<
typename MT
1003 template<
typename Other
1005 inline LowerMatrix<MT,SO,true>::LowerMatrix(
const Other (&array)[N][N] )
1039 template<
typename MT
1041 inline LowerMatrix<MT,SO,true>::LowerMatrix( ElementType* ptr,
size_t n )
1042 : matrix_( ptr, n, n )
1077 template<
typename MT
1079 inline LowerMatrix<MT,SO,true>::LowerMatrix( ElementType* ptr,
size_t n,
size_t nn )
1080 : matrix_( ptr, n, n, nn )
1113 template<
typename MT
1115 template<
typename Deleter >
1116 inline LowerMatrix<MT,SO,true>::LowerMatrix( ElementType* ptr,
size_t n, Deleter d )
1117 : matrix_( ptr, n, n, d )
1151 template<
typename MT
1153 template<
typename Deleter >
1154 inline LowerMatrix<MT,SO,true>::LowerMatrix( ElementType* ptr,
size_t n,
size_t nn, Deleter d )
1155 : matrix_( ptr, n, n, nn, d )
1173 template<
typename MT
1175 inline LowerMatrix<MT,SO,true>::LowerMatrix(
const LowerMatrix& m )
1176 : matrix_( m.matrix_ )
1191 template<
typename MT
1193 inline LowerMatrix<MT,SO,true>::LowerMatrix( LowerMatrix&& m ) noexcept
1194 : matrix_(
std::move( m.matrix_ ) )
1227 template<
typename MT
1230 LowerMatrix<MT,SO,true>::operator()(
size_t i,
size_t j )
1257 template<
typename MT
1260 LowerMatrix<MT,SO,true>::operator()(
size_t i,
size_t j )
const
1265 return matrix_(i,j);
1288 template<
typename MT
1291 LowerMatrix<MT,SO,true>::at(
size_t i,
size_t j )
1299 return (*
this)(i,j);
1322 template<
typename MT
1325 LowerMatrix<MT,SO,true>::at(
size_t i,
size_t j )
const
1333 return (*
this)(i,j);
1352 template<
typename MT
1354 inline typename LowerMatrix<MT,SO,true>::ConstPointer
1355 LowerMatrix<MT,SO,true>::data() const noexcept
1357 return matrix_.data();
1372 template<
typename MT
1374 inline typename LowerMatrix<MT,SO,true>::ConstPointer
1375 LowerMatrix<MT,SO,true>::data(
size_t i )
const noexcept
1377 return matrix_.data(i);
1395 template<
typename MT
1401 return Iterator( matrix_, 0UL, i );
1403 return Iterator( matrix_, i, 0UL );
1421 template<
typename MT
1426 return matrix_.begin(i);
1444 template<
typename MT
1449 return matrix_.cbegin(i);
1467 template<
typename MT
1493 template<
typename MT
1498 return matrix_.end(i);
1516 template<
typename MT
1521 return matrix_.cend(i);
1542 template<
typename MT
1544 inline LowerMatrix<MT,SO,true>&
1545 LowerMatrix<MT,SO,true>::operator=(
const ElementType& rhs )
1548 for(
size_t j=0UL; j<
columns(); ++j )
1549 for(
size_t i=j; i<
rows(); ++i )
1553 for(
size_t i=0UL; i<
rows(); ++i )
1554 for(
size_t j=0UL; j<=i; ++j )
1588 template<
typename MT
1590 inline LowerMatrix<MT,SO,true>&
1591 LowerMatrix<MT,SO,true>::operator=( initializer_list< initializer_list<ElementType> > list )
1599 matrix_ = std::move( tmp );
1634 template<
typename MT
1636 template<
typename Other
1638 inline LowerMatrix<MT,SO,true>&
1639 LowerMatrix<MT,SO,true>::operator=(
const Other (&array)[N][N] )
1647 matrix_ = std::move( tmp );
1668 template<
typename MT
1670 inline LowerMatrix<MT,SO,true>&
1671 LowerMatrix<MT,SO,true>::operator=(
const LowerMatrix& rhs )
1673 matrix_ = rhs.matrix_;
1691 template<
typename MT
1693 inline LowerMatrix<MT,SO,true>&
1694 LowerMatrix<MT,SO,true>::operator=( LowerMatrix&& rhs ) noexcept
1696 matrix_ = std::move( rhs.matrix_ );
1720 template<
typename MT
1722 template<
typename MT2
1724 inline DisableIf_< IsComputation<MT2>, LowerMatrix<MT,SO,true>& >
1725 LowerMatrix<MT,SO,true>::operator=(
const Matrix<MT2,SO2>& rhs )
1727 if( !IsLower<MT2>::value && !
isLower( ~rhs ) ) {
1755 template<
typename MT
1757 template<
typename MT2
1759 inline EnableIf_< IsComputation<MT2>, LowerMatrix<MT,SO,true>& >
1760 LowerMatrix<MT,SO,true>::operator=(
const Matrix<MT2,SO2>& rhs )
1762 if( !IsSquare<MT2>::value && !
isSquare( ~rhs ) ) {
1766 if( IsLower<MT2>::value ) {
1776 matrix_ = std::move( tmp );
1801 template<
typename MT
1803 template<
typename MT2
1805 inline DisableIf_< IsComputation<MT2>, LowerMatrix<MT,SO,true>& >
1808 if( !IsLower<MT2>::value && !
isLower( ~rhs ) ) {
1836 template<
typename MT
1838 template<
typename MT2
1840 inline EnableIf_< IsComputation<MT2>, LowerMatrix<MT,SO,true>& >
1843 if( !IsSquare<MT2>::value && !
isSquare( ~rhs ) ) {
1847 if( IsLower<MT2>::value ) {
1851 const ResultType_<MT2> tmp( ~rhs );
1882 template<
typename MT
1884 template<
typename MT2
1886 inline DisableIf_< IsComputation<MT2>, LowerMatrix<MT,SO,true>& >
1889 if( !IsLower<MT2>::value && !
isLower( ~rhs ) ) {
1917 template<
typename MT
1919 template<
typename MT2
1921 inline EnableIf_< IsComputation<MT2>, LowerMatrix<MT,SO,true>& >
1924 if( !IsSquare<MT2>::value && !
isSquare( ~rhs ) ) {
1928 if( IsLower<MT2>::value ) {
1932 const ResultType_<MT2> tmp( ~rhs );
1962 template<
typename MT
1964 template<
typename MT2
1966 inline LowerMatrix<MT,SO,true>&
1969 if( matrix_.rows() != (~rhs).
columns() ) {
1973 MT tmp( matrix_ * ~rhs );
1979 matrix_ = std::move( tmp );
1998 template<
typename MT
2000 template<
typename Other >
2001 inline EnableIf_< IsNumeric<Other>, LowerMatrix<MT,SO,true> >&
2018 template<
typename MT
2020 template<
typename Other >
2021 inline EnableIf_< IsNumeric<Other>, LowerMatrix<MT,SO,true> >&
2047 template<
typename MT
2051 return matrix_.rows();
2063 template<
typename MT
2067 return matrix_.columns();
2084 template<
typename MT
2088 return matrix_.spacing();
2100 template<
typename MT
2104 return matrix_.capacity();
2122 template<
typename MT
2126 return matrix_.capacity(i);
2138 template<
typename MT
2142 return matrix_.nonZeros();
2160 template<
typename MT
2164 return matrix_.nonZeros(i);
2176 template<
typename MT
2183 for(
size_t j=0UL; j<
columns(); ++j )
2184 for(
size_t i=j; i<
rows(); ++i )
2185 clear( matrix_(i,j) );
2188 for(
size_t i=0UL; i<
rows(); ++i )
2189 for(
size_t j=0UL; j<=i; ++j )
2190 clear( matrix_(i,j) );
2210 template<
typename MT
2217 for(
size_t j=i; j<
rows(); ++j )
2218 clear( matrix_(j,i) );
2221 for(
size_t j=0UL; j<=i; ++j )
2222 clear( matrix_(i,j) );
2241 template<
typename MT
2247 if( IsResizable<MT>::value ) {
2294 template<
typename MT
2304 const size_t oldsize( matrix_.rows() );
2306 matrix_.resize( n, n,
true );
2309 const size_t increment( n - oldsize );
2310 submatrix( matrix_, 0UL, oldsize, n-1UL, increment ).reset();
2330 template<
typename MT
2332 inline void LowerMatrix<MT,SO,true>::extend(
size_t n,
bool preserve )
2353 template<
typename MT
2355 inline void LowerMatrix<MT,SO,true>::reserve(
size_t elements )
2357 matrix_.reserve( elements );
2370 template<
typename MT
2372 template<
typename Other >
2373 inline LowerMatrix<MT,SO,true>& LowerMatrix<MT,SO,true>::scale(
const Other& scalar )
2375 matrix_.scale( scalar );
2389 template<
typename MT
2395 swap( matrix_, m.matrix_ );
2413 template<
typename MT
2415 inline constexpr
size_t LowerMatrix<MT,SO,true>::maxNonZeros() noexcept
2419 return maxNonZeros( Rows<MT>::value );
2435 template<
typename MT
2437 inline constexpr
size_t LowerMatrix<MT,SO,true>::maxNonZeros(
size_t n ) noexcept
2439 return ( ( n + 1UL ) * n ) / 2UL;
2463 template<
typename MT
2494 template<
typename MT
2496 template<
typename Other >
2497 inline bool LowerMatrix<MT,SO,true>::canAlias(
const Other* alias )
const noexcept
2499 return matrix_.canAlias( alias );
2516 template<
typename MT
2518 template<
typename Other >
2519 inline bool LowerMatrix<MT,SO,true>::isAliased(
const Other* alias )
const noexcept
2521 return matrix_.isAliased( alias );
2537 template<
typename MT
2539 inline bool LowerMatrix<MT,SO,true>::isAligned() const noexcept
2541 return matrix_.isAligned();
2558 template<
typename MT
2560 inline bool LowerMatrix<MT,SO,true>::canSMPAssign() const noexcept
2562 return matrix_.canSMPAssign();
2584 template<
typename MT
2587 LowerMatrix<MT,SO,true>::load(
size_t i,
size_t j )
const noexcept
2589 return matrix_.load( i, j );
2611 template<
typename MT
2616 return matrix_.loada( i, j );
2638 template<
typename MT
2643 return matrix_.loadu( i, j );
2664 template<
typename MT
2666 inline const MT LowerMatrix<MT,SO,true>::construct(
size_t n, TrueType )
2683 template<
typename MT
2685 inline const MT LowerMatrix<MT,SO,true>::construct(
const ElementType& init, FalseType )
2693 for(
size_t j=0UL; j<tmp.columns(); ++j )
2694 for(
size_t i=j; i<tmp.rows(); ++i )
2698 for(
size_t i=0UL; i<tmp.rows(); ++i )
2699 for(
size_t j=0UL; j<=i; ++j )
2720 template<
typename MT
2722 template<
typename MT2
2725 inline const MT LowerMatrix<MT,SO,true>::construct(
const Matrix<MT2,SO2>& m, T )
2729 if( !IsLower<MT2>::value && !
isLower( tmp ) ) {
Constraint on the data type.
Header file for the implementation of the Submatrix view.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_CONST(T)
Constraint on the data type.In case the given data type is a const-qualified type, a compilation error is created.
Definition: Const.h:79
BoolConstant< false > 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_THROW_INVALID_ARGUMENT(MESSAGE)
Macro for the emission of a std::invalid_argument exception.This macro encapsulates the default way o...
Definition: Exception.h:235
Header file for auxiliary alias declarations.
#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:7800
BLAZE_ALWAYS_INLINE size_t capacity(const Matrix< MT, SO > &matrix) noexcept
Returns the maximum capacity of the matrix.
Definition: Matrix.h:346
Header file for basic type definitions.
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
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:63
#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:61
BLAZE_ALWAYS_INLINE T1 & operator/=(SIMDPack< T1 > &lhs, const SIMDPack< T2 > &rhs)
Division assignment operator for the division of two SIMD packs.
Definition: BasicTypes.h:1339
Constraint on the data type.
BLAZE_ALWAYS_INLINE MT::Iterator begin(Matrix< MT, SO > &matrix, size_t i)
Returns an iterator to the first element of row/column i.
Definition: Matrix.h:188
Constraint on the data type.
void reset(const DiagonalProxy< MT > &proxy)
Resetting the represented element to the default initial values.
Definition: DiagonalProxy.h:533
const DenseIterator< Type, AF > operator+(const DenseIterator< Type, AF > &it, ptrdiff_t inc) noexcept
Addition between a DenseIterator and an integral value.
Definition: DenseIterator.h:699
const This & CompositeType
Data type for composite expression templates.
Definition: CompressedMatrix.h:2643
typename DisableIf< Condition, T >::Type DisableIf_
Auxiliary type for the DisableIf class template.The DisableIf_ alias declaration provides a convenien...
Definition: DisableIf.h:223
void clear(CompressedMatrix< Type, SO > &m)
Clearing the given compressed matrix.
Definition: CompressedMatrix.h:5077
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:2636
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:79
BLAZE_ALWAYS_INLINE size_t nonZeros(const Matrix< MT, SO > &matrix)
Returns the total number of non-zero elements in the matrix.
Definition: Matrix.h:384
#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:60
const DenseIterator< Type, AF > operator-(const DenseIterator< Type, AF > &it, ptrdiff_t inc) noexcept
Subtraction between a DenseIterator and an integral value.
Definition: DenseIterator.h:731
BoolConstant< true > TrueType
Type traits base class.The TrueType class is used as base class for type traits and value traits that...
Definition: TrueType.h:61
BLAZE_ALWAYS_INLINE T1 & operator*=(SIMDPack< T1 > &lhs, const SIMDPack< T2 > &rhs)
Multiplication assignment operator for the multiplication of two SIMD packs.
Definition: BasicTypes.h:1321
Constraint on the data type.
BLAZE_ALWAYS_INLINE const EnableIf_< And< IsIntegral< T >, HasSize< T, 1UL > >, If_< IsSigned< T >, SIMDint8, SIMDuint8 > > loadu(const T *address) noexcept
Loads a vector of 1-byte integral values.
Definition: Loadu.h:77
CompressedMatrix< Type, false > OppositeType
Result type with opposite storage order for expression template evaluations.
Definition: CompressedMatrix.h:2639
DisableIf_< Or< IsComputation< MT >, IsTransExpr< MT > >, ColumnExprTrait_< MT > > column(Matrix< MT, SO > &matrix, size_t index)
Creating a view on a specific column of the given matrix.
Definition: Column.h:126
BLAZE_ALWAYS_INLINE MT::ConstIterator cend(const Matrix< MT, SO > &matrix, size_t i)
Returns an iterator just past the last element of row/column i.
Definition: Matrix.h:298
bool isLower(const DenseMatrix< MT, SO > &dm)
Checks if the given dense matrix is a lower triangular matrix.
Definition: DenseMatrix.h:1036
BLAZE_ALWAYS_INLINE MT::ConstIterator cbegin(const Matrix< MT, SO > &matrix, size_t i)
Returns an iterator to the first element of row/column i.
Definition: Matrix.h:232
bool isDefault(const DiagonalProxy< MT > &proxy)
Returns whether the represented element is in default state.
Definition: DiagonalProxy.h:573
Constraint on the data type.
Constraint on the data type.
constexpr bool spacing
Adding an additional spacing line between two log messages.This setting gives the opportunity to add ...
Definition: Logging.h:70
Header file for the std::initializer_list aliases.
Header file for the IsSquare type trait.
Constraint on the data type.
Constraint on the data type.
Header file for the DisableIf class template.
Header file for the clear shim.
Namespace of the Blaze C++ math library.
Definition: Blaze.h:57
#define BLAZE_ALWAYS_INLINE
Platform dependent setup of an enforced inline keyword.
Definition: Inline.h:85
void swap(CompressedMatrix< Type, SO > &a, CompressedMatrix< Type, SO > &b) noexcept
Swapping the contents of two compressed matrices.
Definition: CompressedMatrix.h:5148
bool isIntact(const CompressedMatrix< Type, SO > &m)
Returns whether the invariants of the given compressed matrix are intact.
Definition: CompressedMatrix.h:5131
const Element * ConstIterator
Iterator over constant elements.
Definition: CompressedMatrix.h:2647
#define BLAZE_CONSTRAINT_MUST_NOT_BE_POINTER_TYPE(T)
Constraint on the data type.In case the given data type T is not a pointer type, a compilation error ...
Definition: Pointer.h:79
#define BLAZE_THROW_OUT_OF_RANGE(MESSAGE)
Macro for the emission of a std::out_of_range exception.This macro encapsulates the default way of Bl...
Definition: Exception.h:331
Header file for the DenseMatrix base class.
Header file for the Columns type trait.
Constraint on the data type.
Header file for the IsLower type trait.
Header file for the LowerProxy class.
BLAZE_ALWAYS_INLINE size_t columns(const Matrix< MT, SO > &matrix) noexcept
Returns the current number of columns of the matrix.
Definition: Matrix.h:330
BLAZE_ALWAYS_INLINE const EnableIf_< And< IsIntegral< T >, HasSize< T, 1UL > >, If_< IsSigned< T >, SIMDint8, SIMDuint8 > > loada(const T *address) noexcept
Loads a vector of 1-byte integral values.
Definition: Loada.h:80
CompressedMatrix< Type, false > TransposeType
Transpose type for expression template evaluations.
Definition: CompressedMatrix.h:2640
Constraints on the storage order of matrix types.
Header file for the exception macros of the math module.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_UPPER_MATRIX_TYPE(T)
Constraint on the data type.In case the given data type T is a upper triangular matrix type...
Definition: Upper.h:81
BLAZE_ALWAYS_INLINE void resize(Matrix< MT, SO > &matrix, size_t rows, size_t columns, bool preserve=true)
Changing the size of the matrix.
Definition: Matrix.h:538
BLAZE_ALWAYS_INLINE MT::Iterator end(Matrix< MT, SO > &matrix, size_t i)
Returns an iterator just past the last element of row/column i.
Definition: Matrix.h:254
Type ElementType
Type of the sparse matrix elements.
Definition: CompressedMatrix.h:2641
const Type & ConstReference
Reference to a constant matrix value.
Definition: CompressedMatrix.h:2645
Header file for the EnableIf class template.
Header file for utility functions for dense matrices.
void clear(const DiagonalProxy< MT > &proxy)
Clearing the represented element.
Definition: DiagonalProxy.h:553
Header file for the IsNumeric type trait.
Header file for all adaptor forward declarations.
DisableIf_< Or< IsComputation< MT >, IsTransExpr< MT > >, RowExprTrait_< MT > > row(Matrix< MT, SO > &matrix, size_t index)
Creating a view on a specific row of the given matrix.
Definition: Row.h:126
#define BLAZE_CONSTRAINT_MUST_NOT_BE_SYMMETRIC_MATRIX_TYPE(T)
Constraint on the data type.In case the given data type T is a symmetric matrix type, a compilation error is created.
Definition: Symmetric.h:79
const Type & ReturnType
Return type for expression template evaluations.
Definition: CompressedMatrix.h:2642
BLAZE_ALWAYS_INLINE T1 & operator+=(SIMDPack< T1 > &lhs, const SIMDPack< T2 > &rhs)
Addition assignment operator for the addition of two SIMD packs.
Definition: BasicTypes.h:1285
Header file for run time assertion macros.
Constraint on the data type.
Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_LOWER_MATRIX_TYPE(T)
Constraint on the data type.In case the given data type T is a lower triangular matrix type...
Definition: Lower.h:81
#define BLAZE_CONSTRAINT_MUST_NOT_BE_REFERENCE_TYPE(T)
Constraint on the data type.In case the given data type T is not a reference type, a compilation error is created.
Definition: Reference.h:79
Element * Iterator
Iterator over non-constant elements.
Definition: CompressedMatrix.h:2646
Header file for the isDefault shim.
void swap(DiagonalMatrix< MT, SO, DF > &a, DiagonalMatrix< MT, SO, DF > &b) noexcept
Swapping the contents of two matrices.
Definition: DiagonalMatrix.h:258
Constraint on the data type.
Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_RESIZABLE(T)
Constraint on the data type.In case the given data type T is resizable, i.e. has a 'resize' member fu...
Definition: Resizable.h:81
typename EnableIf< Condition, T >::Type EnableIf_
Auxiliary alias declaration for the EnableIf class template.The EnableIf_ alias declaration provides ...
Definition: EnableIf.h:223
BLAZE_ALWAYS_INLINE size_t rows(const Matrix< MT, SO > &matrix) noexcept
Returns the current number of rows of the matrix.
Definition: Matrix.h:314
SparseMatrix< This, true > BaseType
Base type of this CompressedMatrix instance.
Definition: CompressedMatrix.h:2637
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:61
Header file for the implementation of the base template of the LowerMatrix.
Header file for the IsComputation type trait class.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_EXPRESSION_TYPE(T)
Constraint on the data type.In case the given data type T is an expression (i.e. a type derived from ...
Definition: Expression.h:81
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:2638
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:240
MatrixAccessProxy< This > Reference
Reference to a non-constant matrix value.
Definition: CompressedMatrix.h:2644
#define BLAZE_CONSTRAINT_MUST_NOT_BE_HERMITIAN_MATRIX_TYPE(T)
Constraint on the data type.In case the given data type T is an Hermitian matrix type, a compilation error is created.
Definition: Hermitian.h:79
BLAZE_ALWAYS_INLINE T1 & operator-=(SIMDPack< T1 > &lhs, const SIMDPack< T2 > &rhs)
Subtraction assignment operator for the subtraction of two SIMD packs.
Definition: BasicTypes.h:1303
void UNUSED_PARAMETER(const Args &...)
Suppression of unused parameter warnings.
Definition: Unused.h:81
#define BLAZE_STATIC_ASSERT(expr)
Compile time assertion macro.In case of an invalid compile time expression, a compilation error is cr...
Definition: StaticAssert.h:112
SubmatrixExprTrait_< MT, unaligned > 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:167
BLAZE_ALWAYS_INLINE bool isSquare(const Matrix< MT, SO > &matrix) noexcept
Checks if the given matrix is a square matrix.
Definition: Matrix.h:609
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.