35 #ifndef _BLAZE_MATH_ADAPTORS_DIAGONALMATRIX_DENSE_H_ 36 #define _BLAZE_MATH_ADAPTORS_DIAGONALMATRIX_DENSE_H_ 103 template<
typename MT
105 class DiagonalMatrix<MT,SO,true>
106 :
public DenseMatrix< DiagonalMatrix<MT,SO,true>, SO >
110 typedef OppositeType_<MT> OT;
111 typedef TransposeType_<MT> TT;
112 typedef ElementType_<MT> ET;
117 typedef DiagonalMatrix<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 NewType >
139 typedef DiagonalMatrix< typename MT::template Rebind<NewType>::Other > Other;
146 template<
size_t NewM
150 typedef DiagonalMatrix< typename MT::template Resize<NewM,NewN>::Other > Other;
161 typedef std::random_access_iterator_tag IteratorCategory;
162 typedef ElementType_<MT> ValueType;
163 typedef DiagonalProxy<MT> PointerType;
164 typedef DiagonalProxy<MT> ReferenceType;
165 typedef ptrdiff_t DifferenceType;
168 typedef IteratorCategory iterator_category;
169 typedef ValueType value_type;
170 typedef PointerType pointer;
171 typedef ReferenceType reference;
172 typedef DifferenceType difference_type;
206 ( SO )?( row_ += inc ):( column_ += inc );
218 ( SO )?( row_ -= dec ):( column_ -= dec );
228 inline Iterator& operator++() noexcept {
229 ( SO )?( ++row_ ):( ++column_ );
239 inline const Iterator operator++(
int ) noexcept {
251 inline Iterator& operator--() noexcept {
252 ( SO )?( --row_ ):( --column_ );
262 inline const Iterator operator--(
int ) noexcept {
275 return ReferenceType( *matrix_, row_, column_ );
284 inline PointerType operator->()
const {
285 return PointerType( *matrix_, row_, column_ );
299 inline SIMDType load()
const {
300 return (*matrix_).load(row_,column_);
314 inline SIMDType
loada()
const {
315 return (*matrix_).loada(row_,column_);
329 inline SIMDType
loadu()
const {
330 return (*matrix_).loadu(row_,column_);
341 return matrix_->begin( column_ ) + row_;
343 return matrix_->begin( row_ ) + column_;
355 return ( SO )?( lhs.row_ == rhs.row_ ):( lhs.column_ == rhs.column_ );
391 return ( SO )?( lhs.row_ != rhs.row_ ):( lhs.column_ != rhs.column_ );
427 return ( SO )?( lhs.row_ < rhs.row_ ):( lhs.column_ < rhs.column_ );
463 return ( SO )?( lhs.row_ > rhs.row_ ):( lhs.column_ > rhs.column_ );
499 return ( SO )?( lhs.row_ <= rhs.row_ ):( lhs.column_ <= rhs.column_ );
535 return ( SO )?( lhs.row_ >= rhs.row_ ):( lhs.column_ >= rhs.column_ );
570 return ( SO )?( row_ - rhs.row_ ):( column_ - rhs.column_ );
583 return Iterator( *it.matrix_, it.row_ + inc, it.column_ );
585 return Iterator( *it.matrix_, it.row_, it.column_ + inc );
598 return Iterator( *it.matrix_, it.row_ + inc, it.column_ );
600 return Iterator( *it.matrix_, it.row_, it.column_ + inc );
613 return Iterator( *it.matrix_, it.row_ - dec, it.column_ );
615 return Iterator( *it.matrix_, it.row_, it.column_ - dec );
630 enum :
bool { simdEnabled = MT::simdEnabled };
633 enum :
bool { smpAssignable = MT::smpAssignable };
639 explicit inline DiagonalMatrix();
640 template<
typename A1 >
explicit inline DiagonalMatrix(
const A1& a1 );
641 explicit inline DiagonalMatrix(
size_t n,
const ElementType& init );
643 explicit inline DiagonalMatrix( initializer_list< initializer_list<ElementType> > list );
645 template<
typename Other >
646 explicit inline DiagonalMatrix(
size_t n,
const Other* array );
648 template<
typename Other,
size_t N >
649 explicit inline DiagonalMatrix(
const Other (&array)[N][N] );
651 explicit inline DiagonalMatrix( ElementType* ptr,
size_t n );
652 explicit inline DiagonalMatrix( ElementType* ptr,
size_t n,
size_t nn );
654 template<
typename Deleter >
655 explicit inline DiagonalMatrix( ElementType* ptr,
size_t n, Deleter d );
657 template<
typename Deleter >
658 explicit inline DiagonalMatrix( ElementType* ptr,
size_t n,
size_t nn, Deleter d );
660 inline DiagonalMatrix(
const DiagonalMatrix& m );
661 inline DiagonalMatrix( DiagonalMatrix&& m ) noexcept;
672 inline Reference operator()(
size_t i,
size_t j );
673 inline ConstReference operator()(
size_t i,
size_t j )
const;
674 inline Reference at(
size_t i,
size_t j );
675 inline ConstReference at(
size_t i,
size_t j )
const;
676 inline ConstPointer data () const noexcept;
677 inline ConstPointer data (
size_t i ) const noexcept;
679 inline ConstIterator
begin (
size_t i ) const;
680 inline ConstIterator
cbegin(
size_t i ) const;
682 inline ConstIterator
end (
size_t i ) const;
683 inline ConstIterator
cend (
size_t i ) const;
690 inline DiagonalMatrix& operator=( const ElementType& rhs );
691 inline DiagonalMatrix& operator=( initializer_list< initializer_list<ElementType> > list );
693 template< typename Other,
size_t N >
694 inline DiagonalMatrix& operator=( const Other (&array)[N][N] );
696 inline DiagonalMatrix& operator=( const DiagonalMatrix& rhs );
697 inline DiagonalMatrix& operator=( DiagonalMatrix&& rhs ) noexcept;
699 template< typename MT2,
bool SO2 >
700 inline
DisableIf_< IsComputation<MT2>, DiagonalMatrix& > operator=( const Matrix<MT2,SO2>& rhs );
702 template< typename MT2,
bool SO2 >
703 inline
EnableIf_< IsComputation<MT2>, DiagonalMatrix& > operator=( const Matrix<MT2,SO2>& rhs );
705 template< typename MT2,
bool SO2 >
706 inline
DisableIf_< IsComputation<MT2>, DiagonalMatrix& > operator+=( const Matrix<MT2,SO2>& rhs );
708 template< typename MT2,
bool SO2 >
709 inline
EnableIf_< IsComputation<MT2>, DiagonalMatrix& > operator+=( const Matrix<MT2,SO2>& rhs );
711 template< typename MT2,
bool SO2 >
712 inline
DisableIf_< IsComputation<MT2>, DiagonalMatrix& > operator-=( const Matrix<MT2,SO2>& rhs );
714 template< typename MT2,
bool SO2 >
715 inline
EnableIf_< IsComputation<MT2>, DiagonalMatrix& > operator-=( const Matrix<MT2,SO2>& rhs );
717 template< typename MT2,
bool SO2 >
718 inline DiagonalMatrix& operator*=( const Matrix<MT2,SO2>& rhs );
720 template< typename Other >
721 inline
EnableIf_< IsNumeric<Other>, DiagonalMatrix >& operator*=( Other rhs );
723 template< typename Other >
724 inline
EnableIf_< IsNumeric<Other>, DiagonalMatrix >& operator/=( Other rhs );
731 inline
size_t rows() const noexcept;
732 inline
size_t columns() const noexcept;
733 inline
size_t spacing() const noexcept;
734 inline
size_t capacity() const noexcept;
735 inline
size_t capacity(
size_t i ) const noexcept;
737 inline
size_t nonZeros(
size_t i ) const;
739 inline
void reset(
size_t i );
741 void resize (
size_t n,
bool preserve=true );
742 inline
void extend (
size_t n,
bool preserve=true );
743 inline
void reserve(
size_t elements );
744 inline
void swap( DiagonalMatrix& m ) noexcept;
751 template< typename Other > inline DiagonalMatrix& scale( const Other& scalar );
758 inline
bool isIntact() const noexcept;
765 template< typename Other > inline
bool canAlias ( const Other* alias ) const noexcept;
766 template< typename Other > inline
bool isAliased( const Other* alias ) const noexcept;
768 inline
bool isAligned () const noexcept;
769 inline
bool canSMPAssign() const noexcept;
781 inline const MT construct(
size_t n ,
TrueType );
782 inline const MT construct( const ElementType& value,
FalseType );
784 template< typename MT2,
bool SO2, typename T >
785 inline const MT construct( const Matrix<MT2,SO2>& m, T );
797 template<
bool RF, typename MT2,
bool SO2,
bool DF2 >
798 friend
bool isDefault( const DiagonalMatrix<MT2,SO2,DF2>& m );
800 template< typename MT2,
bool SO2,
bool DF2 >
801 friend MT2& derestrict( DiagonalMatrix<MT2,SO2,DF2>& m );
836 template< typename MT
838 inline DiagonalMatrix<MT,SO,true>::DiagonalMatrix()
866 template<
typename MT
868 template<
typename A1 >
869 inline DiagonalMatrix<MT,SO,true>::DiagonalMatrix(
const A1& a1 )
870 : matrix_( construct( a1, typename IsResizable<MT>::Type() ) )
886 template<
typename MT
888 inline DiagonalMatrix<MT,SO,true>::DiagonalMatrix(
size_t n,
const ElementType& init )
889 : matrix_( n, n, ElementType() )
893 for(
size_t i=0UL; i<n; ++i )
926 template<
typename MT
928 inline DiagonalMatrix<MT,SO,true>::DiagonalMatrix( initializer_list< initializer_list<ElementType> > list )
967 template<
typename MT
969 template<
typename Other >
970 inline DiagonalMatrix<MT,SO,true>::DiagonalMatrix(
size_t n,
const Other* array )
971 : matrix_( n, n, array )
1006 template<
typename MT
1008 template<
typename Other
1010 inline DiagonalMatrix<MT,SO,true>::DiagonalMatrix(
const Other (&array)[N][N] )
1044 template<
typename MT
1046 inline DiagonalMatrix<MT,SO,true>::DiagonalMatrix( ElementType* ptr,
size_t n )
1047 : matrix_( ptr, n, n )
1082 template<
typename MT
1084 inline DiagonalMatrix<MT,SO,true>::DiagonalMatrix( ElementType* ptr,
size_t n,
size_t nn )
1085 : matrix_( ptr, n, n, nn )
1118 template<
typename MT
1120 template<
typename Deleter >
1121 inline DiagonalMatrix<MT,SO,true>::DiagonalMatrix( ElementType* ptr,
size_t n, Deleter d )
1122 : matrix_( ptr, n, n, d )
1156 template<
typename MT
1158 template<
typename Deleter >
1159 inline DiagonalMatrix<MT,SO,true>::DiagonalMatrix( ElementType* ptr,
size_t n,
size_t nn, Deleter d )
1160 : matrix_( ptr, n, n, nn, d )
1178 template<
typename MT
1180 inline DiagonalMatrix<MT,SO,true>::DiagonalMatrix(
const DiagonalMatrix& m )
1181 : matrix_( m.matrix_ )
1196 template<
typename MT
1198 inline DiagonalMatrix<MT,SO,true>::DiagonalMatrix( DiagonalMatrix&& m ) noexcept
1199 : matrix_( std::move( m.matrix_ ) )
1232 template<
typename MT
1235 DiagonalMatrix<MT,SO,true>::operator()(
size_t i,
size_t j )
1262 template<
typename MT
1265 DiagonalMatrix<MT,SO,true>::operator()(
size_t i,
size_t j )
const 1270 return matrix_(i,j);
1293 template<
typename MT
1296 DiagonalMatrix<MT,SO,true>::at(
size_t i,
size_t j )
1304 return (*
this)(i,j);
1327 template<
typename MT
1330 DiagonalMatrix<MT,SO,true>::at(
size_t i,
size_t j )
const 1338 return (*
this)(i,j);
1357 template<
typename MT
1359 inline typename DiagonalMatrix<MT,SO,true>::ConstPointer
1360 DiagonalMatrix<MT,SO,true>::data() const noexcept
1362 return matrix_.data();
1377 template<
typename MT
1379 inline typename DiagonalMatrix<MT,SO,true>::ConstPointer
1380 DiagonalMatrix<MT,SO,true>::data(
size_t i )
const noexcept
1382 return matrix_.data(i);
1400 template<
typename MT
1406 return Iterator( matrix_, 0UL, i );
1408 return Iterator( matrix_, i, 0UL );
1426 template<
typename MT
1431 return matrix_.begin(i);
1449 template<
typename MT
1454 return matrix_.cbegin(i);
1472 template<
typename MT
1498 template<
typename MT
1503 return matrix_.end(i);
1521 template<
typename MT
1526 return matrix_.cend(i);
1547 template<
typename MT
1549 inline DiagonalMatrix<MT,SO,true>&
1550 DiagonalMatrix<MT,SO,true>::operator=(
const ElementType& rhs )
1553 for(
size_t j=0UL; j<
columns(); ++j )
1557 for(
size_t i=0UL; i<
rows(); ++i )
1591 template<
typename MT
1593 inline DiagonalMatrix<MT,SO,true>&
1594 DiagonalMatrix<MT,SO,true>::operator=( initializer_list< initializer_list<ElementType> > list )
1602 matrix_ = std::move( tmp );
1637 template<
typename MT
1639 template<
typename Other
1641 inline DiagonalMatrix<MT,SO,true>&
1642 DiagonalMatrix<MT,SO,true>::operator=(
const Other (&array)[N][N] )
1650 matrix_ = std::move( tmp );
1671 template<
typename MT
1673 inline DiagonalMatrix<MT,SO,true>&
1674 DiagonalMatrix<MT,SO,true>::operator=(
const DiagonalMatrix& rhs )
1676 matrix_ = rhs.matrix_;
1694 template<
typename MT
1696 inline DiagonalMatrix<MT,SO,true>&
1697 DiagonalMatrix<MT,SO,true>::operator=( DiagonalMatrix&& rhs ) noexcept
1699 matrix_ = std::move( rhs.matrix_ );
1723 template<
typename MT
1725 template<
typename MT2
1727 inline DisableIf_< IsComputation<MT2>, DiagonalMatrix<MT,SO,true>& >
1728 DiagonalMatrix<MT,SO,true>::operator=(
const Matrix<MT2,SO2>& rhs )
1730 if( !IsDiagonal<MT2>::value && !
isDiagonal( ~rhs ) ) {
1758 template<
typename MT
1760 template<
typename MT2
1762 inline EnableIf_< IsComputation<MT2>, DiagonalMatrix<MT,SO,true>& >
1763 DiagonalMatrix<MT,SO,true>::operator=(
const Matrix<MT2,SO2>& rhs )
1765 if( !IsSquare<MT2>::value && !
isSquare( ~rhs ) ) {
1769 if( IsDiagonal<MT2>::value ) {
1779 matrix_ = std::move( tmp );
1804 template<
typename MT
1806 template<
typename MT2
1808 inline DisableIf_< IsComputation<MT2>, DiagonalMatrix<MT,SO,true>& >
1811 if( !IsDiagonal<MT2>::value && !
isDiagonal( ~rhs ) ) {
1839 template<
typename MT
1841 template<
typename MT2
1843 inline EnableIf_< IsComputation<MT2>, DiagonalMatrix<MT,SO,true>& >
1846 if( !IsSquare<MT2>::value && !
isSquare( ~rhs ) ) {
1850 if( IsDiagonal<MT2>::value ) {
1854 const ResultType_<MT2> tmp( ~rhs );
1885 template<
typename MT
1887 template<
typename MT2
1889 inline DisableIf_< IsComputation<MT2>, DiagonalMatrix<MT,SO,true>& >
1892 if( !IsDiagonal<MT2>::value && !
isDiagonal( ~rhs ) ) {
1920 template<
typename MT
1922 template<
typename MT2
1924 inline EnableIf_< IsComputation<MT2>, DiagonalMatrix<MT,SO,true>& >
1927 if( !IsSquare<MT2>::value && !
isSquare( ~rhs ) ) {
1931 if( IsDiagonal<MT2>::value ) {
1935 const ResultType_<MT2> tmp( ~rhs );
1965 template<
typename MT
1967 template<
typename MT2
1969 inline DiagonalMatrix<MT,SO,true>&
1972 if( matrix_.rows() != (~rhs).
columns() ) {
1976 MT tmp( matrix_ * ~rhs );
1982 matrix_ = std::move( tmp );
2001 template<
typename MT
2003 template<
typename Other >
2004 inline EnableIf_< IsNumeric<Other>, DiagonalMatrix<MT,SO,true> >&
2021 template<
typename MT
2023 template<
typename Other >
2024 inline EnableIf_< IsNumeric<Other>, DiagonalMatrix<MT,SO,true> >&
2050 template<
typename MT
2054 return matrix_.rows();
2066 template<
typename MT
2070 return matrix_.columns();
2087 template<
typename MT
2091 return matrix_.spacing();
2103 template<
typename MT
2107 return matrix_.capacity();
2125 template<
typename MT
2129 return matrix_.capacity(i);
2141 template<
typename MT
2145 return matrix_.nonZeros();
2163 template<
typename MT
2167 return matrix_.nonZeros(i);
2179 template<
typename MT
2202 template<
typename MT
2224 template<
typename MT
2272 template<
typename MT
2282 const size_t oldsize( matrix_.rows() );
2284 matrix_.resize( n, n,
true );
2287 const size_t increment( n - oldsize );
2288 submatrix( matrix_, 0UL, oldsize, n, increment ).reset();
2289 submatrix( matrix_, oldsize, 0UL, increment, increment ).reset();
2309 template<
typename MT
2311 inline void DiagonalMatrix<MT,SO,true>::extend(
size_t n,
bool preserve )
2332 template<
typename MT
2334 inline void DiagonalMatrix<MT,SO,true>::reserve(
size_t elements )
2336 matrix_.reserve( elements );
2349 template<
typename MT
2355 swap( matrix_, m.matrix_ );
2376 template<
typename MT
2378 template<
typename Other >
2379 inline DiagonalMatrix<MT,SO,true>& DiagonalMatrix<MT,SO,true>::scale(
const Other& scalar )
2381 matrix_.scale( scalar );
2406 template<
typename MT
2437 template<
typename MT
2439 template<
typename Other >
2440 inline bool DiagonalMatrix<MT,SO,true>::canAlias(
const Other* alias )
const noexcept
2442 return matrix_.canAlias( alias );
2459 template<
typename MT
2461 template<
typename Other >
2462 inline bool DiagonalMatrix<MT,SO,true>::isAliased(
const Other* alias )
const noexcept
2464 return matrix_.isAliased( alias );
2480 template<
typename MT
2482 inline bool DiagonalMatrix<MT,SO,true>::isAligned() const noexcept
2484 return matrix_.isAligned();
2501 template<
typename MT
2503 inline bool DiagonalMatrix<MT,SO,true>::canSMPAssign() const noexcept
2505 return matrix_.canSMPAssign();
2527 template<
typename MT
2530 DiagonalMatrix<MT,SO,true>::load(
size_t i,
size_t j )
const noexcept
2532 return matrix_.load( i, j );
2554 template<
typename MT
2559 return matrix_.loada( i, j );
2581 template<
typename MT
2586 return matrix_.loadu( i, j );
2607 template<
typename MT
2609 inline const MT DiagonalMatrix<MT,SO,true>::construct(
size_t n, TrueType )
2626 template<
typename MT
2628 inline const MT DiagonalMatrix<MT,SO,true>::construct(
const ElementType& init, FalseType )
2635 for(
size_t i=0UL; i<tmp.rows(); ++i )
2655 template<
typename MT
2657 template<
typename MT2
2660 inline const MT DiagonalMatrix<MT,SO,true>::construct(
const Matrix<MT2,SO2>& m, T )
2664 if( !IsDiagonal<MT2>::value && !
isDiagonal( 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.
#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
Header file for the IsDiagonal type trait.
#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
bool isDiagonal(const DenseMatrix< MT, SO > &dm)
Checks if the give dense matrix is diagonal.
Definition: DenseMatrix.h:1577
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 DiagonalProxy class.
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
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.
#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
Header file for the implementation of the base template of the DiagonalMatrix.
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
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 TrueType type/value trait base class.