35 #ifndef _BLAZE_MATH_ADAPTORS_UNIUPPERMATRIX_DENSE_H_ 36 #define _BLAZE_MATH_ADAPTORS_UNIUPPERMATRIX_DENSE_H_ 108 template<
typename MT
110 class UniUpperMatrix<MT,SO,true>
111 :
public DenseMatrix< UniUpperMatrix<MT,SO,true>, SO >
115 typedef OppositeType_<MT> OT;
116 typedef TransposeType_<MT> TT;
117 typedef ElementType_<MT> ET;
122 typedef UniUpperMatrix<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 NewType >
144 typedef UniUpperMatrix< typename MT::template Rebind<NewType>::Other > Other;
151 template<
size_t NewM
155 typedef UniUpperMatrix< typename MT::template Resize<NewM,NewN>::Other > Other;
166 typedef std::random_access_iterator_tag IteratorCategory;
167 typedef ElementType_<MT> ValueType;
168 typedef UniUpperProxy<MT> PointerType;
169 typedef UniUpperProxy<MT> ReferenceType;
170 typedef ptrdiff_t DifferenceType;
173 typedef IteratorCategory iterator_category;
174 typedef ValueType value_type;
175 typedef PointerType pointer;
176 typedef ReferenceType reference;
177 typedef DifferenceType difference_type;
211 ( SO )?( row_ += inc ):( column_ += inc );
223 ( SO )?( row_ -= dec ):( column_ -= dec );
233 inline Iterator& operator++() noexcept {
234 ( SO )?( ++row_ ):( ++column_ );
244 inline const Iterator operator++(
int ) noexcept {
256 inline Iterator& operator--() noexcept {
257 ( SO )?( --row_ ):( --column_ );
267 inline const Iterator operator--(
int ) {
280 return ReferenceType( *matrix_, row_, column_ );
289 inline PointerType operator->()
const {
290 return PointerType( *matrix_, row_, column_ );
304 inline SIMDType load()
const {
305 return (*matrix_).load(row_,column_);
319 inline SIMDType
loada()
const {
320 return (*matrix_).loada(row_,column_);
334 inline SIMDType
loadu()
const {
335 return (*matrix_).loadu(row_,column_);
346 return matrix_->begin( column_ ) + row_;
348 return matrix_->begin( row_ ) + column_;
360 return ( SO )?( lhs.row_ == rhs.row_ ):( lhs.column_ == rhs.column_ );
396 return ( SO )?( lhs.row_ != rhs.row_ ):( lhs.column_ != rhs.column_ );
432 return ( SO )?( lhs.row_ < rhs.row_ ):( lhs.column_ < rhs.column_ );
468 return ( SO )?( lhs.row_ > rhs.row_ ):( lhs.column_ > rhs.column_ );
504 return ( SO )?( lhs.row_ <= rhs.row_ ):( lhs.column_ <= rhs.column_ );
540 return ( SO )?( lhs.row_ >= rhs.row_ ):( lhs.column_ >= rhs.column_ );
575 return ( SO )?( row_ - rhs.row_ ):( column_ - rhs.column_ );
588 return Iterator( *it.matrix_, it.row_ + inc, it.column_ );
590 return Iterator( *it.matrix_, it.row_, it.column_ + inc );
603 return Iterator( *it.matrix_, it.row_ + inc, it.column_ );
605 return Iterator( *it.matrix_, it.row_, it.column_ + inc );
618 return Iterator( *it.matrix_, it.row_ - dec, it.column_ );
620 return Iterator( *it.matrix_, it.row_, it.column_ - dec );
635 enum :
bool { simdEnabled = MT::simdEnabled };
638 enum :
bool { smpAssignable = MT::smpAssignable };
644 explicit inline UniUpperMatrix();
645 template<
typename A1 >
explicit inline UniUpperMatrix(
const A1& a1 );
646 explicit inline UniUpperMatrix(
size_t n,
const ElementType& init );
648 explicit inline UniUpperMatrix( initializer_list< initializer_list<ElementType> > list );
650 template<
typename Other >
651 explicit inline UniUpperMatrix(
size_t n,
const Other* array );
653 template<
typename Other,
size_t N >
654 explicit inline UniUpperMatrix(
const Other (&array)[N][N] );
656 explicit inline UniUpperMatrix( ElementType* ptr,
size_t n );
657 explicit inline UniUpperMatrix( ElementType* ptr,
size_t n,
size_t nn );
659 template<
typename Deleter >
660 explicit inline UniUpperMatrix( ElementType* ptr,
size_t n, Deleter d );
662 template<
typename Deleter >
663 explicit inline UniUpperMatrix( ElementType* ptr,
size_t n,
size_t nn, Deleter d );
665 inline UniUpperMatrix(
const UniUpperMatrix& m );
666 inline UniUpperMatrix( UniUpperMatrix&& m ) noexcept;
677 inline Reference operator()(
size_t i,
size_t j );
678 inline ConstReference operator()(
size_t i,
size_t j )
const;
679 inline Reference at(
size_t i,
size_t j );
680 inline ConstReference at(
size_t i,
size_t j )
const;
681 inline ConstPointer data () const noexcept;
682 inline ConstPointer data (
size_t i ) const noexcept;
684 inline ConstIterator
begin (
size_t i ) const;
685 inline ConstIterator
cbegin(
size_t i ) const;
687 inline ConstIterator
end (
size_t i ) const;
688 inline ConstIterator
cend (
size_t i ) const;
695 inline UniUpperMatrix& operator=( const ElementType& rhs );
696 inline UniUpperMatrix& operator=( initializer_list< initializer_list<ElementType> > list );
698 template< typename Other,
size_t N >
699 inline UniUpperMatrix& operator=( const Other (&array)[N][N] );
701 inline UniUpperMatrix& operator=( const UniUpperMatrix& rhs );
702 inline UniUpperMatrix& operator=( UniUpperMatrix&& rhs ) noexcept;
704 template< typename MT2,
bool SO2 >
705 inline
DisableIf_< IsComputation<MT2>, UniUpperMatrix& > operator=( const Matrix<MT2,SO2>& rhs );
707 template< typename MT2,
bool SO2 >
708 inline
EnableIf_< IsComputation<MT2>, UniUpperMatrix& > operator=( const Matrix<MT2,SO2>& rhs );
710 template< typename MT2,
bool SO2 >
711 inline
DisableIf_< IsComputation<MT2>, UniUpperMatrix& > operator+=( const Matrix<MT2,SO2>& rhs );
713 template< typename MT2,
bool SO2 >
714 inline
EnableIf_< IsComputation<MT2>, UniUpperMatrix& > operator+=( const Matrix<MT2,SO2>& rhs );
716 template< typename MT2,
bool SO2 >
717 inline
DisableIf_< IsComputation<MT2>, UniUpperMatrix& > operator-=( const Matrix<MT2,SO2>& rhs );
719 template< typename MT2,
bool SO2 >
720 inline
EnableIf_< IsComputation<MT2>, UniUpperMatrix& > operator-=( const Matrix<MT2,SO2>& rhs );
722 template< typename MT2,
bool SO2 >
723 inline UniUpperMatrix& operator*=( const Matrix<MT2,SO2>& rhs );
730 inline
size_t rows() const noexcept;
731 inline
size_t columns() const noexcept;
732 inline
size_t spacing() const noexcept;
733 inline
size_t capacity() const noexcept;
734 inline
size_t capacity(
size_t i ) const noexcept;
736 inline
size_t nonZeros(
size_t i ) const;
738 inline
void reset(
size_t i );
740 void resize (
size_t n,
bool preserve=true );
741 inline
void extend (
size_t n,
bool preserve=true );
742 inline
void reserve(
size_t elements );
743 inline
void swap( UniUpperMatrix& m ) noexcept;
745 static inline constexpr
size_t maxNonZeros() noexcept;
746 static inline constexpr
size_t maxNonZeros(
size_t n ) noexcept;
753 inline
bool isIntact() const noexcept;
760 template< typename Other > inline
bool canAlias ( const Other* alias ) const noexcept;
761 template< typename Other > inline
bool isAliased( const Other* alias ) const noexcept;
763 inline
bool isAligned () const noexcept;
764 inline
bool canSMPAssign() const noexcept;
776 inline const MT construct(
size_t n ,
TrueType );
777 inline const MT construct( const ElementType& value,
FalseType );
779 template< typename MT2,
bool SO2, typename T >
780 inline const MT construct( const Matrix<MT2,SO2>& m, T );
792 template< typename MT2,
bool SO2,
bool DF2 >
793 friend MT2& derestrict( UniUpperMatrix<MT2,SO2,DF2>& m );
829 template< typename MT
831 inline UniUpperMatrix<MT,SO,true>::UniUpperMatrix()
834 for(
size_t i=0UL; i<Rows<MT>::value; ++i )
862 template<
typename MT
864 template<
typename A1 >
865 inline UniUpperMatrix<MT,SO,true>::UniUpperMatrix(
const A1& a1 )
866 : matrix_( construct( a1, typename IsResizable<MT>::Type() ) )
882 template<
typename MT
884 inline UniUpperMatrix<MT,SO,true>::UniUpperMatrix(
size_t n,
const ElementType& init )
885 : matrix_( n, n, ElementType() )
890 for(
size_t j=0UL; j<
columns(); ++j ) {
891 for(
size_t i=0UL; i<j; ++i )
897 for(
size_t i=0UL; i<
rows(); ++i ) {
899 for(
size_t j=i+1UL; j<
columns(); ++j )
934 template<
typename MT
936 inline UniUpperMatrix<MT,SO,true>::UniUpperMatrix( initializer_list< initializer_list<ElementType> > list )
975 template<
typename MT
977 template<
typename Other >
978 inline UniUpperMatrix<MT,SO,true>::UniUpperMatrix(
size_t n,
const Other* array )
979 : matrix_( n, n, array )
1014 template<
typename MT
1016 template<
typename Other
1018 inline UniUpperMatrix<MT,SO,true>::UniUpperMatrix(
const Other (&array)[N][N] )
1052 template<
typename MT
1054 inline UniUpperMatrix<MT,SO,true>::UniUpperMatrix( ElementType* ptr,
size_t n )
1055 : matrix_( ptr, n, n )
1090 template<
typename MT
1092 inline UniUpperMatrix<MT,SO,true>::UniUpperMatrix( ElementType* ptr,
size_t n,
size_t nn )
1093 : matrix_( ptr, n, n, nn )
1126 template<
typename MT
1128 template<
typename Deleter >
1129 inline UniUpperMatrix<MT,SO,true>::UniUpperMatrix( ElementType* ptr,
size_t n, Deleter d )
1130 : matrix_( ptr, n, n, d )
1164 template<
typename MT
1166 template<
typename Deleter >
1167 inline UniUpperMatrix<MT,SO,true>::UniUpperMatrix( ElementType* ptr,
size_t n,
size_t nn, Deleter d )
1168 : matrix_( ptr, n, n, nn, d )
1186 template<
typename MT
1188 inline UniUpperMatrix<MT,SO,true>::UniUpperMatrix(
const UniUpperMatrix& m )
1189 : matrix_( m.matrix_ )
1204 template<
typename MT
1206 inline UniUpperMatrix<MT,SO,true>::UniUpperMatrix( UniUpperMatrix&& m ) noexcept
1207 : matrix_( std::move( m.matrix_ ) )
1240 template<
typename MT
1243 UniUpperMatrix<MT,SO,true>::operator()(
size_t i,
size_t j )
1270 template<
typename MT
1273 UniUpperMatrix<MT,SO,true>::operator()(
size_t i,
size_t j )
const 1278 return matrix_(i,j);
1301 template<
typename MT
1304 UniUpperMatrix<MT,SO,true>::at(
size_t i,
size_t j )
1312 return (*
this)(i,j);
1335 template<
typename MT
1338 UniUpperMatrix<MT,SO,true>::at(
size_t i,
size_t j )
const 1346 return (*
this)(i,j);
1365 template<
typename MT
1367 inline typename UniUpperMatrix<MT,SO,true>::ConstPointer
1368 UniUpperMatrix<MT,SO,true>::data() const noexcept
1370 return matrix_.data();
1385 template<
typename MT
1387 inline typename UniUpperMatrix<MT,SO,true>::ConstPointer
1388 UniUpperMatrix<MT,SO,true>::data(
size_t i )
const noexcept
1390 return matrix_.data(i);
1408 template<
typename MT
1414 return Iterator( matrix_, 0UL, i );
1416 return Iterator( matrix_, i, 0UL );
1434 template<
typename MT
1439 return matrix_.begin(i);
1457 template<
typename MT
1462 return matrix_.cbegin(i);
1480 template<
typename MT
1506 template<
typename MT
1511 return matrix_.end(i);
1529 template<
typename MT
1534 return matrix_.cend(i);
1555 template<
typename MT
1557 inline UniUpperMatrix<MT,SO,true>&
1558 UniUpperMatrix<MT,SO,true>::operator=(
const ElementType& rhs )
1561 for(
size_t j=1UL; j<
columns(); ++j )
1562 for(
size_t i=0UL; i<j; ++i )
1566 for(
size_t i=0UL; i<
rows(); ++i )
1567 for(
size_t j=i+1UL; j<
columns(); ++j )
1601 template<
typename MT
1603 inline UniUpperMatrix<MT,SO,true>&
1604 UniUpperMatrix<MT,SO,true>::operator=( initializer_list< initializer_list<ElementType> > list )
1612 matrix_ = std::move( tmp );
1647 template<
typename MT
1649 template<
typename Other
1651 inline UniUpperMatrix<MT,SO,true>&
1652 UniUpperMatrix<MT,SO,true>::operator=(
const Other (&array)[N][N] )
1660 matrix_ = std::move( tmp );
1681 template<
typename MT
1683 inline UniUpperMatrix<MT,SO,true>&
1684 UniUpperMatrix<MT,SO,true>::operator=(
const UniUpperMatrix& rhs )
1686 matrix_ = rhs.matrix_;
1704 template<
typename MT
1706 inline UniUpperMatrix<MT,SO,true>&
1707 UniUpperMatrix<MT,SO,true>::operator=( UniUpperMatrix&& rhs ) noexcept
1709 matrix_ = std::move( rhs.matrix_ );
1733 template<
typename MT
1735 template<
typename MT2
1737 inline DisableIf_< IsComputation<MT2>, UniUpperMatrix<MT,SO,true>& >
1738 UniUpperMatrix<MT,SO,true>::operator=(
const Matrix<MT2,SO2>& rhs )
1740 if( IsStrictlyTriangular<MT2>::value || ( !IsUniUpper<MT2>::value && !
isUniUpper( ~rhs ) ) ) {
1768 template<
typename MT
1770 template<
typename MT2
1772 inline EnableIf_< IsComputation<MT2>, UniUpperMatrix<MT,SO,true>& >
1773 UniUpperMatrix<MT,SO,true>::operator=(
const Matrix<MT2,SO2>& rhs )
1775 if( IsStrictlyTriangular<MT2>::value || ( !IsSquare<MT2>::value && !
isSquare( ~rhs ) ) ) {
1779 if( IsUniUpper<MT2>::value ) {
1789 matrix_ = std::move( tmp );
1814 template<
typename MT
1816 template<
typename MT2
1818 inline DisableIf_< IsComputation<MT2>, UniUpperMatrix<MT,SO,true>& >
1821 if( IsLower<MT2>::value || IsUniTriangular<MT2>::value ||
1850 template<
typename MT
1852 template<
typename MT2
1854 inline EnableIf_< IsComputation<MT2>, UniUpperMatrix<MT,SO,true>& >
1857 if( IsLower<MT2>::value || IsUniTriangular<MT2>::value ||
1858 ( !IsSquare<MT2>::value && !
isSquare( ~rhs ) ) ) {
1862 if( IsStrictlyUpper<MT2>::value ) {
1866 const ResultType_<MT2> tmp( ~rhs );
1897 template<
typename MT
1899 template<
typename MT2
1901 inline DisableIf_< IsComputation<MT2>, UniUpperMatrix<MT,SO,true>& >
1904 if( IsLower<MT2>::value || IsUniTriangular<MT2>::value ||
1933 template<
typename MT
1935 template<
typename MT2
1937 inline EnableIf_< IsComputation<MT2>, UniUpperMatrix<MT,SO,true>& >
1940 if( IsLower<MT2>::value || IsUniTriangular<MT2>::value ||
1941 ( !IsSquare<MT2>::value && !
isSquare( ~rhs ) ) ) {
1945 if( IsStrictlyUpper<MT2>::value ) {
1949 const ResultType_<MT2> tmp( ~rhs );
1979 template<
typename MT
1981 template<
typename MT2
1983 inline UniUpperMatrix<MT,SO,true>&
1986 if( matrix_.rows() != (~rhs).
columns() ) {
1990 MT tmp( matrix_ * ~rhs );
1996 matrix_ = std::move( tmp );
2021 template<
typename MT
2025 return matrix_.rows();
2037 template<
typename MT
2041 return matrix_.columns();
2058 template<
typename MT
2062 return matrix_.spacing();
2074 template<
typename MT
2078 return matrix_.capacity();
2096 template<
typename MT
2100 return matrix_.capacity(i);
2112 template<
typename MT
2116 return matrix_.nonZeros();
2134 template<
typename MT
2138 return matrix_.nonZeros(i);
2150 template<
typename MT
2157 for(
size_t j=1UL; j<
columns(); ++j )
2158 for(
size_t i=0UL; i<j; ++i )
2159 clear( matrix_(i,j) );
2162 for(
size_t i=0UL; i<
rows(); ++i )
2163 for(
size_t j=i+1UL; j<
columns(); ++j )
2164 clear( matrix_(i,j) );
2184 template<
typename MT
2191 for(
size_t j=0UL; j<i; ++j )
2192 clear( matrix_(j,i) );
2195 for(
size_t j=i+1UL; j<
columns(); ++j )
2196 clear( matrix_(i,j) );
2215 template<
typename MT
2221 if( IsResizable<MT>::value ) {
2268 template<
typename MT
2278 const size_t oldsize( matrix_.rows() );
2280 matrix_.resize( n, n,
true );
2284 const size_t increment( n - oldsize );
2285 submatrix( matrix_, oldsize, 0UL, increment, n-1UL ).reset();
2287 for(
size_t i=oldsize; i<n; ++i )
2308 template<
typename MT
2310 inline void UniUpperMatrix<MT,SO,true>::extend(
size_t n,
bool preserve )
2331 template<
typename MT
2333 inline void UniUpperMatrix<MT,SO,true>::reserve(
size_t elements )
2335 matrix_.reserve( elements );
2348 template<
typename MT
2354 swap( matrix_, m.matrix_ );
2372 template<
typename MT
2374 inline constexpr
size_t UniUpperMatrix<MT,SO,true>::maxNonZeros() noexcept
2378 return maxNonZeros( Rows<MT>::value );
2394 template<
typename MT
2396 inline constexpr
size_t UniUpperMatrix<MT,SO,true>::maxNonZeros(
size_t n ) noexcept
2398 return ( ( n + 1UL ) * n ) / 2UL;
2422 template<
typename MT
2453 template<
typename MT
2455 template<
typename Other >
2456 inline bool UniUpperMatrix<MT,SO,true>::canAlias(
const Other* alias )
const noexcept
2458 return matrix_.canAlias( alias );
2475 template<
typename MT
2477 template<
typename Other >
2478 inline bool UniUpperMatrix<MT,SO,true>::isAliased(
const Other* alias )
const noexcept
2480 return matrix_.isAliased( alias );
2496 template<
typename MT
2498 inline bool UniUpperMatrix<MT,SO,true>::isAligned() const noexcept
2500 return matrix_.isAligned();
2517 template<
typename MT
2519 inline bool UniUpperMatrix<MT,SO,true>::canSMPAssign() const noexcept
2521 return matrix_.canSMPAssign();
2543 template<
typename MT
2546 UniUpperMatrix<MT,SO,true>::load(
size_t i,
size_t j )
const noexcept
2548 return matrix_.load( i, j );
2570 template<
typename MT
2575 return matrix_.loada( i, j );
2597 template<
typename MT
2602 return matrix_.loadu( i, j );
2623 template<
typename MT
2625 inline const MT UniUpperMatrix<MT,SO,true>::construct(
size_t n, TrueType )
2631 for(
size_t i=0UL; i<n; ++i )
2647 template<
typename MT
2649 inline const MT UniUpperMatrix<MT,SO,true>::construct(
const ElementType& init, FalseType )
2657 for(
size_t j=0UL; j<
columns(); ++j ) {
2658 for(
size_t i=0UL; i<j; ++i )
2664 for(
size_t i=0UL; i<
rows(); ++i ) {
2666 for(
size_t j=i+1UL; j<
columns(); ++j )
2688 template<
typename MT
2690 template<
typename MT2
2693 inline const MT UniUpperMatrix<MT,SO,true>::construct(
const Matrix<MT2,SO2>& m, T )
2697 if( IsStrictlyTriangular<MT2>::value || ( !IsUniUpper<MT2>::value && !
isUniUpper( 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.
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.
Header file for the IsUniUpper type trait.
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
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 IsStrictlyUpper type trait.
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.
Header file for the IsLower type trait.
Header file for the UniUpperProxy class.
BLAZE_ALWAYS_INLINE size_t columns(const Matrix< MT, SO > &matrix) noexcept
Returns the current number of columns of the matrix.
Definition: Matrix.h: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
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: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
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 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
bool isStrictlyUpper(const DenseMatrix< MT, SO > &dm)
Checks if the given dense matrix is a strictly upper triangular matrix.
Definition: DenseMatrix.h:1493
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_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: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 isUniUpper(const DenseMatrix< MT, SO > &dm)
Checks if the given dense matrix is an upper unitriangular matrix.
Definition: DenseMatrix.h:1406
bool isIntact(const DiagonalMatrix< MT, SO, DF > &m)
Returns whether the invariants of the given diagonal matrix are intact.
Definition: DiagonalMatrix.h:249
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
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: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 implementation of the base template of the UniUpperMatrix.
Header file for the TrueType type/value trait base class.