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 ET >
139 typedef DiagonalMatrix< typename MT::template Rebind<ET>::Other > Other;
150 typedef std::random_access_iterator_tag IteratorCategory;
151 typedef ElementType_<MT> ValueType;
152 typedef DiagonalProxy<MT> PointerType;
153 typedef DiagonalProxy<MT> ReferenceType;
154 typedef ptrdiff_t DifferenceType;
157 typedef IteratorCategory iterator_category;
158 typedef ValueType value_type;
159 typedef PointerType pointer;
160 typedef ReferenceType reference;
161 typedef DifferenceType difference_type;
195 ( SO )?( row_ += inc ):( column_ += inc );
207 ( SO )?( row_ -= dec ):( column_ -= dec );
217 inline Iterator& operator++() noexcept {
218 ( SO )?( ++row_ ):( ++column_ );
228 inline const Iterator operator++(
int ) noexcept {
240 inline Iterator& operator--() noexcept {
241 ( SO )?( --row_ ):( --column_ );
251 inline const Iterator operator--(
int ) noexcept {
264 return ReferenceType( *matrix_, row_, column_ );
273 inline PointerType operator->()
const {
274 return PointerType( *matrix_, row_, column_ );
288 inline SIMDType load()
const {
289 return (*matrix_).load(row_,column_);
303 inline SIMDType
loada()
const {
304 return (*matrix_).loada(row_,column_);
318 inline SIMDType
loadu()
const {
319 return (*matrix_).loadu(row_,column_);
330 return matrix_->begin( column_ ) + row_;
332 return matrix_->begin( row_ ) + column_;
344 return ( SO )?( lhs.row_ == rhs.row_ ):( lhs.column_ == rhs.column_ );
380 return ( SO )?( lhs.row_ != rhs.row_ ):( lhs.column_ != rhs.column_ );
416 return ( SO )?( lhs.row_ < rhs.row_ ):( lhs.column_ < rhs.column_ );
452 return ( SO )?( lhs.row_ > rhs.row_ ):( lhs.column_ > rhs.column_ );
488 return ( SO )?( lhs.row_ <= rhs.row_ ):( lhs.column_ <= rhs.column_ );
524 return ( SO )?( lhs.row_ >= rhs.row_ ):( lhs.column_ >= rhs.column_ );
559 return ( SO )?( row_ - rhs.row_ ):( column_ - rhs.column_ );
572 return Iterator( *it.matrix_, it.row_ + inc, it.column_ );
574 return Iterator( *it.matrix_, it.row_, it.column_ + inc );
587 return Iterator( *it.matrix_, it.row_ + inc, it.column_ );
589 return Iterator( *it.matrix_, it.row_, it.column_ + inc );
602 return Iterator( *it.matrix_, it.row_ - dec, it.column_ );
604 return Iterator( *it.matrix_, it.row_, it.column_ - dec );
619 enum :
bool { simdEnabled = MT::simdEnabled };
622 enum :
bool { smpAssignable = MT::smpAssignable };
628 explicit inline DiagonalMatrix();
629 template<
typename A1 >
explicit inline DiagonalMatrix(
const A1& a1 );
630 explicit inline DiagonalMatrix(
size_t n,
const ElementType& init );
632 explicit inline DiagonalMatrix( initializer_list< initializer_list<ElementType> > list );
634 template<
typename Other >
635 explicit inline DiagonalMatrix(
size_t n,
const Other* array );
637 template<
typename Other,
size_t N >
638 explicit inline DiagonalMatrix(
const Other (&array)[N][N] );
640 explicit inline DiagonalMatrix( ElementType* ptr,
size_t n );
641 explicit inline DiagonalMatrix( ElementType* ptr,
size_t n,
size_t nn );
643 template<
typename Deleter >
644 explicit inline DiagonalMatrix( ElementType* ptr,
size_t n, Deleter d );
646 template<
typename Deleter >
647 explicit inline DiagonalMatrix( ElementType* ptr,
size_t n,
size_t nn, Deleter d );
649 inline DiagonalMatrix(
const DiagonalMatrix& m );
650 inline DiagonalMatrix( DiagonalMatrix&& m ) noexcept;
661 inline Reference operator()(
size_t i,
size_t j );
662 inline ConstReference operator()(
size_t i,
size_t j ) const;
663 inline Reference at(
size_t i,
size_t j );
664 inline ConstReference at(
size_t i,
size_t j ) const;
665 inline ConstPointer data () const noexcept;
666 inline ConstPointer data (
size_t i ) const noexcept;
668 inline ConstIterator
begin (
size_t i ) const;
669 inline ConstIterator
cbegin(
size_t i ) const;
671 inline ConstIterator
end (
size_t i ) const;
672 inline ConstIterator
cend (
size_t i ) const;
679 inline DiagonalMatrix& operator=( const ElementType& rhs );
680 inline DiagonalMatrix& operator=( initializer_list< initializer_list<ElementType> > list );
682 template< typename Other,
size_t N >
683 inline DiagonalMatrix& operator=( const Other (&array)[N][N] );
685 inline DiagonalMatrix& operator=( const DiagonalMatrix& rhs );
686 inline DiagonalMatrix& operator=( DiagonalMatrix&& rhs ) noexcept;
688 template< typename MT2,
bool SO2 >
689 inline
DisableIf_< IsComputation<MT2>, DiagonalMatrix& > operator=( const Matrix<MT2,SO2>& rhs );
691 template< typename MT2,
bool SO2 >
692 inline
EnableIf_< IsComputation<MT2>, DiagonalMatrix& > operator=( const Matrix<MT2,SO2>& rhs );
694 template< typename MT2,
bool SO2 >
695 inline
DisableIf_< IsComputation<MT2>, DiagonalMatrix& > operator+=( const Matrix<MT2,SO2>& rhs );
697 template< typename MT2,
bool SO2 >
698 inline
EnableIf_< IsComputation<MT2>, DiagonalMatrix& > operator+=( const Matrix<MT2,SO2>& rhs );
700 template< typename MT2,
bool SO2 >
701 inline
DisableIf_< IsComputation<MT2>, DiagonalMatrix& > operator-=( const Matrix<MT2,SO2>& rhs );
703 template< typename MT2,
bool SO2 >
704 inline
EnableIf_< IsComputation<MT2>, DiagonalMatrix& > operator-=( const Matrix<MT2,SO2>& rhs );
706 template< typename MT2,
bool SO2 >
707 inline DiagonalMatrix& operator*=( const Matrix<MT2,SO2>& rhs );
709 template< typename Other >
710 inline
EnableIf_< IsNumeric<Other>, DiagonalMatrix >& operator*=( Other rhs );
712 template< typename Other >
713 inline
EnableIf_< IsNumeric<Other>, DiagonalMatrix >& operator/=( Other rhs );
720 inline
size_t rows() const noexcept;
721 inline
size_t columns() const noexcept;
722 inline
size_t spacing() const noexcept;
723 inline
size_t capacity() const noexcept;
724 inline
size_t capacity(
size_t i ) const noexcept;
726 inline
size_t nonZeros(
size_t i ) const;
728 inline
void reset(
size_t i );
730 void resize (
size_t n,
bool preserve=true );
731 inline
void extend (
size_t n,
bool preserve=true );
732 inline
void reserve(
size_t elements );
733 template< typename Other > inline DiagonalMatrix& scale( const Other& scalar );
734 inline
void swap( DiagonalMatrix& m ) noexcept;
741 inline
bool isIntact() const noexcept;
748 template< typename Other > inline
bool canAlias ( const Other* alias ) const noexcept;
749 template< typename Other > inline
bool isAliased( const Other* alias ) const noexcept;
751 inline
bool isAligned () const noexcept;
752 inline
bool canSMPAssign() const noexcept;
764 inline const MT construct(
size_t n ,
TrueType );
765 inline const MT construct( const ElementType& value,
FalseType );
767 template< typename MT2,
bool SO2, typename T >
768 inline const MT construct( const Matrix<MT2,SO2>& m, T );
780 template< typename MT2,
bool SO2,
bool DF2 >
781 friend
bool isDefault( const DiagonalMatrix<MT2,SO2,DF2>& m );
783 template< typename MT2,
bool SO2,
bool DF2 >
784 friend MT2& derestrict( DiagonalMatrix<MT2,SO2,DF2>& m );
819 template< typename MT
821 inline DiagonalMatrix<MT,SO,true>::DiagonalMatrix()
849 template<
typename MT
851 template<
typename A1 >
852 inline DiagonalMatrix<MT,SO,true>::DiagonalMatrix(
const A1& a1 )
853 : matrix_( construct( a1, typename IsResizable<MT>::Type() ) )
869 template<
typename MT
871 inline DiagonalMatrix<MT,SO,true>::DiagonalMatrix(
size_t n,
const ElementType& init )
872 : matrix_( n, n, ElementType() )
876 for(
size_t i=0UL; i<n; ++i )
909 template<
typename MT
911 inline DiagonalMatrix<MT,SO,true>::DiagonalMatrix( initializer_list< initializer_list<ElementType> > list )
950 template<
typename MT
952 template<
typename Other >
953 inline DiagonalMatrix<MT,SO,true>::DiagonalMatrix(
size_t n,
const Other* array )
954 : matrix_( n, n, array )
989 template<
typename MT
991 template<
typename Other
993 inline DiagonalMatrix<MT,SO,true>::DiagonalMatrix(
const Other (&array)[N][N] )
1027 template<
typename MT
1029 inline DiagonalMatrix<MT,SO,true>::DiagonalMatrix( ElementType* ptr,
size_t n )
1030 : matrix_( ptr, n, n )
1065 template<
typename MT
1067 inline DiagonalMatrix<MT,SO,true>::DiagonalMatrix( ElementType* ptr,
size_t n,
size_t nn )
1068 : matrix_( ptr, n, n, nn )
1101 template<
typename MT
1103 template<
typename Deleter >
1104 inline DiagonalMatrix<MT,SO,true>::DiagonalMatrix( ElementType* ptr,
size_t n, Deleter d )
1105 : matrix_( ptr, n, n, d )
1139 template<
typename MT
1141 template<
typename Deleter >
1142 inline DiagonalMatrix<MT,SO,true>::DiagonalMatrix( ElementType* ptr,
size_t n,
size_t nn, Deleter d )
1143 : matrix_( ptr, n, n, nn, d )
1161 template<
typename MT
1163 inline DiagonalMatrix<MT,SO,true>::DiagonalMatrix(
const DiagonalMatrix& m )
1164 : matrix_( m.matrix_ )
1179 template<
typename MT
1181 inline DiagonalMatrix<MT,SO,true>::DiagonalMatrix( DiagonalMatrix&& m ) noexcept
1182 : matrix_(
std::move( m.matrix_ ) )
1215 template<
typename MT
1218 DiagonalMatrix<MT,SO,true>::operator()(
size_t i,
size_t j )
1245 template<
typename MT
1248 DiagonalMatrix<MT,SO,true>::operator()(
size_t i,
size_t j )
const
1253 return matrix_(i,j);
1276 template<
typename MT
1279 DiagonalMatrix<MT,SO,true>::at(
size_t i,
size_t j )
1287 return (*
this)(i,j);
1310 template<
typename MT
1313 DiagonalMatrix<MT,SO,true>::at(
size_t i,
size_t j )
const
1321 return (*
this)(i,j);
1340 template<
typename MT
1342 inline typename DiagonalMatrix<MT,SO,true>::ConstPointer
1343 DiagonalMatrix<MT,SO,true>::data() const noexcept
1345 return matrix_.data();
1360 template<
typename MT
1362 inline typename DiagonalMatrix<MT,SO,true>::ConstPointer
1363 DiagonalMatrix<MT,SO,true>::data(
size_t i )
const noexcept
1365 return matrix_.data(i);
1383 template<
typename MT
1389 return Iterator( matrix_, 0UL, i );
1391 return Iterator( matrix_, i, 0UL );
1409 template<
typename MT
1414 return matrix_.begin(i);
1432 template<
typename MT
1437 return matrix_.cbegin(i);
1455 template<
typename MT
1481 template<
typename MT
1486 return matrix_.end(i);
1504 template<
typename MT
1509 return matrix_.cend(i);
1530 template<
typename MT
1532 inline DiagonalMatrix<MT,SO,true>&
1533 DiagonalMatrix<MT,SO,true>::operator=(
const ElementType& rhs )
1536 for(
size_t j=0UL; j<
columns(); ++j )
1540 for(
size_t i=0UL; i<
rows(); ++i )
1574 template<
typename MT
1576 inline DiagonalMatrix<MT,SO,true>&
1577 DiagonalMatrix<MT,SO,true>::operator=( initializer_list< initializer_list<ElementType> > list )
1585 matrix_ = std::move( tmp );
1620 template<
typename MT
1622 template<
typename Other
1624 inline DiagonalMatrix<MT,SO,true>&
1625 DiagonalMatrix<MT,SO,true>::operator=(
const Other (&array)[N][N] )
1633 matrix_ = std::move( tmp );
1654 template<
typename MT
1656 inline DiagonalMatrix<MT,SO,true>&
1657 DiagonalMatrix<MT,SO,true>::operator=(
const DiagonalMatrix& rhs )
1659 matrix_ = rhs.matrix_;
1677 template<
typename MT
1679 inline DiagonalMatrix<MT,SO,true>&
1680 DiagonalMatrix<MT,SO,true>::operator=( DiagonalMatrix&& rhs ) noexcept
1682 matrix_ = std::move( rhs.matrix_ );
1706 template<
typename MT
1708 template<
typename MT2
1710 inline DisableIf_< IsComputation<MT2>, DiagonalMatrix<MT,SO,true>& >
1711 DiagonalMatrix<MT,SO,true>::operator=(
const Matrix<MT2,SO2>& rhs )
1713 if( !IsDiagonal<MT2>::value && !
isDiagonal( ~rhs ) ) {
1741 template<
typename MT
1743 template<
typename MT2
1745 inline EnableIf_< IsComputation<MT2>, DiagonalMatrix<MT,SO,true>& >
1746 DiagonalMatrix<MT,SO,true>::operator=(
const Matrix<MT2,SO2>& rhs )
1748 if( !IsSquare<MT2>::value && !
isSquare( ~rhs ) ) {
1752 if( IsDiagonal<MT2>::value ) {
1762 matrix_ = std::move( tmp );
1787 template<
typename MT
1789 template<
typename MT2
1791 inline DisableIf_< IsComputation<MT2>, DiagonalMatrix<MT,SO,true>& >
1794 if( !IsDiagonal<MT2>::value && !
isDiagonal( ~rhs ) ) {
1822 template<
typename MT
1824 template<
typename MT2
1826 inline EnableIf_< IsComputation<MT2>, DiagonalMatrix<MT,SO,true>& >
1829 if( !IsSquare<MT2>::value && !
isSquare( ~rhs ) ) {
1833 if( IsDiagonal<MT2>::value ) {
1837 const ResultType_<MT2> tmp( ~rhs );
1868 template<
typename MT
1870 template<
typename MT2
1872 inline DisableIf_< IsComputation<MT2>, DiagonalMatrix<MT,SO,true>& >
1875 if( !IsDiagonal<MT2>::value && !
isDiagonal( ~rhs ) ) {
1903 template<
typename MT
1905 template<
typename MT2
1907 inline EnableIf_< IsComputation<MT2>, DiagonalMatrix<MT,SO,true>& >
1910 if( !IsSquare<MT2>::value && !
isSquare( ~rhs ) ) {
1914 if( IsDiagonal<MT2>::value ) {
1918 const ResultType_<MT2> tmp( ~rhs );
1948 template<
typename MT
1950 template<
typename MT2
1952 inline DiagonalMatrix<MT,SO,true>&
1955 if( matrix_.rows() != (~rhs).
columns() ) {
1959 MT tmp( matrix_ * ~rhs );
1965 matrix_ = std::move( tmp );
1984 template<
typename MT
1986 template<
typename Other >
1987 inline EnableIf_< IsNumeric<Other>, DiagonalMatrix<MT,SO,true> >&
2004 template<
typename MT
2006 template<
typename Other >
2007 inline EnableIf_< IsNumeric<Other>, DiagonalMatrix<MT,SO,true> >&
2033 template<
typename MT
2037 return matrix_.rows();
2049 template<
typename MT
2053 return matrix_.columns();
2070 template<
typename MT
2074 return matrix_.spacing();
2086 template<
typename MT
2090 return matrix_.capacity();
2108 template<
typename MT
2112 return matrix_.capacity(i);
2124 template<
typename MT
2128 return matrix_.nonZeros();
2146 template<
typename MT
2150 return matrix_.nonZeros(i);
2162 template<
typename MT
2185 template<
typename MT
2207 template<
typename MT
2255 template<
typename MT
2265 const size_t oldsize( matrix_.rows() );
2267 matrix_.resize( n, n,
true );
2270 const size_t increment( n - oldsize );
2271 submatrix( matrix_, 0UL, oldsize, n, increment ).reset();
2272 submatrix( matrix_, oldsize, 0UL, increment, increment ).reset();
2292 template<
typename MT
2294 inline void DiagonalMatrix<MT,SO,true>::extend(
size_t n,
bool preserve )
2315 template<
typename MT
2317 inline void DiagonalMatrix<MT,SO,true>::reserve(
size_t elements )
2319 matrix_.reserve( elements );
2332 template<
typename MT
2334 template<
typename Other >
2335 inline DiagonalMatrix<MT,SO,true>& DiagonalMatrix<MT,SO,true>::scale(
const Other& scalar )
2337 matrix_.scale( scalar );
2351 template<
typename MT
2357 swap( matrix_, m.matrix_ );
2381 template<
typename MT
2412 template<
typename MT
2414 template<
typename Other >
2415 inline bool DiagonalMatrix<MT,SO,true>::canAlias(
const Other* alias )
const noexcept
2417 return matrix_.canAlias( alias );
2434 template<
typename MT
2436 template<
typename Other >
2437 inline bool DiagonalMatrix<MT,SO,true>::isAliased(
const Other* alias )
const noexcept
2439 return matrix_.isAliased( alias );
2455 template<
typename MT
2457 inline bool DiagonalMatrix<MT,SO,true>::isAligned() const noexcept
2459 return matrix_.isAligned();
2476 template<
typename MT
2478 inline bool DiagonalMatrix<MT,SO,true>::canSMPAssign() const noexcept
2480 return matrix_.canSMPAssign();
2502 template<
typename MT
2505 DiagonalMatrix<MT,SO,true>::load(
size_t i,
size_t j )
const noexcept
2507 return matrix_.load( i, j );
2529 template<
typename MT
2534 return matrix_.loada( i, j );
2556 template<
typename MT
2561 return matrix_.loadu( i, j );
2582 template<
typename MT
2584 inline const MT DiagonalMatrix<MT,SO,true>::construct(
size_t n, TrueType )
2601 template<
typename MT
2603 inline const MT DiagonalMatrix<MT,SO,true>::construct(
const ElementType& init, FalseType )
2610 for(
size_t i=0UL; i<tmp.rows(); ++i )
2630 template<
typename MT
2632 template<
typename MT2
2635 inline const MT DiagonalMatrix<MT,SO,true>::construct(
const Matrix<MT2,SO2>& m, T )
2639 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
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
bool isDiagonal(const DenseMatrix< MT, SO > &dm)
Checks if the give dense matrix is diagonal.
Definition: DenseMatrix.h:1499
Header file for the Rows type trait.
Header file for the UNUSED_PARAMETER function template.
const DMatDMatMultExpr< T1, T2 > operator*(const DenseMatrix< T1, false > &lhs, const DenseMatrix< T2, false > &rhs)
Multiplication operator for the multiplication of two row-major dense matrices ( ).
Definition: DMatDMatMultExpr.h:7800
BLAZE_ALWAYS_INLINE size_t capacity(const Matrix< MT, SO > &matrix) noexcept
Returns the maximum capacity of the matrix.
Definition: Matrix.h:346
Header file for basic type definitions.
bool operator<=(const NegativeAccuracy< A > &, const T &rhs)
Less-or-equal-than comparison between a NegativeAccuracy object and a floating point value...
Definition: Accuracy.h:404
Header file for the FalseType type/value trait base class.
#define BLAZE_CONSTRAINT_MUST_BE_MATRIX_WITH_STORAGE_ORDER(T, SO)
Constraint on the data type.In case the given data type T is not a dense or sparse matrix type and in...
Definition: StorageOrder.h:63
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
BLAZE_ALWAYS_INLINE T1 & operator/=(SIMDPack< T1 > &lhs, const SIMDPack< T2 > &rhs)
Division assignment operator for the division of two SIMD packs.
Definition: BasicTypes.h:1339
Constraint on the data type.
BLAZE_ALWAYS_INLINE MT::Iterator begin(Matrix< MT, SO > &matrix, size_t i)
Returns an iterator to the first element of row/column i.
Definition: Matrix.h:188
Constraint on the data type.
void reset(const DiagonalProxy< MT > &proxy)
Resetting the represented element to the default initial values.
Definition: DiagonalProxy.h:533
const DenseIterator< Type, AF > operator+(const DenseIterator< Type, AF > &it, ptrdiff_t inc) noexcept
Addition between a DenseIterator and an integral value.
Definition: DenseIterator.h:699
const This & CompositeType
Data type for composite expression templates.
Definition: CompressedMatrix.h:2643
typename DisableIf< Condition, T >::Type DisableIf_
Auxiliary type for the DisableIf class template.The DisableIf_ alias declaration provides a convenien...
Definition: DisableIf.h:223
void clear(CompressedMatrix< Type, SO > &m)
Clearing the given compressed matrix.
Definition: CompressedMatrix.h:5077
bool operator>(const NegativeAccuracy< A > &lhs, const T &rhs)
Greater-than comparison between a NegativeAccuracy object and a floating point value.
Definition: Accuracy.h:366
CompressedMatrix< Type, true > This
Type of this CompressedMatrix instance.
Definition: CompressedMatrix.h:2636
bool operator>=(const NegativeAccuracy< A > &, const T &rhs)
Greater-or-equal-than comparison between a NegativeAccuracy object and a floating point value...
Definition: Accuracy.h:442
#define BLAZE_CONSTRAINT_MUST_NOT_BE_VOLATILE(T)
Constraint on the data type.In case the given data type is a volatile-qualified type, a compilation error is created.
Definition: Volatile.h:79
BLAZE_ALWAYS_INLINE size_t nonZeros(const Matrix< MT, SO > &matrix)
Returns the total number of non-zero elements in the matrix.
Definition: Matrix.h:384
#define BLAZE_CONSTRAINT_MUST_BE_SQUARE(T)
Constraint on the data type.In case the given data type T is not a square matrix type, a compilation error is created.
Definition: Square.h:60
const DenseIterator< Type, AF > operator-(const DenseIterator< Type, AF > &it, ptrdiff_t inc) noexcept
Subtraction between a DenseIterator and an integral value.
Definition: DenseIterator.h:731
BoolConstant< true > TrueType
Type traits base class.The TrueType class is used as base class for type traits and value traits that...
Definition: TrueType.h:61
BLAZE_ALWAYS_INLINE T1 & operator*=(SIMDPack< T1 > &lhs, const SIMDPack< T2 > &rhs)
Multiplication assignment operator for the multiplication of two SIMD packs.
Definition: BasicTypes.h:1321
Constraint on the data type.
BLAZE_ALWAYS_INLINE const EnableIf_< And< IsIntegral< T >, HasSize< T, 1UL > >, If_< IsSigned< T >, SIMDint8, SIMDuint8 > > loadu(const T *address) noexcept
Loads a vector of 1-byte integral values.
Definition: Loadu.h:77
CompressedMatrix< Type, false > OppositeType
Result type with opposite storage order for expression template evaluations.
Definition: CompressedMatrix.h:2639
DisableIf_< Or< IsComputation< MT >, IsTransExpr< MT > >, ColumnExprTrait_< MT > > column(Matrix< MT, SO > &matrix, size_t index)
Creating a view on a specific column of the given matrix.
Definition: Column.h:126
BLAZE_ALWAYS_INLINE MT::ConstIterator cend(const Matrix< MT, SO > &matrix, size_t i)
Returns an iterator just past the last element of row/column i.
Definition: Matrix.h:298
BLAZE_ALWAYS_INLINE MT::ConstIterator cbegin(const Matrix< MT, SO > &matrix, size_t i)
Returns an iterator to the first element of row/column i.
Definition: Matrix.h:232
bool isDefault(const DiagonalProxy< MT > &proxy)
Returns whether the represented element is in default state.
Definition: DiagonalProxy.h:573
Constraint on the data type.
Constraint on the data type.
constexpr bool spacing
Adding an additional spacing line between two log messages.This setting gives the opportunity to add ...
Definition: Logging.h:70
Header file for the std::initializer_list aliases.
Header file for the IsSquare type trait.
Constraint on the data type.
Constraint on the data type.
Header file for the DisableIf class template.
Header file for the 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:5148
bool isIntact(const CompressedMatrix< Type, SO > &m)
Returns whether the invariants of the given compressed matrix are intact.
Definition: CompressedMatrix.h:5131
const Element * ConstIterator
Iterator over constant elements.
Definition: CompressedMatrix.h:2647
#define BLAZE_CONSTRAINT_MUST_NOT_BE_POINTER_TYPE(T)
Constraint on the data type.In case the given data type T is not a pointer type, a compilation error ...
Definition: Pointer.h:79
#define BLAZE_THROW_OUT_OF_RANGE(MESSAGE)
Macro for the emission of a std::out_of_range exception.This macro encapsulates the default way of Bl...
Definition: Exception.h:331
Header file for the DenseMatrix base class.
Header file for the Columns type trait.
Constraint on the data type.
BLAZE_ALWAYS_INLINE size_t columns(const Matrix< MT, SO > &matrix) noexcept
Returns the current number of columns of the matrix.
Definition: Matrix.h:330
BLAZE_ALWAYS_INLINE const EnableIf_< And< IsIntegral< T >, HasSize< T, 1UL > >, If_< IsSigned< T >, SIMDint8, SIMDuint8 > > loada(const T *address) noexcept
Loads a vector of 1-byte integral values.
Definition: Loada.h:80
CompressedMatrix< Type, false > TransposeType
Transpose type for expression template evaluations.
Definition: CompressedMatrix.h:2640
Constraints on the storage order of matrix types.
Header file for the exception macros of the math module.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_UPPER_MATRIX_TYPE(T)
Constraint on the data type.In case the given data type T is a upper triangular matrix type...
Definition: Upper.h:81
BLAZE_ALWAYS_INLINE void resize(Matrix< MT, SO > &matrix, size_t rows, size_t columns, bool preserve=true)
Changing the size of the matrix.
Definition: Matrix.h:538
BLAZE_ALWAYS_INLINE MT::Iterator end(Matrix< MT, SO > &matrix, size_t i)
Returns an iterator just past the last element of row/column i.
Definition: Matrix.h:254
Type ElementType
Type of the sparse matrix elements.
Definition: CompressedMatrix.h:2641
const Type & ConstReference
Reference to a constant matrix value.
Definition: CompressedMatrix.h:2645
Header file for the EnableIf class template.
Header file for utility functions for dense matrices.
void clear(const DiagonalProxy< MT > &proxy)
Clearing the represented element.
Definition: DiagonalProxy.h:553
Header file for the IsNumeric type trait.
DisableIf_< Or< IsComputation< MT >, IsTransExpr< MT > >, RowExprTrait_< MT > > row(Matrix< MT, SO > &matrix, size_t index)
Creating a view on a specific row of the given matrix.
Definition: Row.h:126
#define BLAZE_CONSTRAINT_MUST_NOT_BE_SYMMETRIC_MATRIX_TYPE(T)
Constraint on the data type.In case the given data type T is a symmetric matrix type, a compilation error is created.
Definition: Symmetric.h:79
const Type & ReturnType
Return type for expression template evaluations.
Definition: CompressedMatrix.h:2642
BLAZE_ALWAYS_INLINE T1 & operator+=(SIMDPack< T1 > &lhs, const SIMDPack< T2 > &rhs)
Addition assignment operator for the addition of two SIMD packs.
Definition: BasicTypes.h:1285
Header file for run time assertion macros.
Constraint on the data type.
Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_LOWER_MATRIX_TYPE(T)
Constraint on the data type.In case the given data type T is a lower triangular matrix type...
Definition: Lower.h:81
#define BLAZE_CONSTRAINT_MUST_NOT_BE_REFERENCE_TYPE(T)
Constraint on the data type.In case the given data type T is not a reference type, a compilation error is created.
Definition: Reference.h:79
Element * Iterator
Iterator over non-constant elements.
Definition: CompressedMatrix.h:2646
Header file for the isDefault shim.
void swap(DiagonalMatrix< MT, SO, DF > &a, DiagonalMatrix< MT, SO, DF > &b) noexcept
Swapping the contents of two matrices.
Definition: DiagonalMatrix.h:258
Constraint on the data type.
Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_RESIZABLE(T)
Constraint on the data type.In case the given data type T is resizable, i.e. has a 'resize' member fu...
Definition: Resizable.h:81
typename EnableIf< Condition, T >::Type EnableIf_
Auxiliary alias declaration for the EnableIf class template.The EnableIf_ alias declaration provides ...
Definition: EnableIf.h:223
BLAZE_ALWAYS_INLINE size_t rows(const Matrix< MT, SO > &matrix) noexcept
Returns the current number of rows of the matrix.
Definition: Matrix.h:314
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:2637
bool operator<(const NegativeAccuracy< A > &lhs, const T &rhs)
Less-than comparison between a NegativeAccuracy object and a floating point value.
Definition: Accuracy.h:328
#define BLAZE_CONSTRAINT_MUST_BE_RESIZABLE(T)
Constraint on the data type.In case the given data type T is not resizable, i.e. does not have a 'res...
Definition: Resizable.h:61
Header file for the IsComputation type trait class.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_EXPRESSION_TYPE(T)
Constraint on the data type.In case the given data type T is an expression (i.e. a type derived from ...
Definition: Expression.h:81
bool operator==(const NegativeAccuracy< A > &lhs, const T &rhs)
Equality comparison between a NegativeAccuracy object and a floating point value. ...
Definition: Accuracy.h:249
This ResultType
Result type for expression template evaluations.
Definition: CompressedMatrix.h:2638
bool operator!=(const NegativeAccuracy< A > &lhs, const T &rhs)
Inequality comparison between a NegativeAccuracy object and a floating point value.
Definition: Accuracy.h:289
bool isIntact(const DiagonalMatrix< MT, SO, DF > &m)
Returns whether the invariants of the given diagonal matrix are intact.
Definition: DiagonalMatrix.h:240
MatrixAccessProxy< This > Reference
Reference to a non-constant matrix value.
Definition: CompressedMatrix.h:2644
#define BLAZE_CONSTRAINT_MUST_NOT_BE_HERMITIAN_MATRIX_TYPE(T)
Constraint on the data type.In case the given data type T is an Hermitian matrix type, a compilation error is created.
Definition: Hermitian.h:79
BLAZE_ALWAYS_INLINE T1 & operator-=(SIMDPack< T1 > &lhs, const SIMDPack< T2 > &rhs)
Subtraction assignment operator for the subtraction of two SIMD packs.
Definition: BasicTypes.h:1303
void UNUSED_PARAMETER(const Args &...)
Suppression of unused parameter warnings.
Definition: Unused.h:81
#define BLAZE_STATIC_ASSERT(expr)
Compile time assertion macro.In case of an invalid compile time expression, a compilation error is cr...
Definition: StaticAssert.h:112
SubmatrixExprTrait_< MT, unaligned > submatrix(Matrix< MT, SO > &matrix, size_t row, size_t column, size_t m, size_t n)
Creating a view on a specific submatrix of the given matrix.
Definition: Submatrix.h:167
BLAZE_ALWAYS_INLINE bool isSquare(const Matrix< MT, SO > &matrix) noexcept
Checks if the given matrix is a square matrix.
Definition: Matrix.h:609
Header file for the IsResizable type trait.
System settings for the inline keywords.
#define BLAZE_INTERNAL_ASSERT(expr, msg)
Run time assertion macro for internal checks.In case of an invalid run time expression, the program execution is terminated. The BLAZE_INTERNAL_ASSERT macro can be disabled by setting the BLAZE_USER_ASSERTION flag to zero or by defining NDEBUG during the compilation.
Definition: Assert.h:101
Header file for the TrueType type/value trait base class.