35 #ifndef _BLAZE_MATH_ADAPTORS_UNILOWERMATRIX_DENSE_H_
36 #define _BLAZE_MATH_ADAPTORS_UNILOWERMATRIX_DENSE_H_
108 template<
typename MT
110 class UniLowerMatrix<MT,SO,true>
111 :
public DenseMatrix< UniLowerMatrix<MT,SO,true>, SO >
115 typedef OppositeType_<MT> OT;
116 typedef TransposeType_<MT> TT;
117 typedef ElementType_<MT> ET;
122 typedef UniLowerMatrix<MT,SO,true>
This;
123 typedef DenseMatrix<This,SO>
BaseType;
128 typedef SIMDType_<MT> SIMDType;
133 typedef Pointer_<MT> Pointer;
134 typedef ConstPointer_<MT> ConstPointer;
141 template<
typename ET >
144 typedef UniLowerMatrix< typename MT::template Rebind<ET>::Other > Other;
155 typedef std::random_access_iterator_tag IteratorCategory;
156 typedef ElementType_<MT> ValueType;
157 typedef UniLowerProxy<MT> PointerType;
158 typedef UniLowerProxy<MT> ReferenceType;
159 typedef ptrdiff_t DifferenceType;
162 typedef IteratorCategory iterator_category;
163 typedef ValueType value_type;
164 typedef PointerType pointer;
165 typedef ReferenceType reference;
166 typedef DifferenceType difference_type;
200 ( SO )?( row_ += inc ):( column_ += inc );
212 ( SO )?( row_ -= dec ):( column_ -= dec );
222 inline Iterator& operator++() noexcept {
223 ( SO )?( ++row_ ):( ++column_ );
233 inline const Iterator operator++(
int ) noexcept {
245 inline Iterator& operator--() noexcept {
246 ( SO )?( --row_ ):( --column_ );
256 inline const Iterator operator--(
int ) noexcept {
269 return ReferenceType( *matrix_, row_, column_ );
278 inline PointerType operator->()
const {
279 return PointerType( *matrix_, row_, column_ );
293 inline SIMDType load()
const {
294 return (*matrix_).load(row_,column_);
308 inline SIMDType
loada()
const {
309 return (*matrix_).loada(row_,column_);
323 inline SIMDType
loadu()
const {
324 return (*matrix_).loadu(row_,column_);
335 return matrix_->begin( column_ ) + row_;
337 return matrix_->begin( row_ ) + column_;
349 return ( SO )?( lhs.row_ == rhs.row_ ):( lhs.column_ == rhs.column_ );
360 friend inline bool operator==(
const Iterator& lhs,
const ConstIterator& rhs ) noexcept {
372 friend inline bool operator==(
const ConstIterator& lhs,
const Iterator& rhs ) noexcept {
385 return ( SO )?( lhs.row_ != rhs.row_ ):( lhs.column_ != rhs.column_ );
421 return ( SO )?( lhs.row_ < rhs.row_ ):( lhs.column_ < rhs.column_ );
457 return ( SO )?( lhs.row_ > rhs.row_ ):( lhs.column_ > rhs.column_ );
493 return ( SO )?( lhs.row_ <= rhs.row_ ):( lhs.column_ <= rhs.column_ );
529 return ( SO )?( lhs.row_ >= rhs.row_ ):( lhs.column_ >= rhs.column_ );
564 return ( SO )?( row_ - rhs.row_ ):( column_ - rhs.column_ );
577 return Iterator( *it.matrix_, it.row_ + inc, it.column_ );
579 return Iterator( *it.matrix_, it.row_, it.column_ + inc );
592 return Iterator( *it.matrix_, it.row_ + inc, it.column_ );
594 return Iterator( *it.matrix_, it.row_, it.column_ + inc );
607 return Iterator( *it.matrix_, it.row_ - dec, it.column_ );
609 return Iterator( *it.matrix_, it.row_, it.column_ - dec );
624 enum :
bool { simdEnabled = MT::simdEnabled };
627 enum :
bool { smpAssignable = MT::smpAssignable };
633 explicit inline UniLowerMatrix();
634 template<
typename A1 >
explicit inline UniLowerMatrix(
const A1& a1 );
635 explicit inline UniLowerMatrix(
size_t n,
const ElementType& init );
637 explicit inline UniLowerMatrix( initializer_list< initializer_list<ElementType> > list );
639 template<
typename Other >
640 explicit inline UniLowerMatrix(
size_t n,
const Other* array );
642 template<
typename Other,
size_t N >
643 explicit inline UniLowerMatrix(
const Other (&array)[N][N] );
645 explicit inline UniLowerMatrix( ElementType* ptr,
size_t n );
646 explicit inline UniLowerMatrix( ElementType* ptr,
size_t n,
size_t nn );
648 template<
typename Deleter >
649 explicit inline UniLowerMatrix( ElementType* ptr,
size_t n, Deleter d );
651 template<
typename Deleter >
652 explicit inline UniLowerMatrix( ElementType* ptr,
size_t n,
size_t nn, Deleter d );
654 inline UniLowerMatrix(
const UniLowerMatrix& m );
655 inline UniLowerMatrix( UniLowerMatrix&& m ) noexcept;
666 inline Reference operator()(
size_t i,
size_t j );
667 inline ConstReference operator()(
size_t i,
size_t j ) const;
668 inline Reference at(
size_t i,
size_t j );
669 inline ConstReference at(
size_t i,
size_t j ) const;
670 inline ConstPointer data () const noexcept;
671 inline ConstPointer data (
size_t i ) const noexcept;
673 inline ConstIterator
begin (
size_t i ) const;
674 inline ConstIterator
cbegin(
size_t i ) const;
676 inline ConstIterator
end (
size_t i ) const;
677 inline ConstIterator
cend (
size_t i ) const;
684 inline UniLowerMatrix& operator=( const ElementType& rhs );
685 inline UniLowerMatrix& operator=( initializer_list< initializer_list<ElementType> > list );
687 template< typename Other,
size_t N >
688 inline UniLowerMatrix& operator=( const Other (&array)[N][N] );
690 inline UniLowerMatrix& operator=( const UniLowerMatrix& rhs );
691 inline UniLowerMatrix& operator=( UniLowerMatrix&& rhs ) noexcept;
693 template< typename MT2,
bool SO2 >
694 inline
DisableIf_< IsComputation<MT2>, UniLowerMatrix& > operator=( const Matrix<MT2,SO2>& rhs );
696 template< typename MT2,
bool SO2 >
697 inline
EnableIf_< IsComputation<MT2>, UniLowerMatrix& > operator=( const Matrix<MT2,SO2>& rhs );
699 template< typename MT2,
bool SO2 >
700 inline
DisableIf_< IsComputation<MT2>, UniLowerMatrix& > operator+=( const Matrix<MT2,SO2>& rhs );
702 template< typename MT2,
bool SO2 >
703 inline
EnableIf_< IsComputation<MT2>, UniLowerMatrix& > operator+=( const Matrix<MT2,SO2>& rhs );
705 template< typename MT2,
bool SO2 >
706 inline
DisableIf_< IsComputation<MT2>, UniLowerMatrix& > operator-=( const Matrix<MT2,SO2>& rhs );
708 template< typename MT2,
bool SO2 >
709 inline
EnableIf_< IsComputation<MT2>, UniLowerMatrix& > operator-=( const Matrix<MT2,SO2>& rhs );
711 template< typename MT2,
bool SO2 >
712 inline UniLowerMatrix& operator*=( const Matrix<MT2,SO2>& rhs );
719 inline
size_t rows() const noexcept;
720 inline
size_t columns() const noexcept;
721 inline
size_t spacing() const noexcept;
722 inline
size_t capacity() const noexcept;
723 inline
size_t capacity(
size_t i ) const noexcept;
725 inline
size_t nonZeros(
size_t i ) const;
727 inline
void reset(
size_t i );
729 void resize (
size_t n,
bool preserve=true );
730 inline
void extend (
size_t n,
bool preserve=true );
731 inline
void reserve(
size_t elements );
732 inline
void swap( UniLowerMatrix& m ) noexcept;
734 static inline constexpr
size_t maxNonZeros() noexcept;
735 static inline constexpr
size_t maxNonZeros(
size_t n ) noexcept;
742 inline
bool isIntact() const noexcept;
749 template< typename Other > inline
bool canAlias ( const Other* alias ) const noexcept;
750 template< typename Other > inline
bool isAliased( const Other* alias ) const noexcept;
752 inline
bool isAligned () const noexcept;
753 inline
bool canSMPAssign() const noexcept;
765 inline const MT construct(
size_t n ,
TrueType );
766 inline const MT construct( const ElementType& value,
FalseType );
768 template< typename MT2,
bool SO2, typename T >
769 inline const MT construct( const Matrix<MT2,SO2>& m, T );
781 template< typename MT2,
bool SO2,
bool DF2 >
782 friend MT2& derestrict( UniLowerMatrix<MT2,SO2,DF2>& m );
818 template< typename MT
820 inline UniLowerMatrix<MT,SO,true>::UniLowerMatrix()
823 for(
size_t i=0UL; i<Rows<MT>::value; ++i )
851 template<
typename MT
853 template<
typename A1 >
854 inline UniLowerMatrix<MT,SO,true>::UniLowerMatrix(
const A1& a1 )
855 : matrix_( construct( a1, typename IsResizable<MT>::Type() ) )
871 template<
typename MT
873 inline UniLowerMatrix<MT,SO,true>::UniLowerMatrix(
size_t n,
const ElementType& init )
874 : matrix_( n, n, ElementType() )
879 for(
size_t j=0UL; j<
columns(); ++j ) {
881 for(
size_t i=j+1UL; i<
rows(); ++i )
886 for(
size_t i=0UL; i<
rows(); ++i ) {
887 for(
size_t j=0UL; j<i; ++j )
923 template<
typename MT
925 inline UniLowerMatrix<MT,SO,true>::UniLowerMatrix( initializer_list< initializer_list<ElementType> > list )
964 template<
typename MT
966 template<
typename Other >
967 inline UniLowerMatrix<MT,SO,true>::UniLowerMatrix(
size_t n,
const Other* array )
968 : matrix_( n, n, array )
1003 template<
typename MT
1005 template<
typename Other
1007 inline UniLowerMatrix<MT,SO,true>::UniLowerMatrix(
const Other (&array)[N][N] )
1041 template<
typename MT
1043 inline UniLowerMatrix<MT,SO,true>::UniLowerMatrix( ElementType* ptr,
size_t n )
1044 : matrix_( ptr, n, n )
1079 template<
typename MT
1081 inline UniLowerMatrix<MT,SO,true>::UniLowerMatrix( ElementType* ptr,
size_t n,
size_t nn )
1082 : matrix_( ptr, n, n, nn )
1115 template<
typename MT
1117 template<
typename Deleter >
1118 inline UniLowerMatrix<MT,SO,true>::UniLowerMatrix( ElementType* ptr,
size_t n, Deleter d )
1119 : matrix_( ptr, n, n, d )
1153 template<
typename MT
1155 template<
typename Deleter >
1156 inline UniLowerMatrix<MT,SO,true>::UniLowerMatrix( ElementType* ptr,
size_t n,
size_t nn, Deleter d )
1157 : matrix_( ptr, n, n, nn, d )
1175 template<
typename MT
1177 inline UniLowerMatrix<MT,SO,true>::UniLowerMatrix(
const UniLowerMatrix& m )
1178 : matrix_( m.matrix_ )
1193 template<
typename MT
1195 inline UniLowerMatrix<MT,SO,true>::UniLowerMatrix( UniLowerMatrix&& m ) noexcept
1196 : matrix_(
std::move( m.matrix_ ) )
1229 template<
typename MT
1232 UniLowerMatrix<MT,SO,true>::operator()(
size_t i,
size_t j )
1259 template<
typename MT
1262 UniLowerMatrix<MT,SO,true>::operator()(
size_t i,
size_t j )
const
1267 return matrix_(i,j);
1290 template<
typename MT
1293 UniLowerMatrix<MT,SO,true>::at(
size_t i,
size_t j )
1301 return (*
this)(i,j);
1324 template<
typename MT
1327 UniLowerMatrix<MT,SO,true>::at(
size_t i,
size_t j )
const
1335 return (*
this)(i,j);
1354 template<
typename MT
1356 inline typename UniLowerMatrix<MT,SO,true>::ConstPointer
1357 UniLowerMatrix<MT,SO,true>::data() const noexcept
1359 return matrix_.data();
1374 template<
typename MT
1376 inline typename UniLowerMatrix<MT,SO,true>::ConstPointer
1377 UniLowerMatrix<MT,SO,true>::data(
size_t i )
const noexcept
1379 return matrix_.data(i);
1397 template<
typename MT
1403 return Iterator( matrix_, 0UL, i );
1405 return Iterator( matrix_, i, 0UL );
1423 template<
typename MT
1428 return matrix_.begin(i);
1446 template<
typename MT
1451 return matrix_.cbegin(i);
1469 template<
typename MT
1495 template<
typename MT
1500 return matrix_.end(i);
1518 template<
typename MT
1523 return matrix_.cend(i);
1544 template<
typename MT
1546 inline UniLowerMatrix<MT,SO,true>&
1547 UniLowerMatrix<MT,SO,true>::operator=(
const ElementType& rhs )
1550 for(
size_t j=0UL; j<
columns(); ++j )
1551 for(
size_t i=j+1UL; i<
rows(); ++i )
1555 for(
size_t i=1UL; i<
rows(); ++i )
1556 for(
size_t j=0UL; j<i; ++j )
1590 template<
typename MT
1592 inline UniLowerMatrix<MT,SO,true>&
1593 UniLowerMatrix<MT,SO,true>::operator=( initializer_list< initializer_list<ElementType> > list )
1601 matrix_ = std::move( tmp );
1636 template<
typename MT
1638 template<
typename Other
1640 inline UniLowerMatrix<MT,SO,true>&
1641 UniLowerMatrix<MT,SO,true>::operator=(
const Other (&array)[N][N] )
1649 matrix_ = std::move( tmp );
1670 template<
typename MT
1672 inline UniLowerMatrix<MT,SO,true>&
1673 UniLowerMatrix<MT,SO,true>::operator=(
const UniLowerMatrix& rhs )
1675 matrix_ = rhs.matrix_;
1693 template<
typename MT
1695 inline UniLowerMatrix<MT,SO,true>&
1696 UniLowerMatrix<MT,SO,true>::operator=( UniLowerMatrix&& rhs ) noexcept
1698 matrix_ = std::move( rhs.matrix_ );
1722 template<
typename MT
1724 template<
typename MT2
1726 inline DisableIf_< IsComputation<MT2>, UniLowerMatrix<MT,SO,true>& >
1727 UniLowerMatrix<MT,SO,true>::operator=(
const Matrix<MT2,SO2>& rhs )
1729 if( IsStrictlyTriangular<MT2>::value || ( !IsUniLower<MT2>::value && !
isUniLower( ~rhs ) ) ) {
1757 template<
typename MT
1759 template<
typename MT2
1761 inline EnableIf_< IsComputation<MT2>, UniLowerMatrix<MT,SO,true>& >
1762 UniLowerMatrix<MT,SO,true>::operator=(
const Matrix<MT2,SO2>& rhs )
1764 if( IsStrictlyTriangular<MT2>::value || ( !IsSquare<MT2>::value && !
isSquare( ~rhs ) ) ) {
1768 if( IsUniLower<MT2>::value ) {
1778 matrix_ = std::move( tmp );
1803 template<
typename MT
1805 template<
typename MT2
1807 inline DisableIf_< IsComputation<MT2>, UniLowerMatrix<MT,SO,true>& >
1810 if( IsUpper<MT2>::value || IsUniTriangular<MT2>::value ||
1839 template<
typename MT
1841 template<
typename MT2
1843 inline EnableIf_< IsComputation<MT2>, UniLowerMatrix<MT,SO,true>& >
1846 if( IsUpper<MT2>::value || IsUniTriangular<MT2>::value ||
1847 ( !IsSquare<MT2>::value && !
isSquare( ~rhs ) ) ) {
1851 if( IsStrictlyLower<MT2>::value ) {
1855 const ResultType_<MT2> tmp( ~rhs );
1886 template<
typename MT
1888 template<
typename MT2
1890 inline DisableIf_< IsComputation<MT2>, UniLowerMatrix<MT,SO,true>& >
1893 if( IsUpper<MT2>::value || IsUniTriangular<MT2>::value ||
1922 template<
typename MT
1924 template<
typename MT2
1926 inline EnableIf_< IsComputation<MT2>, UniLowerMatrix<MT,SO,true>& >
1929 if( IsUpper<MT2>::value || IsUniTriangular<MT2>::value ||
1930 ( !IsSquare<MT2>::value && !
isSquare( ~rhs ) ) ) {
1934 if( IsStrictlyLower<MT2>::value ) {
1938 const ResultType_<MT2> tmp( ~rhs );
1968 template<
typename MT
1970 template<
typename MT2
1972 inline UniLowerMatrix<MT,SO,true>&
1975 if( matrix_.rows() != (~rhs).
columns() ) {
1979 MT tmp( matrix_ * ~rhs );
1985 matrix_ = std::move( tmp );
2010 template<
typename MT
2014 return matrix_.rows();
2026 template<
typename MT
2030 return matrix_.columns();
2047 template<
typename MT
2051 return matrix_.spacing();
2063 template<
typename MT
2067 return matrix_.capacity();
2085 template<
typename MT
2089 return matrix_.capacity(i);
2101 template<
typename MT
2105 return matrix_.nonZeros();
2123 template<
typename MT
2127 return matrix_.nonZeros(i);
2139 template<
typename MT
2146 for(
size_t j=0UL; j<
columns(); ++j )
2147 for(
size_t i=j+1UL; i<
rows(); ++i )
2148 clear( matrix_(i,j) );
2151 for(
size_t i=1UL; i<
rows(); ++i )
2152 for(
size_t j=0UL; j<i; ++j )
2153 clear( matrix_(i,j) );
2173 template<
typename MT
2180 for(
size_t j=i+1UL; j<
rows(); ++j )
2181 clear( matrix_(j,i) );
2184 for(
size_t j=0UL; j<i; ++j )
2185 clear( matrix_(i,j) );
2204 template<
typename MT
2210 if( IsResizable<MT>::value ) {
2257 template<
typename MT
2267 const size_t oldsize( matrix_.rows() );
2269 matrix_.resize( n, n,
true );
2273 const size_t increment( n - oldsize );
2274 submatrix( matrix_, 0UL, oldsize, n-1UL, increment ).reset();
2276 for(
size_t i=oldsize; i<n; ++i )
2297 template<
typename MT
2299 inline void UniLowerMatrix<MT,SO,true>::extend(
size_t n,
bool preserve )
2320 template<
typename MT
2322 inline void UniLowerMatrix<MT,SO,true>::reserve(
size_t elements )
2324 matrix_.reserve( elements );
2337 template<
typename MT
2343 swap( matrix_, m.matrix_ );
2361 template<
typename MT
2363 inline constexpr
size_t UniLowerMatrix<MT,SO,true>::maxNonZeros() noexcept
2367 return maxNonZeros( Rows<MT>::value );
2383 template<
typename MT
2385 inline constexpr
size_t UniLowerMatrix<MT,SO,true>::maxNonZeros(
size_t n ) noexcept
2387 return ( ( n + 1UL ) * n ) / 2UL;
2411 template<
typename MT
2442 template<
typename MT
2444 template<
typename Other >
2445 inline bool UniLowerMatrix<MT,SO,true>::canAlias(
const Other* alias )
const noexcept
2447 return matrix_.canAlias( alias );
2464 template<
typename MT
2466 template<
typename Other >
2467 inline bool UniLowerMatrix<MT,SO,true>::isAliased(
const Other* alias )
const noexcept
2469 return matrix_.isAliased( alias );
2485 template<
typename MT
2487 inline bool UniLowerMatrix<MT,SO,true>::isAligned() const noexcept
2489 return matrix_.isAligned();
2506 template<
typename MT
2508 inline bool UniLowerMatrix<MT,SO,true>::canSMPAssign() const noexcept
2510 return matrix_.canSMPAssign();
2532 template<
typename MT
2535 UniLowerMatrix<MT,SO,true>::load(
size_t i,
size_t j )
const noexcept
2537 return matrix_.load( i, j );
2559 template<
typename MT
2564 return matrix_.loada( i, j );
2586 template<
typename MT
2591 return matrix_.loadu( i, j );
2612 template<
typename MT
2614 inline const MT UniLowerMatrix<MT,SO,true>::construct(
size_t n, TrueType )
2620 for(
size_t i=0UL; i<n; ++i )
2636 template<
typename MT
2638 inline const MT UniLowerMatrix<MT,SO,true>::construct(
const ElementType& init, FalseType )
2646 for(
size_t j=0UL; j<tmp.columns(); ++j ) {
2648 for(
size_t i=j+1UL; i<tmp.rows(); ++i )
2653 for(
size_t i=0UL; i<tmp.rows(); ++i ) {
2654 for(
size_t j=0UL; j<i; ++j )
2677 template<
typename MT
2679 template<
typename MT2
2682 inline const MT UniLowerMatrix<MT,SO,true>::construct(
const Matrix<MT2,SO2>& m, T )
2686 if( IsStrictlyTriangular<MT2>::value || ( !IsUniLower<MT2>::value && !
isUniLower( 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 the implementation of the base template of the UniLowerMatrix.
Header file for auxiliary alias declarations.
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: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
bool isStrictlyLower(const DenseMatrix< MT, SO > &dm)
Checks if the given dense matrix is a strictly lower triangular matrix.
Definition: DenseMatrix.h:1192
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
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
Header file for the IsUniLower type trait.
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
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
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.
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
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: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
bool isUniLower(const DenseMatrix< MT, SO > &dm)
Checks if the given dense matrix is a lower unitriangular matrix.
Definition: DenseMatrix.h:1113
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 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:553
Header file for the UniLowerProxy class.
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_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:61
#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 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
Header file for the IsUpper type trait.
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.