35 #ifndef _BLAZE_MATH_ADAPTORS_UPPERMATRIX_DENSE_H_ 36 #define _BLAZE_MATH_ADAPTORS_UPPERMATRIX_DENSE_H_ 104 template<
typename MT
106 class UpperMatrix<MT,SO,true>
107 :
public DenseMatrix< UpperMatrix<MT,SO,true>, SO >
111 typedef OppositeType_<MT> OT;
112 typedef TransposeType_<MT> TT;
113 typedef ElementType_<MT> ET;
118 typedef UpperMatrix<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 NewType >
140 typedef UpperMatrix< typename MT::template Rebind<NewType>::Other > Other;
147 template<
size_t NewM
151 typedef UpperMatrix< typename MT::template Resize<NewM,NewN>::Other > Other;
162 typedef std::random_access_iterator_tag IteratorCategory;
163 typedef ElementType_<MT> ValueType;
164 typedef UpperProxy<MT> PointerType;
165 typedef UpperProxy<MT> ReferenceType;
166 typedef ptrdiff_t DifferenceType;
169 typedef IteratorCategory iterator_category;
170 typedef ValueType value_type;
171 typedef PointerType pointer;
172 typedef ReferenceType reference;
173 typedef DifferenceType difference_type;
207 ( SO )?( row_ += inc ):( column_ += inc );
219 ( SO )?( row_ -= dec ):( column_ -= dec );
229 inline Iterator& operator++() noexcept {
230 ( SO )?( ++row_ ):( ++column_ );
240 inline const Iterator operator++(
int ) noexcept {
252 inline Iterator& operator--() noexcept {
253 ( SO )?( --row_ ):( --column_ );
263 inline const Iterator operator--(
int ) noexcept {
276 return ReferenceType( *matrix_, row_, column_ );
285 inline PointerType operator->()
const {
286 return PointerType( *matrix_, row_, column_ );
300 inline SIMDType load()
const {
301 return (*matrix_).load(row_,column_);
315 inline SIMDType
loada()
const {
316 return (*matrix_).loada(row_,column_);
330 inline SIMDType
loadu()
const {
331 return (*matrix_).loadu(row_,column_);
342 return matrix_->begin( column_ ) + row_;
344 return matrix_->begin( row_ ) + column_;
356 return ( SO )?( lhs.row_ == rhs.row_ ):( lhs.column_ == rhs.column_ );
392 return ( SO )?( lhs.row_ != rhs.row_ ):( lhs.column_ != rhs.column_ );
428 return ( SO )?( lhs.row_ < rhs.row_ ):( lhs.column_ < rhs.column_ );
464 return ( SO )?( lhs.row_ > rhs.row_ ):( lhs.column_ > rhs.column_ );
500 return ( SO )?( lhs.row_ <= rhs.row_ ):( lhs.column_ <= rhs.column_ );
536 return ( SO )?( lhs.row_ >= rhs.row_ ):( lhs.column_ >= rhs.column_ );
571 return ( SO )?( row_ - rhs.row_ ):( column_ - rhs.column_ );
584 return Iterator( *it.matrix_, it.row_ + inc, it.column_ );
586 return Iterator( *it.matrix_, it.row_, it.column_ + inc );
599 return Iterator( *it.matrix_, it.row_ + inc, it.column_ );
601 return Iterator( *it.matrix_, it.row_, it.column_ + inc );
614 return Iterator( *it.matrix_, it.row_ - dec, it.column_ );
616 return Iterator( *it.matrix_, it.row_, it.column_ - dec );
631 enum :
bool { simdEnabled = MT::simdEnabled };
634 enum :
bool { smpAssignable = MT::smpAssignable };
640 explicit inline UpperMatrix();
641 template<
typename A1 >
explicit inline UpperMatrix(
const A1& a1 );
642 explicit inline UpperMatrix(
size_t n,
const ElementType& init );
644 explicit inline UpperMatrix( initializer_list< initializer_list<ElementType> > list );
646 template<
typename Other >
647 explicit inline UpperMatrix(
size_t n,
const Other* array );
649 template<
typename Other,
size_t N >
650 explicit inline UpperMatrix(
const Other (&array)[N][N] );
652 explicit inline UpperMatrix( ElementType* ptr,
size_t n );
653 explicit inline UpperMatrix( ElementType* ptr,
size_t n,
size_t nn );
655 template<
typename Deleter >
656 explicit inline UpperMatrix( ElementType* ptr,
size_t n, Deleter d );
658 template<
typename Deleter >
659 explicit inline UpperMatrix( ElementType* ptr,
size_t n,
size_t nn, Deleter d );
661 inline UpperMatrix(
const UpperMatrix& m );
662 inline UpperMatrix( UpperMatrix&& m ) noexcept;
673 inline Reference operator()(
size_t i,
size_t j );
674 inline ConstReference operator()(
size_t i,
size_t j )
const;
675 inline Reference at(
size_t i,
size_t j );
676 inline ConstReference at(
size_t i,
size_t j )
const;
677 inline ConstPointer data () const noexcept;
678 inline ConstPointer data (
size_t i ) const noexcept;
680 inline ConstIterator
begin (
size_t i ) const;
681 inline ConstIterator
cbegin(
size_t i ) const;
683 inline ConstIterator
end (
size_t i ) const;
684 inline ConstIterator
cend (
size_t i ) const;
691 inline UpperMatrix& operator=( const ElementType& rhs );
692 inline UpperMatrix& operator=( initializer_list< initializer_list<ElementType> > list );
694 template< typename Other,
size_t N >
695 inline UpperMatrix& operator=( const Other (&array)[N][N] );
697 inline UpperMatrix& operator=( const UpperMatrix& rhs );
698 inline UpperMatrix& operator=( UpperMatrix&& rhs ) noexcept;
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
DisableIf_< IsComputation<MT2>, UpperMatrix& > operator+=( const Matrix<MT2,SO2>& rhs );
709 template< typename MT2,
bool SO2 >
710 inline
EnableIf_< IsComputation<MT2>, UpperMatrix& > operator+=( const Matrix<MT2,SO2>& rhs );
712 template< typename MT2,
bool SO2 >
713 inline
DisableIf_< IsComputation<MT2>, UpperMatrix& > operator-=( const Matrix<MT2,SO2>& rhs );
715 template< typename MT2,
bool SO2 >
716 inline
EnableIf_< IsComputation<MT2>, UpperMatrix& > operator-=( const Matrix<MT2,SO2>& rhs );
718 template< typename MT2,
bool SO2 >
719 inline UpperMatrix& operator*=( const Matrix<MT2,SO2>& rhs );
721 template< typename Other >
722 inline
EnableIf_< IsNumeric<Other>, UpperMatrix >& operator*=( Other rhs );
724 template< typename Other >
725 inline
EnableIf_< IsNumeric<Other>, UpperMatrix >& operator/=( Other rhs );
732 inline
size_t rows() const noexcept;
733 inline
size_t columns() const noexcept;
734 inline
size_t spacing() const noexcept;
735 inline
size_t capacity() const noexcept;
736 inline
size_t capacity(
size_t i ) const noexcept;
738 inline
size_t nonZeros(
size_t i ) const;
740 inline
void reset(
size_t i );
742 void resize (
size_t n,
bool preserve=true );
743 inline
void extend (
size_t n,
bool preserve=true );
744 inline
void reserve(
size_t elements );
745 inline
void swap( UpperMatrix& m ) noexcept;
747 static inline constexpr
size_t maxNonZeros() noexcept;
748 static inline constexpr
size_t maxNonZeros(
size_t n ) noexcept;
755 template< typename Other > inline UpperMatrix& scale( const Other& scalar );
762 inline
bool isIntact() const noexcept;
769 template< typename Other > inline
bool canAlias ( const Other* alias ) const noexcept;
770 template< typename Other > inline
bool isAliased( const Other* alias ) const noexcept;
772 inline
bool isAligned () const noexcept;
773 inline
bool canSMPAssign() const noexcept;
785 inline const MT construct(
size_t n ,
TrueType );
786 inline const MT construct( const ElementType& value,
FalseType );
788 template< typename MT2,
bool SO2, typename T >
789 inline const MT construct( const Matrix<MT2,SO2>& m, T );
801 template<
bool RF, typename MT2,
bool SO2,
bool DF2 >
802 friend
bool isDefault( const UpperMatrix<MT2,SO2,DF2>& m );
804 template< typename MT2,
bool SO2,
bool DF2 >
805 friend MT2& derestrict( UpperMatrix<MT2,SO2,DF2>& m );
840 template< typename MT
842 inline UpperMatrix<MT,SO,true>::UpperMatrix()
870 template<
typename MT
872 template<
typename A1 >
873 inline UpperMatrix<MT,SO,true>::UpperMatrix(
const A1& a1 )
874 : matrix_( construct( a1, typename IsResizable<MT>::Type() ) )
890 template<
typename MT
892 inline UpperMatrix<MT,SO,true>::UpperMatrix(
size_t n,
const ElementType& init )
893 : matrix_( n, n, ElementType() )
898 for(
size_t j=0UL; j<
columns(); ++j )
899 for(
size_t i=0UL; i<=j; ++i )
903 for(
size_t i=0UL; i<
rows(); ++i )
904 for(
size_t j=i; j<
columns(); ++j )
938 template<
typename MT
940 inline UpperMatrix<MT,SO,true>::UpperMatrix( initializer_list< initializer_list<ElementType> > list )
979 template<
typename MT
981 template<
typename Other >
982 inline UpperMatrix<MT,SO,true>::UpperMatrix(
size_t n,
const Other* array )
983 : matrix_( n, n, array )
1018 template<
typename MT
1020 template<
typename Other
1022 inline UpperMatrix<MT,SO,true>::UpperMatrix(
const Other (&array)[N][N] )
1056 template<
typename MT
1058 inline UpperMatrix<MT,SO,true>::UpperMatrix( ElementType* ptr,
size_t n )
1059 : matrix_( ptr, n, n )
1094 template<
typename MT
1096 inline UpperMatrix<MT,SO,true>::UpperMatrix( ElementType* ptr,
size_t n,
size_t nn )
1097 : matrix_( ptr, n, n, nn )
1130 template<
typename MT
1132 template<
typename Deleter >
1133 inline UpperMatrix<MT,SO,true>::UpperMatrix( ElementType* ptr,
size_t n, Deleter d )
1134 : matrix_( ptr, n, n, d )
1168 template<
typename MT
1170 template<
typename Deleter >
1171 inline UpperMatrix<MT,SO,true>::UpperMatrix( ElementType* ptr,
size_t n,
size_t nn, Deleter d )
1172 : matrix_( ptr, n, n, nn, d )
1190 template<
typename MT
1192 inline UpperMatrix<MT,SO,true>::UpperMatrix(
const UpperMatrix& m )
1193 : matrix_( m.matrix_ )
1208 template<
typename MT
1210 inline UpperMatrix<MT,SO,true>::UpperMatrix( UpperMatrix&& m ) noexcept
1211 : matrix_( std::move( m.matrix_ ) )
1244 template<
typename MT
1247 UpperMatrix<MT,SO,true>::operator()(
size_t i,
size_t j )
1274 template<
typename MT
1277 UpperMatrix<MT,SO,true>::operator()(
size_t i,
size_t j )
const 1282 return matrix_(i,j);
1305 template<
typename MT
1308 UpperMatrix<MT,SO,true>::at(
size_t i,
size_t j )
1316 return (*
this)(i,j);
1339 template<
typename MT
1342 UpperMatrix<MT,SO,true>::at(
size_t i,
size_t j )
const 1350 return (*
this)(i,j);
1369 template<
typename MT
1371 inline typename UpperMatrix<MT,SO,true>::ConstPointer
1372 UpperMatrix<MT,SO,true>::data() const noexcept
1374 return matrix_.data();
1389 template<
typename MT
1391 inline typename UpperMatrix<MT,SO,true>::ConstPointer
1392 UpperMatrix<MT,SO,true>::data(
size_t i )
const noexcept
1394 return matrix_.data(i);
1412 template<
typename MT
1418 return Iterator( matrix_, 0UL, i );
1420 return Iterator( matrix_, i, 0UL );
1438 template<
typename MT
1443 return matrix_.begin(i);
1461 template<
typename MT
1466 return matrix_.cbegin(i);
1484 template<
typename MT
1510 template<
typename MT
1515 return matrix_.end(i);
1533 template<
typename MT
1538 return matrix_.cend(i);
1559 template<
typename MT
1561 inline UpperMatrix<MT,SO,true>&
1562 UpperMatrix<MT,SO,true>::operator=(
const ElementType& rhs )
1565 for(
size_t j=0UL; j<
columns(); ++j )
1566 for(
size_t i=0UL; i<=j; ++i )
1570 for(
size_t i=0UL; i<
rows(); ++i )
1571 for(
size_t j=i; j<
columns(); ++j )
1605 template<
typename MT
1607 inline UpperMatrix<MT,SO,true>&
1608 UpperMatrix<MT,SO,true>::operator=( initializer_list< initializer_list<ElementType> > list )
1616 matrix_ = std::move( tmp );
1651 template<
typename MT
1653 template<
typename Other
1655 inline UpperMatrix<MT,SO,true>&
1656 UpperMatrix<MT,SO,true>::operator=(
const Other (&array)[N][N] )
1664 matrix_ = std::move( tmp );
1685 template<
typename MT
1687 inline UpperMatrix<MT,SO,true>&
1688 UpperMatrix<MT,SO,true>::operator=(
const UpperMatrix& rhs )
1690 matrix_ = rhs.matrix_;
1708 template<
typename MT
1710 inline UpperMatrix<MT,SO,true>&
1711 UpperMatrix<MT,SO,true>::operator=( UpperMatrix&& rhs ) noexcept
1713 matrix_ = std::move( rhs.matrix_ );
1737 template<
typename MT
1739 template<
typename MT2
1741 inline DisableIf_< IsComputation<MT2>, UpperMatrix<MT,SO,true>& >
1742 UpperMatrix<MT,SO,true>::operator=(
const Matrix<MT2,SO2>& rhs )
1744 if( !IsUpper<MT2>::value && !
isUpper( ~rhs ) ) {
1772 template<
typename MT
1774 template<
typename MT2
1776 inline EnableIf_< IsComputation<MT2>, UpperMatrix<MT,SO,true>& >
1777 UpperMatrix<MT,SO,true>::operator=(
const Matrix<MT2,SO2>& rhs )
1779 if( !IsSquare<MT2>::value && !
isSquare( ~rhs ) ) {
1783 if( IsUpper<MT2>::value ) {
1793 matrix_ = std::move( tmp );
1818 template<
typename MT
1820 template<
typename MT2
1822 inline DisableIf_< IsComputation<MT2>, UpperMatrix<MT,SO,true>& >
1825 if( !IsUpper<MT2>::value && !
isUpper( ~rhs ) ) {
1853 template<
typename MT
1855 template<
typename MT2
1857 inline EnableIf_< IsComputation<MT2>, UpperMatrix<MT,SO,true>& >
1860 if( !IsSquare<MT2>::value && !
isSquare( ~rhs ) ) {
1864 if( IsUpper<MT2>::value ) {
1868 const ResultType_<MT2> tmp( ~rhs );
1899 template<
typename MT
1901 template<
typename MT2
1903 inline DisableIf_< IsComputation<MT2>, UpperMatrix<MT,SO,true>& >
1906 if( !IsUpper<MT2>::value && !
isUpper( ~rhs ) ) {
1934 template<
typename MT
1936 template<
typename MT2
1938 inline EnableIf_< IsComputation<MT2>, UpperMatrix<MT,SO,true>& >
1941 if( !IsSquare<MT2>::value && !
isSquare( ~rhs ) ) {
1945 if( IsUpper<MT2>::value ) {
1949 const ResultType_<MT2> tmp( ~rhs );
1979 template<
typename MT
1981 template<
typename MT2
1983 inline UpperMatrix<MT,SO,true>&
1986 if( matrix_.rows() != (~rhs).
columns() ) {
1990 MT tmp( matrix_ * ~rhs );
1996 matrix_ = std::move( tmp );
2015 template<
typename MT
2017 template<
typename Other >
2018 inline EnableIf_< IsNumeric<Other>, UpperMatrix<MT,SO,true> >&
2035 template<
typename MT
2037 template<
typename Other >
2038 inline EnableIf_< IsNumeric<Other>, UpperMatrix<MT,SO,true> >&
2064 template<
typename MT
2068 return matrix_.rows();
2080 template<
typename MT
2084 return matrix_.columns();
2101 template<
typename MT
2105 return matrix_.spacing();
2117 template<
typename MT
2121 return matrix_.capacity();
2139 template<
typename MT
2143 return matrix_.capacity(i);
2155 template<
typename MT
2159 return matrix_.nonZeros();
2177 template<
typename MT
2181 return matrix_.nonZeros(i);
2193 template<
typename MT
2200 for(
size_t j=0UL; j<
columns(); ++j )
2201 for(
size_t i=0UL; i<=j; ++i )
2202 clear( matrix_(i,j) );
2205 for(
size_t i=0UL; i<
rows(); ++i )
2206 for(
size_t j=i; j<
columns(); ++j )
2207 clear( matrix_(i,j) );
2227 template<
typename MT
2234 for(
size_t j=0UL; j<=i; ++j )
2235 clear( matrix_(j,i) );
2238 for(
size_t j=i; j<
columns(); ++j )
2239 clear( matrix_(i,j) );
2258 template<
typename MT
2264 if( IsResizable<MT>::value ) {
2311 template<
typename MT
2321 const size_t oldsize( matrix_.rows() );
2323 matrix_.resize( n, n,
true );
2326 const size_t increment( n - oldsize );
2327 submatrix( matrix_, oldsize, 0UL, increment, n-1 ).reset();
2347 template<
typename MT
2349 inline void UpperMatrix<MT,SO,true>::extend(
size_t n,
bool preserve )
2370 template<
typename MT
2372 inline void UpperMatrix<MT,SO,true>::reserve(
size_t elements )
2374 matrix_.reserve( elements );
2387 template<
typename MT
2393 swap( matrix_, m.matrix_ );
2411 template<
typename MT
2413 inline constexpr
size_t UpperMatrix<MT,SO,true>::maxNonZeros() noexcept
2417 return maxNonZeros( Rows<MT>::value );
2433 template<
typename MT
2435 inline constexpr
size_t UpperMatrix<MT,SO,true>::maxNonZeros(
size_t n ) noexcept
2437 return ( ( n + 1UL ) * n ) / 2UL;
2458 template<
typename MT
2460 template<
typename Other >
2461 inline UpperMatrix<MT,SO,true>& UpperMatrix<MT,SO,true>::scale(
const Other& scalar )
2463 matrix_.scale( scalar );
2488 template<
typename MT
2519 template<
typename MT
2521 template<
typename Other >
2522 inline bool UpperMatrix<MT,SO,true>::canAlias(
const Other* alias )
const noexcept
2524 return matrix_.canAlias( alias );
2541 template<
typename MT
2543 template<
typename Other >
2544 inline bool UpperMatrix<MT,SO,true>::isAliased(
const Other* alias )
const noexcept
2546 return matrix_.isAliased( alias );
2562 template<
typename MT
2564 inline bool UpperMatrix<MT,SO,true>::isAligned() const noexcept
2566 return matrix_.isAligned();
2583 template<
typename MT
2585 inline bool UpperMatrix<MT,SO,true>::canSMPAssign() const noexcept
2587 return matrix_.canSMPAssign();
2609 template<
typename MT
2612 UpperMatrix<MT,SO,true>::load(
size_t i,
size_t j )
const noexcept
2614 return matrix_.load( i, j );
2636 template<
typename MT
2641 return matrix_.loada( i, j );
2663 template<
typename MT
2668 return matrix_.loadu( i, j );
2689 template<
typename MT
2691 inline const MT UpperMatrix<MT,SO,true>::construct(
size_t n, TrueType )
2708 template<
typename MT
2710 inline const MT UpperMatrix<MT,SO,true>::construct(
const ElementType& init, FalseType )
2718 for(
size_t j=0UL; j<
columns(); ++j )
2719 for(
size_t i=0UL; i<=j; ++i )
2723 for(
size_t i=0UL; i<
rows(); ++i )
2724 for(
size_t j=i; j<
columns(); ++j )
2745 template<
typename MT
2747 template<
typename MT2
2750 inline const MT UpperMatrix<MT,SO,true>::construct(
const Matrix<MT2,SO2>& m, T )
2754 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
BLAZE_ALWAYS_INLINE size_t spacing(const DenseMatrix< MT, SO > &dm) noexcept
Returns the spacing between the beginning of two rows/columns.
Definition: DenseMatrix.h:102
Header file for auxiliary alias declarations.
bool isUpper(const DenseMatrix< MT, SO > &dm)
Checks if the given dense matrix is an upper triangular matrix.
Definition: DenseMatrix.h:1321
#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.
BLAZE_ALWAYS_INLINE size_t capacity(const Matrix< MT, SO > &matrix) noexcept
Returns the maximum capacity of the matrix.
Definition: Matrix.h:352
Header file for basic type definitions.
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
constexpr bool operator<(const NegativeAccuracy< A > &lhs, const T &rhs)
Less-than comparison between a NegativeAccuracy object and a floating point value.
Definition: Accuracy.h:329
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:194
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:2935
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:5556
CompressedMatrix< Type, true > This
Type of this CompressedMatrix instance.
Definition: CompressedMatrix.h:2928
#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:390
#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:2931
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:304
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:238
Constraint on the data type.
Constraint on the data type.
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:5635
bool isIntact(const CompressedMatrix< Type, SO > &m)
Returns whether the invariants of the given compressed matrix are intact.
Definition: CompressedMatrix.h:5618
const Element * ConstIterator
Iterator over constant elements.
Definition: CompressedMatrix.h:2939
#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.
constexpr bool operator>(const NegativeAccuracy< A > &lhs, const T &rhs)
Greater-than comparison between a NegativeAccuracy object and a floating point value.
Definition: Accuracy.h:367
constexpr 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:443
constexpr bool operator==(const NegativeAccuracy< A > &lhs, const T &rhs)
Equality comparison between a NegativeAccuracy object and a floating point value. ...
Definition: Accuracy.h:250
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:336
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
DisableIf_< Or< IsComputation< MT >, IsTransExpr< MT >, IsDeclExpr< 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:128
CompressedMatrix< Type, false > TransposeType
Transpose type for expression template evaluations.
Definition: CompressedMatrix.h:2932
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:544
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:260
Type ElementType
Type of the compressed matrix elements.
Definition: CompressedMatrix.h:2933
constexpr bool operator!=(const NegativeAccuracy< A > &lhs, const T &rhs)
Inequality comparison between a NegativeAccuracy object and a floating point value.
Definition: Accuracy.h:290
Header file for the UpperProxy class.
const Type & ConstReference
Reference to a constant matrix value.
Definition: CompressedMatrix.h:2937
DisableIf_< Or< IsComputation< MT >, IsTransExpr< MT >, IsDeclExpr< 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:128
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.
#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:2934
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:2938
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:267
Constraint on the data type.
Constraint on the data type.
constexpr 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:405
#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:320
SparseMatrix< This, true > BaseType
Base type of this CompressedMatrix instance.
Definition: CompressedMatrix.h:2929
#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
This ResultType
Result type for expression template evaluations.
Definition: CompressedMatrix.h:2930
bool isIntact(const DiagonalMatrix< MT, SO, DF > &m)
Returns whether the invariants of the given diagonal matrix are intact.
Definition: DiagonalMatrix.h:249
bool isDefault(const DiagonalProxy< MT > &proxy)
Returns whether the represented element is in default state.
Definition: DiagonalProxy.h:573
MatrixAccessProxy< This > Reference
Reference to a non-constant matrix value.
Definition: CompressedMatrix.h:2936
#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:168
BLAZE_ALWAYS_INLINE bool isSquare(const Matrix< MT, SO > &matrix) noexcept
Checks if the given matrix is a square matrix.
Definition: Matrix.h:677
Header file for the IsResizable type trait.
const DMatDMatMultExpr< T1, T2, false, false, false, false > 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:7505
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.