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