SMatDeclLowExpr.h
Go to the documentation of this file.
1 //=================================================================================================
33 //=================================================================================================
34 
35 #ifndef _BLAZE_MATH_EXPRESSIONS_SMATDECLLOWEXPR_H_
36 #define _BLAZE_MATH_EXPRESSIONS_SMATDECLLOWEXPR_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>
74 #include <blaze/util/InvalidType.h>
75 #include <blaze/util/mpl/And.h>
76 #include <blaze/util/mpl/If.h>
77 #include <blaze/util/mpl/Not.h>
78 #include <blaze/util/mpl/Or.h>
79 #include <blaze/util/TrueType.h>
80 #include <blaze/util/Types.h>
82 
83 
84 namespace blaze {
85 
86 //=================================================================================================
87 //
88 // CLASS SMATDECLLOWEXPR
89 //
90 //=================================================================================================
91 
92 //*************************************************************************************************
99 template< typename MT // Type of the sparse matrix
100  , bool SO > // Storage order
101 class SMatDeclLowExpr
102  : public DeclLowExpr< SparseMatrix< SMatDeclLowExpr<MT,SO>, SO > >
103  , public Declaration<MT>
104 {
105  private:
106  //**Type definitions****************************************************************************
107  using RT = ResultType_<MT>;
108  //**********************************************************************************************
109 
110  //**Serial evaluation strategy******************************************************************
112 
118  enum : bool { useAssign = RequiresEvaluation<MT>::value };
119 
121  template< typename MT2 >
123  struct UseAssign {
124  enum : bool { value = useAssign };
125  };
127  //**********************************************************************************************
128 
129  //**Parallel evaluation strategy****************************************************************
131 
136  template< typename MT2 >
137  struct UseSMPAssign {
138  enum : bool { value = MT2::smpAssignable && useAssign };
139  };
141  //**********************************************************************************************
142 
143  //**********************************************************************************************
145 
149  template< typename MT2 >
150  struct GetConstIterator {
152  struct Success { using Type = typename MT2::ConstIterator; };
153  struct Failure { using Type = INVALID_TYPE; };
154  using Type = typename If_< HasConstIterator<MT2>, Success, Failure >::Type;
155  };
157  //**********************************************************************************************
158 
159  public:
160  //**Type definitions****************************************************************************
167 
170 
172  using ConstIterator = typename GetConstIterator<MT>::Type;
173 
175  using Operand = If_< IsExpression<MT>, const MT, const MT& >;
176  //**********************************************************************************************
177 
178  //**Compilation flags***************************************************************************
180  enum : bool { smpAssignable = MT::smpAssignable };
181  //**********************************************************************************************
182 
183  //**Constructor*********************************************************************************
188  explicit inline SMatDeclLowExpr( const MT& sm ) noexcept
189  : sm_( sm ) // Sparse matrix of the decllow expression
190  {
191  BLAZE_INTERNAL_ASSERT( isSquare( ~sm ), "Non-square matrix detected" );
192  }
193  //**********************************************************************************************
194 
195  //**Access operator*****************************************************************************
202  inline ReturnType operator()( size_t i, size_t j ) const {
203  BLAZE_INTERNAL_ASSERT( i < sm_.rows() , "Invalid row access index" );
204  BLAZE_INTERNAL_ASSERT( j < sm_.columns(), "Invalid column access index" );
205  return sm_(i,j);
206  }
207  //**********************************************************************************************
208 
209  //**At function*********************************************************************************
217  inline ReturnType at( size_t i, size_t j ) const {
218  if( i >= sm_.rows() ) {
219  BLAZE_THROW_OUT_OF_RANGE( "Invalid row access index" );
220  }
221  if( j >= sm_.columns() ) {
222  BLAZE_THROW_OUT_OF_RANGE( "Invalid column access index" );
223  }
224  return (*this)(i,j);
225  }
226  //**********************************************************************************************
227 
228  //**Begin function******************************************************************************
234  inline ConstIterator begin( size_t i ) const {
235  return ConstIterator( sm_.begin(i) );
236  }
237  //**********************************************************************************************
238 
239  //**End function********************************************************************************
245  inline ConstIterator end( size_t i ) const {
246  return ConstIterator( sm_.end(i) );
247  }
248  //**********************************************************************************************
249 
250  //**Rows function*******************************************************************************
255  inline size_t rows() const noexcept {
256  return sm_.rows();
257  }
258  //**********************************************************************************************
259 
260  //**Columns function****************************************************************************
265  inline size_t columns() const noexcept {
266  return sm_.columns();
267  }
268  //**********************************************************************************************
269 
270  //**NonZeros function***************************************************************************
275  inline size_t nonZeros() const {
276  return sm_.nonZeros();
277  }
278  //**********************************************************************************************
279 
280  //**NonZeros function***************************************************************************
286  inline size_t nonZeros( size_t i ) const {
287  return sm_.nonZeros(i);
288  }
289  //**********************************************************************************************
290 
291  //**Operand access******************************************************************************
296  inline Operand operand() const noexcept {
297  return sm_;
298  }
299  //**********************************************************************************************
300 
301  //**********************************************************************************************
307  template< typename T >
308  inline bool canAlias( const T* alias ) const noexcept {
309  return sm_.canAlias( alias );
310  }
311  //**********************************************************************************************
312 
313  //**********************************************************************************************
319  template< typename T >
320  inline bool isAliased( const T* alias ) const noexcept {
321  return sm_.isAliased( alias );
322  }
323  //**********************************************************************************************
324 
325  //**********************************************************************************************
330  inline bool canSMPAssign() const noexcept {
331  return sm_.canSMPAssign();
332  }
333  //**********************************************************************************************
334 
335  private:
336  //**Member variables****************************************************************************
338  //**********************************************************************************************
339 
340  //**Assignment to dense matrices****************************************************************
352  template< typename MT2 // Type of the target dense matrix
353  , bool SO2 > // Storage order of the target dense matrix
354  friend inline EnableIf_< UseAssign<MT2> >
355  assign( DenseMatrix<MT2,SO2>& lhs, const SMatDeclLowExpr& rhs )
356  {
358 
359  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
360  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
361 
362  assign( ~lhs, rhs.sm_ );
363  }
365  //**********************************************************************************************
366 
367  //**Assignment to sparse matrices***************************************************************
379  template< typename MT2 // Type of the target sparse matrix
380  , bool SO2 > // Storage order of the target sparse matrix
381  friend inline EnableIf_< UseAssign<MT2> >
382  assign( SparseMatrix<MT2,SO2>& lhs, const SMatDeclLowExpr& rhs )
383  {
385 
386  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
387  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
388 
389  assign( ~lhs, rhs.sm_ );
390  }
392  //**********************************************************************************************
393 
394  //**Addition assignment to dense matrices*******************************************************
406  template< typename MT2 // Type of the target dense matrix
407  , bool SO2 > // Storage order of the target dense matrix
408  friend inline EnableIf_< UseAssign<MT2> >
409  addAssign( DenseMatrix<MT2,SO2>& lhs, const SMatDeclLowExpr& rhs )
410  {
412 
413  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
414  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
415 
416  addAssign( ~lhs, rhs.sm_ );
417  }
419  //**********************************************************************************************
420 
421  //**Addition assignment to sparse matrices******************************************************
433  template< typename MT2 // Type of the target sparse matrix
434  , bool SO2 > // Storage order of the target sparse matrix
435  friend inline EnableIf_< UseAssign<MT2> >
436  addAssign( SparseMatrix<MT2,SO2>& lhs, const SMatDeclLowExpr& rhs )
437  {
439 
440  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
441  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
442 
443  addAssign( ~lhs, rhs.sm_ );
444  }
446  //**********************************************************************************************
447 
448  //**Subtraction assignment to dense matrices****************************************************
460  template< typename MT2 // Type of the target dense matrix
461  , bool SO2 > // Storage order of the target dense matrix
462  friend inline EnableIf_< UseAssign<MT2> >
463  subAssign( DenseMatrix<MT2,SO2>& lhs, const SMatDeclLowExpr& rhs )
464  {
466 
467  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
468  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
469 
470  subAssign( ~lhs, rhs.sm_ );
471  }
473  //**********************************************************************************************
474 
475  //**Subtraction assignment to sparse matrices***************************************************
487  template< typename MT2 // Type of the target sparse matrix
488  , bool SO2 > // Storage order of the target sparse matrix
489  friend inline EnableIf_< UseAssign<MT2> >
490  subAssign( SparseMatrix<MT2,SO2>& lhs, const SMatDeclLowExpr& rhs )
491  {
493 
494  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
495  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
496 
497  subAssign( ~lhs, rhs.sm_ );
498  }
500  //**********************************************************************************************
501 
502  //**Schur product assignment to dense matrices**************************************************
514  template< typename MT2 // Type of the target dense matrix
515  , bool SO2 > // Storage order of the target dense matrix
516  friend inline EnableIf_< UseAssign<MT2> >
517  schurAssign( DenseMatrix<MT2,SO2>& lhs, const SMatDeclLowExpr& rhs )
518  {
520 
521  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
522  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
523 
524  schurAssign( ~lhs, rhs.sm_ );
525  }
527  //**********************************************************************************************
528 
529  //**Schur product assignment to sparse matrices*************************************************
541  template< typename MT2 // Type of the target sparse matrix
542  , bool SO2 > // Storage order of the target sparse matrix
543  friend inline EnableIf_< UseAssign<MT2> >
544  schurAssign( SparseMatrix<MT2,SO2>& lhs, const SMatDeclLowExpr& rhs )
545  {
547 
548  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
549  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
550 
551  schurAssign( ~lhs, rhs.sm_ );
552  }
554  //**********************************************************************************************
555 
556  //**Multiplication assignment to dense matrices*************************************************
568  template< typename MT2 // Type of the target dense matrix
569  , bool SO2 > // Storage order of the target dense matrix
570  friend inline EnableIf_< UseAssign<MT2> >
571  multAssign( DenseMatrix<MT2,SO2>& lhs, const SMatDeclLowExpr& rhs )
572  {
574 
575  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
576  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
577 
578  multAssign( ~lhs, rhs.sm_ );
579  }
581  //**********************************************************************************************
582 
583  //**Multiplication assignment to sparse matrices************************************************
595  template< typename MT2 // Type of the target sparse matrix
596  , bool SO2 > // Storage order of the target sparse matrix
597  friend inline EnableIf_< UseAssign<MT2> >
598  multAssign( SparseMatrix<MT2,SO2>& lhs, const SMatDeclLowExpr& rhs )
599  {
601 
602  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
603  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
604 
605  multAssign( ~lhs, rhs.sm_ );
606  }
608  //**********************************************************************************************
609 
610  //**SMP assignment to dense matrices************************************************************
622  template< typename MT2 // Type of the target dense matrix
623  , bool SO2 > // Storage order of the target dense matrix
624  friend inline EnableIf_< UseSMPAssign<MT2> >
625  smpAssign( DenseMatrix<MT2,SO2>& lhs, const SMatDeclLowExpr& rhs )
626  {
628 
629  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
630  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
631 
632  smpAssign( ~lhs, rhs.sm_ );
633  }
635  //**********************************************************************************************
636 
637  //**SMP assignment to sparse matrices***********************************************************
649  template< typename MT2 // Type of the target sparse matrix
650  , bool SO2 > // Storage order of the target sparse matrix
651  friend inline EnableIf_< UseSMPAssign<MT2> >
652  smpAssign( SparseMatrix<MT2,SO2>& lhs, const SMatDeclLowExpr& rhs )
653  {
655 
656  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
657  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
658 
659  smpAssign( ~lhs, rhs.sm_ );
660  }
662  //**********************************************************************************************
663 
664  //**SMP addition assignment to dense matrices***************************************************
676  template< typename MT2 // Type of the target dense matrix
677  , bool SO2 > // Storage order of the target dense matrix
678  friend inline EnableIf_< UseSMPAssign<MT2> >
679  smpAddAssign( DenseMatrix<MT2,SO2>& lhs, const SMatDeclLowExpr& rhs )
680  {
682 
683  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
684  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
685 
686  smpAddAssign( ~lhs, rhs.sm_ );
687  }
689  //**********************************************************************************************
690 
691  //**SMP addition assignment to sparse matrices**************************************************
703  template< typename MT2 // Type of the target sparse matrix
704  , bool SO2 > // Storage order of the target sparse matrix
705  friend inline EnableIf_< UseSMPAssign<MT2> >
706  smpAddAssign( SparseMatrix<MT2,SO2>& lhs, const SMatDeclLowExpr& rhs )
707  {
709 
710  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
711  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
712 
713  smpAddAssign( ~lhs, rhs.sm_ );
714  }
716  //**********************************************************************************************
717 
718  //**SMP subtraction assignment to dense matrices************************************************
730  template< typename MT2 // Type of the target dense matrix
731  , bool SO2 > // Storage order of the target dense matrix
732  friend inline EnableIf_< UseSMPAssign<MT2> >
733  smpSubAssign( DenseMatrix<MT2,SO2>& lhs, const SMatDeclLowExpr& rhs )
734  {
736 
737  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
738  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
739 
740  smpSubAssign( ~lhs, rhs.sm_ );
741  }
743  //**********************************************************************************************
744 
745  //**SMP subtraction assignment to sparse matrices***********************************************
757  template< typename MT2 // Type of the target sparse matrix
758  , bool SO2 > // Storage order of the target sparse matrix
759  friend inline EnableIf_< UseSMPAssign<MT2> >
760  smpSubAssign( SparseMatrix<MT2,SO2>& lhs, const SMatDeclLowExpr& rhs )
761  {
763 
764  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
765  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
766 
767  smpSubAssign( ~lhs, rhs.sm_ );
768  }
770  //**********************************************************************************************
771 
772  //**SMP Schur product assignment to dense matrices**********************************************
784  template< typename MT2 // Type of the target dense matrix
785  , bool SO2 > // Storage order of the target dense matrix
786  friend inline EnableIf_< UseSMPAssign<MT2> >
787  smpSchurAssign( DenseMatrix<MT2,SO2>& lhs, const SMatDeclLowExpr& rhs )
788  {
790 
791  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
792  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
793 
794  smpSchurAssign( ~lhs, rhs.sm_ );
795  }
797  //**********************************************************************************************
798 
799  //**SMP Schur product assignment to sparse matrices*********************************************
811  template< typename MT2 // Type of the target sparse matrix
812  , bool SO2 > // Storage order of the target sparse matrix
813  friend inline EnableIf_< UseSMPAssign<MT2> >
814  smpSchurAssign( SparseMatrix<MT2,SO2>& lhs, const SMatDeclLowExpr& rhs )
815  {
817 
818  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
819  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
820 
821  smpSchurAssign( ~lhs, rhs.sm_ );
822  }
824  //**********************************************************************************************
825 
826  //**SMP multiplication assignment to dense matrices*********************************************
839  template< typename MT2 // Type of the target dense matrix
840  , bool SO2 > // Storage order of the target dense matrix
841  friend inline EnableIf_< UseSMPAssign<MT2> >
842  smpMultAssign( DenseMatrix<MT2,SO2>& lhs, const SMatDeclLowExpr& rhs )
843  {
845 
846  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
847  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
848 
849  smpMultAssign( ~lhs, rhs.sm_ );
850  }
852  //**********************************************************************************************
853 
854  //**SMP multiplication assignment to sparse matrices********************************************
867  template< typename MT2 // Type of the target sparse matrix
868  , bool SO2 > // Storage order of the target sparse matrix
869  friend inline EnableIf_< UseSMPAssign<MT2> >
870  smpMultAssign( SparseMatrix<MT2,SO2>& lhs, const SMatDeclLowExpr& rhs )
871  {
873 
874  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
875  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
876 
877  smpMultAssign( ~lhs, rhs.sm_ );
878  }
880  //**********************************************************************************************
881 
882  //**Compile time checks*************************************************************************
889  //**********************************************************************************************
890 };
891 //*************************************************************************************************
892 
893 
894 
895 
896 //=================================================================================================
897 //
898 // GLOBAL FUNCTIONS
899 //
900 //=================================================================================================
901 
902 //*************************************************************************************************
913 template< typename MT // Type of the sparse matrix
914  , bool SO // Storage order
915  , typename = DisableIf_< Or< IsLower<MT>, IsUniUpper<MT> > > >
916 inline const SMatDeclLowExpr<MT,SO> decllow_backend( const SparseMatrix<MT,SO>& sm )
917 {
919 
920  BLAZE_INTERNAL_ASSERT( isSquare( ~sm ), "Non-square matrix detected" );
921 
922  return SMatDeclLowExpr<MT,SO>( ~sm );
923 }
925 //*************************************************************************************************
926 
927 
928 //*************************************************************************************************
939 template< typename MT // Type of the sparse matrix
940  , bool SO // Storage order
942 inline const IdentityMatrix<ElementType_<MT>,SO> decllow_backend( const SparseMatrix<MT,SO>& sm )
943 {
945 
946  BLAZE_INTERNAL_ASSERT( isSquare( ~sm ), "Non-square matrix detected" );
947 
948  return IdentityMatrix<ElementType_<MT>,SO>( (~sm).rows() );
949 }
951 //*************************************************************************************************
952 
953 
954 //*************************************************************************************************
965 template< typename MT // Type of the sparse matrix
966  , bool SO // Storage order
967  , typename = EnableIf_< IsLower<MT> > >
968 inline const MT& decllow_backend( const SparseMatrix<MT,SO>& sm )
969 {
971 
972  BLAZE_INTERNAL_ASSERT( isSquare( ~sm ), "Non-square matrix detected" );
973 
974  return ~sm;
975 }
977 //*************************************************************************************************
978 
979 
980 //*************************************************************************************************
998 template< typename MT // Type of the sparse matrix
999  , bool SO > // Storage order
1000 inline decltype(auto) decllow( const SparseMatrix<MT,SO>& sm )
1001 {
1003 
1004  if( !isSquare( ~sm ) ) {
1005  BLAZE_THROW_INVALID_ARGUMENT( "Invalid lower matrix specification" );
1006  }
1007 
1008  return decllow_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_< IsLower<MT> > >
1039 inline decltype(auto) decllow( const SMatScalarMultExpr<MT,ST,SO>& sm )
1040 {
1042 
1043  if( !isSquare( ~sm ) ) {
1044  BLAZE_THROW_INVALID_ARGUMENT( "Invalid lower matrix specification" );
1045  }
1046 
1047  return decllow( sm.leftOperand() ) * sm.rightOperand();
1048 }
1050 //*************************************************************************************************
1051 
1052 
1053 
1054 
1055 //=================================================================================================
1056 //
1057 // ROWS SPECIALIZATIONS
1058 //
1059 //=================================================================================================
1060 
1061 //*************************************************************************************************
1063 template< typename MT, bool SO >
1064 struct Rows< SMatDeclLowExpr<MT,SO> >
1065  : public Rows<MT>
1066 {};
1068 //*************************************************************************************************
1069 
1070 
1071 
1072 
1073 //=================================================================================================
1074 //
1075 // COLUMNS SPECIALIZATIONS
1076 //
1077 //=================================================================================================
1078 
1079 //*************************************************************************************************
1081 template< typename MT, bool SO >
1082 struct Columns< SMatDeclLowExpr<MT,SO> >
1083  : public Columns<MT>
1084 {};
1086 //*************************************************************************************************
1087 
1088 
1089 
1090 
1091 //=================================================================================================
1092 //
1093 // ISSYMMETRIC SPECIALIZATIONS
1094 //
1095 //=================================================================================================
1096 
1097 //*************************************************************************************************
1099 template< typename MT, bool SO >
1100 struct IsSymmetric< SMatDeclLowExpr<MT,SO> >
1101  : public BoolConstant< IsSymmetric<MT>::value >
1102 {};
1104 //*************************************************************************************************
1105 
1106 
1107 
1108 
1109 //=================================================================================================
1110 //
1111 // ISHERMITIAN SPECIALIZATIONS
1112 //
1113 //=================================================================================================
1114 
1115 //*************************************************************************************************
1117 template< typename MT, bool SO >
1118 struct IsHermitian< SMatDeclLowExpr<MT,SO> >
1119  : public BoolConstant< IsHermitian<MT>::value >
1120 {};
1122 //*************************************************************************************************
1123 
1124 
1125 
1126 
1127 //=================================================================================================
1128 //
1129 // ISLOWER SPECIALIZATIONS
1130 //
1131 //=================================================================================================
1132 
1133 //*************************************************************************************************
1135 template< typename MT, bool SO >
1136 struct IsLower< SMatDeclLowExpr<MT,SO> >
1137  : public TrueType
1138 {};
1140 //*************************************************************************************************
1141 
1142 
1143 
1144 
1145 //=================================================================================================
1146 //
1147 // ISUNILOWER SPECIALIZATIONS
1148 //
1149 //=================================================================================================
1150 
1151 //*************************************************************************************************
1153 template< typename MT, bool SO >
1154 struct IsUniLower< SMatDeclLowExpr<MT,SO> >
1155  : public BoolConstant< IsUniLower<MT>::value >
1156 {};
1158 //*************************************************************************************************
1159 
1160 
1161 
1162 
1163 //=================================================================================================
1164 //
1165 // ISSTRICTLYLOWER SPECIALIZATIONS
1166 //
1167 //=================================================================================================
1168 
1169 //*************************************************************************************************
1171 template< typename MT, bool SO >
1172 struct IsStrictlyLower< SMatDeclLowExpr<MT,SO> >
1173  : public BoolConstant< IsStrictlyLower<MT>::value >
1174 {};
1176 //*************************************************************************************************
1177 
1178 
1179 
1180 
1181 //=================================================================================================
1182 //
1183 // ISUPPER SPECIALIZATIONS
1184 //
1185 //=================================================================================================
1186 
1187 //*************************************************************************************************
1189 template< typename MT, bool SO >
1190 struct IsUpper< SMatDeclLowExpr<MT,SO> >
1191  : public BoolConstant< Or< IsSymmetric<MT>, IsHermitian<MT>, IsUpper<MT> >::value >
1192 {};
1194 //*************************************************************************************************
1195 
1196 
1197 
1198 
1199 //=================================================================================================
1200 //
1201 // ISUNIUPPER SPECIALIZATIONS
1202 //
1203 //=================================================================================================
1204 
1205 //*************************************************************************************************
1207 template< typename MT, bool SO >
1208 struct IsUniUpper< SMatDeclLowExpr<MT,SO> >
1209  : public BoolConstant< IsUniUpper<MT>::value >
1210 {};
1212 //*************************************************************************************************
1213 
1214 
1215 
1216 
1217 //=================================================================================================
1218 //
1219 // ISSTRICTLYUPPER SPECIALIZATIONS
1220 //
1221 //=================================================================================================
1222 
1223 //*************************************************************************************************
1225 template< typename MT, bool SO >
1226 struct IsStrictlyUpper< SMatDeclLowExpr<MT,SO> >
1227  : public BoolConstant< IsStrictlyUpper<MT>::value >
1228 {};
1230 //*************************************************************************************************
1231 
1232 } // namespace blaze
1233 
1234 #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.
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
DeclLowTrait_< RT > ResultType
Result type for expression template evaluations.
Definition: SMatDeclLowExpr.h:162
RightOperand rightOperand() const noexcept
Returns the right-hand side scalar operand.
Definition: SMatScalarMultExpr.h:478
Header file for basic type definitions.
bool canAlias(const T *alias) const noexcept
Returns whether the expression can alias with the given address alias.
Definition: SMatDeclLowExpr.h:308
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
ReturnType_< MT > ReturnType
Return type for expression template evaluations.
Definition: SMatDeclLowExpr.h:166
#define BLAZE_CONSTRAINT_MUST_NOT_BE_UNIUPPER_MATRIX_TYPE(T)
Constraint on the data type.In case the given data type T is a upper unitriangular matrix type...
Definition: UniUpper.h:81
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
bool canSMPAssign() const noexcept
Returns whether the expression can be used in SMP assignments.
Definition: SMatDeclLowExpr.h:330
Expression object for the explicit lower declaration of sparse matrices.The SMatDeclLowExpr class rep...
Definition: Forward.h:104
ReturnType at(size_t i, size_t j) const
Checked access to the matrix elements.
Definition: SMatDeclLowExpr.h:217
Compile time check for upper triangular matrices.This type trait tests whether or not the given templ...
Definition: IsUpper.h:88
typename DeclLowTrait< MT >::Type DeclLowTrait_
Auxiliary alias declaration for the DeclLowTrait type trait.The DeclLowTrait_ alias declaration provi...
Definition: DeclLowTrait.h:176
Header file for the RequiresEvaluation type trait.
Constraint on the data type.
Header file for the IsUniLower type trait.
ReturnType operator()(size_t i, size_t j) const
2D-access to the matrix elements.
Definition: SMatDeclLowExpr.h:202
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
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.
ConstIterator end(size_t i) const
Returns an iterator just past the last non-zero element of row i.
Definition: SMatDeclLowExpr.h:245
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.
If_< RequiresEvaluation< MT >, const ResultType, const SMatDeclLowExpr &> CompositeType
Data type for composite expression templates.
Definition: SMatDeclLowExpr.h:169
Constraint on the data type.
ConstIterator begin(size_t i) const
Returns an iterator to the first non-zero element of row i.
Definition: SMatDeclLowExpr.h:234
Compile time check to query the requirement to evaluate an expression.Via this type trait it is possi...
Definition: RequiresEvaluation.h:72
Compile time check for upper unitriangular matrices.This type trait tests whether or not the given te...
Definition: IsUniUpper.h:86
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.
ElementType_< MT > ElementType
Resulting element type.
Definition: SMatDeclLowExpr.h:165
Namespace of the Blaze C++ math library.
Definition: Blaze.h:57
Operand operand() const noexcept
Returns the sparse matrix operand.
Definition: SMatDeclLowExpr.h:296
Header file for the If class template.
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.
Header file for the decllow trait.
#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
size_t rows() const noexcept
Returns the current number of rows of the matrix.
Definition: SMatDeclLowExpr.h:255
decltype(auto) decllow(const DenseMatrix< MT, SO > &dm)
Declares the given dense matrix expression dm as lower.
Definition: DMatDeclLowExpr.h:1027
Header file for the IsLower type trait.
Constraints on the storage order of matrix types.
size_t nonZeros() const
Returns the number of non-zero elements in the sparse matrix.
Definition: SMatDeclLowExpr.h:275
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
Header file for the DeclLowExpr base class.
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.
Constraint on the data type.
Header file for the EnableIf class template.
Header file for the IsStrictlyLower type trait.
Compile time check for lower unitriangular matrices.This type trait tests whether or not the given te...
Definition: IsUniLower.h:86
Header file for the Declaration base class.
Header file for run time assertion macros.
Utility type for generic codes.
ResultType_< MT > RT
Result type of the sparse matrix expression.
Definition: SMatDeclLowExpr.h:107
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
#define BLAZE_CONSTRAINT_MUST_NOT_BE_LOWER_MATRIX_TYPE(T)
Constraint on the data type.In case the given data type T is a lower triangular matrix type...
Definition: Lower.h:81
#define BLAZE_FUNCTION_TRACE
Function trace macro.This macro can be used to reliably trace function calls. In case function tracin...
Definition: FunctionTrace.h:94
Compile time check for Hermitian matrices.This type trait tests whether or not the given template par...
Definition: IsHermitian.h:85
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: SMatDeclLowExpr.h:164
If_< IsExpression< MT >, const MT, const MT &> Operand
Composite data type of the sparse matrix expression.
Definition: SMatDeclLowExpr.h:175
typename GetConstIterator< MT >::Type ConstIterator
Iterator over the elements of the dense matrix.
Definition: SMatDeclLowExpr.h:172
Header file for the implementation of the base template of the LowerMatrix.
SMatDeclLowExpr(const MT &sm) noexcept
Constructor for the SMatDeclLowExpr class.
Definition: SMatDeclLowExpr.h:188
Operand sm_
Sparse matrix of the decllow expression.
Definition: SMatDeclLowExpr.h:337
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
OppositeType_< ResultType > OppositeType
Result type with opposite storage order for expression template evaluations.
Definition: SMatDeclLowExpr.h:163
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 nonZeros(size_t i) const
Returns the number of non-zero elements in the specified row.
Definition: SMatDeclLowExpr.h:286
Header file for the IsHermitian type trait.
BLAZE_ALWAYS_INLINE bool isSquare(const Matrix< MT, SO > &matrix) noexcept
Checks if the given matrix is a square matrix.
Definition: Matrix.h:742
size_t columns() const noexcept
Returns the current number of columns of the matrix.
Definition: SMatDeclLowExpr.h:265
#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
bool isAliased(const T *alias) const noexcept
Returns whether the expression is aliased with the given address alias.
Definition: SMatDeclLowExpr.h:320
Header file for the TrueType type/value trait base class.
Header file for the IsExpression type trait class.
Header file for the function trace functionality.