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>
70 #include <blaze/util/Assert.h>
71 #include <blaze/util/DisableIf.h>
72 #include <blaze/util/EnableIf.h>
75 #include <blaze/util/InvalidType.h>
76 #include <blaze/util/mpl/And.h>
77 #include <blaze/util/mpl/If.h>
78 #include <blaze/util/mpl/Not.h>
79 #include <blaze/util/mpl/Or.h>
80 #include <blaze/util/TrueType.h>
81 #include <blaze/util/Types.h>
83 
84 
85 namespace blaze {
86 
87 //=================================================================================================
88 //
89 // CLASS SMATDECLSYMEXPR
90 //
91 //=================================================================================================
92 
93 //*************************************************************************************************
100 template< typename MT // Type of the sparse matrix
101  , bool SO > // Storage order
102 class SMatDeclSymExpr
103  : public DeclSymExpr< SparseMatrix< SMatDeclSymExpr<MT,SO>, SO > >
104  , public Declaration<MT>
105 {
106  private:
107  //**Type definitions****************************************************************************
108  using RT = ResultType_<MT>;
109  //**********************************************************************************************
110 
111  //**Serial evaluation strategy******************************************************************
113 
119  enum : bool { useAssign = RequiresEvaluation<MT>::value };
120 
122  template< typename MT2 >
124  struct UseAssign {
125  enum : bool { value = useAssign };
126  };
128  //**********************************************************************************************
129 
130  //**Parallel evaluation strategy****************************************************************
132 
137  template< typename MT2 >
138  struct UseSMPAssign {
139  enum : bool { value = MT2::smpAssignable && useAssign };
140  };
142  //**********************************************************************************************
143 
144  //**********************************************************************************************
146 
150  template< typename MT2 >
151  struct GetConstIterator {
153  struct Success { using Type = typename MT2::ConstIterator; };
154  struct Failure { using Type = INVALID_TYPE; };
155  using Type = typename If_< HasConstIterator<MT2>, Success, Failure >::Type;
156  };
158  //**********************************************************************************************
159 
160  public:
161  //**Type definitions****************************************************************************
168 
171 
173  using ConstIterator = typename GetConstIterator<MT>::Type;
174 
176  using Operand = If_< IsExpression<MT>, const MT, const MT& >;
177  //**********************************************************************************************
178 
179  //**Compilation flags***************************************************************************
181  enum : bool { smpAssignable = MT::smpAssignable };
182  //**********************************************************************************************
183 
184  //**Constructor*********************************************************************************
189  explicit inline SMatDeclSymExpr( const MT& sm ) noexcept
190  : sm_( sm ) // Sparse matrix of the declsym expression
191  {
192  BLAZE_INTERNAL_ASSERT( isSquare( ~sm ), "Non-square matrix detected" );
193  }
194  //**********************************************************************************************
195 
196  //**Access operator*****************************************************************************
203  inline ReturnType operator()( size_t i, size_t j ) const {
204  BLAZE_INTERNAL_ASSERT( i < sm_.rows() , "Invalid row access index" );
205  BLAZE_INTERNAL_ASSERT( j < sm_.columns(), "Invalid column access index" );
206  return sm_(i,j);
207  }
208  //**********************************************************************************************
209 
210  //**At function*********************************************************************************
218  inline ReturnType at( size_t i, size_t j ) const {
219  if( i >= sm_.rows() ) {
220  BLAZE_THROW_OUT_OF_RANGE( "Invalid row access index" );
221  }
222  if( j >= sm_.columns() ) {
223  BLAZE_THROW_OUT_OF_RANGE( "Invalid column access index" );
224  }
225  return (*this)(i,j);
226  }
227  //**********************************************************************************************
228 
229  //**Begin function******************************************************************************
235  inline ConstIterator begin( size_t i ) const {
236  return ConstIterator( sm_.begin(i) );
237  }
238  //**********************************************************************************************
239 
240  //**End function********************************************************************************
246  inline ConstIterator end( size_t i ) const {
247  return ConstIterator( sm_.end(i) );
248  }
249  //**********************************************************************************************
250 
251  //**Rows function*******************************************************************************
256  inline size_t rows() const noexcept {
257  return sm_.rows();
258  }
259  //**********************************************************************************************
260 
261  //**Columns function****************************************************************************
266  inline size_t columns() const noexcept {
267  return sm_.columns();
268  }
269  //**********************************************************************************************
270 
271  //**NonZeros function***************************************************************************
276  inline size_t nonZeros() const {
277  return sm_.nonZeros();
278  }
279  //**********************************************************************************************
280 
281  //**NonZeros function***************************************************************************
287  inline size_t nonZeros( size_t i ) const {
288  return sm_.nonZeros(i);
289  }
290  //**********************************************************************************************
291 
292  //**Operand access******************************************************************************
297  inline Operand operand() const noexcept {
298  return sm_;
299  }
300  //**********************************************************************************************
301 
302  //**********************************************************************************************
308  template< typename T >
309  inline bool canAlias( const T* alias ) const noexcept {
310  return sm_.canAlias( alias );
311  }
312  //**********************************************************************************************
313 
314  //**********************************************************************************************
320  template< typename T >
321  inline bool isAliased( const T* alias ) const noexcept {
322  return sm_.isAliased( alias );
323  }
324  //**********************************************************************************************
325 
326  //**********************************************************************************************
331  inline bool canSMPAssign() const noexcept {
332  return sm_.canSMPAssign();
333  }
334  //**********************************************************************************************
335 
336  private:
337  //**Member variables****************************************************************************
339  //**********************************************************************************************
340 
341  //**Assignment to dense matrices****************************************************************
353  template< typename MT2 // Type of the target dense matrix
354  , bool SO2 > // Storage order of the target dense matrix
355  friend inline EnableIf_< UseAssign<MT2> >
356  assign( DenseMatrix<MT2,SO2>& lhs, const SMatDeclSymExpr& rhs )
357  {
359 
360  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
361  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
362 
363  assign( ~lhs, rhs.sm_ );
364  }
366  //**********************************************************************************************
367 
368  //**Assignment to sparse matrices***************************************************************
380  template< typename MT2 // Type of the target sparse matrix
381  , bool SO2 > // Storage order of the target sparse matrix
382  friend inline EnableIf_< UseAssign<MT2> >
383  assign( SparseMatrix<MT2,SO2>& lhs, const SMatDeclSymExpr& rhs )
384  {
386 
387  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
388  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
389 
390  assign( ~lhs, rhs.sm_ );
391  }
393  //**********************************************************************************************
394 
395  //**Addition assignment to dense matrices*******************************************************
407  template< typename MT2 // Type of the target dense matrix
408  , bool SO2 > // Storage order of the target dense matrix
409  friend inline EnableIf_< UseAssign<MT2> >
410  addAssign( DenseMatrix<MT2,SO2>& lhs, const SMatDeclSymExpr& rhs )
411  {
413 
414  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
415  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
416 
417  addAssign( ~lhs, rhs.sm_ );
418  }
420  //**********************************************************************************************
421 
422  //**Addition assignment to sparse matrices******************************************************
434  template< typename MT2 // Type of the target sparse matrix
435  , bool SO2 > // Storage order of the target sparse matrix
436  friend inline EnableIf_< UseAssign<MT2> >
437  addAssign( SparseMatrix<MT2,SO2>& lhs, const SMatDeclSymExpr& rhs )
438  {
440 
441  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
442  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
443 
444  addAssign( ~lhs, rhs.sm_ );
445  }
447  //**********************************************************************************************
448 
449  //**Subtraction assignment to dense matrices****************************************************
461  template< typename MT2 // Type of the target dense matrix
462  , bool SO2 > // Storage order of the target dense matrix
463  friend inline EnableIf_< UseAssign<MT2> >
464  subAssign( DenseMatrix<MT2,SO2>& lhs, const SMatDeclSymExpr& rhs )
465  {
467 
468  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
469  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
470 
471  subAssign( ~lhs, rhs.sm_ );
472  }
474  //**********************************************************************************************
475 
476  //**Subtraction assignment to sparse matrices***************************************************
488  template< typename MT2 // Type of the target sparse matrix
489  , bool SO2 > // Storage order of the target sparse matrix
490  friend inline EnableIf_< UseAssign<MT2> >
491  subAssign( SparseMatrix<MT2,SO2>& lhs, const SMatDeclSymExpr& rhs )
492  {
494 
495  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
496  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
497 
498  subAssign( ~lhs, rhs.sm_ );
499  }
501  //**********************************************************************************************
502 
503  //**Schur product assignment to dense matrices**************************************************
515  template< typename MT2 // Type of the target dense matrix
516  , bool SO2 > // Storage order of the target dense matrix
517  friend inline EnableIf_< UseAssign<MT2> >
518  schurAssign( DenseMatrix<MT2,SO2>& lhs, const SMatDeclSymExpr& rhs )
519  {
521 
522  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
523  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
524 
525  schurAssign( ~lhs, rhs.sm_ );
526  }
528  //**********************************************************************************************
529 
530  //**Schur product assignment to sparse matrices*************************************************
542  template< typename MT2 // Type of the target sparse matrix
543  , bool SO2 > // Storage order of the target sparse matrix
544  friend inline EnableIf_< UseAssign<MT2> >
545  schurAssign( SparseMatrix<MT2,SO2>& lhs, const SMatDeclSymExpr& rhs )
546  {
548 
549  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
550  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
551 
552  schurAssign( ~lhs, rhs.sm_ );
553  }
555  //**********************************************************************************************
556 
557  //**Multiplication assignment to dense matrices*************************************************
569  template< typename MT2 // Type of the target dense matrix
570  , bool SO2 > // Storage order of the target dense matrix
571  friend inline EnableIf_< UseAssign<MT2> >
572  multAssign( DenseMatrix<MT2,SO2>& lhs, const SMatDeclSymExpr& rhs )
573  {
575 
576  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
577  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
578 
579  multAssign( ~lhs, rhs.sm_ );
580  }
582  //**********************************************************************************************
583 
584  //**Multiplication assignment to sparse matrices************************************************
596  template< typename MT2 // Type of the target sparse matrix
597  , bool SO2 > // Storage order of the target sparse matrix
598  friend inline EnableIf_< UseAssign<MT2> >
599  multAssign( SparseMatrix<MT2,SO2>& lhs, const SMatDeclSymExpr& rhs )
600  {
602 
603  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
604  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
605 
606  multAssign( ~lhs, rhs.sm_ );
607  }
609  //**********************************************************************************************
610 
611  //**SMP assignment to dense matrices************************************************************
623  template< typename MT2 // Type of the target dense matrix
624  , bool SO2 > // Storage order of the target dense matrix
625  friend inline EnableIf_< UseSMPAssign<MT2> >
626  smpAssign( DenseMatrix<MT2,SO2>& lhs, const SMatDeclSymExpr& rhs )
627  {
629 
630  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
631  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
632 
633  smpAssign( ~lhs, rhs.sm_ );
634  }
636  //**********************************************************************************************
637 
638  //**SMP assignment to sparse matrices***********************************************************
650  template< typename MT2 // Type of the target sparse matrix
651  , bool SO2 > // Storage order of the target sparse matrix
652  friend inline EnableIf_< UseSMPAssign<MT2> >
653  smpAssign( SparseMatrix<MT2,SO2>& lhs, const SMatDeclSymExpr& rhs )
654  {
656 
657  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
658  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
659 
660  smpAssign( ~lhs, rhs.sm_ );
661  }
663  //**********************************************************************************************
664 
665  //**SMP addition assignment to dense matrices***************************************************
677  template< typename MT2 // Type of the target dense matrix
678  , bool SO2 > // Storage order of the target dense matrix
679  friend inline EnableIf_< UseSMPAssign<MT2> >
680  smpAddAssign( DenseMatrix<MT2,SO2>& lhs, const SMatDeclSymExpr& rhs )
681  {
683 
684  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
685  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
686 
687  smpAddAssign( ~lhs, rhs.sm_ );
688  }
690  //**********************************************************************************************
691 
692  //**SMP addition assignment to sparse matrices**************************************************
704  template< typename MT2 // Type of the target sparse matrix
705  , bool SO2 > // Storage order of the target sparse matrix
706  friend inline EnableIf_< UseSMPAssign<MT2> >
707  smpAddAssign( SparseMatrix<MT2,SO2>& lhs, const SMatDeclSymExpr& rhs )
708  {
710 
711  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
712  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
713 
714  smpAddAssign( ~lhs, rhs.sm_ );
715  }
717  //**********************************************************************************************
718 
719  //**SMP subtraction assignment to dense matrices************************************************
731  template< typename MT2 // Type of the target dense matrix
732  , bool SO2 > // Storage order of the target dense matrix
733  friend inline EnableIf_< UseSMPAssign<MT2> >
734  smpSubAssign( DenseMatrix<MT2,SO2>& lhs, const SMatDeclSymExpr& rhs )
735  {
737 
738  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
739  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
740 
741  smpSubAssign( ~lhs, rhs.sm_ );
742  }
744  //**********************************************************************************************
745 
746  //**SMP subtraction assignment to sparse matrices***********************************************
758  template< typename MT2 // Type of the target sparse matrix
759  , bool SO2 > // Storage order of the target sparse matrix
760  friend inline EnableIf_< UseSMPAssign<MT2> >
761  smpSubAssign( SparseMatrix<MT2,SO2>& lhs, const SMatDeclSymExpr& rhs )
762  {
764 
765  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
766  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
767 
768  smpSubAssign( ~lhs, rhs.sm_ );
769  }
771  //**********************************************************************************************
772 
773  //**SMP Schur product assignment to dense matrices**********************************************
785  template< typename MT2 // Type of the target dense matrix
786  , bool SO2 > // Storage order of the target dense matrix
787  friend inline EnableIf_< UseSMPAssign<MT2> >
788  smpSchurAssign( DenseMatrix<MT2,SO2>& lhs, const SMatDeclSymExpr& rhs )
789  {
791 
792  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
793  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
794 
795  smpSchurAssign( ~lhs, rhs.sm_ );
796  }
798  //**********************************************************************************************
799 
800  //**SMP Schur product assignment to sparse matrices*********************************************
812  template< typename MT2 // Type of the target sparse matrix
813  , bool SO2 > // Storage order of the target sparse matrix
814  friend inline EnableIf_< UseSMPAssign<MT2> >
815  smpSchurAssign( SparseMatrix<MT2,SO2>& lhs, const SMatDeclSymExpr& rhs )
816  {
818 
819  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
820  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
821 
822  smpSchurAssign( ~lhs, rhs.sm_ );
823  }
825  //**********************************************************************************************
826 
827  //**SMP multiplication assignment to dense matrices*********************************************
840  template< typename MT2 // Type of the target dense matrix
841  , bool SO2 > // Storage order of the target dense matrix
842  friend inline EnableIf_< UseSMPAssign<MT2> >
843  smpMultAssign( DenseMatrix<MT2,SO2>& lhs, const SMatDeclSymExpr& rhs )
844  {
846 
847  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
848  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
849 
850  smpMultAssign( ~lhs, rhs.sm_ );
851  }
853  //**********************************************************************************************
854 
855  //**SMP multiplication assignment to sparse matrices********************************************
868  template< typename MT2 // Type of the target sparse matrix
869  , bool SO2 > // Storage order of the target sparse matrix
870  friend inline EnableIf_< UseSMPAssign<MT2> >
871  smpMultAssign( SparseMatrix<MT2,SO2>& lhs, const SMatDeclSymExpr& rhs )
872  {
874 
875  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
876  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
877 
878  smpMultAssign( ~lhs, rhs.sm_ );
879  }
881  //**********************************************************************************************
882 
883  //**Compile time checks*************************************************************************
890  //**********************************************************************************************
891 };
892 //*************************************************************************************************
893 
894 
895 
896 
897 //=================================================================================================
898 //
899 // GLOBAL FUNCTIONS
900 //
901 //=================================================================================================
902 
903 //*************************************************************************************************
914 template< typename MT // Type of the sparse matrix
915  , bool SO // Storage order
917 inline const SMatDeclSymExpr<MT,SO> declsym_backend( const SparseMatrix<MT,SO>& sm )
918 {
920 
921  BLAZE_INTERNAL_ASSERT( isSquare( ~sm ), "Non-square matrix detected" );
922 
923  return SMatDeclSymExpr<MT,SO>( ~sm );
924 }
926 //*************************************************************************************************
927 
928 
929 //*************************************************************************************************
940 template< typename MT // Type of the sparse matrix
941  , bool SO // Storage order
943 inline const IdentityMatrix<ElementType_<MT>,SO> declsym_backend( const SparseMatrix<MT,SO>& sm )
944 {
946 
947  BLAZE_INTERNAL_ASSERT( isSquare( ~sm ), "Non-square matrix detected" );
948 
949  return IdentityMatrix<ElementType_<MT>,SO>( (~sm).rows() );
950 }
952 //*************************************************************************************************
953 
954 
955 //*************************************************************************************************
966 template< typename MT // Type of the sparse matrix
967  , bool SO // Storage order
968  , typename = EnableIf_< IsSymmetric<MT> > >
969 inline const MT& declsym_backend( const SparseMatrix<MT,SO>& sm )
970 {
972 
973  BLAZE_INTERNAL_ASSERT( isSquare( ~sm ), "Non-square matrix detected" );
974 
975  return ~sm;
976 }
978 //*************************************************************************************************
979 
980 
981 //*************************************************************************************************
1000 template< typename MT // Type of the sparse matrix
1001  , bool SO > // Storage order
1002 inline decltype(auto) declsym( const SparseMatrix<MT,SO>& sm )
1003 {
1005 
1006  if( !isSquare( ~sm ) ) {
1007  BLAZE_THROW_INVALID_ARGUMENT( "Invalid symmetric matrix specification" );
1008  }
1009 
1010  return declsym_backend( ~sm );
1011 }
1012 //*************************************************************************************************
1013 
1014 
1015 
1016 
1017 //=================================================================================================
1018 //
1019 // GLOBAL RESTRUCTURING FUNCTIONS
1020 //
1021 //=================================================================================================
1022 
1023 //*************************************************************************************************
1037 template< typename MT // Type of the left-hand side sparse matrix
1038  , typename ST // Type of the right-hand side scalar value
1039  , bool SO // Storage order
1040  , typename = DisableIf_< IsSymmetric<MT> > >
1041 inline decltype(auto) declsym( const SMatScalarMultExpr<MT,ST,SO>& sm )
1042 {
1044 
1045  if( !isSquare( ~sm ) ) {
1046  BLAZE_THROW_INVALID_ARGUMENT( "Invalid symmetric matrix specification" );
1047  }
1048 
1049  return declsym( sm.leftOperand() ) * sm.rightOperand();
1050 }
1052 //*************************************************************************************************
1053 
1054 
1055 
1056 
1057 //=================================================================================================
1058 //
1059 // ROWS SPECIALIZATIONS
1060 //
1061 //=================================================================================================
1062 
1063 //*************************************************************************************************
1065 template< typename MT, bool SO >
1066 struct Rows< SMatDeclSymExpr<MT,SO> >
1067  : public Rows<MT>
1068 {};
1070 //*************************************************************************************************
1071 
1072 
1073 
1074 
1075 //=================================================================================================
1076 //
1077 // COLUMNS SPECIALIZATIONS
1078 //
1079 //=================================================================================================
1080 
1081 //*************************************************************************************************
1083 template< typename MT, bool SO >
1084 struct Columns< SMatDeclSymExpr<MT,SO> >
1085  : public Columns<MT>
1086 {};
1088 //*************************************************************************************************
1089 
1090 
1091 
1092 
1093 //=================================================================================================
1094 //
1095 // ISSYMMETRIC SPECIALIZATIONS
1096 //
1097 //=================================================================================================
1098 
1099 //*************************************************************************************************
1101 template< typename MT, bool SO >
1102 struct IsSymmetric< SMatDeclSymExpr<MT,SO> >
1103  : public TrueType
1104 {};
1106 //*************************************************************************************************
1107 
1108 
1109 
1110 
1111 //=================================================================================================
1112 //
1113 // ISHERMITIAN SPECIALIZATIONS
1114 //
1115 //=================================================================================================
1116 
1117 //*************************************************************************************************
1119 template< typename MT, bool SO >
1120 struct IsHermitian< SMatDeclSymExpr<MT,SO> >
1121  : public BoolConstant< IsHermitian<MT>::value >
1122 {};
1124 //*************************************************************************************************
1125 
1126 
1127 
1128 
1129 //=================================================================================================
1130 //
1131 // ISLOWER SPECIALIZATIONS
1132 //
1133 //=================================================================================================
1134 
1135 //*************************************************************************************************
1137 template< typename MT, bool SO >
1138 struct IsLower< SMatDeclSymExpr<MT,SO> >
1139  : public BoolConstant< IsLower<MT>::value >
1140 {};
1142 //*************************************************************************************************
1143 
1144 
1145 
1146 
1147 //=================================================================================================
1148 //
1149 // ISUNILOWER SPECIALIZATIONS
1150 //
1151 //=================================================================================================
1152 
1153 //*************************************************************************************************
1155 template< typename MT, bool SO >
1156 struct IsUniLower< SMatDeclSymExpr<MT,SO> >
1157  : public BoolConstant< IsUniLower<MT>::value >
1158 {};
1160 //*************************************************************************************************
1161 
1162 
1163 
1164 
1165 //=================================================================================================
1166 //
1167 // ISSTRICTLYLOWER SPECIALIZATIONS
1168 //
1169 //=================================================================================================
1170 
1171 //*************************************************************************************************
1173 template< typename MT, bool SO >
1174 struct IsStrictlyLower< SMatDeclSymExpr<MT,SO> >
1175  : public BoolConstant< IsStrictlyLower<MT>::value >
1176 {};
1178 //*************************************************************************************************
1179 
1180 
1181 
1182 
1183 //=================================================================================================
1184 //
1185 // ISUPPER SPECIALIZATIONS
1186 //
1187 //=================================================================================================
1188 
1189 //*************************************************************************************************
1191 template< typename MT, bool SO >
1192 struct IsUpper< SMatDeclSymExpr<MT,SO> >
1193  : public BoolConstant< IsUpper<MT>::value >
1194 {};
1196 //*************************************************************************************************
1197 
1198 
1199 
1200 
1201 //=================================================================================================
1202 //
1203 // ISUNIUPPER SPECIALIZATIONS
1204 //
1205 //=================================================================================================
1206 
1207 //*************************************************************************************************
1209 template< typename MT, bool SO >
1210 struct IsUniUpper< SMatDeclSymExpr<MT,SO> >
1211  : public BoolConstant< IsUniUpper<MT>::value >
1212 {};
1214 //*************************************************************************************************
1215 
1216 
1217 
1218 
1219 //=================================================================================================
1220 //
1221 // ISSTRICTLYUPPER SPECIALIZATIONS
1222 //
1223 //=================================================================================================
1224 
1225 //*************************************************************************************************
1227 template< typename MT, bool SO >
1228 struct IsStrictlyUpper< SMatDeclSymExpr<MT,SO> >
1229  : public BoolConstant< IsStrictlyUpper<MT>::value >
1230 {};
1232 //*************************************************************************************************
1233 
1234 } // namespace blaze
1235 
1236 #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:170
SMatDeclSymExpr(const MT &sm) noexcept
Constructor for the SMatDeclSymExpr class.
Definition: SMatDeclSymExpr.h:189
Header file for the Rows type trait.
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:478
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:321
typename GetConstIterator< MT >::Type ConstIterator
Iterator over the elements of the dense matrix.
Definition: SMatDeclSymExpr.h:173
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:468
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:88
#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:88
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:338
ConstIterator end(size_t i) const
Returns an iterator just past the last non-zero element of row i.
Definition: SMatDeclSymExpr.h:246
Base class for dense matrices.The DenseMatrix class is a base class for all dense matrix classes...
Definition: DenseMatrix.h:78
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:287
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:218
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:72
typename DeclSymTrait< MT >::Type DeclSymTrait_
Auxiliary alias declaration for the DeclSymTrait type trait.The DeclSymTrait_ alias declaration provi...
Definition: DeclSymTrait.h:177
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:235
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:108
Namespace of the Blaze C++ math library.
Definition: Blaze.h:57
Header file for the If class template.
size_t rows() const noexcept
Returns the current number of rows of the matrix.
Definition: SMatDeclSymExpr.h:256
bool canSMPAssign() const noexcept
Returns whether the expression can be used in SMP assignments.
Definition: SMatDeclSymExpr.h:331
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 Columns type trait.
Header file for the Not class template.
const Element * ConstIterator
Iterator over constant elements.
Definition: CompressedMatrix.h:3087
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:167
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:309
ElementType_< MT > ElementType
Resulting element type.
Definition: SMatDeclSymExpr.h:166
DeclSymTrait_< RT > ResultType
Result type for expression template evaluations.
Definition: SMatDeclSymExpr.h:163
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:203
#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:164
Utility type for generic codes.
Operand operand() const noexcept
Returns the sparse matrix operand.
Definition: SMatDeclSymExpr.h:297
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:276
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:1029
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:165
Expression object for the explicit symmetry declaration of sparse matrices.The SMatDeclSymExpr class ...
Definition: Forward.h:105
Header file for the IntegralConstant class template.
Compile time evaluation of the number of columns of a matrix.The Columns type trait evaluates the num...
Definition: Columns.h:75
Compile time evaluation of the number of rows of a matrix.The Rows type trait evaluates the number of...
Definition: Rows.h:75
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:266
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:176
BLAZE_ALWAYS_INLINE bool isSquare(const Matrix< MT, SO > &matrix) noexcept
Checks if the given matrix is a square matrix.
Definition: Matrix.h:742
#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:87
Header file for the IsExpression type trait class.
Header file for the function trace functionality.