35 #ifndef _BLAZE_MATH_ADAPTORS_UPPERMATRIX_DENSE_H_
36 #define _BLAZE_MATH_ADAPTORS_UPPERMATRIX_DENSE_H_
103 template<
typename MT
105 class UpperMatrix<MT,SO,true>
106 :
public DenseMatrix< UpperMatrix<MT,SO,true>, SO >
110 typedef OppositeType_<MT> OT;
111 typedef TransposeType_<MT> TT;
112 typedef ElementType_<MT> ET;
117 typedef UpperMatrix<MT,SO,true>
This;
118 typedef DenseMatrix<This,SO>
BaseType;
123 typedef SIMDType_<MT> SIMDType;
128 typedef Pointer_<MT> Pointer;
129 typedef ConstPointer_<MT> ConstPointer;
136 template<
typename ET >
139 typedef UpperMatrix< typename MT::template Rebind<ET>::Other > Other;
150 typedef std::random_access_iterator_tag IteratorCategory;
151 typedef ElementType_<MT> ValueType;
152 typedef UpperProxy<MT> PointerType;
153 typedef UpperProxy<MT> ReferenceType;
154 typedef ptrdiff_t DifferenceType;
157 typedef IteratorCategory iterator_category;
158 typedef ValueType value_type;
159 typedef PointerType pointer;
160 typedef ReferenceType reference;
161 typedef DifferenceType difference_type;
195 ( SO )?( row_ += inc ):( column_ += inc );
207 ( SO )?( row_ -= dec ):( column_ -= dec );
217 inline Iterator& operator++() noexcept {
218 ( SO )?( ++row_ ):( ++column_ );
228 inline const Iterator operator++(
int ) noexcept {
240 inline Iterator& operator--() noexcept {
241 ( SO )?( --row_ ):( --column_ );
251 inline const Iterator operator--(
int ) noexcept {
264 return ReferenceType( *matrix_, row_, column_ );
273 inline PointerType operator->()
const {
274 return PointerType( *matrix_, row_, column_ );
288 inline SIMDType load()
const {
289 return (*matrix_).load(row_,column_);
303 inline SIMDType
loada()
const {
304 return (*matrix_).loada(row_,column_);
318 inline SIMDType
loadu()
const {
319 return (*matrix_).loadu(row_,column_);
330 return matrix_->begin( column_ ) + row_;
332 return matrix_->begin( row_ ) + column_;
344 return ( SO )?( lhs.row_ == rhs.row_ ):( lhs.column_ == rhs.column_ );
380 return ( SO )?( lhs.row_ != rhs.row_ ):( lhs.column_ != rhs.column_ );
416 return ( SO )?( lhs.row_ < rhs.row_ ):( lhs.column_ < rhs.column_ );
452 return ( SO )?( lhs.row_ > rhs.row_ ):( lhs.column_ > rhs.column_ );
488 return ( SO )?( lhs.row_ <= rhs.row_ ):( lhs.column_ <= rhs.column_ );
524 return ( SO )?( lhs.row_ >= rhs.row_ ):( lhs.column_ >= rhs.column_ );
559 return ( SO )?( row_ - rhs.row_ ):( column_ - rhs.column_ );
572 return Iterator( *it.matrix_, it.row_ + inc, it.column_ );
574 return Iterator( *it.matrix_, it.row_, it.column_ + inc );
587 return Iterator( *it.matrix_, it.row_ + inc, it.column_ );
589 return Iterator( *it.matrix_, it.row_, it.column_ + inc );
602 return Iterator( *it.matrix_, it.row_ - dec, it.column_ );
604 return Iterator( *it.matrix_, it.row_, it.column_ - dec );
619 enum :
bool { simdEnabled = MT::simdEnabled };
622 enum :
bool { smpAssignable = MT::smpAssignable };
628 explicit inline UpperMatrix();
629 template<
typename A1 >
explicit inline UpperMatrix(
const A1& a1 );
630 explicit inline UpperMatrix(
size_t n,
const ElementType& init );
632 explicit inline UpperMatrix( initializer_list< initializer_list<ElementType> > list );
634 template<
typename Other >
635 explicit inline UpperMatrix(
size_t n,
const Other* array );
637 template<
typename Other,
size_t N >
638 explicit inline UpperMatrix(
const Other (&array)[N][N] );
640 explicit inline UpperMatrix( ElementType* ptr,
size_t n );
641 explicit inline UpperMatrix( ElementType* ptr,
size_t n,
size_t nn );
643 template<
typename Deleter >
644 explicit inline UpperMatrix( ElementType* ptr,
size_t n, Deleter d );
646 template<
typename Deleter >
647 explicit inline UpperMatrix( ElementType* ptr,
size_t n,
size_t nn, Deleter d );
649 inline UpperMatrix(
const UpperMatrix& m );
650 inline UpperMatrix( UpperMatrix&& m ) noexcept;
661 inline Reference operator()(
size_t i,
size_t j );
662 inline ConstReference operator()(
size_t i,
size_t j ) const;
663 inline Reference at(
size_t i,
size_t j );
664 inline ConstReference at(
size_t i,
size_t j ) const;
665 inline ConstPointer data () const noexcept;
666 inline ConstPointer data (
size_t i ) const noexcept;
668 inline ConstIterator
begin (
size_t i ) const;
669 inline ConstIterator
cbegin(
size_t i ) const;
671 inline ConstIterator
end (
size_t i ) const;
672 inline ConstIterator
cend (
size_t i ) const;
679 inline UpperMatrix& operator=( const ElementType& rhs );
680 inline UpperMatrix& operator=( initializer_list< initializer_list<ElementType> > list );
682 template< typename Other,
size_t N >
683 inline UpperMatrix& operator=( const Other (&array)[N][N] );
685 inline UpperMatrix& operator=( const UpperMatrix& rhs );
686 inline UpperMatrix& operator=( UpperMatrix&& rhs ) noexcept;
688 template< typename MT2,
bool SO2 >
689 inline
DisableIf_< IsComputation<MT2>, UpperMatrix& > operator=( const Matrix<MT2,SO2>& rhs );
691 template< typename MT2,
bool SO2 >
692 inline
EnableIf_< IsComputation<MT2>, UpperMatrix& > operator=( const Matrix<MT2,SO2>& rhs );
694 template< typename MT2,
bool SO2 >
695 inline
DisableIf_< IsComputation<MT2>, UpperMatrix& > operator+=( const Matrix<MT2,SO2>& rhs );
697 template< typename MT2,
bool SO2 >
698 inline
EnableIf_< IsComputation<MT2>, UpperMatrix& > operator+=( const Matrix<MT2,SO2>& rhs );
700 template< typename MT2,
bool SO2 >
701 inline
DisableIf_< IsComputation<MT2>, UpperMatrix& > operator-=( const Matrix<MT2,SO2>& rhs );
703 template< typename MT2,
bool SO2 >
704 inline
EnableIf_< IsComputation<MT2>, UpperMatrix& > operator-=( const Matrix<MT2,SO2>& rhs );
706 template< typename MT2,
bool SO2 >
707 inline UpperMatrix& operator*=( const Matrix<MT2,SO2>& rhs );
709 template< typename Other >
710 inline
EnableIf_< IsNumeric<Other>, UpperMatrix >& operator*=( Other rhs );
712 template< typename Other >
713 inline
EnableIf_< IsNumeric<Other>, UpperMatrix >& operator/=( Other rhs );
720 inline
size_t rows() const noexcept;
721 inline
size_t columns() const noexcept;
722 inline
size_t spacing() const noexcept;
723 inline
size_t capacity() const noexcept;
724 inline
size_t capacity(
size_t i ) const noexcept;
726 inline
size_t nonZeros(
size_t i ) const;
728 inline
void reset(
size_t i );
730 void resize (
size_t n,
bool preserve=true );
731 inline
void extend (
size_t n,
bool preserve=true );
732 inline
void reserve(
size_t elements );
733 template< typename Other > inline UpperMatrix& scale( const Other& scalar );
734 inline
void swap( UpperMatrix& m ) noexcept;
736 static inline constexpr
size_t maxNonZeros() noexcept;
737 static inline constexpr
size_t maxNonZeros(
size_t n ) noexcept;
744 inline
bool isIntact() const noexcept;
751 template< typename Other > inline
bool canAlias ( const Other* alias ) const noexcept;
752 template< typename Other > inline
bool isAliased( const Other* alias ) const noexcept;
754 inline
bool isAligned () const noexcept;
755 inline
bool canSMPAssign() const noexcept;
767 inline const MT construct(
size_t n ,
TrueType );
768 inline const MT construct( const ElementType& value,
FalseType );
770 template< typename MT2,
bool SO2, typename T >
771 inline const MT construct( const Matrix<MT2,SO2>& m, T );
783 template< typename MT2,
bool SO2,
bool DF2 >
784 friend
bool isDefault( const UpperMatrix<MT2,SO2,DF2>& m );
786 template< typename MT2,
bool SO2,
bool DF2 >
787 friend MT2& derestrict( UpperMatrix<MT2,SO2,DF2>& m );
822 template< typename MT
824 inline UpperMatrix<MT,SO,true>::UpperMatrix()
852 template<
typename MT
854 template<
typename A1 >
855 inline UpperMatrix<MT,SO,true>::UpperMatrix(
const A1& a1 )
856 : matrix_( construct( a1, typename IsResizable<MT>::Type() ) )
872 template<
typename MT
874 inline UpperMatrix<MT,SO,true>::UpperMatrix(
size_t n,
const ElementType& init )
875 : matrix_( n, n, ElementType() )
880 for(
size_t j=0UL; j<
columns(); ++j )
881 for(
size_t i=0UL; i<=j; ++i )
885 for(
size_t i=0UL; i<
rows(); ++i )
886 for(
size_t j=i; j<
columns(); ++j )
920 template<
typename MT
922 inline UpperMatrix<MT,SO,true>::UpperMatrix( initializer_list< initializer_list<ElementType> > list )
961 template<
typename MT
963 template<
typename Other >
964 inline UpperMatrix<MT,SO,true>::UpperMatrix(
size_t n,
const Other* array )
965 : matrix_( n, n, array )
1000 template<
typename MT
1002 template<
typename Other
1004 inline UpperMatrix<MT,SO,true>::UpperMatrix(
const Other (&array)[N][N] )
1038 template<
typename MT
1040 inline UpperMatrix<MT,SO,true>::UpperMatrix( ElementType* ptr,
size_t n )
1041 : matrix_( ptr, n, n )
1076 template<
typename MT
1078 inline UpperMatrix<MT,SO,true>::UpperMatrix( ElementType* ptr,
size_t n,
size_t nn )
1079 : matrix_( ptr, n, n, nn )
1112 template<
typename MT
1114 template<
typename Deleter >
1115 inline UpperMatrix<MT,SO,true>::UpperMatrix( ElementType* ptr,
size_t n, Deleter d )
1116 : matrix_( ptr, n, n, d )
1150 template<
typename MT
1152 template<
typename Deleter >
1153 inline UpperMatrix<MT,SO,true>::UpperMatrix( ElementType* ptr,
size_t n,
size_t nn, Deleter d )
1154 : matrix_( ptr, n, n, nn, d )
1172 template<
typename MT
1174 inline UpperMatrix<MT,SO,true>::UpperMatrix(
const UpperMatrix& m )
1175 : matrix_( m.matrix_ )
1190 template<
typename MT
1192 inline UpperMatrix<MT,SO,true>::UpperMatrix( UpperMatrix&& m ) noexcept
1193 : matrix_(
std::move( m.matrix_ ) )
1226 template<
typename MT
1229 UpperMatrix<MT,SO,true>::operator()(
size_t i,
size_t j )
1256 template<
typename MT
1259 UpperMatrix<MT,SO,true>::operator()(
size_t i,
size_t j )
const
1264 return matrix_(i,j);
1287 template<
typename MT
1290 UpperMatrix<MT,SO,true>::at(
size_t i,
size_t j )
1298 return (*
this)(i,j);
1321 template<
typename MT
1324 UpperMatrix<MT,SO,true>::at(
size_t i,
size_t j )
const
1332 return (*
this)(i,j);
1351 template<
typename MT
1353 inline typename UpperMatrix<MT,SO,true>::ConstPointer
1354 UpperMatrix<MT,SO,true>::data() const noexcept
1356 return matrix_.data();
1371 template<
typename MT
1373 inline typename UpperMatrix<MT,SO,true>::ConstPointer
1374 UpperMatrix<MT,SO,true>::data(
size_t i )
const noexcept
1376 return matrix_.data(i);
1394 template<
typename MT
1400 return Iterator( matrix_, 0UL, i );
1402 return Iterator( matrix_, i, 0UL );
1420 template<
typename MT
1425 return matrix_.begin(i);
1443 template<
typename MT
1448 return matrix_.cbegin(i);
1466 template<
typename MT
1492 template<
typename MT
1497 return matrix_.end(i);
1515 template<
typename MT
1520 return matrix_.cend(i);
1541 template<
typename MT
1543 inline UpperMatrix<MT,SO,true>&
1544 UpperMatrix<MT,SO,true>::operator=(
const ElementType& rhs )
1547 for(
size_t j=0UL; j<
columns(); ++j )
1548 for(
size_t i=0UL; i<=j; ++i )
1552 for(
size_t i=0UL; i<
rows(); ++i )
1553 for(
size_t j=i; j<
columns(); ++j )
1587 template<
typename MT
1589 inline UpperMatrix<MT,SO,true>&
1590 UpperMatrix<MT,SO,true>::operator=( initializer_list< initializer_list<ElementType> > list )
1598 matrix_ = std::move( tmp );
1633 template<
typename MT
1635 template<
typename Other
1637 inline UpperMatrix<MT,SO,true>&
1638 UpperMatrix<MT,SO,true>::operator=(
const Other (&array)[N][N] )
1646 matrix_ = std::move( tmp );
1667 template<
typename MT
1669 inline UpperMatrix<MT,SO,true>&
1670 UpperMatrix<MT,SO,true>::operator=(
const UpperMatrix& rhs )
1672 matrix_ = rhs.matrix_;
1690 template<
typename MT
1692 inline UpperMatrix<MT,SO,true>&
1693 UpperMatrix<MT,SO,true>::operator=( UpperMatrix&& rhs ) noexcept
1695 matrix_ = std::move( rhs.matrix_ );
1719 template<
typename MT
1721 template<
typename MT2
1723 inline DisableIf_< IsComputation<MT2>, UpperMatrix<MT,SO,true>& >
1724 UpperMatrix<MT,SO,true>::operator=(
const Matrix<MT2,SO2>& rhs )
1726 if( !IsUpper<MT2>::value && !
isUpper( ~rhs ) ) {
1754 template<
typename MT
1756 template<
typename MT2
1758 inline EnableIf_< IsComputation<MT2>, UpperMatrix<MT,SO,true>& >
1759 UpperMatrix<MT,SO,true>::operator=(
const Matrix<MT2,SO2>& rhs )
1761 if( !IsSquare<MT2>::value && !
isSquare( ~rhs ) ) {
1765 if( IsUpper<MT2>::value ) {
1775 matrix_ = std::move( tmp );
1800 template<
typename MT
1802 template<
typename MT2
1804 inline DisableIf_< IsComputation<MT2>, UpperMatrix<MT,SO,true>& >
1807 if( !IsUpper<MT2>::value && !
isUpper( ~rhs ) ) {
1835 template<
typename MT
1837 template<
typename MT2
1839 inline EnableIf_< IsComputation<MT2>, UpperMatrix<MT,SO,true>& >
1842 if( !IsSquare<MT2>::value && !
isSquare( ~rhs ) ) {
1846 if( IsUpper<MT2>::value ) {
1850 const ResultType_<MT2> tmp( ~rhs );
1881 template<
typename MT
1883 template<
typename MT2
1885 inline DisableIf_< IsComputation<MT2>, UpperMatrix<MT,SO,true>& >
1888 if( !IsUpper<MT2>::value && !
isUpper( ~rhs ) ) {
1916 template<
typename MT
1918 template<
typename MT2
1920 inline EnableIf_< IsComputation<MT2>, UpperMatrix<MT,SO,true>& >
1923 if( !IsSquare<MT2>::value && !
isSquare( ~rhs ) ) {
1927 if( IsUpper<MT2>::value ) {
1931 const ResultType_<MT2> tmp( ~rhs );
1961 template<
typename MT
1963 template<
typename MT2
1965 inline UpperMatrix<MT,SO,true>&
1968 if( matrix_.rows() != (~rhs).
columns() ) {
1972 MT tmp( matrix_ * ~rhs );
1978 matrix_ = std::move( tmp );
1997 template<
typename MT
1999 template<
typename Other >
2000 inline EnableIf_< IsNumeric<Other>, UpperMatrix<MT,SO,true> >&
2017 template<
typename MT
2019 template<
typename Other >
2020 inline EnableIf_< IsNumeric<Other>, UpperMatrix<MT,SO,true> >&
2046 template<
typename MT
2050 return matrix_.rows();
2062 template<
typename MT
2066 return matrix_.columns();
2083 template<
typename MT
2087 return matrix_.spacing();
2099 template<
typename MT
2103 return matrix_.capacity();
2121 template<
typename MT
2125 return matrix_.capacity(i);
2137 template<
typename MT
2141 return matrix_.nonZeros();
2159 template<
typename MT
2163 return matrix_.nonZeros(i);
2175 template<
typename MT
2182 for(
size_t j=0UL; j<
columns(); ++j )
2183 for(
size_t i=0UL; i<=j; ++i )
2184 clear( matrix_(i,j) );
2187 for(
size_t i=0UL; i<
rows(); ++i )
2188 for(
size_t j=i; j<
columns(); ++j )
2189 clear( matrix_(i,j) );
2209 template<
typename MT
2216 for(
size_t j=0UL; j<=i; ++j )
2217 clear( matrix_(j,i) );
2220 for(
size_t j=i; j<
columns(); ++j )
2221 clear( matrix_(i,j) );
2240 template<
typename MT
2246 if( IsResizable<MT>::value ) {
2293 template<
typename MT
2303 const size_t oldsize( matrix_.rows() );
2305 matrix_.resize( n, n,
true );
2308 const size_t increment( n - oldsize );
2309 submatrix( matrix_, oldsize, 0UL, increment, n-1 ).reset();
2329 template<
typename MT
2331 inline void UpperMatrix<MT,SO,true>::extend(
size_t n,
bool preserve )
2352 template<
typename MT
2354 inline void UpperMatrix<MT,SO,true>::reserve(
size_t elements )
2356 matrix_.reserve( elements );
2369 template<
typename MT
2371 template<
typename Other >
2372 inline UpperMatrix<MT,SO,true>& UpperMatrix<MT,SO,true>::scale(
const Other& scalar )
2374 matrix_.scale( scalar );
2388 template<
typename MT
2394 swap( matrix_, m.matrix_ );
2412 template<
typename MT
2414 inline constexpr
size_t UpperMatrix<MT,SO,true>::maxNonZeros() noexcept
2418 return maxNonZeros( Rows<MT>::value );
2434 template<
typename MT
2436 inline constexpr
size_t UpperMatrix<MT,SO,true>::maxNonZeros(
size_t n ) noexcept
2438 return ( ( n + 1UL ) * n ) / 2UL;
2462 template<
typename MT
2493 template<
typename MT
2495 template<
typename Other >
2496 inline bool UpperMatrix<MT,SO,true>::canAlias(
const Other* alias )
const noexcept
2498 return matrix_.canAlias( alias );
2515 template<
typename MT
2517 template<
typename Other >
2518 inline bool UpperMatrix<MT,SO,true>::isAliased(
const Other* alias )
const noexcept
2520 return matrix_.isAliased( alias );
2536 template<
typename MT
2538 inline bool UpperMatrix<MT,SO,true>::isAligned() const noexcept
2540 return matrix_.isAligned();
2557 template<
typename MT
2559 inline bool UpperMatrix<MT,SO,true>::canSMPAssign() const noexcept
2561 return matrix_.canSMPAssign();
2583 template<
typename MT
2586 UpperMatrix<MT,SO,true>::load(
size_t i,
size_t j )
const noexcept
2588 return matrix_.load( i, j );
2610 template<
typename MT
2615 return matrix_.loada( i, j );
2637 template<
typename MT
2642 return matrix_.loadu( i, j );
2663 template<
typename MT
2665 inline const MT UpperMatrix<MT,SO,true>::construct(
size_t n, TrueType )
2682 template<
typename MT
2684 inline const MT UpperMatrix<MT,SO,true>::construct(
const ElementType& init, FalseType )
2692 for(
size_t j=0UL; j<
columns(); ++j )
2693 for(
size_t i=0UL; i<=j; ++i )
2697 for(
size_t i=0UL; i<
rows(); ++i )
2698 for(
size_t j=i; j<
columns(); ++j )
2719 template<
typename MT
2721 template<
typename MT2
2724 inline const MT UpperMatrix<MT,SO,true>::construct(
const Matrix<MT2,SO2>& m, T )
2728 if( !IsUpper<MT2>::value && !
isUpper( 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
#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
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.
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
bool isUpper(const DenseMatrix< MT, SO > &dm)
Checks if the given dense matrix is an upper triangular matrix.
Definition: DenseMatrix.h:1267
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
Header file for the UpperProxy class.
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 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
Header file for the implementation of the base template of the UpperMatrix.
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.