SMatDeclSymExpr.h
Go to the documentation of this file.
1 //=================================================================================================
33 //=================================================================================================
34 
35 #ifndef _BLAZE_MATH_EXPRESSIONS_SMATDECLSYMEXPR_H_
36 #define _BLAZE_MATH_EXPRESSIONS_SMATDECLSYMEXPR_H_
37 
38 
39 //*************************************************************************************************
40 // Includes
41 //*************************************************************************************************
42 
43 #include <iterator>
45 #include <blaze/math/Aliases.h>
50 #include <blaze/math/Exception.h>
69 #include <blaze/util/Assert.h>
70 #include <blaze/util/DisableIf.h>
71 #include <blaze/util/EnableIf.h>
73 #include <blaze/util/InvalidType.h>
74 #include <blaze/util/mpl/And.h>
75 #include <blaze/util/mpl/If.h>
76 #include <blaze/util/mpl/Not.h>
77 #include <blaze/util/mpl/Or.h>
78 #include <blaze/util/TrueType.h>
79 #include <blaze/util/Types.h>
81 
82 
83 namespace blaze {
84 
85 //=================================================================================================
86 //
87 // CLASS SMATDECLSYMEXPR
88 //
89 //=================================================================================================
90 
91 //*************************************************************************************************
98 template< typename MT // Type of the sparse matrix
99  , bool SO > // Storage order
100 class SMatDeclSymExpr
101  : public DeclSymExpr< SparseMatrix< SMatDeclSymExpr<MT,SO>, SO > >
102  , public Declaration<MT>
103 {
104  private:
105  //**Type definitions****************************************************************************
106  using RT = ResultType_<MT>;
107  //**********************************************************************************************
108 
109  //**Serial evaluation strategy******************************************************************
111 
117  enum : bool { useAssign = RequiresEvaluation<MT>::value };
118 
120  template< typename MT2 >
122  struct UseAssign {
123  enum : bool { value = useAssign };
124  };
126  //**********************************************************************************************
127 
128  //**Parallel evaluation strategy****************************************************************
130 
135  template< typename MT2 >
136  struct UseSMPAssign {
137  enum : bool { value = MT2::smpAssignable && useAssign };
138  };
140  //**********************************************************************************************
141 
142  //**********************************************************************************************
144 
148  template< typename MT2 >
149  struct GetConstIterator {
151  struct Success { using Type = typename MT2::ConstIterator; };
152  struct Failure { using Type = INVALID_TYPE; };
153  using Type = typename If_< HasConstIterator<MT2>, Success, Failure >::Type;
154  };
156  //**********************************************************************************************
157 
158  public:
159  //**Type definitions****************************************************************************
166 
169 
171  using ConstIterator = typename GetConstIterator<MT>::Type;
172 
174  using Operand = If_< IsExpression<MT>, const MT, const MT& >;
175  //**********************************************************************************************
176 
177  //**Compilation flags***************************************************************************
179  enum : bool { smpAssignable = MT::smpAssignable };
180  //**********************************************************************************************
181 
182  //**Constructor*********************************************************************************
187  explicit inline SMatDeclSymExpr( const MT& sm ) noexcept
188  : sm_( sm ) // Sparse matrix of the declsym expression
189  {
190  BLAZE_INTERNAL_ASSERT( isSquare( ~sm ), "Non-square matrix detected" );
191  }
192  //**********************************************************************************************
193 
194  //**Access operator*****************************************************************************
201  inline ReturnType operator()( size_t i, size_t j ) const {
202  BLAZE_INTERNAL_ASSERT( i < sm_.rows() , "Invalid row access index" );
203  BLAZE_INTERNAL_ASSERT( j < sm_.columns(), "Invalid column access index" );
204  return sm_(i,j);
205  }
206  //**********************************************************************************************
207 
208  //**At function*********************************************************************************
216  inline ReturnType at( size_t i, size_t j ) const {
217  if( i >= sm_.rows() ) {
218  BLAZE_THROW_OUT_OF_RANGE( "Invalid row access index" );
219  }
220  if( j >= sm_.columns() ) {
221  BLAZE_THROW_OUT_OF_RANGE( "Invalid column access index" );
222  }
223  return (*this)(i,j);
224  }
225  //**********************************************************************************************
226 
227  //**Begin function******************************************************************************
233  inline ConstIterator begin( size_t i ) const {
234  return ConstIterator( sm_.begin(i) );
235  }
236  //**********************************************************************************************
237 
238  //**End function********************************************************************************
244  inline ConstIterator end( size_t i ) const {
245  return ConstIterator( sm_.end(i) );
246  }
247  //**********************************************************************************************
248 
249  //**Rows function*******************************************************************************
254  inline size_t rows() const noexcept {
255  return sm_.rows();
256  }
257  //**********************************************************************************************
258 
259  //**Columns function****************************************************************************
264  inline size_t columns() const noexcept {
265  return sm_.columns();
266  }
267  //**********************************************************************************************
268 
269  //**NonZeros function***************************************************************************
274  inline size_t nonZeros() const {
275  return sm_.nonZeros();
276  }
277  //**********************************************************************************************
278 
279  //**NonZeros function***************************************************************************
285  inline size_t nonZeros( size_t i ) const {
286  return sm_.nonZeros(i);
287  }
288  //**********************************************************************************************
289 
290  //**Operand access******************************************************************************
295  inline Operand operand() const noexcept {
296  return sm_;
297  }
298  //**********************************************************************************************
299 
300  //**********************************************************************************************
306  template< typename T >
307  inline bool canAlias( const T* alias ) const noexcept {
308  return sm_.canAlias( alias );
309  }
310  //**********************************************************************************************
311 
312  //**********************************************************************************************
318  template< typename T >
319  inline bool isAliased( const T* alias ) const noexcept {
320  return sm_.isAliased( alias );
321  }
322  //**********************************************************************************************
323 
324  //**********************************************************************************************
329  inline bool canSMPAssign() const noexcept {
330  return sm_.canSMPAssign();
331  }
332  //**********************************************************************************************
333 
334  private:
335  //**Member variables****************************************************************************
337  //**********************************************************************************************
338 
339  //**Assignment to dense matrices****************************************************************
351  template< typename MT2 // Type of the target dense matrix
352  , bool SO2 > // Storage order of the target dense matrix
353  friend inline EnableIf_< UseAssign<MT2> >
354  assign( DenseMatrix<MT2,SO2>& lhs, const SMatDeclSymExpr& rhs )
355  {
357 
358  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
359  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
360 
361  assign( ~lhs, rhs.sm_ );
362  }
364  //**********************************************************************************************
365 
366  //**Assignment to sparse matrices***************************************************************
378  template< typename MT2 // Type of the target sparse matrix
379  , bool SO2 > // Storage order of the target sparse matrix
380  friend inline EnableIf_< UseAssign<MT2> >
381  assign( SparseMatrix<MT2,SO2>& lhs, const SMatDeclSymExpr& rhs )
382  {
384 
385  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
386  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
387 
388  assign( ~lhs, rhs.sm_ );
389  }
391  //**********************************************************************************************
392 
393  //**Addition assignment to dense matrices*******************************************************
405  template< typename MT2 // Type of the target dense matrix
406  , bool SO2 > // Storage order of the target dense matrix
407  friend inline EnableIf_< UseAssign<MT2> >
408  addAssign( DenseMatrix<MT2,SO2>& lhs, const SMatDeclSymExpr& rhs )
409  {
411 
412  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
413  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
414 
415  addAssign( ~lhs, rhs.sm_ );
416  }
418  //**********************************************************************************************
419 
420  //**Addition assignment to sparse matrices******************************************************
432  template< typename MT2 // Type of the target sparse matrix
433  , bool SO2 > // Storage order of the target sparse matrix
434  friend inline EnableIf_< UseAssign<MT2> >
435  addAssign( SparseMatrix<MT2,SO2>& lhs, const SMatDeclSymExpr& rhs )
436  {
438 
439  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
440  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
441 
442  addAssign( ~lhs, rhs.sm_ );
443  }
445  //**********************************************************************************************
446 
447  //**Subtraction assignment to dense matrices****************************************************
459  template< typename MT2 // Type of the target dense matrix
460  , bool SO2 > // Storage order of the target dense matrix
461  friend inline EnableIf_< UseAssign<MT2> >
462  subAssign( DenseMatrix<MT2,SO2>& lhs, const SMatDeclSymExpr& rhs )
463  {
465 
466  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
467  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
468 
469  subAssign( ~lhs, rhs.sm_ );
470  }
472  //**********************************************************************************************
473 
474  //**Subtraction assignment to sparse matrices***************************************************
486  template< typename MT2 // Type of the target sparse matrix
487  , bool SO2 > // Storage order of the target sparse matrix
488  friend inline EnableIf_< UseAssign<MT2> >
489  subAssign( SparseMatrix<MT2,SO2>& lhs, const SMatDeclSymExpr& rhs )
490  {
492 
493  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
494  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
495 
496  subAssign( ~lhs, rhs.sm_ );
497  }
499  //**********************************************************************************************
500 
501  //**Schur product assignment to dense matrices**************************************************
513  template< typename MT2 // Type of the target dense matrix
514  , bool SO2 > // Storage order of the target dense matrix
515  friend inline EnableIf_< UseAssign<MT2> >
516  schurAssign( DenseMatrix<MT2,SO2>& lhs, const SMatDeclSymExpr& rhs )
517  {
519 
520  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
521  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
522 
523  schurAssign( ~lhs, rhs.sm_ );
524  }
526  //**********************************************************************************************
527 
528  //**Schur product assignment to sparse matrices*************************************************
540  template< typename MT2 // Type of the target sparse matrix
541  , bool SO2 > // Storage order of the target sparse matrix
542  friend inline EnableIf_< UseAssign<MT2> >
543  schurAssign( SparseMatrix<MT2,SO2>& lhs, const SMatDeclSymExpr& rhs )
544  {
546 
547  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
548  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
549 
550  schurAssign( ~lhs, rhs.sm_ );
551  }
553  //**********************************************************************************************
554 
555  //**Multiplication assignment to dense matrices*************************************************
567  template< typename MT2 // Type of the target dense matrix
568  , bool SO2 > // Storage order of the target dense matrix
569  friend inline EnableIf_< UseAssign<MT2> >
570  multAssign( DenseMatrix<MT2,SO2>& lhs, const SMatDeclSymExpr& rhs )
571  {
573 
574  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
575  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
576 
577  multAssign( ~lhs, rhs.sm_ );
578  }
580  //**********************************************************************************************
581 
582  //**Multiplication assignment to sparse matrices************************************************
594  template< typename MT2 // Type of the target sparse matrix
595  , bool SO2 > // Storage order of the target sparse matrix
596  friend inline EnableIf_< UseAssign<MT2> >
597  multAssign( SparseMatrix<MT2,SO2>& lhs, const SMatDeclSymExpr& rhs )
598  {
600 
601  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
602  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
603 
604  multAssign( ~lhs, rhs.sm_ );
605  }
607  //**********************************************************************************************
608 
609  //**SMP assignment to dense matrices************************************************************
621  template< typename MT2 // Type of the target dense matrix
622  , bool SO2 > // Storage order of the target dense matrix
623  friend inline EnableIf_< UseSMPAssign<MT2> >
624  smpAssign( DenseMatrix<MT2,SO2>& lhs, const SMatDeclSymExpr& rhs )
625  {
627 
628  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
629  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
630 
631  smpAssign( ~lhs, rhs.sm_ );
632  }
634  //**********************************************************************************************
635 
636  //**SMP assignment to sparse matrices***********************************************************
648  template< typename MT2 // Type of the target sparse matrix
649  , bool SO2 > // Storage order of the target sparse matrix
650  friend inline EnableIf_< UseSMPAssign<MT2> >
651  smpAssign( SparseMatrix<MT2,SO2>& lhs, const SMatDeclSymExpr& rhs )
652  {
654 
655  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
656  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
657 
658  smpAssign( ~lhs, rhs.sm_ );
659  }
661  //**********************************************************************************************
662 
663  //**SMP addition assignment to dense matrices***************************************************
675  template< typename MT2 // Type of the target dense matrix
676  , bool SO2 > // Storage order of the target dense matrix
677  friend inline EnableIf_< UseSMPAssign<MT2> >
678  smpAddAssign( DenseMatrix<MT2,SO2>& lhs, const SMatDeclSymExpr& rhs )
679  {
681 
682  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
683  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
684 
685  smpAddAssign( ~lhs, rhs.sm_ );
686  }
688  //**********************************************************************************************
689 
690  //**SMP addition assignment to sparse matrices**************************************************
702  template< typename MT2 // Type of the target sparse matrix
703  , bool SO2 > // Storage order of the target sparse matrix
704  friend inline EnableIf_< UseSMPAssign<MT2> >
705  smpAddAssign( SparseMatrix<MT2,SO2>& lhs, const SMatDeclSymExpr& rhs )
706  {
708 
709  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
710  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
711 
712  smpAddAssign( ~lhs, rhs.sm_ );
713  }
715  //**********************************************************************************************
716 
717  //**SMP subtraction assignment to dense matrices************************************************
729  template< typename MT2 // Type of the target dense matrix
730  , bool SO2 > // Storage order of the target dense matrix
731  friend inline EnableIf_< UseSMPAssign<MT2> >
732  smpSubAssign( DenseMatrix<MT2,SO2>& lhs, const SMatDeclSymExpr& rhs )
733  {
735 
736  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
737  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
738 
739  smpSubAssign( ~lhs, rhs.sm_ );
740  }
742  //**********************************************************************************************
743 
744  //**SMP subtraction assignment to sparse matrices***********************************************
756  template< typename MT2 // Type of the target sparse matrix
757  , bool SO2 > // Storage order of the target sparse matrix
758  friend inline EnableIf_< UseSMPAssign<MT2> >
759  smpSubAssign( SparseMatrix<MT2,SO2>& lhs, const SMatDeclSymExpr& rhs )
760  {
762 
763  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
764  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
765 
766  smpSubAssign( ~lhs, rhs.sm_ );
767  }
769  //**********************************************************************************************
770 
771  //**SMP Schur product assignment to dense matrices**********************************************
783  template< typename MT2 // Type of the target dense matrix
784  , bool SO2 > // Storage order of the target dense matrix
785  friend inline EnableIf_< UseSMPAssign<MT2> >
786  smpSchurAssign( DenseMatrix<MT2,SO2>& lhs, const SMatDeclSymExpr& rhs )
787  {
789 
790  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
791  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
792 
793  smpSchurAssign( ~lhs, rhs.sm_ );
794  }
796  //**********************************************************************************************
797 
798  //**SMP Schur product assignment to sparse matrices*********************************************
810  template< typename MT2 // Type of the target sparse matrix
811  , bool SO2 > // Storage order of the target sparse matrix
812  friend inline EnableIf_< UseSMPAssign<MT2> >
813  smpSchurAssign( SparseMatrix<MT2,SO2>& lhs, const SMatDeclSymExpr& rhs )
814  {
816 
817  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
818  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
819 
820  smpSchurAssign( ~lhs, rhs.sm_ );
821  }
823  //**********************************************************************************************
824 
825  //**SMP multiplication assignment to dense matrices*********************************************
838  template< typename MT2 // Type of the target dense matrix
839  , bool SO2 > // Storage order of the target dense matrix
840  friend inline EnableIf_< UseSMPAssign<MT2> >
841  smpMultAssign( DenseMatrix<MT2,SO2>& lhs, const SMatDeclSymExpr& rhs )
842  {
844 
845  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
846  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
847 
848  smpMultAssign( ~lhs, rhs.sm_ );
849  }
851  //**********************************************************************************************
852 
853  //**SMP multiplication assignment to sparse matrices********************************************
866  template< typename MT2 // Type of the target sparse matrix
867  , bool SO2 > // Storage order of the target sparse matrix
868  friend inline EnableIf_< UseSMPAssign<MT2> >
869  smpMultAssign( SparseMatrix<MT2,SO2>& lhs, const SMatDeclSymExpr& rhs )
870  {
872 
873  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
874  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
875 
876  smpMultAssign( ~lhs, rhs.sm_ );
877  }
879  //**********************************************************************************************
880 
881  //**Compile time checks*************************************************************************
888  //**********************************************************************************************
889 };
890 //*************************************************************************************************
891 
892 
893 
894 
895 //=================================================================================================
896 //
897 // GLOBAL FUNCTIONS
898 //
899 //=================================================================================================
900 
901 //*************************************************************************************************
912 template< typename MT // Type of the sparse matrix
913  , bool SO // Storage order
915 inline const SMatDeclSymExpr<MT,SO> declsym_backend( const SparseMatrix<MT,SO>& sm )
916 {
918 
919  BLAZE_INTERNAL_ASSERT( isSquare( ~sm ), "Non-square matrix detected" );
920 
921  return SMatDeclSymExpr<MT,SO>( ~sm );
922 }
924 //*************************************************************************************************
925 
926 
927 //*************************************************************************************************
938 template< typename MT // Type of the sparse matrix
939  , bool SO // Storage order
941 inline const IdentityMatrix<ElementType_<MT>,SO> declsym_backend( const SparseMatrix<MT,SO>& sm )
942 {
944 
945  BLAZE_INTERNAL_ASSERT( isSquare( ~sm ), "Non-square matrix detected" );
946 
947  return IdentityMatrix<ElementType_<MT>,SO>( (~sm).rows() );
948 }
950 //*************************************************************************************************
951 
952 
953 //*************************************************************************************************
964 template< typename MT // Type of the sparse matrix
965  , bool SO // Storage order
966  , typename = EnableIf_< IsSymmetric<MT> > >
967 inline const MT& declsym_backend( const SparseMatrix<MT,SO>& sm )
968 {
970 
971  BLAZE_INTERNAL_ASSERT( isSquare( ~sm ), "Non-square matrix detected" );
972 
973  return ~sm;
974 }
976 //*************************************************************************************************
977 
978 
979 //*************************************************************************************************
998 template< typename MT // Type of the sparse matrix
999  , bool SO > // Storage order
1000 inline decltype(auto) declsym( const SparseMatrix<MT,SO>& sm )
1001 {
1003 
1004  if( !isSquare( ~sm ) ) {
1005  BLAZE_THROW_INVALID_ARGUMENT( "Invalid symmetric matrix specification" );
1006  }
1007 
1008  return declsym_backend( ~sm );
1009 }
1010 //*************************************************************************************************
1011 
1012 
1013 
1014 
1015 //=================================================================================================
1016 //
1017 // GLOBAL RESTRUCTURING FUNCTIONS
1018 //
1019 //=================================================================================================
1020 
1021 //*************************************************************************************************
1035 template< typename MT // Type of the left-hand side sparse matrix
1036  , typename ST // Type of the right-hand side scalar value
1037  , bool SO // Storage order
1038  , typename = DisableIf_< IsSymmetric<MT> > >
1039 inline decltype(auto) declsym( const SMatScalarMultExpr<MT,ST,SO>& sm )
1040 {
1042 
1043  if( !isSquare( ~sm ) ) {
1044  BLAZE_THROW_INVALID_ARGUMENT( "Invalid symmetric matrix specification" );
1045  }
1046 
1047  return declsym( sm.leftOperand() ) * sm.rightOperand();
1048 }
1050 //*************************************************************************************************
1051 
1052 
1053 
1054 
1055 //=================================================================================================
1056 //
1057 // Size SPECIALIZATIONS
1058 //
1059 //=================================================================================================
1060 
1061 //*************************************************************************************************
1063 template< typename MT, bool SO >
1064 struct Size< SMatDeclSymExpr<MT,SO>,0UL >
1065  : public Size<MT,0UL>
1066 {};
1067 
1068 template< typename MT, bool SO >
1069 struct Size< SMatDeclSymExpr<MT,SO>, 1UL >
1070  : public Size<MT,1UL>
1071 {};
1073 //*************************************************************************************************
1074 
1075 
1076 
1077 
1078 //=================================================================================================
1079 //
1080 // ISSYMMETRIC SPECIALIZATIONS
1081 //
1082 //=================================================================================================
1083 
1084 //*************************************************************************************************
1086 template< typename MT, bool SO >
1087 struct IsSymmetric< SMatDeclSymExpr<MT,SO> >
1088  : public TrueType
1089 {};
1091 //*************************************************************************************************
1092 
1093 
1094 
1095 
1096 //=================================================================================================
1097 //
1098 // ISHERMITIAN SPECIALIZATIONS
1099 //
1100 //=================================================================================================
1101 
1102 //*************************************************************************************************
1104 template< typename MT, bool SO >
1105 struct IsHermitian< SMatDeclSymExpr<MT,SO> >
1106  : public IsHermitian<MT>
1107 {};
1109 //*************************************************************************************************
1110 
1111 
1112 
1113 
1114 //=================================================================================================
1115 //
1116 // ISLOWER SPECIALIZATIONS
1117 //
1118 //=================================================================================================
1119 
1120 //*************************************************************************************************
1122 template< typename MT, bool SO >
1123 struct IsLower< SMatDeclSymExpr<MT,SO> >
1124  : public IsLower<MT>
1125 {};
1127 //*************************************************************************************************
1128 
1129 
1130 
1131 
1132 //=================================================================================================
1133 //
1134 // ISUNILOWER SPECIALIZATIONS
1135 //
1136 //=================================================================================================
1137 
1138 //*************************************************************************************************
1140 template< typename MT, bool SO >
1141 struct IsUniLower< SMatDeclSymExpr<MT,SO> >
1142  : public IsUniLower<MT>
1143 {};
1145 //*************************************************************************************************
1146 
1147 
1148 
1149 
1150 //=================================================================================================
1151 //
1152 // ISSTRICTLYLOWER SPECIALIZATIONS
1153 //
1154 //=================================================================================================
1155 
1156 //*************************************************************************************************
1158 template< typename MT, bool SO >
1159 struct IsStrictlyLower< SMatDeclSymExpr<MT,SO> >
1160  : public IsStrictlyLower<MT>
1161 {};
1163 //*************************************************************************************************
1164 
1165 
1166 
1167 
1168 //=================================================================================================
1169 //
1170 // ISUPPER SPECIALIZATIONS
1171 //
1172 //=================================================================================================
1173 
1174 //*************************************************************************************************
1176 template< typename MT, bool SO >
1177 struct IsUpper< SMatDeclSymExpr<MT,SO> >
1178  : public IsUpper<MT>
1179 {};
1181 //*************************************************************************************************
1182 
1183 
1184 
1185 
1186 //=================================================================================================
1187 //
1188 // ISUNIUPPER SPECIALIZATIONS
1189 //
1190 //=================================================================================================
1191 
1192 //*************************************************************************************************
1194 template< typename MT, bool SO >
1195 struct IsUniUpper< SMatDeclSymExpr<MT,SO> >
1196  : public IsUniUpper<MT>
1197 {};
1199 //*************************************************************************************************
1200 
1201 
1202 
1203 
1204 //=================================================================================================
1205 //
1206 // ISSTRICTLYUPPER SPECIALIZATIONS
1207 //
1208 //=================================================================================================
1209 
1210 //*************************************************************************************************
1212 template< typename MT, bool SO >
1213 struct IsStrictlyUpper< SMatDeclSymExpr<MT,SO> >
1214  : public IsStrictlyUpper<MT>
1215 {};
1217 //*************************************************************************************************
1218 
1219 } // namespace blaze
1220 
1221 #endif
#define BLAZE_THROW_INVALID_ARGUMENT(MESSAGE)
Macro for the emission of a std::invalid_argument exception.This macro encapsulates the default way o...
Definition: Exception.h:235
Header file for auxiliary alias declarations.
If_< RequiresEvaluation< MT >, const ResultType, const SMatDeclSymExpr &> CompositeType
Data type for composite expression templates.
Definition: SMatDeclSymExpr.h:168
SMatDeclSymExpr(const MT &sm) noexcept
Constructor for the SMatDeclSymExpr class.
Definition: SMatDeclSymExpr.h:187
Header file for the IsUniUpper type trait.
EnableIf_< IsDenseMatrix< MT1 > > smpSchurAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the SMP Schur product assignment of a matrix to dense matrix.
Definition: DenseMatrix.h:196
RightOperand rightOperand() const noexcept
Returns the right-hand side scalar operand.
Definition: SMatScalarMultExpr.h:475
Header file for basic type definitions.
bool isAliased(const T *alias) const noexcept
Returns whether the expression is aliased with the given address alias.
Definition: SMatDeclSymExpr.h:319
typename GetConstIterator< MT >::Type ConstIterator
Iterator over the elements of the dense matrix.
Definition: SMatDeclSymExpr.h:171
EnableIf_< IsDenseMatrix< MT1 > > smpSubAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the SMP subtraction assignment of a matrix to dense matrix.
Definition: DenseMatrix.h:164
#define BLAZE_CONSTRAINT_MUST_BE_MATRIX_WITH_STORAGE_ORDER(T, SO)
Constraint on the data type.In case the given data type T is not a dense or sparse matrix type and in...
Definition: StorageOrder.h:63
Generic wrapper for a compile time constant integral value.The IntegralConstant class template repres...
Definition: IntegralConstant.h:71
LeftOperand leftOperand() const noexcept
Returns the left-hand side sparse matrix operand.
Definition: SMatScalarMultExpr.h:465
EnableIf_< IsDenseVector< VT1 > > smpMultAssign(Vector< VT1, TF1 > &lhs, const Vector< VT2, TF2 > &rhs)
Default implementation of the SMP multiplication assignment of a vector to a dense vector...
Definition: DenseVector.h:193
typename DisableIf< Condition, T >::Type DisableIf_
Auxiliary type for the DisableIf class template.The DisableIf_ alias declaration provides a convenien...
Definition: DisableIf.h:224
Header file for the And class template.
Compile time check for lower triangular matrices.This type trait tests whether or not the given templ...
Definition: IsLower.h:87
#define BLAZE_CREATE_HAS_TYPE_MEMBER_TYPE_TRAIT(TYPE_TRAIT_NAME, MEMBER_NAME)
Macro for the creation of a type trait for compile time checks for member types.This macro creates th...
Definition: HasMember.h:182
#define BLAZE_CONSTRAINT_MUST_NOT_BE_UNITRIANGULAR_MATRIX_TYPE(T)
Constraint on the data type.In case the given data type T is a lower or upper unitriangular matrix ty...
Definition: UniTriangular.h:81
Compile time check for upper triangular matrices.This type trait tests whether or not the given templ...
Definition: IsUpper.h:87
Header file for the RequiresEvaluation type trait.
Header file for the IsUniLower type trait.
typename T::ResultType ResultType_
Alias declaration for nested ResultType type definitions.The ResultType_ alias declaration provides a...
Definition: Aliases.h:343
EnableIf_< IsDenseMatrix< MT1 > > smpAddAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the SMP addition assignment of a matrix to a dense matrix.
Definition: DenseMatrix.h:133
Operand sm_
Sparse matrix of the declsym expression.
Definition: SMatDeclSymExpr.h:336
ConstIterator end(size_t i) const
Returns an iterator just past the last non-zero element of row i.
Definition: SMatDeclSymExpr.h:244
Base class for dense matrices.The DenseMatrix class is a base class for all dense matrix classes...
Definition: DenseMatrix.h:80
Base class for sparse matrices.The SparseMatrix class is a base class for all sparse matrix classes...
Definition: Forward.h:129
Header file for all forward declarations for sparse vectors and matrices.
Header file for the implementation of the base template of the SymmetricMatrix.
size_t nonZeros(size_t i) const
Returns the number of non-zero elements in the specified row.
Definition: SMatDeclSymExpr.h:285
typename T::ReturnType ReturnType_
Alias declaration for nested ReturnType type definitions.The ReturnType_ alias declaration provides a...
Definition: Aliases.h:363
Header file for the SparseMatrix base class.
ReturnType at(size_t i, size_t j) const
Checked access to the matrix elements.
Definition: SMatDeclSymExpr.h:216
Constraint on the data type.
Compile time check to query the requirement to evaluate an expression.Via this type trait it is possi...
Definition: RequiresEvaluation.h:71
typename DeclSymTrait< MT >::Type DeclSymTrait_
Auxiliary alias declaration for the DeclSymTrait type trait.The DeclSymTrait_ alias declaration provi...
Definition: DeclSymTrait.h:156
Compile time check for upper unitriangular matrices.This type trait tests whether or not the given te...
Definition: IsUniUpper.h:86
ConstIterator begin(size_t i) const
Returns an iterator to the first non-zero element of row i.
Definition: SMatDeclSymExpr.h:233
Efficient implementation of an identity matrix.The IdentityMatrix class template is the representati...
Definition: Forward.h:49
Header file for the DisableIf class template.
Header file for the IsStrictlyUpper type trait.
Header file for the IsSymmetric type trait.
ResultType_< MT > RT
Result type of the sparse matrix expression.
Definition: SMatDeclSymExpr.h:106
Namespace of the Blaze C++ math library.
Definition: Blaze.h:58
Header file for the If class template.
size_t rows() const noexcept
Returns the current number of rows of the matrix.
Definition: SMatDeclSymExpr.h:254
bool canSMPAssign() const noexcept
Returns whether the expression can be used in SMP assignments.
Definition: SMatDeclSymExpr.h:329
EnableIf_< IsDenseMatrix< MT1 > > smpAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the SMP assignment of a matrix to a dense matrix.
Definition: DenseMatrix.h:102
Header file for the Or class template.
#define BLAZE_THROW_OUT_OF_RANGE(MESSAGE)
Macro for the emission of a std::out_of_range exception.This macro encapsulates the default way of Bl...
Definition: Exception.h:331
Header file for the Not class template.
const Element * ConstIterator
Iterator over constant elements.
Definition: CompressedMatrix.h:3085
typename T::ElementType ElementType_
Alias declaration for nested ElementType type definitions.The ElementType_ alias declaration provides...
Definition: Aliases.h:163
ReturnType_< MT > ReturnType
Return type for expression template evaluations.
Definition: SMatDeclSymExpr.h:165
Header file for the IsLower type trait.
bool canAlias(const T *alias) const noexcept
Returns whether the expression can alias with the given address alias.
Definition: SMatDeclSymExpr.h:307
ElementType_< MT > ElementType
Resulting element type.
Definition: SMatDeclSymExpr.h:164
DeclSymTrait_< RT > ResultType
Result type for expression template evaluations.
Definition: SMatDeclSymExpr.h:161
Header file for the IsUniTriangular type trait.
Constraints on the storage order of matrix types.
Compile time check for symmetric matrices.This type trait tests whether or not the given template par...
Definition: IsSymmetric.h:85
Header file for the exception macros of the math module.
Compile time check for strictly upper triangular matrices.This type trait tests whether or not the gi...
Definition: IsStrictlyUpper.h:86
Expression object for sparse matrix-scalar multiplications.The SMatScalarMult class represents the co...
Definition: Forward.h:114
Header file for all forward declarations for expression class templates.
Header file for the EnableIf class template.
Header file for the IsStrictlyLower type trait.
Header file for the DeclSymExpr base class.
Compile time check for lower unitriangular matrices.This type trait tests whether or not the given te...
Definition: IsUniLower.h:86
Constraint on the data type.
Header file for the Declaration base class.
ReturnType operator()(size_t i, size_t j) const
2D-access to the matrix elements.
Definition: SMatDeclSymExpr.h:201
#define BLAZE_CONSTRAINT_MUST_NOT_BE_SYMMETRIC_MATRIX_TYPE(T)
Constraint on the data type.In case the given data type T is a symmetric matrix type, a compilation error is created.
Definition: Symmetric.h:79
Header file for run time assertion macros.
OppositeType_< ResultType > OppositeType
Result type with opposite storage order for expression template evaluations.
Definition: SMatDeclSymExpr.h:162
Utility type for generic codes.
Operand operand() const noexcept
Returns the sparse matrix operand.
Definition: SMatDeclSymExpr.h:295
typename If< T1, T2, T3 >::Type If_
Auxiliary alias declaration for the If class template.The If_ alias declaration provides a convenient...
Definition: If.h:154
size_t nonZeros() const
Returns the number of non-zero elements in the sparse matrix.
Definition: SMatDeclSymExpr.h:274
Header file for the declsym trait.
#define BLAZE_FUNCTION_TRACE
Function trace macro.This macro can be used to reliably trace function calls. In case function tracin...
Definition: FunctionTrace.h:94
decltype(auto) declsym(const DenseMatrix< MT, SO > &dm)
Declares the given dense matrix expression dm as symmetric.
Definition: DMatDeclSymExpr.h:1028
Compile time check for Hermitian matrices.This type trait tests whether or not the given template par...
Definition: IsHermitian.h:85
Constraint on the data type.
Header file for the HasMember type traits.
typename EnableIf< Condition, T >::Type EnableIf_
Auxiliary alias declaration for the EnableIf class template.The EnableIf_ alias declaration provides ...
Definition: EnableIf.h:224
typename T::OppositeType OppositeType_
Alias declaration for nested OppositeType type definitions.The OppositeType_ alias declaration provid...
Definition: Aliases.h:263
Compile time check for strictly lower triangular matrices.This type trait tests whether or not the gi...
Definition: IsStrictlyLower.h:86
TransposeType_< ResultType > TransposeType
Transpose type for expression template evaluations.
Definition: SMatDeclSymExpr.h:163
Expression object for the explicit symmetry declaration of sparse matrices.The SMatDeclSymExpr class ...
Definition: Forward.h:105
Compile time evaluation of the size of vectors and matrices.The Size type trait evaluates the size of...
Definition: Size.h:80
typename T::TransposeType TransposeType_
Alias declaration for nested TransposeType type definitions.The TransposeType_ alias declaration prov...
Definition: Aliases.h:423
Header file for the IsUpper type trait.
size_t columns() const noexcept
Returns the current number of columns of the matrix.
Definition: SMatDeclSymExpr.h:264
Header file for the IsHermitian type trait.
If_< IsExpression< MT >, const MT, const MT &> Operand
Composite data type of the sparse matrix expression.
Definition: SMatDeclSymExpr.h:174
BLAZE_ALWAYS_INLINE bool isSquare(const Matrix< MT, SO > &matrix) noexcept
Checks if the given matrix is a square matrix.
Definition: Matrix.h:908
Header file for the Size type trait.
#define BLAZE_INTERNAL_ASSERT(expr, msg)
Run time assertion macro for internal checks.In case of an invalid run time expression, the program execution is terminated. The BLAZE_INTERNAL_ASSERT macro can be disabled by setting the BLAZE_USER_ASSERTION flag to zero or by defining NDEBUG during the compilation.
Definition: Assert.h:101
#define BLAZE_CONSTRAINT_MUST_BE_SPARSE_MATRIX_TYPE(T)
Constraint on the data type.In case the given data type T is not a sparse, N-dimensional matrix type...
Definition: SparseMatrix.h:61
Header file for the TrueType type/value trait base class.
Compile time check for unitriangular matrix types.This type trait tests whether or not the given temp...
Definition: IsUniTriangular.h:86
Header file for the IsExpression type trait class.
Header file for the function trace functionality.