35#ifndef _BLAZE_MATH_ADAPTORS_SYMMETRICMATRIX_DENSESCALAR_H_
36#define _BLAZE_MATH_ADAPTORS_SYMMETRICMATRIX_DENSESCALAR_H_
112class SymmetricMatrix<MT,SO,true,true>
113 :
public DenseMatrix< SymmetricMatrix<MT,SO,true,true>, SO >
117 using OT = OppositeType_t<MT>;
118 using TT = TransposeType_t<MT>;
119 using ET = ElementType_t<MT>;
124 using This = SymmetricMatrix<MT,SO,true,true>;
125 using BaseType = DenseMatrix<This,SO>;
126 using ResultType = This;
127 using OppositeType = SymmetricMatrix<OT,!SO,true,true>;
128 using TransposeType = SymmetricMatrix<TT,!SO,true,true>;
129 using ElementType = ET;
130 using SIMDType = SIMDType_t<MT>;
131 using TagType = TagType_t<MT>;
132 using ReturnType = ReturnType_t<MT>;
133 using CompositeType =
const This&;
134 using Reference = ScalarProxy<MT>;
135 using ConstReference = ConstReference_t<MT>;
136 using Pointer = Pointer_t<MT>;
137 using ConstPointer = ConstPointer_t<MT>;
138 using ConstIterator = ConstIterator_t<MT>;
144 template<
typename NewType >
147 using Other = SymmetricMatrix< typename MT::template Rebind<NewType>::Other >;
154 template<
size_t NewM
158 using Other = SymmetricMatrix< typename MT::template Resize<NewM,NewN>::Other >;
169 using IteratorCategory = std::random_access_iterator_tag;
170 using ValueType = ElementType_t<MT>;
171 using PointerType = ScalarProxy<MT>;
172 using ReferenceType = ScalarProxy<MT>;
176 using iterator_category = IteratorCategory;
177 using value_type = ValueType;
178 using pointer = PointerType;
179 using reference = ReferenceType;
180 using difference_type = DifferenceType;
186 inline Iterator() noexcept
200 inline Iterator( MT& matrix,
size_t row,
size_t column ) noexcept
213 inline Iterator&
operator+=(
size_t inc )
noexcept {
214 ( SO )?( row_ += inc ):( column_ += inc );
225 inline Iterator&
operator-=(
size_t dec )
noexcept {
226 ( SO )?( row_ -= dec ):( column_ -= dec );
236 inline Iterator& operator++() noexcept {
237 ( SO )?( ++row_ ):( ++column_ );
247 inline const Iterator operator++(
int )
noexcept {
248 const Iterator tmp( *
this );
259 inline Iterator& operator--() noexcept {
260 ( SO )?( --row_ ):( --column_ );
270 inline const Iterator operator--(
int )
noexcept {
271 const Iterator tmp( *
this );
283 return ReferenceType( *matrix_, row_, column_ );
292 inline PointerType operator->()
const {
293 return PointerType( *matrix_, row_, column_ );
307 inline SIMDType load()
const {
308 return (*matrix_).load(row_,column_);
322 inline SIMDType
loada()
const {
323 return (*matrix_).loada(row_,column_);
337 inline SIMDType
loadu()
const {
338 return (*matrix_).loadu(row_,column_);
353 inline void store(
const SIMDType& value )
const {
354 (*matrix_).store( row_, column_, value );
370 inline void storea(
const SIMDType& value )
const {
371 (*matrix_).storea( row_, column_, value );
387 inline void storeu(
const SIMDType& value )
const {
388 (*matrix_).storeu( row_, column_, value );
404 inline void stream(
const SIMDType& value )
const {
405 (*matrix_).stream( row_, column_, value );
415 inline operator ConstIterator()
const {
417 return matrix_->begin( column_ ) + row_;
419 return matrix_->begin( row_ ) + column_;
430 friend inline bool operator==(
const Iterator& lhs,
const Iterator& rhs )
noexcept {
431 return ( SO )?( lhs.row_ == rhs.row_ ):( lhs.column_ == rhs.column_ );
442 friend inline bool operator==(
const Iterator& lhs,
const ConstIterator& rhs ) {
443 return ( ConstIterator( lhs ) == rhs );
454 friend inline bool operator==(
const ConstIterator& lhs,
const Iterator& rhs ) {
455 return ( lhs == ConstIterator( rhs ) );
466 friend inline bool operator!=(
const Iterator& lhs,
const Iterator& rhs )
noexcept {
467 return ( SO )?( lhs.row_ != rhs.row_ ):( lhs.column_ != rhs.column_ );
478 friend inline bool operator!=(
const Iterator& lhs,
const ConstIterator& rhs ) {
479 return ( ConstIterator( lhs ) != rhs );
490 friend inline bool operator!=(
const ConstIterator& lhs,
const Iterator& rhs ) {
491 return ( lhs != ConstIterator( rhs ) );
502 friend inline bool operator<(
const Iterator& lhs,
const Iterator& rhs )
noexcept {
503 return ( SO )?( lhs.row_ < rhs.row_ ):( lhs.column_ < rhs.column_ );
514 friend inline bool operator<(
const Iterator& lhs,
const ConstIterator& rhs ) {
515 return ( ConstIterator( lhs ) < rhs );
526 friend inline bool operator<(
const ConstIterator& lhs,
const Iterator& rhs ) {
527 return ( lhs < ConstIterator( rhs ) );
538 friend inline bool operator>(
const Iterator& lhs,
const Iterator& rhs )
noexcept {
539 return ( SO )?( lhs.row_ > rhs.row_ ):( lhs.column_ > rhs.column_ );
550 friend inline bool operator>(
const Iterator& lhs,
const ConstIterator& rhs ) {
551 return ( ConstIterator( lhs ) > rhs );
562 friend inline bool operator>(
const ConstIterator& lhs,
const Iterator& rhs ) {
563 return ( lhs > ConstIterator( rhs ) );
574 friend inline bool operator<=(
const Iterator& lhs,
const Iterator& rhs )
noexcept {
575 return ( SO )?( lhs.row_ <= rhs.row_ ):( lhs.column_ <= rhs.column_ );
586 friend inline bool operator<=(
const Iterator& lhs,
const ConstIterator& rhs ) {
587 return ( ConstIterator( lhs ) <= rhs );
598 friend inline bool operator<=(
const ConstIterator& lhs,
const Iterator& rhs ) {
599 return ( lhs <= ConstIterator( rhs ) );
610 friend inline bool operator>=(
const Iterator& lhs,
const Iterator& rhs )
noexcept {
611 return ( SO )?( lhs.row_ >= rhs.row_ ):( lhs.column_ >= rhs.column_ );
622 friend inline bool operator>=(
const Iterator& lhs,
const ConstIterator& rhs ) {
623 return ( ConstIterator( lhs ) >= rhs );
634 friend inline bool operator>=(
const ConstIterator& lhs,
const Iterator& rhs ) {
635 return ( lhs >= ConstIterator( rhs ) );
645 inline DifferenceType
operator-(
const Iterator& rhs )
const noexcept {
646 return ( SO )?( row_ - rhs.row_ ):( column_ - rhs.column_ );
657 friend inline const Iterator
operator+(
const Iterator& it,
size_t inc )
noexcept {
659 return Iterator( *it.matrix_, it.row_ + inc, it.column_ );
661 return Iterator( *it.matrix_, it.row_, it.column_ + inc );
672 friend inline const Iterator
operator+(
size_t inc,
const Iterator& it )
noexcept {
674 return Iterator( *it.matrix_, it.row_ + inc, it.column_ );
676 return Iterator( *it.matrix_, it.row_, it.column_ + inc );
687 friend inline const Iterator
operator-(
const Iterator& it,
size_t dec )
noexcept {
689 return Iterator( *it.matrix_, it.row_ - dec, it.column_ );
691 return Iterator( *it.matrix_, it.row_, it.column_ - dec );
703 const size_t kend(
min( row_+SIMDSIZE, (*matrix_).rows() ) );
704 for(
size_t k=row_; k<kend; ++k )
705 (*matrix_)(column_,k) = (*matrix_)(k,column_);
708 const size_t kend(
min( column_+SIMDSIZE, (*matrix_).columns() ) );
709 for(
size_t k=column_; k<kend; ++k )
710 (*matrix_)(k,row_) = (*matrix_)(row_,k);
725 static constexpr bool simdEnabled = MT::simdEnabled;
728 static constexpr bool smpAssignable = MT::smpAssignable;
734 inline SymmetricMatrix();
735 explicit inline SymmetricMatrix(
size_t n );
738 template<
typename Other >
739 inline SymmetricMatrix(
size_t n,
const Other* array );
741 template<
typename Other,
size_t N >
742 inline SymmetricMatrix(
const Other (&array)[N][N] );
744 inline SymmetricMatrix( ElementType* ptr,
size_t n );
745 inline SymmetricMatrix( ElementType* ptr,
size_t n,
size_t nn );
747 inline SymmetricMatrix(
const SymmetricMatrix& m );
748 inline SymmetricMatrix( SymmetricMatrix&& m )
noexcept;
750 template<
typename MT2 >
inline SymmetricMatrix(
const Matrix<MT2,SO>& m );
751 template<
typename MT2 >
inline SymmetricMatrix(
const Matrix<MT2,!SO>& m );
758 ~SymmetricMatrix() =
default;
765 inline Reference operator()(
size_t i,
size_t j );
766 inline ConstReference operator()(
size_t i,
size_t j )
const;
767 inline Reference at(
size_t i,
size_t j );
768 inline ConstReference at(
size_t i,
size_t j )
const;
769 inline ConstPointer
data () const noexcept;
770 inline ConstPointer
data (
size_t i ) const noexcept;
771 inline Iterator
begin (
size_t i );
772 inline ConstIterator
begin (
size_t i ) const;
773 inline ConstIterator
cbegin(
size_t i ) const;
774 inline Iterator
end (
size_t i );
775 inline ConstIterator
end (
size_t i ) const;
776 inline ConstIterator
cend (
size_t i ) const;
785 template< typename Other,
size_t N >
786 inline SymmetricMatrix& operator=( const Other (&array)[N][N] );
788 inline SymmetricMatrix& operator=( const SymmetricMatrix& rhs );
789 inline SymmetricMatrix& operator=( SymmetricMatrix&& rhs ) noexcept;
791 template< typename MT2 >
792 inline auto operator=( const Matrix<MT2,SO>& rhs )
795 template< typename MT2 >
796 inline auto operator=( const Matrix<MT2,SO>& rhs )
799 template< typename MT2 >
800 inline auto operator=( const Matrix<MT2,!SO>& rhs ) -> SymmetricMatrix&;
802 template< typename MT2 >
803 inline auto operator+=( const Matrix<MT2,SO>& rhs )
806 template< typename MT2 >
807 inline auto operator+=( const Matrix<MT2,SO>& rhs )
810 template< typename MT2 >
811 inline auto operator+=( const Matrix<MT2,!SO>& rhs ) -> SymmetricMatrix&;
813 template< typename MT2 >
814 inline auto operator-=( const Matrix<MT2,SO>& rhs )
817 template< typename MT2 >
818 inline auto operator-=( const Matrix<MT2,SO>& rhs )
821 template< typename MT2 >
822 inline auto operator-=( const Matrix<MT2,!SO>& rhs ) -> SymmetricMatrix&;
824 template< typename MT2 >
825 inline auto operator%=( const Matrix<MT2,SO>& rhs )
828 template< typename MT2 >
829 inline auto operator%=( const Matrix<MT2,SO>& rhs )
832 template< typename MT2 >
833 inline auto operator%=( const Matrix<MT2,!SO>& rhs ) -> SymmetricMatrix&;
835 template< typename ST >
838 template< typename ST >
846 inline
size_t rows() const noexcept;
847 inline
size_t columns() const noexcept;
848 inline
size_t spacing() const noexcept;
849 inline
size_t capacity() const noexcept;
850 inline
size_t capacity(
size_t i ) const noexcept;
852 inline
size_t nonZeros(
size_t i ) const;
854 inline
void reset(
size_t i );
856 void resize (
size_t n,
bool preserve=true );
857 inline
void extend (
size_t n,
bool preserve=true );
858 inline
void reserve(
size_t elements );
860 inline
void swap( SymmetricMatrix& m ) noexcept;
870 template< typename Other > inline SymmetricMatrix& scale( const Other& scalar );
877 inline
bool isIntact() const noexcept;
884 template< typename Other > inline
bool canAlias ( const Other* alias ) const noexcept;
885 template< typename Other > inline
bool isAliased( const Other* alias ) const noexcept;
887 inline
bool isAligned () const noexcept;
888 inline
bool canSMPAssign() const noexcept;
894 inline
void store (
size_t i,
size_t j, const SIMDType& value ) noexcept;
895 inline
void storea(
size_t i,
size_t j, const SIMDType& value ) noexcept;
896 inline
void storeu(
size_t i,
size_t j, const SIMDType& value ) noexcept;
897 inline
void stream(
size_t i,
size_t j, const SIMDType& value ) noexcept;
904 static constexpr
size_t SIMDSIZE = SIMDTrait<ET>::
size;
916 friend
void invert( SymmetricMatrix<MT2,SO2,true,true>& m );
956inline SymmetricMatrix<MT,SO,true,true>::SymmetricMatrix()
974inline SymmetricMatrix<MT,SO,true,true>::SymmetricMatrix(
size_t n )
975 : matrix_( n, n, ElementType() )
1010template<
typename MT
1051template<
typename MT
1053template<
typename Other >
1054inline SymmetricMatrix<MT,SO,true,true>::SymmetricMatrix(
size_t n,
const Other* array )
1055 : matrix_( n, n, array )
1090template<
typename MT
1092template<
typename Other
1094inline SymmetricMatrix<MT,SO,true,true>::SymmetricMatrix(
const Other (&array)[N][N] )
1139template<
typename MT
1141inline SymmetricMatrix<MT,SO,true,true>::SymmetricMatrix( ElementType* ptr,
size_t n )
1142 : matrix_( ptr, n, n )
1188template<
typename MT
1190inline SymmetricMatrix<MT,SO,true,true>::SymmetricMatrix( ElementType* ptr,
size_t n,
size_t nn )
1191 : matrix_( ptr, n, n, nn )
1209template<
typename MT
1211inline SymmetricMatrix<MT,SO,true,true>::SymmetricMatrix(
const SymmetricMatrix& m )
1212 : matrix_( m.matrix_ )
1227template<
typename MT
1229inline SymmetricMatrix<MT,SO,true,true>::SymmetricMatrix( SymmetricMatrix&& m ) noexcept
1230 : matrix_( std::move( m.matrix_ ) )
1249template<
typename MT
1251template<
typename MT2 >
1252inline SymmetricMatrix<MT,SO,true,true>::SymmetricMatrix(
const Matrix<MT2,SO>& m )
1255 if( !IsSymmetric_v<MT2> && !
isSymmetric( matrix_ ) ) {
1276template<
typename MT
1278template<
typename MT2 >
1279inline SymmetricMatrix<MT,SO,true,true>::SymmetricMatrix(
const Matrix<MT2,!SO>& m )
1280 : matrix_(
trans( *m ) )
1282 if( !IsSymmetric_v<MT2> && !
isSymmetric( matrix_ ) ) {
1316template<
typename MT
1318inline typename SymmetricMatrix<MT,SO,true,true>::Reference
1319 SymmetricMatrix<MT,SO,true,true>::operator()(
size_t i,
size_t j )
1324 return Reference( matrix_, i, j );
1345template<
typename MT
1347inline typename SymmetricMatrix<MT,SO,true,true>::ConstReference
1348 SymmetricMatrix<MT,SO,true,true>::operator()(
size_t i,
size_t j )
const
1353 return matrix_(i,j);
1375template<
typename MT
1377inline typename SymmetricMatrix<MT,SO,true,true>::Reference
1378 SymmetricMatrix<MT,SO,true,true>::at(
size_t i,
size_t j )
1386 return (*
this)(i,j);
1408template<
typename MT
1410inline typename SymmetricMatrix<MT,SO,true,true>::ConstReference
1411 SymmetricMatrix<MT,SO,true,true>::at(
size_t i,
size_t j )
const
1419 return (*
this)(i,j);
1439template<
typename MT
1441inline typename SymmetricMatrix<MT,SO,true,true>::ConstPointer
1444 return matrix_.data();
1461template<
typename MT
1463inline typename SymmetricMatrix<MT,SO,true,true>::ConstPointer
1466 return matrix_.data(i);
1484template<
typename MT
1486inline typename SymmetricMatrix<MT,SO,true,true>::Iterator
1490 return Iterator( matrix_, 0UL, i );
1492 return Iterator( matrix_, i, 0UL );
1510template<
typename MT
1512inline typename SymmetricMatrix<MT,SO,true,true>::ConstIterator
1515 return matrix_.begin(i);
1533template<
typename MT
1535inline typename SymmetricMatrix<MT,SO,true,true>::ConstIterator
1538 return matrix_.cbegin(i);
1556template<
typename MT
1558inline typename SymmetricMatrix<MT,SO,true,true>::Iterator
1562 return Iterator( matrix_,
rows(), i );
1564 return Iterator( matrix_, i,
columns() );
1582template<
typename MT
1584inline typename SymmetricMatrix<MT,SO,true,true>::ConstIterator
1587 return matrix_.end(i);
1605template<
typename MT
1607inline typename SymmetricMatrix<MT,SO,true,true>::ConstIterator
1610 return matrix_.cend(i);
1649template<
typename MT
1651inline SymmetricMatrix<MT,SO,true,true>&
1654 const InitializerMatrix<ElementType> tmp( list, list.size() );
1695template<
typename MT
1697template<
typename Other
1699inline SymmetricMatrix<MT,SO,true,true>&
1700 SymmetricMatrix<MT,SO,true,true>::operator=(
const Other (&array)[N][N] )
1708 matrix_ = std::move( tmp );
1729template<
typename MT
1731inline SymmetricMatrix<MT,SO,true,true>&
1732 SymmetricMatrix<MT,SO,true,true>::operator=(
const SymmetricMatrix& rhs )
1734 matrix_ = rhs.matrix_;
1752template<
typename MT
1754inline SymmetricMatrix<MT,SO,true,true>&
1755 SymmetricMatrix<MT,SO,true,true>::operator=( SymmetricMatrix&& rhs )
noexcept
1757 matrix_ = std::move( rhs.matrix_ );
1781template<
typename MT
1783template<
typename MT2 >
1784inline auto SymmetricMatrix<MT,SO,true,true>::operator=(
const Matrix<MT2,SO>& rhs )
1785 -> DisableIf_t< IsComputation_v<MT2>, SymmetricMatrix& >
1787 if( !IsSymmetric_v<MT2> && !
isSymmetric( *rhs ) ) {
1815template<
typename MT
1817template<
typename MT2 >
1818inline auto SymmetricMatrix<MT,SO,true,true>::operator=(
const Matrix<MT2,SO>& rhs )
1819 -> EnableIf_t< IsComputation_v<MT2>, SymmetricMatrix& >
1821 if( !IsSquare_v<MT2> && !
isSquare( *rhs ) ) {
1825 if( IsSymmetric_v<MT2> ) {
1835 matrix_ = std::move( tmp );
1860template<
typename MT
1862template<
typename MT2 >
1863inline auto SymmetricMatrix<MT,SO,true,true>::operator=(
const Matrix<MT2,!SO>& rhs )
1866 return this->operator=(
trans( *rhs ) );
1885template<
typename MT
1887template<
typename MT2 >
1889 -> DisableIf_t< IsComputation_v<MT2>, SymmetricMatrix& >
1891 if( !IsSymmetric_v<MT2> && !
isSymmetric( *rhs ) ) {
1919template<
typename MT
1921template<
typename MT2 >
1923 -> EnableIf_t< IsComputation_v<MT2>, SymmetricMatrix& >
1925 if( !IsSquare_v<MT2> && !
isSquare( *rhs ) ) {
1929 if( IsSymmetric_v<MT2> ) {
1933 const ResultType_t<MT2> tmp( *rhs );
1965template<
typename MT
1967template<
typename MT2 >
1990template<
typename MT
1992template<
typename MT2 >
1994 -> DisableIf_t< IsComputation_v<MT2>, SymmetricMatrix& >
1996 if( !IsSymmetric_v<MT2> && !
isSymmetric( *rhs ) ) {
2024template<
typename MT
2026template<
typename MT2 >
2028 -> EnableIf_t< IsComputation_v<MT2>, SymmetricMatrix& >
2030 if( !IsSquare_v<MT2> && !
isSquare( *rhs ) ) {
2034 if( IsSymmetric_v<MT2> ) {
2038 const ResultType_t<MT2> tmp( *rhs );
2070template<
typename MT
2072template<
typename MT2 >
2096template<
typename MT
2098template<
typename MT2 >
2099inline auto SymmetricMatrix<MT,SO,true,true>::operator%=(
const Matrix<MT2,SO>& rhs )
2100 -> DisableIf_t< IsComputation_v<MT2>, SymmetricMatrix& >
2102 if( !IsSymmetric_v<MT2> && !
isSymmetric( *rhs ) ) {
2131template<
typename MT
2133template<
typename MT2 >
2134inline auto SymmetricMatrix<MT,SO,true,true>::operator%=(
const Matrix<MT2,SO>& rhs )
2135 -> EnableIf_t< IsComputation_v<MT2>, SymmetricMatrix& >
2137 if( !IsSquare_v<MT2> && !
isSquare( *rhs ) ) {
2141 if( IsSymmetric_v<MT2> ) {
2145 const ResultType_t<MT2> tmp( *rhs );
2177template<
typename MT
2179template<
typename MT2 >
2180inline auto SymmetricMatrix<MT,SO,true,true>::operator%=(
const Matrix<MT2,!SO>& rhs )
2183 return this->operator%=(
trans( *rhs ) );
2197template<
typename MT
2199template<
typename ST >
2201 -> EnableIf_t< IsScalar_v<ST>, SymmetricMatrix& >
2217template<
typename MT
2219template<
typename ST >
2221 -> EnableIf_t< IsScalar_v<ST>, SymmetricMatrix& >
2246template<
typename MT
2250 return matrix_.rows();
2262template<
typename MT
2266 return matrix_.columns();
2284template<
typename MT
2288 return matrix_.spacing();
2300template<
typename MT
2304 return matrix_.capacity();
2321template<
typename MT
2325 return matrix_.capacity(i);
2337template<
typename MT
2341 return matrix_.nonZeros();
2359template<
typename MT
2363 return matrix_.nonZeros(i);
2375template<
typename MT
2421template<
typename MT
2444template<
typename MT
2492template<
typename MT
2502 const size_t oldsize( matrix_.rows() );
2504 matrix_.resize( n, n,
true );
2507 const size_t increment( n - oldsize );
2508 submatrix( matrix_, 0UL, oldsize, oldsize, increment ).reset();
2509 submatrix( matrix_, oldsize, 0UL, increment, n ).reset();
2529template<
typename MT
2531inline void SymmetricMatrix<MT,SO,true,true>::extend(
size_t n,
bool preserve )
2552template<
typename MT
2554inline void SymmetricMatrix<MT,SO,true,true>::reserve(
size_t elements )
2572template<
typename MT
2576 matrix_.shrinkToFit();
2589template<
typename MT
2595 swap( matrix_, m.matrix_ );
2615template<
typename MT
2631template<
typename MT
2635 if( !IsBuiltin_v<ElementType> )
2662template<
typename MT
2664template<
typename Other >
2665inline SymmetricMatrix<MT,SO,true,true>&
2666 SymmetricMatrix<MT,SO,true,true>::scale(
const Other& scalar )
2668 matrix_.scale( scalar );
2693template<
typename MT
2724template<
typename MT
2726template<
typename Other >
2727inline bool SymmetricMatrix<MT,SO,true,true>::canAlias(
const Other* alias )
const noexcept
2729 return matrix_.canAlias( alias );
2746template<
typename MT
2748template<
typename Other >
2749inline bool SymmetricMatrix<MT,SO,true,true>::isAliased(
const Other* alias )
const noexcept
2751 return matrix_.isAliased( alias );
2767template<
typename MT
2769inline bool SymmetricMatrix<MT,SO,true,true>::isAligned() const noexcept
2771 return matrix_.isAligned();
2788template<
typename MT
2790inline bool SymmetricMatrix<MT,SO,true,true>::canSMPAssign() const noexcept
2792 return matrix_.canSMPAssign();
2814template<
typename MT
2817 SymmetricMatrix<MT,SO,true,true>::load(
size_t i,
size_t j )
const noexcept
2819 return matrix_.load( i, j );
2841template<
typename MT
2846 return matrix_.loada( i, j );
2868template<
typename MT
2873 return matrix_.loadu( i, j );
2896template<
typename MT
2899 SymmetricMatrix<MT,SO,true,true>::store(
size_t i,
size_t j,
const SIMDType& value )
noexcept
2901 matrix_.store( i, j, value );
2904 const size_t kend(
min( i+SIMDSIZE,
rows() ) );
2905 for(
size_t k=i; k<kend; ++k )
2906 matrix_(j,k) = matrix_(k,j);
2909 const size_t kend(
min( j+SIMDSIZE,
columns() ) );
2910 for(
size_t k=j; k<kend; ++k )
2911 matrix_(k,i) = matrix_(i,k);
2935template<
typename MT
2940 matrix_.storea( i, j, value );
2943 const size_t kend(
min( i+SIMDSIZE,
rows() ) );
2944 for(
size_t k=i; k<kend; ++k )
2945 matrix_(j,k) = matrix_(k,j);
2948 const size_t kend(
min( j+SIMDSIZE,
columns() ) );
2949 for(
size_t k=j; k<kend; ++k )
2950 matrix_(k,i) = matrix_(i,k);
2974template<
typename MT
2979 matrix_.storeu( i, j, value );
2982 const size_t kend(
min( i+SIMDSIZE,
rows() ) );
2983 for(
size_t k=i; k<kend; ++k )
2984 matrix_(j,k) = matrix_(k,j);
2987 const size_t kend(
min( j+SIMDSIZE,
columns() ) );
2988 for(
size_t k=j; k<kend; ++k )
2989 matrix_(k,i) = matrix_(i,k);
3013template<
typename MT
3018 matrix_.stream( i, j, value );
3021 const size_t kend(
min( i+SIMDSIZE,
rows() ) );
3022 for(
size_t k=i; k<kend; ++k )
3023 matrix_(j,k) = matrix_(k,j);
3026 const size_t kend(
min( j+SIMDSIZE,
columns() ) );
3027 for(
size_t k=j; k<kend; ++k )
3028 matrix_(k,i) = matrix_(i,k);
Header file for auxiliary alias declarations.
Header file for run time assertion macros.
Header file for the blaze::checked and blaze::unchecked instances.
Header file for the conjugate shim.
Constraint on the data type.
constexpr 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:751
constexpr 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:719
Header file for the EnableIf class template.
Constraint on the data type.
Header file for the If class template.
Header file for the dense matrix inversion flags.
Header file for the IsBuiltin type trait.
Header file for the IsComputation type trait class.
Header file for the IsScalar type trait.
Header file for the IsSquare type trait.
Header file for the IsSymmetric type trait.
Constraint on the data type.
Header file for the MAYBE_UNUSED function template.
Constraint on the data type.
Constraint on the data type.
Constraint on the data type.
Header file for all SIMD functionality.
Header file for the ScalarProxy class.
Constraint on the data type.
Constraint on the data type.
Constraint on the data type.
Constraint on the data type.
Header file for the implementation of the base template of the SymmetricMatrix.
Initializer list type of the Blaze library.
Pointer difference type of the Blaze library.
Constraint on the data type.
Constraint on the data type.
Constraint on the data type.
Header file for utility functions for dense matrices.
Header file for the implementation of a matrix representation of an initializer list.
Header file for the DenseMatrix base class.
decltype(auto) column(Matrix< MT, SO > &matrix, RCAs... args)
Creating a view on a specific column of the given matrix.
Definition: Column.h:137
#define BLAZE_CONSTRAINT_MUST_NOT_BE_VOLATILE(T)
Constraint on the data type.
Definition: Volatile.h:79
#define BLAZE_CONSTRAINT_MUST_NOT_BE_POINTER_TYPE(T)
Constraint on the data type.
Definition: Pointer.h:79
#define BLAZE_CONSTRAINT_MUST_NOT_BE_CONST(T)
Constraint on the data type.
Definition: Const.h:79
#define BLAZE_CONSTRAINT_MUST_NOT_BE_REFERENCE_TYPE(T)
Constraint on the data type.
Definition: Reference.h:79
auto operator/=(DenseMatrix< MT, SO > &mat, ST scalar) -> EnableIf_t< IsScalar_v< ST >, MT & >
Division assignment operator for the division of a dense matrix by a scalar value ( ).
Definition: DenseMatrix.h:574
decltype(auto) min(const DenseMatrix< MT1, SO1 > &lhs, const DenseMatrix< MT2, SO2 > &rhs)
Computes the componentwise minimum of the dense matrices lhs and rhs.
Definition: DMatDMatMapExpr.h:1339
decltype(auto) trans(const DenseMatrix< MT, SO > &dm)
Calculation of the transpose of the given dense matrix.
Definition: DMatTransExpr.h:766
MT::ElementType * data(DenseMatrix< MT, SO > &dm) noexcept
Low-level data access to the dense matrix elements.
Definition: DenseMatrix.h:182
auto operator+=(DenseMatrix< MT, SO > &mat, ST scalar) -> EnableIf_t< IsScalar_v< ST >, MT & >
Addition assignment operator for the addition of a dense matrix and a scalar value ( ).
Definition: DenseMatrix.h:386
auto operator*=(DenseMatrix< MT, SO > &mat, ST scalar) -> EnableIf_t< IsScalar_v< ST >, MT & >
Multiplication assignment operator for the multiplication of a dense matrix and a scalar value ( ).
Definition: DenseMatrix.h:510
size_t spacing(const DenseMatrix< MT, SO > &dm) noexcept
Returns the spacing between the beginning of two rows/columns.
Definition: DenseMatrix.h:265
bool isSymmetric(const DenseMatrix< MT, SO > &dm)
Checks if the given dense matrix is symmetric.
Definition: DenseMatrix.h:1456
decltype(auto) operator*(const DenseMatrix< MT1, false > &lhs, const DenseMatrix< MT2, false > &rhs)
Multiplication operator for the multiplication of two row-major dense matrices ( ).
Definition: DMatDMatMultExpr.h:9640
auto operator-=(DenseMatrix< MT, SO > &mat, ST scalar) -> EnableIf_t< IsScalar_v< ST >, MT & >
Subtraction assignment operator for the subtraction of a dense matrix and a scalar value ( ).
Definition: DenseMatrix.h:448
bool isZero(const DenseMatrix< MT, SO > &dm)
Checks if the given dense matrix is a zero matrix.
Definition: DenseMatrix.h:1819
bool isIntact(const DiagonalMatrix< MT, SO, DF > &m)
Returns whether the invariants of the given diagonal matrix are intact.
Definition: DiagonalMatrix.h:207
void swap(DiagonalMatrix< MT, SO, DF > &a, DiagonalMatrix< MT, SO, DF > &b) noexcept
Swapping the contents of two matrices.
Definition: DiagonalMatrix.h:225
decltype(auto) elements(Vector< VT, TF > &vector, REAs... args)
Creating a view on a selection of elements of the given vector.
Definition: Elements.h:143
void invert(const HermitianProxy< MT > &proxy)
In-place inversion of the represented element.
Definition: HermitianProxy.h:693
#define BLAZE_CONSTRAINT_MUST_NOT_BE_SYMMETRIC_MATRIX_TYPE(T)
Constraint on the data type.
Definition: Symmetric.h:79
#define BLAZE_CONSTRAINT_MUST_NOT_BE_VIEW_TYPE(T)
Constraint on the data type.
Definition: View.h:81
#define BLAZE_CONSTRAINT_MUST_NOT_BE_HERMITIAN_MATRIX_TYPE(T)
Constraint on the data type.
Definition: Hermitian.h:79
#define BLAZE_CONSTRAINT_MUST_NOT_BE_UPPER_MATRIX_TYPE(T)
Constraint on the data type.
Definition: Upper.h:81
#define BLAZE_CONSTRAINT_MUST_BE_DENSE_MATRIX_TYPE(T)
Constraint on the data type.
Definition: DenseMatrix.h:61
#define BLAZE_CONSTRAINT_MUST_NOT_BE_COMPUTATION_TYPE(T)
Constraint on the data type.
Definition: Computation.h:81
#define BLAZE_CONSTRAINT_MUST_NOT_BE_LOWER_MATRIX_TYPE(T)
Constraint on the data type.
Definition: Lower.h:81
#define BLAZE_CONSTRAINT_MUST_BE_RESIZABLE_TYPE(T)
Constraint on the data type.
Definition: Resizable.h:61
#define BLAZE_CONSTRAINT_MUST_BE_SCALAR_TYPE(T)
Constraint on the data type.
Definition: Scalar.h:61
#define BLAZE_CONSTRAINT_MUST_NOT_BE_TRANSFORMATION_TYPE(T)
Constraint on the data type.
Definition: Transformation.h:81
#define BLAZE_CONSTRAINT_MUST_BE_MATRIX_WITH_STORAGE_ORDER(T, SO)
Constraint on the data type.
Definition: StorageOrder.h:63
BLAZE_ALWAYS_INLINE void conjugate(T &a) noexcept(IsNumeric_v< T >)
In-place conjugation of the given value/object.
Definition: Conjugate.h:118
constexpr bool IsScalar_v
Auxiliary variable template for the IsScalar type trait.
Definition: IsScalar.h:104
constexpr ptrdiff_t Size_v
Auxiliary variable template for the Size type trait.
Definition: Size.h:176
constexpr bool IsComputation_v
Auxiliary variable template for the IsComputation type trait.
Definition: IsComputation.h:90
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:370
constexpr bool operator==(const NegativeAccuracy< A > &lhs, const T &rhs)
Equality comparison between a NegativeAccuracy object and a floating point value.
Definition: Accuracy.h:253
InversionFlag
Inversion flag.
Definition: InversionFlag.h:102
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:332
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:446
constexpr bool operator!=(const NegativeAccuracy< A > &lhs, const T &rhs)
Inequality comparison between a NegativeAccuracy object and a floating point value.
Definition: Accuracy.h:293
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:408
constexpr void clear(Matrix< MT, SO > &matrix)
Clearing the given matrix.
Definition: Matrix.h:960
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:628
constexpr size_t rows(const Matrix< MT, SO > &matrix) noexcept
Returns the current number of rows of the matrix.
Definition: Matrix.h:644
size_t nonZeros(const Matrix< MT, SO > &matrix)
Returns the total number of non-zero elements in the matrix.
Definition: Matrix.h:730
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:562
size_t capacity(const Matrix< MT, SO > &matrix) noexcept
Returns the maximum capacity of the matrix.
Definition: Matrix.h:692
constexpr void reset(Matrix< MT, SO > &matrix)
Resetting the given matrix.
Definition: Matrix.h:806
constexpr size_t columns(const Matrix< MT, SO > &matrix) noexcept
Returns the current number of columns of the matrix.
Definition: Matrix.h:660
void resize(Matrix< MT, SO > &matrix, size_t rows, size_t columns, bool preserve=true)
Changing the size of the matrix.
Definition: Matrix.h:1108
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:584
void ctranspose(Matrix< MT, SO > &matrix)
In-place conjugate transpose of the given matrix.
Definition: Matrix.h:1221
MT::Iterator begin(Matrix< MT, SO > &matrix, size_t i)
Returns an iterator to the first element of row/column i.
Definition: Matrix.h:518
constexpr size_t size(const Matrix< MT, SO > &matrix) noexcept
Returns the total number of elements of the matrix.
Definition: Matrix.h:676
void transpose(Matrix< MT, SO > &matrix)
In-place transpose of the given matrix.
Definition: Matrix.h:1195
void shrinkToFit(Matrix< MT, SO > &matrix)
Requesting the removal of unused capacity.
Definition: Matrix.h:1169
bool isSquare(const Matrix< MT, SO > &matrix) noexcept
Checks if the given matrix is a square matrix.
Definition: Matrix.h:1383
decltype(auto) row(Matrix< MT, SO > &, RRAs...)
Creating a view on a specific row of the given matrix.
Definition: Row.h:137
#define BLAZE_INTERNAL_ASSERT(expr, msg)
Run time assertion macro for internal checks.
Definition: Assert.h:101
#define BLAZE_USER_ASSERT(expr, msg)
Run time assertion macro for user checks.
Definition: Assert.h:117
BLAZE_ALWAYS_INLINE EnableIf_t< IsIntegral_v< T1 > &&HasSize_v< T1, 1UL > > storea(T1 *address, const SIMDi8< T2 > &value) noexcept
Aligned store of a vector of 1-byte integral values.
Definition: Storea.h:78
BLAZE_ALWAYS_INLINE EnableIf_t< IsIntegral_v< T1 > &&HasSize_v< T1, 1UL > > storeu(T1 *address, const SIMDi8< T2 > &value) noexcept
Unaligned store of a vector of 1-byte integral values.
Definition: Storeu.h:75
BLAZE_ALWAYS_INLINE EnableIf_t< IsIntegral_v< T1 > &&HasSize_v< T1, 1UL > > stream(T1 *address, const SIMDi8< T2 > &value) noexcept
Aligned, non-temporal store of a vector of 1-byte integral values.
Definition: Stream.h:74
BLAZE_ALWAYS_INLINE const EnableIf_t< IsIntegral_v< T > &&HasSize_v< T, 1UL >, If_t< IsSigned_v< T >, SIMDint8, SIMDuint8 > > loadu(const T *address) noexcept
Loads a vector of 1-byte integral values.
Definition: Loadu.h:76
BLAZE_ALWAYS_INLINE const EnableIf_t< IsIntegral_v< T > &&HasSize_v< T, 1UL >, If_t< IsSigned_v< T >, SIMDint8, SIMDuint8 > > loada(const T *address) noexcept
Loads a vector of 1-byte integral values.
Definition: Loada.h:79
#define BLAZE_STATIC_ASSERT(expr)
Compile time assertion macro.
Definition: StaticAssert.h:112
decltype(auto) submatrix(Matrix< MT, SO > &, RSAs...)
Creating a view on a specific submatrix of the given matrix.
Definition: Submatrix.h:181
#define BLAZE_ALWAYS_INLINE
Platform dependent setup of an enforced inline keyword.
Definition: Inline.h:85
typename EnableIf< Condition, T >::Type EnableIf_t
Auxiliary type for the EnableIf class template.
Definition: EnableIf.h:138
constexpr void MAYBE_UNUSED(const Args &...)
Suppression of unused parameter warnings.
Definition: MaybeUnused.h:81
#define BLAZE_THROW_OUT_OF_RANGE(MESSAGE)
Macro for the emission of a std::out_of_range exception.
Definition: Exception.h:331
#define BLAZE_THROW_INVALID_ARGUMENT(MESSAGE)
Macro for the emission of a std::invalid_argument exception.
Definition: Exception.h:235
typename EnableIf<!Condition, T >::Type DisableIf_t
Auxiliary type for the EnableIf class template.
Definition: EnableIf.h:175
constexpr Unchecked unchecked
Global Unchecked instance.
Definition: Check.h:146
Header file for the exception macros of the math module.
Header file for the extended initializer_list functionality.
Constraints on the storage order of matrix types.
Header file for all forward declarations for expression class templates.
Header file for the Size type trait.
Header file for the clear shim.
Header file for the isZero shim.
System settings for the inline keywords.
Header file for basic type definitions.
Header file for the generic min algorithm.
Header file for the implementation of the Column view.
Header file for the implementation of the Row view.
Header file for the implementation of the Submatrix view.