SMatDeclDiagExpr.h
Go to the documentation of this file.
1 //=================================================================================================
33 //=================================================================================================
34 
35 #ifndef _BLAZE_MATH_EXPRESSIONS_SMATDECLDIAGEXPR_H_
36 #define _BLAZE_MATH_EXPRESSIONS_SMATDECLDIAGEXPR_H_
37 
38 
39 //*************************************************************************************************
40 // Includes
41 //*************************************************************************************************
42 
43 #include <iterator>
45 #include <blaze/math/Aliases.h>
49 #include <blaze/math/Exception.h>
68 #include <blaze/util/Assert.h>
69 #include <blaze/util/DisableIf.h>
70 #include <blaze/util/EnableIf.h>
73 #include <blaze/util/InvalidType.h>
74 #include <blaze/util/mpl/If.h>
75 #include <blaze/util/TrueType.h>
76 #include <blaze/util/Types.h>
78 
79 
80 namespace blaze {
81 
82 //=================================================================================================
83 //
84 // CLASS SMATDECLHERMEXPR
85 //
86 //=================================================================================================
87 
88 //*************************************************************************************************
95 template< typename MT // Type of the sparse matrix
96  , bool SO > // Storage order
97 class SMatDeclDiagExpr
98  : public DeclDiagExpr< SparseMatrix< SMatDeclDiagExpr<MT,SO>, SO > >
99  , public Declaration<MT>
100 {
101  private:
102  //**Type definitions****************************************************************************
103  using RT = ResultType_<MT>;
104  //**********************************************************************************************
105 
106  //**Serial evaluation strategy******************************************************************
108 
114  enum : bool { useAssign = RequiresEvaluation<MT>::value };
115 
117  template< typename MT2 >
119  struct UseAssign {
120  enum : bool { value = useAssign };
121  };
123  //**********************************************************************************************
124 
125  //**Parallel evaluation strategy****************************************************************
127 
132  template< typename MT2 >
133  struct UseSMPAssign {
134  enum : bool { value = MT2::smpAssignable && useAssign };
135  };
137  //**********************************************************************************************
138 
139  //**********************************************************************************************
141 
145  template< typename MT2 >
146  struct GetConstIterator {
148  struct Success { using Type = typename MT2::ConstIterator; };
149  struct Failure { using Type = INVALID_TYPE; };
150  using Type = typename If_< HasConstIterator<MT2>, Success, Failure >::Type;
151  };
153  //**********************************************************************************************
154 
155  public:
156  //**Type definitions****************************************************************************
163 
166 
168  using ConstIterator = typename GetConstIterator<MT>::Type;
169 
171  using Operand = If_< IsExpression<MT>, const MT, const MT& >;
172  //**********************************************************************************************
173 
174  //**Compilation flags***************************************************************************
176  enum : bool { smpAssignable = MT::smpAssignable };
177  //**********************************************************************************************
178 
179  //**Constructor*********************************************************************************
184  explicit inline SMatDeclDiagExpr( const MT& sm ) noexcept
185  : sm_( sm ) // Sparse matrix of the decldiag expression
186  {
187  BLAZE_INTERNAL_ASSERT( isSquare( ~sm ), "Non-square matrix detected" );
188  }
189  //**********************************************************************************************
190 
191  //**Access operator*****************************************************************************
198  inline ReturnType operator()( size_t i, size_t j ) const {
199  BLAZE_INTERNAL_ASSERT( i < sm_.rows() , "Invalid row access index" );
200  BLAZE_INTERNAL_ASSERT( j < sm_.columns(), "Invalid column access index" );
201  return sm_(i,j);
202  }
203  //**********************************************************************************************
204 
205  //**At function*********************************************************************************
213  inline ReturnType at( size_t i, size_t j ) const {
214  if( i >= sm_.rows() ) {
215  BLAZE_THROW_OUT_OF_RANGE( "Invalid row access index" );
216  }
217  if( j >= sm_.columns() ) {
218  BLAZE_THROW_OUT_OF_RANGE( "Invalid column access index" );
219  }
220  return (*this)(i,j);
221  }
222  //**********************************************************************************************
223 
224  //**Begin function******************************************************************************
230  inline ConstIterator begin( size_t i ) const {
231  return ConstIterator( sm_.begin(i) );
232  }
233  //**********************************************************************************************
234 
235  //**End function********************************************************************************
241  inline ConstIterator end( size_t i ) const {
242  return ConstIterator( sm_.end(i) );
243  }
244  //**********************************************************************************************
245 
246  //**Rows function*******************************************************************************
251  inline size_t rows() const noexcept {
252  return sm_.rows();
253  }
254  //**********************************************************************************************
255 
256  //**Columns function****************************************************************************
261  inline size_t columns() const noexcept {
262  return sm_.columns();
263  }
264  //**********************************************************************************************
265 
266  //**NonZeros function***************************************************************************
271  inline size_t nonZeros() const {
272  return sm_.nonZeros();
273  }
274  //**********************************************************************************************
275 
276  //**NonZeros function***************************************************************************
282  inline size_t nonZeros( size_t i ) const {
283  return sm_.nonZeros(i);
284  }
285  //**********************************************************************************************
286 
287  //**Operand access******************************************************************************
292  inline Operand operand() const noexcept {
293  return sm_;
294  }
295  //**********************************************************************************************
296 
297  //**********************************************************************************************
303  template< typename T >
304  inline bool canAlias( const T* alias ) const noexcept {
305  return sm_.canAlias( alias );
306  }
307  //**********************************************************************************************
308 
309  //**********************************************************************************************
315  template< typename T >
316  inline bool isAliased( const T* alias ) const noexcept {
317  return sm_.isAliased( alias );
318  }
319  //**********************************************************************************************
320 
321  //**********************************************************************************************
326  inline bool canSMPAssign() const noexcept {
327  return sm_.canSMPAssign();
328  }
329  //**********************************************************************************************
330 
331  private:
332  //**Member variables****************************************************************************
334  //**********************************************************************************************
335 
336  //**Assignment to dense matrices****************************************************************
348  template< typename MT2 // Type of the target dense matrix
349  , bool SO2 > // Storage order of the target dense matrix
350  friend inline EnableIf_< UseAssign<MT2> >
351  assign( DenseMatrix<MT2,SO2>& lhs, const SMatDeclDiagExpr& rhs )
352  {
354 
355  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
356  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
357 
358  assign( ~lhs, rhs.sm_ );
359  }
361  //**********************************************************************************************
362 
363  //**Assignment to sparse matrices***************************************************************
375  template< typename MT2 // Type of the target sparse matrix
376  , bool SO2 > // Storage order of the target sparse matrix
377  friend inline EnableIf_< UseAssign<MT2> >
378  assign( SparseMatrix<MT2,SO2>& lhs, const SMatDeclDiagExpr& rhs )
379  {
381 
382  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
383  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
384 
385  assign( ~lhs, rhs.sm_ );
386  }
388  //**********************************************************************************************
389 
390  //**Addition assignment to dense matrices*******************************************************
402  template< typename MT2 // Type of the target dense matrix
403  , bool SO2 > // Storage order of the target dense matrix
404  friend inline EnableIf_< UseAssign<MT2> >
405  addAssign( DenseMatrix<MT2,SO2>& lhs, const SMatDeclDiagExpr& rhs )
406  {
408 
409  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
410  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
411 
412  addAssign( ~lhs, rhs.sm_ );
413  }
415  //**********************************************************************************************
416 
417  //**Addition assignment to sparse matrices******************************************************
429  template< typename MT2 // Type of the target sparse matrix
430  , bool SO2 > // Storage order of the target sparse matrix
431  friend inline EnableIf_< UseAssign<MT2> >
432  addAssign( SparseMatrix<MT2,SO2>& lhs, const SMatDeclDiagExpr& rhs )
433  {
435 
436  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
437  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
438 
439  addAssign( ~lhs, rhs.sm_ );
440  }
442  //**********************************************************************************************
443 
444  //**Subtraction assignment to dense matrices****************************************************
456  template< typename MT2 // Type of the target dense matrix
457  , bool SO2 > // Storage order of the target dense matrix
458  friend inline EnableIf_< UseAssign<MT2> >
459  subAssign( DenseMatrix<MT2,SO2>& lhs, const SMatDeclDiagExpr& rhs )
460  {
462 
463  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
464  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
465 
466  subAssign( ~lhs, rhs.sm_ );
467  }
469  //**********************************************************************************************
470 
471  //**Subtraction assignment to sparse matrices***************************************************
483  template< typename MT2 // Type of the target sparse matrix
484  , bool SO2 > // Storage order of the target sparse matrix
485  friend inline EnableIf_< UseAssign<MT2> >
486  subAssign( SparseMatrix<MT2,SO2>& lhs, const SMatDeclDiagExpr& rhs )
487  {
489 
490  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
491  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
492 
493  subAssign( ~lhs, rhs.sm_ );
494  }
496  //**********************************************************************************************
497 
498  //**Schur product assignment to dense matrices**************************************************
510  template< typename MT2 // Type of the target dense matrix
511  , bool SO2 > // Storage order of the target dense matrix
512  friend inline EnableIf_< UseAssign<MT2> >
513  schurAssign( DenseMatrix<MT2,SO2>& lhs, const SMatDeclDiagExpr& rhs )
514  {
516 
517  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
518  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
519 
520  schurAssign( ~lhs, rhs.sm_ );
521  }
523  //**********************************************************************************************
524 
525  //**Schur product assignment to sparse matrices*************************************************
537  template< typename MT2 // Type of the target sparse matrix
538  , bool SO2 > // Storage order of the target sparse matrix
539  friend inline EnableIf_< UseAssign<MT2> >
540  schurAssign( SparseMatrix<MT2,SO2>& lhs, const SMatDeclDiagExpr& rhs )
541  {
543 
544  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
545  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
546 
547  schurAssign( ~lhs, rhs.sm_ );
548  }
550  //**********************************************************************************************
551 
552  //**Multiplication assignment to dense matrices*************************************************
564  template< typename MT2 // Type of the target dense matrix
565  , bool SO2 > // Storage order of the target dense matrix
566  friend inline EnableIf_< UseAssign<MT2> >
567  multAssign( DenseMatrix<MT2,SO2>& lhs, const SMatDeclDiagExpr& rhs )
568  {
570 
571  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
572  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
573 
574  multAssign( ~lhs, rhs.sm_ );
575  }
577  //**********************************************************************************************
578 
579  //**Multiplication assignment to sparse matrices************************************************
591  template< typename MT2 // Type of the target sparse matrix
592  , bool SO2 > // Storage order of the target sparse matrix
593  friend inline EnableIf_< UseAssign<MT2> >
594  multAssign( SparseMatrix<MT2,SO2>& lhs, const SMatDeclDiagExpr& rhs )
595  {
597 
598  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
599  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
600 
601  multAssign( ~lhs, rhs.sm_ );
602  }
604  //**********************************************************************************************
605 
606  //**SMP assignment to dense matrices************************************************************
618  template< typename MT2 // Type of the target dense matrix
619  , bool SO2 > // Storage order of the target dense matrix
620  friend inline EnableIf_< UseSMPAssign<MT2> >
621  smpAssign( DenseMatrix<MT2,SO2>& lhs, const SMatDeclDiagExpr& rhs )
622  {
624 
625  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
626  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
627 
628  smpAssign( ~lhs, rhs.sm_ );
629  }
631  //**********************************************************************************************
632 
633  //**SMP assignment to sparse matrices***********************************************************
645  template< typename MT2 // Type of the target sparse matrix
646  , bool SO2 > // Storage order of the target sparse matrix
647  friend inline EnableIf_< UseSMPAssign<MT2> >
648  smpAssign( SparseMatrix<MT2,SO2>& lhs, const SMatDeclDiagExpr& rhs )
649  {
651 
652  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
653  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
654 
655  smpAssign( ~lhs, rhs.sm_ );
656  }
658  //**********************************************************************************************
659 
660  //**SMP addition assignment to dense matrices***************************************************
672  template< typename MT2 // Type of the target dense matrix
673  , bool SO2 > // Storage order of the target dense matrix
674  friend inline EnableIf_< UseSMPAssign<MT2> >
675  smpAddAssign( DenseMatrix<MT2,SO2>& lhs, const SMatDeclDiagExpr& rhs )
676  {
678 
679  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
680  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
681 
682  smpAddAssign( ~lhs, rhs.sm_ );
683  }
685  //**********************************************************************************************
686 
687  //**SMP addition assignment to sparse matrices**************************************************
699  template< typename MT2 // Type of the target sparse matrix
700  , bool SO2 > // Storage order of the target sparse matrix
701  friend inline EnableIf_< UseSMPAssign<MT2> >
702  smpAddAssign( SparseMatrix<MT2,SO2>& lhs, const SMatDeclDiagExpr& rhs )
703  {
705 
706  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
707  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
708 
709  smpAddAssign( ~lhs, rhs.sm_ );
710  }
712  //**********************************************************************************************
713 
714  //**SMP subtraction assignment to dense matrices************************************************
726  template< typename MT2 // Type of the target dense matrix
727  , bool SO2 > // Storage order of the target dense matrix
728  friend inline EnableIf_< UseSMPAssign<MT2> >
729  smpSubAssign( DenseMatrix<MT2,SO2>& lhs, const SMatDeclDiagExpr& rhs )
730  {
732 
733  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
734  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
735 
736  smpSubAssign( ~lhs, rhs.sm_ );
737  }
739  //**********************************************************************************************
740 
741  //**SMP subtraction assignment to sparse matrices***********************************************
753  template< typename MT2 // Type of the target sparse matrix
754  , bool SO2 > // Storage order of the target sparse matrix
755  friend inline EnableIf_< UseSMPAssign<MT2> >
756  smpSubAssign( SparseMatrix<MT2,SO2>& lhs, const SMatDeclDiagExpr& rhs )
757  {
759 
760  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
761  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
762 
763  smpSubAssign( ~lhs, rhs.sm_ );
764  }
766  //**********************************************************************************************
767 
768  //**SMP Schur product assignment to dense matrices**********************************************
780  template< typename MT2 // Type of the target dense matrix
781  , bool SO2 > // Storage order of the target dense matrix
782  friend inline EnableIf_< UseSMPAssign<MT2> >
783  smpSchurAssign( DenseMatrix<MT2,SO2>& lhs, const SMatDeclDiagExpr& rhs )
784  {
786 
787  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
788  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
789 
790  smpSchurAssign( ~lhs, rhs.sm_ );
791  }
793  //**********************************************************************************************
794 
795  //**SMP Schur product assignment to sparse matrices*********************************************
807  template< typename MT2 // Type of the target sparse matrix
808  , bool SO2 > // Storage order of the target sparse matrix
809  friend inline EnableIf_< UseSMPAssign<MT2> >
810  smpSchurAssign( SparseMatrix<MT2,SO2>& lhs, const SMatDeclDiagExpr& rhs )
811  {
813 
814  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
815  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
816 
817  smpSchurAssign( ~lhs, rhs.sm_ );
818  }
820  //**********************************************************************************************
821 
822  //**SMP multiplication assignment to dense matrices*********************************************
835  template< typename MT2 // Type of the target dense matrix
836  , bool SO2 > // Storage order of the target dense matrix
837  friend inline EnableIf_< UseSMPAssign<MT2> >
838  smpMultAssign( DenseMatrix<MT2,SO2>& lhs, const SMatDeclDiagExpr& rhs )
839  {
841 
842  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
843  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
844 
845  smpMultAssign( ~lhs, rhs.sm_ );
846  }
848  //**********************************************************************************************
849 
850  //**SMP multiplication assignment to sparse matrices********************************************
863  template< typename MT2 // Type of the target sparse matrix
864  , bool SO2 > // Storage order of the target sparse matrix
865  friend inline EnableIf_< UseSMPAssign<MT2> >
866  smpMultAssign( SparseMatrix<MT2,SO2>& lhs, const SMatDeclDiagExpr& rhs )
867  {
869 
870  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
871  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
872 
873  smpMultAssign( ~lhs, rhs.sm_ );
874  }
876  //**********************************************************************************************
877 
878  //**Compile time checks*************************************************************************
884  //**********************************************************************************************
885 };
886 //*************************************************************************************************
887 
888 
889 
890 
891 //=================================================================================================
892 //
893 // GLOBAL FUNCTIONS
894 //
895 //=================================================================================================
896 
897 //*************************************************************************************************
908 template< typename MT // Type of the sparse matrix
909  , bool SO // Storage order
910  , typename = DisableIf_< IsDiagonal<MT> > >
911 inline const SMatDeclDiagExpr<MT,SO> decldiag_backend( const SparseMatrix<MT,SO>& sm )
912 {
914 
915  BLAZE_INTERNAL_ASSERT( isSquare( ~sm ), "Non-square matrix detected" );
916 
917  return SMatDeclDiagExpr<MT,SO>( ~sm );
918 }
920 //*************************************************************************************************
921 
922 
923 //*************************************************************************************************
934 template< typename MT // Type of the sparse matrix
935  , bool SO // Storage order
936  , typename = EnableIf_< IsDiagonal<MT> > >
937 inline const MT& decldiag_backend( const SparseMatrix<MT,SO>& sm )
938 {
940 
941  BLAZE_INTERNAL_ASSERT( isSquare( ~sm ), "Non-square matrix detected" );
942 
943  return ~sm;
944 }
946 //*************************************************************************************************
947 
948 
949 //*************************************************************************************************
967 template< typename MT // Type of the sparse matrix
968  , bool SO > // Storage order
969 inline decltype(auto) decldiag( const SparseMatrix<MT,SO>& sm )
970 {
972 
973  if( !isSquare( ~sm ) ) {
974  BLAZE_THROW_INVALID_ARGUMENT( "Invalid diagonal matrix specification" );
975  }
976 
977  return decldiag_backend( ~sm );
978 }
979 //*************************************************************************************************
980 
981 
982 
983 
984 //=================================================================================================
985 //
986 // GLOBAL RESTRUCTURING FUNCTIONS
987 //
988 //=================================================================================================
989 
990 //*************************************************************************************************
1004 template< typename MT // Type of the left-hand side sparse matrix
1005  , typename ST // Type of the right-hand side scalar value
1006  , bool SO // Storage order
1007  , typename = DisableIf_< IsDiagonal<MT> > >
1008 inline decltype(auto) decldiag( const SMatScalarMultExpr<MT,ST,SO>& sm )
1009 {
1011 
1012  if( !isSquare( ~sm ) ) {
1013  BLAZE_THROW_INVALID_ARGUMENT( "Invalid diagonal matrix specification" );
1014  }
1015 
1016  return decldiag( sm.leftOperand() ) * sm.rightOperand();
1017 }
1019 //*************************************************************************************************
1020 
1021 
1022 
1023 
1024 //=================================================================================================
1025 //
1026 // ROWS SPECIALIZATIONS
1027 //
1028 //=================================================================================================
1029 
1030 //*************************************************************************************************
1032 template< typename MT, bool SO >
1033 struct Rows< SMatDeclDiagExpr<MT,SO> >
1034  : public Rows<MT>
1035 {};
1037 //*************************************************************************************************
1038 
1039 
1040 
1041 
1042 //=================================================================================================
1043 //
1044 // COLUMNS SPECIALIZATIONS
1045 //
1046 //=================================================================================================
1047 
1048 //*************************************************************************************************
1050 template< typename MT, bool SO >
1051 struct Columns< SMatDeclDiagExpr<MT,SO> >
1052  : public Columns<MT>
1053 {};
1055 //*************************************************************************************************
1056 
1057 
1058 
1059 
1060 //=================================================================================================
1061 //
1062 // ISSYMMETRIC SPECIALIZATIONS
1063 //
1064 //=================================================================================================
1065 
1066 //*************************************************************************************************
1068 template< typename MT, bool SO >
1069 struct IsSymmetric< SMatDeclDiagExpr<MT,SO> >
1070  : public TrueType
1071 {};
1073 //*************************************************************************************************
1074 
1075 
1076 
1077 
1078 //=================================================================================================
1079 //
1080 // ISHERMITIAN SPECIALIZATIONS
1081 //
1082 //=================================================================================================
1083 
1084 //*************************************************************************************************
1086 template< typename MT, bool SO >
1087 struct IsHermitian< SMatDeclDiagExpr<MT,SO> >
1088  : public BoolConstant< IsHermitian<MT>::value >
1089 {};
1091 //*************************************************************************************************
1092 
1093 
1094 
1095 
1096 //=================================================================================================
1097 //
1098 // ISLOWER SPECIALIZATIONS
1099 //
1100 //=================================================================================================
1101 
1102 //*************************************************************************************************
1104 template< typename MT, bool SO >
1105 struct IsLower< SMatDeclDiagExpr<MT,SO> >
1106  : public TrueType
1107 {};
1109 //*************************************************************************************************
1110 
1111 
1112 
1113 
1114 //=================================================================================================
1115 //
1116 // ISUNILOWER SPECIALIZATIONS
1117 //
1118 //=================================================================================================
1119 
1120 //*************************************************************************************************
1122 template< typename MT, bool SO >
1123 struct IsUniLower< SMatDeclDiagExpr<MT,SO> >
1124  : public BoolConstant< IsUniLower<MT>::value >
1125 {};
1127 //*************************************************************************************************
1128 
1129 
1130 
1131 
1132 //=================================================================================================
1133 //
1134 // ISSTRICTLYLOWER SPECIALIZATIONS
1135 //
1136 //=================================================================================================
1137 
1138 //*************************************************************************************************
1140 template< typename MT, bool SO >
1141 struct IsStrictlyLower< SMatDeclDiagExpr<MT,SO> >
1142  : public BoolConstant< IsStrictlyLower<MT>::value >
1143 {};
1145 //*************************************************************************************************
1146 
1147 
1148 
1149 
1150 //=================================================================================================
1151 //
1152 // ISUPPER SPECIALIZATIONS
1153 //
1154 //=================================================================================================
1155 
1156 //*************************************************************************************************
1158 template< typename MT, bool SO >
1159 struct IsUpper< SMatDeclDiagExpr<MT,SO> >
1160  : public TrueType
1161 {};
1163 //*************************************************************************************************
1164 
1165 
1166 
1167 
1168 //=================================================================================================
1169 //
1170 // ISUNIUPPER SPECIALIZATIONS
1171 //
1172 //=================================================================================================
1173 
1174 //*************************************************************************************************
1176 template< typename MT, bool SO >
1177 struct IsUniUpper< SMatDeclDiagExpr<MT,SO> >
1178  : public BoolConstant< IsUniUpper<MT>::value >
1179 {};
1181 //*************************************************************************************************
1182 
1183 
1184 
1185 
1186 //=================================================================================================
1187 //
1188 // ISSTRICTLYUPPER SPECIALIZATIONS
1189 //
1190 //=================================================================================================
1191 
1192 //*************************************************************************************************
1194 template< typename MT, bool SO >
1195 struct IsStrictlyUpper< SMatDeclDiagExpr<MT,SO> >
1196  : public BoolConstant< IsStrictlyUpper<MT>::value >
1197 {};
1199 //*************************************************************************************************
1200 
1201 } // namespace blaze
1202 
1203 #endif
size_t nonZeros(size_t i) const
Returns the number of non-zero elements in the specified row.
Definition: SMatDeclDiagExpr.h:282
#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 decldiag trait.
decltype(auto) decldiag(const DenseMatrix< MT, SO > &dm)
Declares the given dense matrix expression dm as diagonal.
Definition: DMatDeclDiagExpr.h:996
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 canAlias(const T *alias) const noexcept
Returns whether the expression can alias with the given address alias.
Definition: SMatDeclDiagExpr.h:304
DeclDiagTrait_< RT > ResultType
Result type for expression template evaluations.
Definition: SMatDeclDiagExpr.h:158
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
ResultType_< MT > RT
Result type of the sparse matrix expression.
Definition: SMatDeclDiagExpr.h:103
Expression object for the explicit diagonal declaration of sparse matrices.The SMatDeclDiagExpr class...
Definition: Forward.h:102
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
ReturnType_< MT > ReturnType
Return type for expression template evaluations.
Definition: SMatDeclDiagExpr.h:162
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
size_t rows() const noexcept
Returns the current number of rows of the matrix.
Definition: SMatDeclDiagExpr.h:251
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.
SMatDeclDiagExpr(const MT &sm) noexcept
Constructor for the SMatDeclDiagExpr class.
Definition: SMatDeclDiagExpr.h:184
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
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.
bool isAliased(const T *alias) const noexcept
Returns whether the expression is aliased with the given address alias.
Definition: SMatDeclDiagExpr.h:316
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.
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
Compile time check for upper unitriangular matrices.This type trait tests whether or not the given te...
Definition: IsUniUpper.h:86
If_< RequiresEvaluation< MT >, const ResultType, const SMatDeclDiagExpr &> CompositeType
Data type for composite expression templates.
Definition: SMatDeclDiagExpr.h:165
typename GetConstIterator< MT >::Type ConstIterator
Iterator over the elements of the dense matrix.
Definition: SMatDeclDiagExpr.h:168
Header file for the DisableIf class template.
Header file for the IsStrictlyUpper type trait.
Header file for the IsSymmetric type trait.
Namespace of the Blaze C++ math library.
Definition: Blaze.h:57
Header file for the If class template.
Header file for the DeclDiagExpr base class.
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
#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
size_t columns() const noexcept
Returns the current number of columns of the matrix.
Definition: SMatDeclDiagExpr.h:261
Header file for the Columns type trait.
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
#define BLAZE_CONSTRAINT_MUST_NOT_BE_DIAGONAL_MATRIX_TYPE(T)
Constraint on the data type.In case the given data type T is a diagonal matrix type, a compilation error is created.
Definition: Diagonal.h:79
ConstIterator end(size_t i) const
Returns an iterator just past the last non-zero element of row i.
Definition: SMatDeclDiagExpr.h:241
Header file for the IsLower type trait.
If_< IsExpression< MT >, const MT, const MT &> Operand
Composite data type of the sparse matrix expression.
Definition: SMatDeclDiagExpr.h:171
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
ConstIterator begin(size_t i) const
Returns an iterator to the first non-zero element of row i.
Definition: SMatDeclDiagExpr.h:230
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.
Operand operand() const noexcept
Returns the sparse matrix operand.
Definition: SMatDeclDiagExpr.h:292
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
bool canSMPAssign() const noexcept
Returns whether the expression can be used in SMP assignments.
Definition: SMatDeclDiagExpr.h:326
Operand sm_
Sparse matrix of the decldiag expression.
Definition: SMatDeclDiagExpr.h:333
Header file for the Declaration base class.
TransposeType_< ResultType > TransposeType
Transpose type for expression template evaluations.
Definition: SMatDeclDiagExpr.h:160
Header file for run time assertion macros.
Utility type for generic codes.
size_t nonZeros() const
Returns the number of non-zero elements in the sparse matrix.
Definition: SMatDeclDiagExpr.h:271
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_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
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
Header file for the implementation of the base template of the DiagonalMatrix.
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
ElementType_< MT > ElementType
Resulting element type.
Definition: SMatDeclDiagExpr.h:161
OppositeType_< ResultType > OppositeType
Result type with opposite storage order for expression template evaluations.
Definition: SMatDeclDiagExpr.h:159
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.
typename DeclDiagTrait< MT >::Type DeclDiagTrait_
Auxiliary alias declaration for the DeclDiagTrait type trait.The DeclDiagTrait_ alias declaration pro...
Definition: DeclDiagTrait.h:176
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
#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
ReturnType operator()(size_t i, size_t j) const
2D-access to the matrix elements.
Definition: SMatDeclDiagExpr.h:198
#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.
Header file for the IsExpression type trait class.
ReturnType at(size_t i, size_t j) const
Checked access to the matrix elements.
Definition: SMatDeclDiagExpr.h:213
Header file for the function trace functionality.