Blaze 3.9
DenseScalar.h
Go to the documentation of this file.
1//=================================================================================================
33//=================================================================================================
34
35#ifndef _BLAZE_MATH_ADAPTORS_SYMMETRICMATRIX_DENSESCALAR_H_
36#define _BLAZE_MATH_ADAPTORS_SYMMETRICMATRIX_DENSESCALAR_H_
37
38
39//*************************************************************************************************
40// Includes
41//*************************************************************************************************
42
43#include <iterator>
44#include <utility>
47#include <blaze/math/Aliases.h>
69#include <blaze/math/SIMD.h>
79#include <blaze/system/Inline.h>
81#include <blaze/util/Assert.h>
86#include <blaze/util/EnableIf.h>
88#include <blaze/util/mpl/If.h>
90#include <blaze/util/Types.h>
92
93
94namespace blaze {
95
96//=================================================================================================
97//
98// CLASS TEMPLATE SPECIALIZATION FOR DENSE MATRICES WITH SCALAR ELEMENT TYPE
99//
100//=================================================================================================
101
102//*************************************************************************************************
110template< typename MT // Type of the adapted dense matrix
111 , bool SO > // Storage order of the adapted dense matrix
112class SymmetricMatrix<MT,SO,true,true>
113 : public DenseMatrix< SymmetricMatrix<MT,SO,true,true>, SO >
114{
115 private:
116 //**Type definitions****************************************************************************
117 using OT = OppositeType_t<MT>;
118 using TT = TransposeType_t<MT>;
119 using ET = ElementType_t<MT>;
120 //**********************************************************************************************
121
122 public:
123 //**Type definitions****************************************************************************
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>;
139 //**********************************************************************************************
140
141 //**Rebind struct definition********************************************************************
144 template< typename NewType > // Data type of the other matrix
145 struct Rebind {
147 using Other = SymmetricMatrix< typename MT::template Rebind<NewType>::Other >;
148 };
149 //**********************************************************************************************
150
151 //**Resize struct definition********************************************************************
154 template< size_t NewM // Number of rows of the other matrix
155 , size_t NewN > // Number of columns of the other matrix
156 struct Resize {
158 using Other = SymmetricMatrix< typename MT::template Resize<NewM,NewN>::Other >;
159 };
160 //**********************************************************************************************
161
162 //**Iterator class definition*******************************************************************
165 class Iterator
166 {
167 public:
168 //**Type definitions*************************************************************************
169 using IteratorCategory = std::random_access_iterator_tag;
170 using ValueType = ElementType_t<MT>;
171 using PointerType = ScalarProxy<MT>;
172 using ReferenceType = ScalarProxy<MT>;
173 using DifferenceType = ptrdiff_t;
174
175 // STL iterator requirements
176 using iterator_category = IteratorCategory;
177 using value_type = ValueType;
178 using pointer = PointerType;
179 using reference = ReferenceType;
180 using difference_type = DifferenceType;
181 //*******************************************************************************************
182
183 //**Constructor******************************************************************************
186 inline Iterator() noexcept
187 : matrix_( nullptr ) // Reference to the adapted dense matrix
188 , row_ ( 0UL ) // The current row index of the iterator
189 , column_( 0UL ) // The current column index of the iterator
190 {}
191 //*******************************************************************************************
192
193 //**Constructor******************************************************************************
200 inline Iterator( MT& matrix, size_t row, size_t column ) noexcept
201 : matrix_( &matrix ) // Reference to the adapted dense matrix
202 , row_ ( row ) // The current row index of the iterator
203 , column_( column ) // The current column index of the iterator
204 {}
205 //*******************************************************************************************
206
207 //**Addition assignment operator*************************************************************
213 inline Iterator& operator+=( size_t inc ) noexcept {
214 ( SO )?( row_ += inc ):( column_ += inc );
215 return *this;
216 }
217 //*******************************************************************************************
218
219 //**Subtraction assignment operator**********************************************************
225 inline Iterator& operator-=( size_t dec ) noexcept {
226 ( SO )?( row_ -= dec ):( column_ -= dec );
227 return *this;
228 }
229 //*******************************************************************************************
230
231 //**Prefix increment operator****************************************************************
236 inline Iterator& operator++() noexcept {
237 ( SO )?( ++row_ ):( ++column_ );
238 return *this;
239 }
240 //*******************************************************************************************
241
242 //**Postfix increment operator***************************************************************
247 inline const Iterator operator++( int ) noexcept {
248 const Iterator tmp( *this );
249 ++(*this);
250 return tmp;
251 }
252 //*******************************************************************************************
253
254 //**Prefix decrement operator****************************************************************
259 inline Iterator& operator--() noexcept {
260 ( SO )?( --row_ ):( --column_ );
261 return *this;
262 }
263 //*******************************************************************************************
264
265 //**Postfix decrement operator***************************************************************
270 inline const Iterator operator--( int ) noexcept {
271 const Iterator tmp( *this );
272 --(*this);
273 return tmp;
274 }
275 //*******************************************************************************************
276
277 //**Element access operator******************************************************************
282 inline ReferenceType operator*() const {
283 return ReferenceType( *matrix_, row_, column_ );
284 }
285 //*******************************************************************************************
286
287 //**Element access operator******************************************************************
292 inline PointerType operator->() const {
293 return PointerType( *matrix_, row_, column_ );
294 }
295 //*******************************************************************************************
296
297 //**Load function****************************************************************************
307 inline SIMDType load() const {
308 return (*matrix_).load(row_,column_);
309 }
310 //*******************************************************************************************
311
312 //**Loada function***************************************************************************
322 inline SIMDType loada() const {
323 return (*matrix_).loada(row_,column_);
324 }
325 //*******************************************************************************************
326
327 //**Loadu function***************************************************************************
337 inline SIMDType loadu() const {
338 return (*matrix_).loadu(row_,column_);
339 }
340 //*******************************************************************************************
341
342 //**Store function***************************************************************************
353 inline void store( const SIMDType& value ) const {
354 (*matrix_).store( row_, column_, value );
355 sync();
356 }
357 //*******************************************************************************************
358
359 //**Storea function**************************************************************************
370 inline void storea( const SIMDType& value ) const {
371 (*matrix_).storea( row_, column_, value );
372 sync();
373 }
374 //*******************************************************************************************
375
376 //**Storeu function**************************************************************************
387 inline void storeu( const SIMDType& value ) const {
388 (*matrix_).storeu( row_, column_, value );
389 sync();
390 }
391 //*******************************************************************************************
392
393 //**Stream function**************************************************************************
404 inline void stream( const SIMDType& value ) const {
405 (*matrix_).stream( row_, column_, value );
406 sync();
407 }
408 //*******************************************************************************************
409
410 //**Conversion operator**********************************************************************
415 inline operator ConstIterator() const {
416 if( SO )
417 return matrix_->begin( column_ ) + row_;
418 else
419 return matrix_->begin( row_ ) + column_;
420 }
421 //*******************************************************************************************
422
423 //**Equality operator************************************************************************
430 friend inline bool operator==( const Iterator& lhs, const Iterator& rhs ) noexcept {
431 return ( SO )?( lhs.row_ == rhs.row_ ):( lhs.column_ == rhs.column_ );
432 }
433 //*******************************************************************************************
434
435 //**Equality operator************************************************************************
442 friend inline bool operator==( const Iterator& lhs, const ConstIterator& rhs ) {
443 return ( ConstIterator( lhs ) == rhs );
444 }
445 //*******************************************************************************************
446
447 //**Equality operator************************************************************************
454 friend inline bool operator==( const ConstIterator& lhs, const Iterator& rhs ) {
455 return ( lhs == ConstIterator( rhs ) );
456 }
457 //*******************************************************************************************
458
459 //**Inequality operator**********************************************************************
466 friend inline bool operator!=( const Iterator& lhs, const Iterator& rhs ) noexcept {
467 return ( SO )?( lhs.row_ != rhs.row_ ):( lhs.column_ != rhs.column_ );
468 }
469 //*******************************************************************************************
470
471 //**Inequality operator**********************************************************************
478 friend inline bool operator!=( const Iterator& lhs, const ConstIterator& rhs ) {
479 return ( ConstIterator( lhs ) != rhs );
480 }
481 //*******************************************************************************************
482
483 //**Inequality operator**********************************************************************
490 friend inline bool operator!=( const ConstIterator& lhs, const Iterator& rhs ) {
491 return ( lhs != ConstIterator( rhs ) );
492 }
493 //*******************************************************************************************
494
495 //**Less-than operator***********************************************************************
502 friend inline bool operator<( const Iterator& lhs, const Iterator& rhs ) noexcept {
503 return ( SO )?( lhs.row_ < rhs.row_ ):( lhs.column_ < rhs.column_ );
504 }
505 //*******************************************************************************************
506
507 //**Less-than operator***********************************************************************
514 friend inline bool operator<( const Iterator& lhs, const ConstIterator& rhs ) {
515 return ( ConstIterator( lhs ) < rhs );
516 }
517 //*******************************************************************************************
518
519 //**Less-than operator***********************************************************************
526 friend inline bool operator<( const ConstIterator& lhs, const Iterator& rhs ) {
527 return ( lhs < ConstIterator( rhs ) );
528 }
529 //*******************************************************************************************
530
531 //**Greater-than operator********************************************************************
538 friend inline bool operator>( const Iterator& lhs, const Iterator& rhs ) noexcept {
539 return ( SO )?( lhs.row_ > rhs.row_ ):( lhs.column_ > rhs.column_ );
540 }
541 //*******************************************************************************************
542
543 //**Greater-than operator********************************************************************
550 friend inline bool operator>( const Iterator& lhs, const ConstIterator& rhs ) {
551 return ( ConstIterator( lhs ) > rhs );
552 }
553 //*******************************************************************************************
554
555 //**Greater-than operator********************************************************************
562 friend inline bool operator>( const ConstIterator& lhs, const Iterator& rhs ) {
563 return ( lhs > ConstIterator( rhs ) );
564 }
565 //*******************************************************************************************
566
567 //**Less-or-equal-than operator**************************************************************
574 friend inline bool operator<=( const Iterator& lhs, const Iterator& rhs ) noexcept {
575 return ( SO )?( lhs.row_ <= rhs.row_ ):( lhs.column_ <= rhs.column_ );
576 }
577 //*******************************************************************************************
578
579 //**Less-or-equal-than operator**************************************************************
586 friend inline bool operator<=( const Iterator& lhs, const ConstIterator& rhs ) {
587 return ( ConstIterator( lhs ) <= rhs );
588 }
589 //*******************************************************************************************
590
591 //**Less-or-equal-than operator**************************************************************
598 friend inline bool operator<=( const ConstIterator& lhs, const Iterator& rhs ) {
599 return ( lhs <= ConstIterator( rhs ) );
600 }
601 //*******************************************************************************************
602
603 //**Greater-or-equal-than operator***********************************************************
610 friend inline bool operator>=( const Iterator& lhs, const Iterator& rhs ) noexcept {
611 return ( SO )?( lhs.row_ >= rhs.row_ ):( lhs.column_ >= rhs.column_ );
612 }
613 //*******************************************************************************************
614
615 //**Greater-or-equal-than operator***********************************************************
622 friend inline bool operator>=( const Iterator& lhs, const ConstIterator& rhs ) {
623 return ( ConstIterator( lhs ) >= rhs );
624 }
625 //*******************************************************************************************
626
627 //**Greater-or-equal-than operator***********************************************************
634 friend inline bool operator>=( const ConstIterator& lhs, const Iterator& rhs ) {
635 return ( lhs >= ConstIterator( rhs ) );
636 }
637 //*******************************************************************************************
638
639 //**Subtraction operator*********************************************************************
645 inline DifferenceType operator-( const Iterator& rhs ) const noexcept {
646 return ( SO )?( row_ - rhs.row_ ):( column_ - rhs.column_ );
647 }
648 //*******************************************************************************************
649
650 //**Addition operator************************************************************************
657 friend inline const Iterator operator+( const Iterator& it, size_t inc ) noexcept {
658 if( SO )
659 return Iterator( *it.matrix_, it.row_ + inc, it.column_ );
660 else
661 return Iterator( *it.matrix_, it.row_, it.column_ + inc );
662 }
663 //*******************************************************************************************
664
665 //**Addition operator************************************************************************
672 friend inline const Iterator operator+( size_t inc, const Iterator& it ) noexcept {
673 if( SO )
674 return Iterator( *it.matrix_, it.row_ + inc, it.column_ );
675 else
676 return Iterator( *it.matrix_, it.row_, it.column_ + inc );
677 }
678 //*******************************************************************************************
679
680 //**Subtraction operator*********************************************************************
687 friend inline const Iterator operator-( const Iterator& it, size_t dec ) noexcept {
688 if( SO )
689 return Iterator( *it.matrix_, it.row_ - dec, it.column_ );
690 else
691 return Iterator( *it.matrix_, it.row_, it.column_ - dec );
692 }
693 //*******************************************************************************************
694
695 private:
696 //**Sync function****************************************************************************
701 void sync() const {
702 if( SO ) {
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_);
706 }
707 else {
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);
711 }
712 }
713 //*******************************************************************************************
714
715 //**Member variables*************************************************************************
716 MT* matrix_;
717 size_t row_;
718 size_t column_;
719 //*******************************************************************************************
720 };
721 //**********************************************************************************************
722
723 //**Compilation flags***************************************************************************
725 static constexpr bool simdEnabled = MT::simdEnabled;
726
728 static constexpr bool smpAssignable = MT::smpAssignable;
729 //**********************************************************************************************
730
731 //**Constructors********************************************************************************
734 inline SymmetricMatrix();
735 explicit inline SymmetricMatrix( size_t n );
736 inline SymmetricMatrix( initializer_list< initializer_list<ElementType> > list );
737
738 template< typename Other >
739 inline SymmetricMatrix( size_t n, const Other* array );
740
741 template< typename Other, size_t N >
742 inline SymmetricMatrix( const Other (&array)[N][N] );
743
744 inline SymmetricMatrix( ElementType* ptr, size_t n );
745 inline SymmetricMatrix( ElementType* ptr, size_t n, size_t nn );
746
747 inline SymmetricMatrix( const SymmetricMatrix& m );
748 inline SymmetricMatrix( SymmetricMatrix&& m ) noexcept;
749
750 template< typename MT2 > inline SymmetricMatrix( const Matrix<MT2,SO>& m );
751 template< typename MT2 > inline SymmetricMatrix( const Matrix<MT2,!SO>& m );
753 //**********************************************************************************************
754
755 //**Destructor**********************************************************************************
758 ~SymmetricMatrix() = default;
760 //**********************************************************************************************
761
762 //**Data access functions***********************************************************************
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;
778 //**********************************************************************************************
779
780 //**Assignment operators************************************************************************
783 inline SymmetricMatrix& operator=( initializer_list< initializer_list<ElementType> > list );
784
785 template< typename Other, size_t N >
786 inline SymmetricMatrix& operator=( const Other (&array)[N][N] );
787
788 inline SymmetricMatrix& operator=( const SymmetricMatrix& rhs );
789 inline SymmetricMatrix& operator=( SymmetricMatrix&& rhs ) noexcept;
790
791 template< typename MT2 >
792 inline auto operator=( const Matrix<MT2,SO>& rhs )
793 -> DisableIf_t< IsComputation_v<MT2>, SymmetricMatrix& >;
794
795 template< typename MT2 >
796 inline auto operator=( const Matrix<MT2,SO>& rhs )
797 -> EnableIf_t< IsComputation_v<MT2>, SymmetricMatrix& >;
798
799 template< typename MT2 >
800 inline auto operator=( const Matrix<MT2,!SO>& rhs ) -> SymmetricMatrix&;
801
802 template< typename MT2 >
803 inline auto operator+=( const Matrix<MT2,SO>& rhs )
804 -> DisableIf_t< IsComputation_v<MT2>, SymmetricMatrix& >;
805
806 template< typename MT2 >
807 inline auto operator+=( const Matrix<MT2,SO>& rhs )
808 -> EnableIf_t< IsComputation_v<MT2>, SymmetricMatrix& >;
809
810 template< typename MT2 >
811 inline auto operator+=( const Matrix<MT2,!SO>& rhs ) -> SymmetricMatrix&;
812
813 template< typename MT2 >
814 inline auto operator-=( const Matrix<MT2,SO>& rhs )
815 -> DisableIf_t< IsComputation_v<MT2>, SymmetricMatrix& >;
816
817 template< typename MT2 >
818 inline auto operator-=( const Matrix<MT2,SO>& rhs )
819 -> EnableIf_t< IsComputation_v<MT2>, SymmetricMatrix& >;
820
821 template< typename MT2 >
822 inline auto operator-=( const Matrix<MT2,!SO>& rhs ) -> SymmetricMatrix&;
823
824 template< typename MT2 >
825 inline auto operator%=( const Matrix<MT2,SO>& rhs )
826 -> DisableIf_t< IsComputation_v<MT2>, SymmetricMatrix& >;
827
828 template< typename MT2 >
829 inline auto operator%=( const Matrix<MT2,SO>& rhs )
830 -> EnableIf_t< IsComputation_v<MT2>, SymmetricMatrix& >;
831
832 template< typename MT2 >
833 inline auto operator%=( const Matrix<MT2,!SO>& rhs ) -> SymmetricMatrix&;
834
835 template< typename ST >
836 inline auto operator*=( ST rhs ) -> EnableIf_t< IsScalar_v<ST>, SymmetricMatrix& >;
837
838 template< typename ST >
839 inline auto operator/=( ST rhs ) -> EnableIf_t< IsScalar_v<ST>, SymmetricMatrix& >;
841 //**********************************************************************************************
842
843 //**Utility functions***************************************************************************
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;
851 inline size_t nonZeros() const;
852 inline size_t nonZeros( size_t i ) const;
853 inline void reset();
854 inline void reset( size_t i );
855 inline void clear();
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 );
859 inline void shrinkToFit();
860 inline void swap( SymmetricMatrix& m ) noexcept;
862 //**********************************************************************************************
863
864 //**Numeric functions***************************************************************************
867 inline SymmetricMatrix& transpose();
868 inline SymmetricMatrix& ctranspose();
869
870 template< typename Other > inline SymmetricMatrix& scale( const Other& scalar );
872 //**********************************************************************************************
873
874 //**Debugging functions*************************************************************************
877 inline bool isIntact() const noexcept;
879 //**********************************************************************************************
880
881 //**Expression template evaluation functions****************************************************
884 template< typename Other > inline bool canAlias ( const Other* alias ) const noexcept;
885 template< typename Other > inline bool isAliased( const Other* alias ) const noexcept;
886
887 inline bool isAligned () const noexcept;
888 inline bool canSMPAssign() const noexcept;
889
890 BLAZE_ALWAYS_INLINE SIMDType load ( size_t i, size_t j ) const noexcept;
891 BLAZE_ALWAYS_INLINE SIMDType loada( size_t i, size_t j ) const noexcept;
892 BLAZE_ALWAYS_INLINE SIMDType loadu( size_t i, size_t j ) const noexcept;
893
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;
899 //**********************************************************************************************
900
901 private:
902 //**SIMD properties*****************************************************************************
904 static constexpr size_t SIMDSIZE = SIMDTrait<ET>::size;
905 //**********************************************************************************************
906
907 //**Member variables****************************************************************************
910 MT matrix_;
912 //**********************************************************************************************
913
914 //**Friend declarations*************************************************************************
915 template< InversionFlag IF, typename MT2, bool SO2 >
916 friend void invert( SymmetricMatrix<MT2,SO2,true,true>& m );
917 //**********************************************************************************************
918
919 //**Compile time checks*************************************************************************
935 BLAZE_STATIC_ASSERT( ( Size_v<MT,0UL> == Size_v<MT,1UL> ) );
936 //**********************************************************************************************
937};
939//*************************************************************************************************
940
941
942
943
944//=================================================================================================
945//
946// CONSTRUCTORS
947//
948//=================================================================================================
949
950//*************************************************************************************************
954template< typename MT // Type of the adapted dense matrix
955 , bool SO > // Storage order of the adapted dense matrix
956inline SymmetricMatrix<MT,SO,true,true>::SymmetricMatrix()
957 : matrix_() // The adapted dense matrix
958{
959 BLAZE_INTERNAL_ASSERT( isSquare( matrix_ ), "Non-square symmetric matrix detected" );
960 BLAZE_INTERNAL_ASSERT( isIntact(), "Broken invariant detected" );
961}
963//*************************************************************************************************
964
965
966//*************************************************************************************************
972template< typename MT // Type of the adapted dense matrix
973 , bool SO > // Storage order of the adapted dense matrix
974inline SymmetricMatrix<MT,SO,true,true>::SymmetricMatrix( size_t n )
975 : matrix_( n, n, ElementType() ) // The adapted dense matrix
976{
978
979 BLAZE_INTERNAL_ASSERT( isSquare( matrix_ ), "Non-square symmetric matrix detected" );
980 BLAZE_INTERNAL_ASSERT( isIntact(), "Broken invariant detected" );
981}
983//*************************************************************************************************
984
985
986//*************************************************************************************************
1010template< typename MT // Type of the adapted dense matrix
1011 , bool SO > // Storage order of the adapted dense matrix
1012inline SymmetricMatrix<MT,SO,true,true>::SymmetricMatrix( initializer_list< initializer_list<ElementType> > list )
1013 : matrix_( list ) // The adapted dense matrix
1014{
1015 if( !isSymmetric( matrix_ ) ) {
1016 BLAZE_THROW_INVALID_ARGUMENT( "Invalid setup of symmetric matrix" );
1017 }
1018
1019 BLAZE_INTERNAL_ASSERT( isIntact(), "Broken invariant detected" );
1020}
1022//*************************************************************************************************
1023
1024
1025//*************************************************************************************************
1051template< typename MT // Type of the adapted dense matrix
1052 , bool SO > // Storage order of the adapted dense matrix
1053template< typename Other > // Data type of the initialization array
1054inline SymmetricMatrix<MT,SO,true,true>::SymmetricMatrix( size_t n, const Other* array )
1055 : matrix_( n, n, array ) // The adapted dense matrix
1056{
1057 if( !isSymmetric( matrix_ ) ) {
1058 BLAZE_THROW_INVALID_ARGUMENT( "Invalid setup of symmetric matrix" );
1059 }
1060
1061 BLAZE_INTERNAL_ASSERT( isIntact(), "Broken invariant detected" );
1062}
1064//*************************************************************************************************
1065
1066
1067//*************************************************************************************************
1090template< typename MT // Type of the adapted dense matrix
1091 , bool SO > // Storage order of the adapted dense matrix
1092template< typename Other // Data type of the initialization array
1093 , size_t N > // Number of rows and columns of the initialization array
1094inline SymmetricMatrix<MT,SO,true,true>::SymmetricMatrix( const Other (&array)[N][N] )
1095 : matrix_( array ) // The adapted dense matrix
1096{
1097 if( !isSymmetric( matrix_ ) ) {
1098 BLAZE_THROW_INVALID_ARGUMENT( "Invalid setup of symmetric matrix" );
1099 }
1100
1101 BLAZE_INTERNAL_ASSERT( isIntact(), "Broken invariant detected" );
1102}
1104//*************************************************************************************************
1105
1106
1107//*************************************************************************************************
1139template< typename MT // Type of the adapted dense matrix
1140 , bool SO > // Storage order of the adapted dense matrix
1141inline SymmetricMatrix<MT,SO,true,true>::SymmetricMatrix( ElementType* ptr, size_t n )
1142 : matrix_( ptr, n, n ) // The adapted dense matrix
1143{
1144 if( !isSymmetric( matrix_ ) ) {
1145 BLAZE_THROW_INVALID_ARGUMENT( "Invalid setup of symmetric matrix" );
1146 }
1147
1148 BLAZE_INTERNAL_ASSERT( isIntact(), "Broken invariant detected" );
1149}
1151//*************************************************************************************************
1152
1153
1154//*************************************************************************************************
1188template< typename MT // Type of the adapted dense matrix
1189 , bool SO > // Storage order of the adapted dense matrix
1190inline SymmetricMatrix<MT,SO,true,true>::SymmetricMatrix( ElementType* ptr, size_t n, size_t nn )
1191 : matrix_( ptr, n, n, nn ) // The adapted dense matrix
1192{
1193 if( !isSymmetric( matrix_ ) ) {
1194 BLAZE_THROW_INVALID_ARGUMENT( "Invalid setup of symmetric matrix" );
1195 }
1196
1197 BLAZE_INTERNAL_ASSERT( isIntact(), "Broken invariant detected" );
1198}
1200//*************************************************************************************************
1201
1202
1203//*************************************************************************************************
1209template< typename MT // Type of the adapted dense matrix
1210 , bool SO > // Storage order of the adapted dense matrix
1211inline SymmetricMatrix<MT,SO,true,true>::SymmetricMatrix( const SymmetricMatrix& m )
1212 : matrix_( m.matrix_ ) // The adapted dense matrix
1213{
1214 BLAZE_INTERNAL_ASSERT( isSquare( matrix_ ), "Non-square symmetric matrix detected" );
1215 BLAZE_INTERNAL_ASSERT( isIntact(), "Broken invariant detected" );
1216}
1218//*************************************************************************************************
1219
1220
1221//*************************************************************************************************
1227template< typename MT // Type of the adapted dense matrix
1228 , bool SO > // Storage order of the adapted dense matrix
1229inline SymmetricMatrix<MT,SO,true,true>::SymmetricMatrix( SymmetricMatrix&& m ) noexcept
1230 : matrix_( std::move( m.matrix_ ) ) // The adapted dense matrix
1231{
1232 BLAZE_INTERNAL_ASSERT( isSquare( matrix_ ), "Non-square symmetric matrix detected" );
1233 BLAZE_INTERNAL_ASSERT( isIntact(), "Broken invariant detected" );
1234}
1236//*************************************************************************************************
1237
1238
1239//*************************************************************************************************
1249template< typename MT // Type of the adapted dense matrix
1250 , bool SO > // Storage order of the adapted dense matrix
1251template< typename MT2 > // Type of the foreign matrix
1252inline SymmetricMatrix<MT,SO,true,true>::SymmetricMatrix( const Matrix<MT2,SO>& m )
1253 : matrix_( *m ) // The adapted dense matrix
1254{
1255 if( !IsSymmetric_v<MT2> && !isSymmetric( matrix_ ) ) {
1256 BLAZE_THROW_INVALID_ARGUMENT( "Invalid setup of symmetric matrix" );
1257 }
1258
1259 BLAZE_INTERNAL_ASSERT( isSquare( matrix_ ), "Non-square symmetric matrix detected" );
1260 BLAZE_INTERNAL_ASSERT( isIntact(), "Broken invariant detected" );
1261}
1263//*************************************************************************************************
1264
1265
1266//*************************************************************************************************
1276template< typename MT // Type of the adapted dense matrix
1277 , bool SO > // Storage order of the adapted dense matrix
1278template< typename MT2 > // Type of the foreign matrix
1279inline SymmetricMatrix<MT,SO,true,true>::SymmetricMatrix( const Matrix<MT2,!SO>& m )
1280 : matrix_( trans( *m ) ) // The adapted dense matrix
1281{
1282 if( !IsSymmetric_v<MT2> && !isSymmetric( matrix_ ) ) {
1283 BLAZE_THROW_INVALID_ARGUMENT( "Invalid setup of symmetric matrix" );
1284 }
1285
1286 BLAZE_INTERNAL_ASSERT( isSquare( matrix_ ), "Non-square symmetric matrix detected" );
1287 BLAZE_INTERNAL_ASSERT( isIntact(), "Broken invariant detected" );
1288}
1290//*************************************************************************************************
1291
1292
1293
1294
1295//=================================================================================================
1296//
1297// DATA ACCESS FUNCTIONS
1298//
1299//=================================================================================================
1300
1301//*************************************************************************************************
1316template< typename MT // Type of the adapted dense matrix
1317 , bool SO > // Storage order of the adapted dense matrix
1318inline typename SymmetricMatrix<MT,SO,true,true>::Reference
1319 SymmetricMatrix<MT,SO,true,true>::operator()( size_t i, size_t j )
1320{
1321 BLAZE_USER_ASSERT( i<rows() , "Invalid row access index" );
1322 BLAZE_USER_ASSERT( j<columns(), "Invalid column access index" );
1323
1324 return Reference( matrix_, i, j );
1325}
1327//*************************************************************************************************
1328
1329
1330//*************************************************************************************************
1345template< typename MT // Type of the adapted dense matrix
1346 , bool SO > // Storage order of the adapted dense matrix
1347inline typename SymmetricMatrix<MT,SO,true,true>::ConstReference
1348 SymmetricMatrix<MT,SO,true,true>::operator()( size_t i, size_t j ) const
1349{
1350 BLAZE_USER_ASSERT( i<rows() , "Invalid row access index" );
1351 BLAZE_USER_ASSERT( j<columns(), "Invalid column access index" );
1352
1353 return matrix_(i,j);
1354}
1356//*************************************************************************************************
1357
1358
1359//*************************************************************************************************
1375template< typename MT // Type of the adapted dense matrix
1376 , bool SO > // Storage order of the adapted dense matrix
1377inline typename SymmetricMatrix<MT,SO,true,true>::Reference
1378 SymmetricMatrix<MT,SO,true,true>::at( size_t i, size_t j )
1379{
1380 if( i >= rows() ) {
1381 BLAZE_THROW_OUT_OF_RANGE( "Invalid row access index" );
1382 }
1383 if( j >= columns() ) {
1384 BLAZE_THROW_OUT_OF_RANGE( "Invalid column access index" );
1385 }
1386 return (*this)(i,j);
1387}
1389//*************************************************************************************************
1390
1391
1392//*************************************************************************************************
1408template< typename MT // Type of the adapted dense matrix
1409 , bool SO > // Storage order of the adapted dense matrix
1410inline typename SymmetricMatrix<MT,SO,true,true>::ConstReference
1411 SymmetricMatrix<MT,SO,true,true>::at( size_t i, size_t j ) const
1412{
1413 if( i >= rows() ) {
1414 BLAZE_THROW_OUT_OF_RANGE( "Invalid row access index" );
1415 }
1416 if( j >= columns() ) {
1417 BLAZE_THROW_OUT_OF_RANGE( "Invalid column access index" );
1418 }
1419 return (*this)(i,j);
1420}
1422//*************************************************************************************************
1423
1424
1425//*************************************************************************************************
1439template< typename MT // Type of the adapted dense matrix
1440 , bool SO > // Storage order of the adapted dense matrix
1441inline typename SymmetricMatrix<MT,SO,true,true>::ConstPointer
1443{
1444 return matrix_.data();
1445}
1447//*************************************************************************************************
1448
1449
1450//*************************************************************************************************
1461template< typename MT // Type of the adapted dense matrix
1462 , bool SO > // Storage order of the adapted dense matrix
1463inline typename SymmetricMatrix<MT,SO,true,true>::ConstPointer
1464 SymmetricMatrix<MT,SO,true,true>::data( size_t i ) const noexcept
1465{
1466 return matrix_.data(i);
1467}
1469//*************************************************************************************************
1470
1471
1472//*************************************************************************************************
1484template< typename MT // Type of the adapted dense matrix
1485 , bool SO > // Storage order of the adapted dense matrix
1486inline typename SymmetricMatrix<MT,SO,true,true>::Iterator
1488{
1489 if( SO )
1490 return Iterator( matrix_, 0UL, i );
1491 else
1492 return Iterator( matrix_, i, 0UL );
1493}
1495//*************************************************************************************************
1496
1497
1498//*************************************************************************************************
1510template< typename MT // Type of the adapted dense matrix
1511 , bool SO > // Storage order of the adapted dense matrix
1512inline typename SymmetricMatrix<MT,SO,true,true>::ConstIterator
1514{
1515 return matrix_.begin(i);
1516}
1518//*************************************************************************************************
1519
1520
1521//*************************************************************************************************
1533template< typename MT // Type of the adapted dense matrix
1534 , bool SO > // Storage order of the adapted dense matrix
1535inline typename SymmetricMatrix<MT,SO,true,true>::ConstIterator
1537{
1538 return matrix_.cbegin(i);
1539}
1541//*************************************************************************************************
1542
1543
1544//*************************************************************************************************
1556template< typename MT // Type of the adapted dense matrix
1557 , bool SO > // Storage order of the adapted dense matrix
1558inline typename SymmetricMatrix<MT,SO,true,true>::Iterator
1560{
1561 if( SO )
1562 return Iterator( matrix_, rows(), i );
1563 else
1564 return Iterator( matrix_, i, columns() );
1565}
1567//*************************************************************************************************
1568
1569
1570//*************************************************************************************************
1582template< typename MT // Type of the adapted dense matrix
1583 , bool SO > // Storage order of the adapted dense matrix
1584inline typename SymmetricMatrix<MT,SO,true,true>::ConstIterator
1586{
1587 return matrix_.end(i);
1588}
1590//*************************************************************************************************
1591
1592
1593//*************************************************************************************************
1605template< typename MT // Type of the adapted dense matrix
1606 , bool SO > // Storage order of the adapted dense matrix
1607inline typename SymmetricMatrix<MT,SO,true,true>::ConstIterator
1609{
1610 return matrix_.cend(i);
1611}
1613//*************************************************************************************************
1614
1615
1616
1617
1618//=================================================================================================
1619//
1620// ASSIGNMENT OPERATORS
1621//
1622//=================================================================================================
1623
1624//*************************************************************************************************
1649template< typename MT // Type of the adapted dense matrix
1650 , bool SO > // Storage order of the adapted dense matrix
1651inline SymmetricMatrix<MT,SO,true,true>&
1652 SymmetricMatrix<MT,SO,true,true>::operator=( initializer_list< initializer_list<ElementType> > list )
1653{
1654 const InitializerMatrix<ElementType> tmp( list, list.size() );
1655
1656 if( !isSymmetric( tmp ) ) {
1657 BLAZE_THROW_INVALID_ARGUMENT( "Invalid assignment to symmetric matrix" );
1658 }
1659
1660 matrix_ = list;
1661
1662 BLAZE_INTERNAL_ASSERT( isSquare( matrix_ ), "Non-square symmetric matrix detected" );
1663 BLAZE_INTERNAL_ASSERT( isIntact(), "Broken invariant detected" );
1664
1665 return *this;
1666}
1668//*************************************************************************************************
1669
1670
1671//*************************************************************************************************
1695template< typename MT // Type of the adapted dense matrix
1696 , bool SO > // Storage order of the adapted dense matrix
1697template< typename Other // Data type of the initialization array
1698 , size_t N > // Number of rows and columns of the initialization array
1699inline SymmetricMatrix<MT,SO,true,true>&
1700 SymmetricMatrix<MT,SO,true,true>::operator=( const Other (&array)[N][N] )
1701{
1702 MT tmp( array );
1703
1704 if( !isSymmetric( tmp ) ) {
1705 BLAZE_THROW_INVALID_ARGUMENT( "Invalid assignment to symmetric matrix" );
1706 }
1707
1708 matrix_ = std::move( tmp );
1709
1710 BLAZE_INTERNAL_ASSERT( isSquare( matrix_ ), "Non-square symmetric matrix detected" );
1711 BLAZE_INTERNAL_ASSERT( isIntact(), "Broken invariant detected" );
1712
1713 return *this;
1714}
1716//*************************************************************************************************
1717
1718
1719//*************************************************************************************************
1729template< typename MT // Type of the adapted dense matrix
1730 , bool SO > // Storage order of the adapted dense matrix
1731inline SymmetricMatrix<MT,SO,true,true>&
1732 SymmetricMatrix<MT,SO,true,true>::operator=( const SymmetricMatrix& rhs )
1733{
1734 matrix_ = rhs.matrix_;
1735
1736 BLAZE_INTERNAL_ASSERT( isSquare( matrix_ ), "Non-square symmetric matrix detected" );
1737 BLAZE_INTERNAL_ASSERT( isIntact(), "Broken invariant detected" );
1738
1739 return *this;
1740}
1742//*************************************************************************************************
1743
1744
1745//*************************************************************************************************
1752template< typename MT // Type of the adapted dense matrix
1753 , bool SO > // Storage order of the adapted dense matrix
1754inline SymmetricMatrix<MT,SO,true,true>&
1755 SymmetricMatrix<MT,SO,true,true>::operator=( SymmetricMatrix&& rhs ) noexcept
1756{
1757 matrix_ = std::move( rhs.matrix_ );
1758
1759 BLAZE_INTERNAL_ASSERT( isSquare( matrix_ ), "Non-square symmetric matrix detected" );
1760 BLAZE_INTERNAL_ASSERT( isIntact(), "Broken invariant detected" );
1761
1762 return *this;
1763}
1765//*************************************************************************************************
1766
1767
1768//*************************************************************************************************
1781template< typename MT // Type of the adapted dense matrix
1782 , bool SO > // Storage order of the adapted dense matrix
1783template< typename MT2 > // Type of the right-hand side matrix
1784inline auto SymmetricMatrix<MT,SO,true,true>::operator=( const Matrix<MT2,SO>& rhs )
1785 -> DisableIf_t< IsComputation_v<MT2>, SymmetricMatrix& >
1786{
1787 if( !IsSymmetric_v<MT2> && !isSymmetric( *rhs ) ) {
1788 BLAZE_THROW_INVALID_ARGUMENT( "Invalid assignment to symmetric matrix" );
1789 }
1790
1791 matrix_ = *rhs;
1792
1793 BLAZE_INTERNAL_ASSERT( isSquare( matrix_ ), "Non-square symmetric matrix detected" );
1794 BLAZE_INTERNAL_ASSERT( isIntact(), "Broken invariant detected" );
1795
1796 return *this;
1797}
1799//*************************************************************************************************
1800
1801
1802//*************************************************************************************************
1815template< typename MT // Type of the adapted dense matrix
1816 , bool SO > // Storage order of the adapted dense matrix
1817template< typename MT2 > // Type of the right-hand side matrix
1818inline auto SymmetricMatrix<MT,SO,true,true>::operator=( const Matrix<MT2,SO>& rhs )
1819 -> EnableIf_t< IsComputation_v<MT2>, SymmetricMatrix& >
1820{
1821 if( !IsSquare_v<MT2> && !isSquare( *rhs ) ) {
1822 BLAZE_THROW_INVALID_ARGUMENT( "Invalid assignment to symmetric matrix" );
1823 }
1824
1825 if( IsSymmetric_v<MT2> ) {
1826 matrix_ = *rhs;
1827 }
1828 else {
1829 MT tmp( *rhs );
1830
1831 if( !isSymmetric( tmp ) ) {
1832 BLAZE_THROW_INVALID_ARGUMENT( "Invalid assignment to symmetric matrix" );
1833 }
1834
1835 matrix_ = std::move( tmp );
1836 }
1837
1838 BLAZE_INTERNAL_ASSERT( isSquare( matrix_ ), "Non-square symmetric matrix detected" );
1839 BLAZE_INTERNAL_ASSERT( isIntact(), "Broken invariant detected" );
1840
1841 return *this;
1842}
1844//*************************************************************************************************
1845
1846
1847//*************************************************************************************************
1860template< typename MT // Type of the adapted dense matrix
1861 , bool SO > // Storage order of the adapted dense matrix
1862template< typename MT2 > // Type of the right-hand side matrix
1863inline auto SymmetricMatrix<MT,SO,true,true>::operator=( const Matrix<MT2,!SO>& rhs )
1864 -> SymmetricMatrix&
1865{
1866 return this->operator=( trans( *rhs ) );
1867}
1869//*************************************************************************************************
1870
1871
1872//*************************************************************************************************
1885template< typename MT // Type of the adapted dense matrix
1886 , bool SO > // Storage order of the adapted dense matrix
1887template< typename MT2 > // Type of the right-hand side matrix
1888inline auto SymmetricMatrix<MT,SO,true,true>::operator+=( const Matrix<MT2,SO>& rhs )
1889 -> DisableIf_t< IsComputation_v<MT2>, SymmetricMatrix& >
1890{
1891 if( !IsSymmetric_v<MT2> && !isSymmetric( *rhs ) ) {
1892 BLAZE_THROW_INVALID_ARGUMENT( "Invalid assignment to symmetric matrix" );
1893 }
1894
1895 matrix_ += *rhs;
1896
1897 BLAZE_INTERNAL_ASSERT( isSquare( matrix_ ), "Non-square symmetric matrix detected" );
1898 BLAZE_INTERNAL_ASSERT( isIntact(), "Broken invariant detected" );
1899
1900 return *this;
1901}
1903//*************************************************************************************************
1904
1905
1906//*************************************************************************************************
1919template< typename MT // Type of the adapted dense matrix
1920 , bool SO > // Storage order of the adapted dense matrix
1921template< typename MT2 > // Type of the right-hand side matrix
1922inline auto SymmetricMatrix<MT,SO,true,true>::operator+=( const Matrix<MT2,SO>& rhs )
1923 -> EnableIf_t< IsComputation_v<MT2>, SymmetricMatrix& >
1924{
1925 if( !IsSquare_v<MT2> && !isSquare( *rhs ) ) {
1926 BLAZE_THROW_INVALID_ARGUMENT( "Invalid assignment to symmetric matrix" );
1927 }
1928
1929 if( IsSymmetric_v<MT2> ) {
1930 matrix_ += *rhs;
1931 }
1932 else {
1933 const ResultType_t<MT2> tmp( *rhs );
1934
1935 if( !isSymmetric( tmp ) ) {
1936 BLAZE_THROW_INVALID_ARGUMENT( "Invalid assignment to symmetric matrix" );
1937 }
1938
1939 matrix_ += tmp;
1940 }
1941
1942 BLAZE_INTERNAL_ASSERT( isSquare( matrix_ ), "Non-square symmetric matrix detected" );
1943 BLAZE_INTERNAL_ASSERT( isIntact(), "Broken invariant detected" );
1944
1945 return *this;
1946}
1948//*************************************************************************************************
1949
1950
1951//*************************************************************************************************
1965template< typename MT // Type of the adapted dense matrix
1966 , bool SO > // Storage order of the adapted dense matrix
1967template< typename MT2 > // Type of the right-hand side matrix
1968inline auto SymmetricMatrix<MT,SO,true,true>::operator+=( const Matrix<MT2,!SO>& rhs )
1969 -> SymmetricMatrix&
1970{
1971 return this->operator+=( trans( *rhs ) );
1972}
1974//*************************************************************************************************
1975
1976
1977//*************************************************************************************************
1990template< typename MT // Type of the adapted dense matrix
1991 , bool SO > // Storage order of the adapted dense matrix
1992template< typename MT2 > // Type of the right-hand side matrix
1993inline auto SymmetricMatrix<MT,SO,true,true>::operator-=( const Matrix<MT2,SO>& rhs )
1994 -> DisableIf_t< IsComputation_v<MT2>, SymmetricMatrix& >
1995{
1996 if( !IsSymmetric_v<MT2> && !isSymmetric( *rhs ) ) {
1997 BLAZE_THROW_INVALID_ARGUMENT( "Invalid assignment to symmetric matrix" );
1998 }
1999
2000 matrix_ -= *rhs;
2001
2002 BLAZE_INTERNAL_ASSERT( isSquare( matrix_ ), "Non-square symmetric matrix detected" );
2003 BLAZE_INTERNAL_ASSERT( isIntact(), "Broken invariant detected" );
2004
2005 return *this;
2006}
2008//*************************************************************************************************
2009
2010
2011//*************************************************************************************************
2024template< typename MT // Type of the adapted dense matrix
2025 , bool SO > // Storage order of the adapted dense matrix
2026template< typename MT2 > // Type of the right-hand side matrix
2027inline auto SymmetricMatrix<MT,SO,true,true>::operator-=( const Matrix<MT2,SO>& rhs )
2028 -> EnableIf_t< IsComputation_v<MT2>, SymmetricMatrix& >
2029{
2030 if( !IsSquare_v<MT2> && !isSquare( *rhs ) ) {
2031 BLAZE_THROW_INVALID_ARGUMENT( "Invalid assignment to symmetric matrix" );
2032 }
2033
2034 if( IsSymmetric_v<MT2> ) {
2035 matrix_ -= *rhs;
2036 }
2037 else {
2038 const ResultType_t<MT2> tmp( *rhs );
2039
2040 if( !isSymmetric( tmp ) ) {
2041 BLAZE_THROW_INVALID_ARGUMENT( "Invalid assignment to symmetric matrix" );
2042 }
2043
2044 matrix_ -= tmp;
2045 }
2046
2047 BLAZE_INTERNAL_ASSERT( isSquare( matrix_ ), "Non-square symmetric matrix detected" );
2048 BLAZE_INTERNAL_ASSERT( isIntact(), "Broken invariant detected" );
2049
2050 return *this;
2051}
2053//*************************************************************************************************
2054
2055
2056//*************************************************************************************************
2070template< typename MT // Type of the adapted dense matrix
2071 , bool SO > // Storage order of the adapted dense matrix
2072template< typename MT2 > // Type of the right-hand side matrix
2073inline auto SymmetricMatrix<MT,SO,true,true>::operator-=( const Matrix<MT2,!SO>& rhs )
2074 -> SymmetricMatrix&
2075{
2076 return this->operator-=( trans( *rhs ) );
2077}
2079//*************************************************************************************************
2080
2081
2082//*************************************************************************************************
2096template< typename MT // Type of the adapted dense matrix
2097 , bool SO > // Storage order of the adapted dense matrix
2098template< typename MT2 > // Type of the right-hand side matrix
2099inline auto SymmetricMatrix<MT,SO,true,true>::operator%=( const Matrix<MT2,SO>& rhs )
2100 -> DisableIf_t< IsComputation_v<MT2>, SymmetricMatrix& >
2101{
2102 if( !IsSymmetric_v<MT2> && !isSymmetric( *rhs ) ) {
2103 BLAZE_THROW_INVALID_ARGUMENT( "Invalid assignment to symmetric matrix" );
2104 }
2105
2106 matrix_ %= *rhs;
2107
2108 BLAZE_INTERNAL_ASSERT( isSquare( matrix_ ), "Non-square symmetric matrix detected" );
2109 BLAZE_INTERNAL_ASSERT( isIntact(), "Broken invariant detected" );
2110
2111 return *this;
2112}
2114//*************************************************************************************************
2115
2116
2117//*************************************************************************************************
2131template< typename MT // Type of the adapted dense matrix
2132 , bool SO > // Storage order of the adapted dense matrix
2133template< typename MT2 > // Type of the right-hand side matrix
2134inline auto SymmetricMatrix<MT,SO,true,true>::operator%=( const Matrix<MT2,SO>& rhs )
2135 -> EnableIf_t< IsComputation_v<MT2>, SymmetricMatrix& >
2136{
2137 if( !IsSquare_v<MT2> && !isSquare( *rhs ) ) {
2138 BLAZE_THROW_INVALID_ARGUMENT( "Invalid assignment to symmetric matrix" );
2139 }
2140
2141 if( IsSymmetric_v<MT2> ) {
2142 matrix_ %= *rhs;
2143 }
2144 else {
2145 const ResultType_t<MT2> tmp( *rhs );
2146
2147 if( !isSymmetric( tmp ) ) {
2148 BLAZE_THROW_INVALID_ARGUMENT( "Invalid assignment to symmetric matrix" );
2149 }
2150
2151 matrix_ %= tmp;
2152 }
2153
2154 BLAZE_INTERNAL_ASSERT( isSquare( matrix_ ), "Non-square symmetric matrix detected" );
2155 BLAZE_INTERNAL_ASSERT( isIntact(), "Broken invariant detected" );
2156
2157 return *this;
2158}
2160//*************************************************************************************************
2161
2162
2163//*************************************************************************************************
2177template< typename MT // Type of the adapted dense matrix
2178 , bool SO > // Storage order of the adapted dense matrix
2179template< typename MT2 > // Type of the right-hand side matrix
2180inline auto SymmetricMatrix<MT,SO,true,true>::operator%=( const Matrix<MT2,!SO>& rhs )
2181 -> SymmetricMatrix&
2182{
2183 return this->operator%=( trans( *rhs ) );
2184}
2186//*************************************************************************************************
2187
2188
2189//*************************************************************************************************
2197template< typename MT // Type of the adapted dense matrix
2198 , bool SO > // Storage order of the adapted dense matrix
2199template< typename ST > // Data type of the right-hand side scalar
2201 -> EnableIf_t< IsScalar_v<ST>, SymmetricMatrix& >
2202{
2203 matrix_ *= rhs;
2204 return *this;
2205}
2206//*************************************************************************************************
2207
2208
2209//*************************************************************************************************
2217template< typename MT // Type of the adapted dense matrix
2218 , bool SO > // Storage order of the adapted dense matrix
2219template< typename ST > // Data type of the right-hand side scalar
2221 -> EnableIf_t< IsScalar_v<ST>, SymmetricMatrix& >
2222{
2223 BLAZE_USER_ASSERT( !isZero( rhs ), "Division by zero detected" );
2224
2225 matrix_ /= rhs;
2226 return *this;
2227}
2229//*************************************************************************************************
2230
2231
2232
2233
2234//=================================================================================================
2235//
2236// UTILITY FUNCTIONS
2237//
2238//=================================================================================================
2239
2240//*************************************************************************************************
2246template< typename MT // Type of the adapted dense matrix
2247 , bool SO > // Storage order of the adapted dense matrix
2248inline size_t SymmetricMatrix<MT,SO,true,true>::rows() const noexcept
2249{
2250 return matrix_.rows();
2251}
2253//*************************************************************************************************
2254
2255
2256//*************************************************************************************************
2262template< typename MT // Type of the adapted dense matrix
2263 , bool SO > // Storage order of the adapted dense matrix
2264inline size_t SymmetricMatrix<MT,SO,true,true>::columns() const noexcept
2265{
2266 return matrix_.columns();
2267}
2269//*************************************************************************************************
2270
2271
2272//*************************************************************************************************
2284template< typename MT // Type of the adapted dense matrix
2285 , bool SO > // Storage order of the adapted dense matrix
2286inline size_t SymmetricMatrix<MT,SO,true,true>::spacing() const noexcept
2287{
2288 return matrix_.spacing();
2289}
2291//*************************************************************************************************
2292
2293
2294//*************************************************************************************************
2300template< typename MT // Type of the adapted dense matrix
2301 , bool SO > // Storage order of the adapted dense matrix
2302inline size_t SymmetricMatrix<MT,SO,true,true>::capacity() const noexcept
2303{
2304 return matrix_.capacity();
2305}
2307//*************************************************************************************************
2308
2309
2310//*************************************************************************************************
2321template< typename MT // Type of the adapted dense matrix
2322 , bool SO > // Storage order of the adapted dense matrix
2323inline size_t SymmetricMatrix<MT,SO,true,true>::capacity( size_t i ) const noexcept
2324{
2325 return matrix_.capacity(i);
2326}
2328//*************************************************************************************************
2329
2330
2331//*************************************************************************************************
2337template< typename MT // Type of the adapted dense matrix
2338 , bool SO > // Storage order of the adapted dense matrix
2340{
2341 return matrix_.nonZeros();
2342}
2344//*************************************************************************************************
2345
2346
2347//*************************************************************************************************
2359template< typename MT // Type of the adapted dense matrix
2360 , bool SO > // Storage order of the adapted dense matrix
2361inline size_t SymmetricMatrix<MT,SO,true,true>::nonZeros( size_t i ) const
2362{
2363 return matrix_.nonZeros(i);
2364}
2366//*************************************************************************************************
2367
2368
2369//*************************************************************************************************
2375template< typename MT // Type of the adapted dense matrix
2376 , bool SO > // Storage order of the adapted dense matrix
2378{
2379 matrix_.reset();
2380}
2382//*************************************************************************************************
2383
2384
2385//*************************************************************************************************
2421template< typename MT // Type of the adapted dense matrix
2422 , bool SO > // Storage order of the adapted dense matrix
2423inline void SymmetricMatrix<MT,SO,true,true>::reset( size_t i )
2424{
2425 row ( matrix_, i, unchecked ).reset();
2426 column( matrix_, i, unchecked ).reset();
2427}
2429//*************************************************************************************************
2430
2431
2432//*************************************************************************************************
2444template< typename MT // Type of the adapted dense matrix
2445 , bool SO > // Storage order of the adapted dense matrix
2447{
2448 matrix_.clear();
2449
2450 BLAZE_INTERNAL_ASSERT( matrix_.rows() == 0UL, "Invalid number of rows" );
2451 BLAZE_INTERNAL_ASSERT( matrix_.columns() == 0UL, "Invalid number of columns" );
2452}
2454//*************************************************************************************************
2455
2456
2457//*************************************************************************************************
2492template< typename MT // Type of the adapted dense matrix
2493 , bool SO > // Storage order of the adapted dense matrix
2494void SymmetricMatrix<MT,SO,true,true>::resize( size_t n, bool preserve )
2495{
2497
2498 MAYBE_UNUSED( preserve );
2499
2500 BLAZE_INTERNAL_ASSERT( isSquare( matrix_ ), "Non-square symmetric matrix detected" );
2501
2502 const size_t oldsize( matrix_.rows() );
2503
2504 matrix_.resize( n, n, true );
2505
2506 if( n > oldsize ) {
2507 const size_t increment( n - oldsize );
2508 submatrix( matrix_, 0UL, oldsize, oldsize, increment ).reset();
2509 submatrix( matrix_, oldsize, 0UL, increment, n ).reset();
2510 }
2511}
2513//*************************************************************************************************
2514
2515
2516//*************************************************************************************************
2529template< typename MT // Type of the adapted dense matrix
2530 , bool SO > // Storage order of the adapted dense matrix
2531inline void SymmetricMatrix<MT,SO,true,true>::extend( size_t n, bool preserve )
2532{
2534
2535 MAYBE_UNUSED( preserve );
2536
2537 resize( rows() + n, true );
2538}
2539//*************************************************************************************************
2540
2541
2542//*************************************************************************************************
2552template< typename MT // Type of the adapted dense matrix
2553 , bool SO > // Storage order of the adapted dense matrix
2554inline void SymmetricMatrix<MT,SO,true,true>::reserve( size_t elements )
2555{
2556 matrix_.reserve( elements );
2557}
2559//*************************************************************************************************
2560
2561
2562//*************************************************************************************************
2572template< typename MT // Type of the adapted dense matrix
2573 , bool SO > // Storage order of the adapted dense matrix
2575{
2576 matrix_.shrinkToFit();
2577}
2579//*************************************************************************************************
2580
2581
2582//*************************************************************************************************
2589template< typename MT // Type of the adapted dense matrix
2590 , bool SO > // Storage order of the adapted dense matrix
2591inline void SymmetricMatrix<MT,SO,true,true>::swap( SymmetricMatrix& m ) noexcept
2592{
2593 using std::swap;
2594
2595 swap( matrix_, m.matrix_ );
2596}
2598//*************************************************************************************************
2599
2600
2601
2602
2603//=================================================================================================
2604//
2605// NUMERIC FUNCTIONS
2606//
2607//=================================================================================================
2608
2609//*************************************************************************************************
2615template< typename MT // Type of the adapted dense matrix
2616 , bool SO > // Storage order of the adapted dense matrix
2617inline SymmetricMatrix<MT,SO,true,true>& SymmetricMatrix<MT,SO,true,true>::transpose()
2618{
2619 return *this;
2620}
2622//*************************************************************************************************
2623
2624
2625//*************************************************************************************************
2631template< typename MT // Type of the adapted dense matrix
2632 , bool SO > // Storage order of the adapted dense matrix
2633inline SymmetricMatrix<MT,SO,true,true>& SymmetricMatrix<MT,SO,true,true>::ctranspose()
2634{
2635 if( !IsBuiltin_v<ElementType> )
2636 conjugate( matrix_ );
2637
2638 return *this;
2639}
2641//*************************************************************************************************
2642
2643
2644//*************************************************************************************************
2662template< typename MT // Type of the adapted dense matrix
2663 , bool SO > // Storage order of the adapted dense matrix
2664template< typename Other > // Data type of the scalar value
2665inline SymmetricMatrix<MT,SO,true,true>&
2666 SymmetricMatrix<MT,SO,true,true>::scale( const Other& scalar )
2667{
2668 matrix_.scale( scalar );
2669 return *this;
2670}
2672//*************************************************************************************************
2673
2674
2675
2676
2677//=================================================================================================
2678//
2679// DEBUGGING FUNCTIONS
2680//
2681//=================================================================================================
2682
2683//*************************************************************************************************
2693template< typename MT // Type of the adapted dense matrix
2694 , bool SO > // Storage order of the adapted dense matrix
2695inline bool SymmetricMatrix<MT,SO,true,true>::isIntact() const noexcept
2696{
2697 using blaze::isIntact;
2698
2699 return ( isIntact( matrix_ ) && isSymmetric( matrix_ ) );
2700}
2702//*************************************************************************************************
2703
2704
2705
2706
2707//=================================================================================================
2708//
2709// EXPRESSION TEMPLATE EVALUATION FUNCTIONS
2710//
2711//=================================================================================================
2712
2713//*************************************************************************************************
2724template< typename MT // Type of the adapted dense matrix
2725 , bool SO > // Storage order of the adapted dense matrix
2726template< typename Other > // Data type of the foreign expression
2727inline bool SymmetricMatrix<MT,SO,true,true>::canAlias( const Other* alias ) const noexcept
2728{
2729 return matrix_.canAlias( alias );
2730}
2732//*************************************************************************************************
2733
2734
2735//*************************************************************************************************
2746template< typename MT // Type of the adapted dense matrix
2747 , bool SO > // Storage order of the adapted dense matrix
2748template< typename Other > // Data type of the foreign expression
2749inline bool SymmetricMatrix<MT,SO,true,true>::isAliased( const Other* alias ) const noexcept
2750{
2751 return matrix_.isAliased( alias );
2752}
2754//*************************************************************************************************
2755
2756
2757//*************************************************************************************************
2767template< typename MT // Type of the adapted dense matrix
2768 , bool SO > // Storage order of the adapted dense matrix
2769inline bool SymmetricMatrix<MT,SO,true,true>::isAligned() const noexcept
2770{
2771 return matrix_.isAligned();
2772}
2774//*************************************************************************************************
2775
2776
2777//*************************************************************************************************
2788template< typename MT // Type of the adapted dense matrix
2789 , bool SO > // Storage order of the adapted dense matrix
2790inline bool SymmetricMatrix<MT,SO,true,true>::canSMPAssign() const noexcept
2791{
2792 return matrix_.canSMPAssign();
2793}
2795//*************************************************************************************************
2796
2797
2798//*************************************************************************************************
2814template< typename MT // Type of the adapted dense matrix
2815 , bool SO > // Storage order of the adapted dense matrix
2816BLAZE_ALWAYS_INLINE typename SymmetricMatrix<MT,SO,true,true>::SIMDType
2817 SymmetricMatrix<MT,SO,true,true>::load( size_t i, size_t j ) const noexcept
2818{
2819 return matrix_.load( i, j );
2820}
2822//*************************************************************************************************
2823
2824
2825//*************************************************************************************************
2841template< typename MT // Type of the adapted dense matrix
2842 , bool SO > // Storage order of the adapted dense matrix
2843BLAZE_ALWAYS_INLINE typename SymmetricMatrix<MT,SO,true,true>::SIMDType
2844 SymmetricMatrix<MT,SO,true,true>::loada( size_t i, size_t j ) const noexcept
2845{
2846 return matrix_.loada( i, j );
2847}
2849//*************************************************************************************************
2850
2851
2852//*************************************************************************************************
2868template< typename MT // Type of the adapted dense matrix
2869 , bool SO > // Storage order of the adapted dense matrix
2870BLAZE_ALWAYS_INLINE typename SymmetricMatrix<MT,SO,true,true>::SIMDType
2871 SymmetricMatrix<MT,SO,true,true>::loadu( size_t i, size_t j ) const noexcept
2872{
2873 return matrix_.loadu( i, j );
2874}
2876//*************************************************************************************************
2877
2878
2879//*************************************************************************************************
2896template< typename MT // Type of the adapted dense matrix
2897 , bool SO > // Storage order of the adapted dense matrix
2898inline void
2899 SymmetricMatrix<MT,SO,true,true>::store( size_t i, size_t j, const SIMDType& value ) noexcept
2900{
2901 matrix_.store( i, j, value );
2902
2903 if( SO ) {
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);
2907 }
2908 else {
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);
2912 }
2913}
2915//*************************************************************************************************
2916
2917
2918//*************************************************************************************************
2935template< typename MT // Type of the adapted dense matrix
2936 , bool SO > // Storage order of the adapted dense matrix
2937inline void
2938 SymmetricMatrix<MT,SO,true,true>::storea( size_t i, size_t j, const SIMDType& value ) noexcept
2939{
2940 matrix_.storea( i, j, value );
2941
2942 if( SO ) {
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);
2946 }
2947 else {
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);
2951 }
2952}
2954//*************************************************************************************************
2955
2956
2957//*************************************************************************************************
2974template< typename MT // Type of the adapted dense matrix
2975 , bool SO > // Storage order of the adapted dense matrix
2976inline void
2977 SymmetricMatrix<MT,SO,true,true>::storeu( size_t i, size_t j, const SIMDType& value ) noexcept
2978{
2979 matrix_.storeu( i, j, value );
2980
2981 if( SO ) {
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);
2985 }
2986 else {
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);
2990 }
2991}
2993//*************************************************************************************************
2994
2995
2996//*************************************************************************************************
3013template< typename MT // Type of the adapted dense matrix
3014 , bool SO > // Storage order of the adapted dense matrix
3015inline void
3016 SymmetricMatrix<MT,SO,true,true>::stream( size_t i, size_t j, const SIMDType& value ) noexcept
3017{
3018 matrix_.stream( i, j, value );
3019
3020 if( SO ) {
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);
3024 }
3025 else {
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);
3029 }
3030}
3032//*************************************************************************************************
3033
3034} // namespace blaze
3035
3036#endif
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.
Compile time assertion.
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.
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.