DMatDeclDiagExpr.h
Go to the documentation of this file.
1 //=================================================================================================
33 //=================================================================================================
34 
35 #ifndef _BLAZE_MATH_EXPRESSIONS_DMATDECLDIAGEXPR_H_
36 #define _BLAZE_MATH_EXPRESSIONS_DMATDECLDIAGEXPR_H_
37 
38 
39 //*************************************************************************************************
40 // Includes
41 //*************************************************************************************************
42 
43 #include <iterator>
44 #include <blaze/math/Aliases.h>
49 #include <blaze/math/Exception.h>
78 #include <blaze/util/Assert.h>
79 #include <blaze/util/DisableIf.h>
80 #include <blaze/util/EmptyType.h>
81 #include <blaze/util/EnableIf.h>
84 #include <blaze/util/InvalidType.h>
85 #include <blaze/util/mpl/And.h>
86 #include <blaze/util/mpl/If.h>
87 #include <blaze/util/TrueType.h>
88 #include <blaze/util/Types.h>
90 
91 
92 namespace blaze {
93 
94 //=================================================================================================
95 //
96 // CLASS DMATDECLDIAGEXPR
97 //
98 //=================================================================================================
99 
100 //*************************************************************************************************
107 template< typename MT // Type of the dense matrix
108  , bool SO > // Storage order
109 class DMatDeclDiagExpr : public DenseMatrix< DMatDeclDiagExpr<MT,SO>, SO >
110  , private DeclDiagExpr
111  , private If< IsComputation<MT>, Computation, EmptyType >::Type
112 {
113  private:
114  //**Serial evaluation strategy******************************************************************
116 
122  enum : bool { useAssign = RequiresEvaluation<MT>::value };
123 
125  template< typename MT2 >
127  struct UseAssign {
128  enum : bool { value = useAssign };
129  };
131  //**********************************************************************************************
132 
133  //**Parallel evaluation strategy****************************************************************
135 
140  template< typename MT2 >
141  struct UseSMPAssign {
142  enum : bool { value = MT2::smpAssignable && useAssign };
143  };
145  //**********************************************************************************************
146 
147  //**********************************************************************************************
149 
153  template< typename MT2 >
154  struct GetConstIterator {
156  struct Success { using Type = typename MT2::ConstIterator; };
157  struct Failure { using Type = INVALID_TYPE; };
158  using Type = typename If_< HasConstIterator<MT2>, Success, Failure >::Type;
159  };
161  //**********************************************************************************************
162 
163  public:
164  //**Type definitions****************************************************************************
171 
174 
176  typedef typename GetConstIterator<MT>::Type ConstIterator;
177 
179  typedef If_< IsExpression<MT>, const MT, const MT& > Operand;
180  //**********************************************************************************************
181 
182  //**Compilation flags***************************************************************************
184  enum : bool { simdEnabled = MT::simdEnabled };
185 
187  enum : bool { smpAssignable = MT::smpAssignable };
188  //**********************************************************************************************
189 
190  //**SIMD properties*****************************************************************************
192  enum : size_t { SIMDSIZE = SIMDTrait<ElementType>::size };
193  //**********************************************************************************************
194 
195  //**Constructor*********************************************************************************
200  explicit inline DMatDeclDiagExpr( const MT& dm ) noexcept
201  : dm_( dm ) // Dense matrix of the decldiag expression
202  {}
203  //**********************************************************************************************
204 
205  //**Access operator*****************************************************************************
212  inline ReturnType operator()( size_t i, size_t j ) const {
213  BLAZE_INTERNAL_ASSERT( i < dm_.rows() , "Invalid row access index" );
214  BLAZE_INTERNAL_ASSERT( j < dm_.columns(), "Invalid column access index" );
215  return dm_(i,j);
216  }
217  //**********************************************************************************************
218 
219  //**At function*********************************************************************************
227  inline ReturnType at( size_t i, size_t j ) const {
228  if( i >= dm_.rows() ) {
229  BLAZE_THROW_OUT_OF_RANGE( "Invalid row access index" );
230  }
231  if( j >= dm_.columns() ) {
232  BLAZE_THROW_OUT_OF_RANGE( "Invalid column access index" );
233  }
234  return (*this)(i,j);
235  }
236  //**********************************************************************************************
237 
238  //**Load function*******************************************************************************
245  BLAZE_ALWAYS_INLINE auto load( size_t i, size_t j ) const noexcept {
246  BLAZE_INTERNAL_ASSERT( i < dm_.columns(), "Invalid row access index" );
247  BLAZE_INTERNAL_ASSERT( j < dm_.rows() , "Invalid column access index" );
248  BLAZE_INTERNAL_ASSERT( !SO || ( i % SIMDSIZE == 0UL ), "Invalid row access index" );
249  BLAZE_INTERNAL_ASSERT( SO || ( j % SIMDSIZE == 0UL ), "Invalid column access index" );
250  return dm_.load(i,j);
251  }
252  //**********************************************************************************************
253 
254  //**Low-level data access***********************************************************************
259  inline const ElementType* data() const noexcept {
260  return dm_.data();
261  }
262  //**********************************************************************************************
263 
264  //**Begin function******************************************************************************
270  inline ConstIterator begin( size_t i ) const {
271  return ConstIterator( dm_.begin(i) );
272  }
273  //**********************************************************************************************
274 
275  //**End function********************************************************************************
281  inline ConstIterator end( size_t i ) const {
282  return ConstIterator( dm_.end(i) );
283  }
284  //**********************************************************************************************
285 
286  //**Rows function*******************************************************************************
291  inline size_t rows() const noexcept {
292  return dm_.rows();
293  }
294  //**********************************************************************************************
295 
296  //**Columns function****************************************************************************
301  inline size_t columns() const noexcept {
302  return dm_.columns();
303  }
304  //**********************************************************************************************
305 
306  //**Operand access******************************************************************************
311  inline Operand operand() const noexcept {
312  return dm_;
313  }
314  //**********************************************************************************************
315 
316  //**********************************************************************************************
322  template< typename T >
323  inline bool canAlias( const T* alias ) const noexcept {
324  return dm_.canAlias( alias );
325  }
326  //**********************************************************************************************
327 
328  //**********************************************************************************************
334  template< typename T >
335  inline bool isAliased( const T* alias ) const noexcept {
336  return dm_.isAliased( alias );
337  }
338  //**********************************************************************************************
339 
340  //**********************************************************************************************
345  inline bool isAligned() const noexcept {
346  return dm_.isAligned();
347  }
348  //**********************************************************************************************
349 
350  //**********************************************************************************************
355  inline bool canSMPAssign() const noexcept {
356  return dm_.canSMPAssign();
357  }
358  //**********************************************************************************************
359 
360  private:
361  //**Member variables****************************************************************************
362  Operand dm_;
363  //**********************************************************************************************
364 
365  //**Assignment to dense matrices****************************************************************
377  template< typename MT2 // Type of the target dense matrix
378  , bool SO2 > // Storage order of the target dense matrix
379  friend inline EnableIf_< UseAssign<MT2> >
380  assign( DenseMatrix<MT2,SO2>& lhs, const DMatDeclDiagExpr& rhs )
381  {
383 
384  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
385  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
386 
387  assign( ~lhs, rhs.dm_ );
388  }
390  //**********************************************************************************************
391 
392  //**Assignment to sparse matrices***************************************************************
404  template< typename MT2 // Type of the target sparse matrix
405  , bool SO2 > // Storage order of the target dense matrix
406  friend inline EnableIf_< UseAssign<MT2> >
407  assign( SparseMatrix<MT2,SO2>& lhs, const DMatDeclDiagExpr& rhs )
408  {
410 
411  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
412  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
413 
414  assign( ~lhs, rhs.dm_ );
415  }
417  //**********************************************************************************************
418 
419  //**Addition assignment to dense matrices*******************************************************
431  template< typename MT2 // Type of the target dense matrix
432  , bool SO2 > // Storage order of the target dense matrix
433  friend inline EnableIf_< UseAssign<MT2> >
434  addAssign( DenseMatrix<MT2,SO2>& lhs, const DMatDeclDiagExpr& rhs )
435  {
437 
438  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
439  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
440 
441  addAssign( ~lhs, rhs.dm_ );
442  }
444  //**********************************************************************************************
445 
446  //**Addition assignment to sparse matrices******************************************************
458  template< typename MT2 // Type of the target sparse matrix
459  , bool SO2 > // Storage order of the target dense matrix
460  friend inline EnableIf_< UseAssign<MT2> >
461  addAssign( SparseMatrix<MT2,SO2>& lhs, const DMatDeclDiagExpr& rhs )
462  {
464 
465  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
466  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
467 
468  addAssign( ~lhs, rhs.dm_ );
469  }
471  //**********************************************************************************************
472 
473  //**Subtraction assignment to dense matrices****************************************************
485  template< typename MT2 // Type of the target dense matrix
486  , bool SO2 > // Storage order of the target dense matrix
487  friend inline EnableIf_< UseAssign<MT2> >
488  subAssign( DenseMatrix<MT2,SO2>& lhs, const DMatDeclDiagExpr& rhs )
489  {
491 
492  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
493  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
494 
495  subAssign( ~lhs, rhs.dm_ );
496  }
498  //**********************************************************************************************
499 
500  //**Subtraction assignment to sparse matrices***************************************************
512  template< typename MT2 // Type of the target sparse matrix
513  , bool SO2 > // Storage order of the target dense matrix
514  friend inline EnableIf_< UseAssign<MT2> >
515  subAssign( SparseMatrix<MT2,SO2>& lhs, const DMatDeclDiagExpr& rhs )
516  {
518 
519  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
520  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
521 
522  subAssign( ~lhs, rhs.dm_ );
523  }
525  //**********************************************************************************************
526 
527  //**Multiplication assignment to dense matrices*************************************************
539  template< typename MT2 // Type of the target dense matrix
540  , bool SO2 > // Storage order of the target dense matrix
541  friend inline EnableIf_< UseAssign<MT2> >
542  multAssign( DenseMatrix<MT2,SO2>& lhs, const DMatDeclDiagExpr& rhs )
543  {
545 
546  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
547  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
548 
549  multAssign( ~lhs, rhs.dm_ );
550  }
552  //**********************************************************************************************
553 
554  //**Multiplication assignment to sparse matrices************************************************
566  template< typename MT2 // Type of the target sparse matrix
567  , bool SO2 > // Storage order of the target dense matrix
568  friend inline EnableIf_< UseAssign<MT2> >
569  multAssign( SparseMatrix<MT2,SO2>& lhs, const DMatDeclDiagExpr& rhs )
570  {
572 
573  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
574  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
575 
576  multAssign( ~lhs, rhs.dm_ );
577  }
579  //**********************************************************************************************
580 
581  //**SMP assignment to dense matrices************************************************************
593  template< typename MT2 // Type of the target dense matrix
594  , bool SO2 > // Storage order of the target dense matrix
595  friend inline EnableIf_< UseSMPAssign<MT2> >
597  {
599 
600  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
601  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
602 
603  smpAssign( ~lhs, rhs.dm_ );
604  }
606  //**********************************************************************************************
607 
608  //**SMP assignment to sparse matrices***********************************************************
620  template< typename MT2 // Type of the target sparse matrix
621  , bool SO2 > // Storage order of the target dense matrix
622  friend inline EnableIf_< UseSMPAssign<MT2> >
624  {
626 
627  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
628  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
629 
630  smpAssign( ~lhs, rhs.dm_ );
631  }
633  //**********************************************************************************************
634 
635  //**SMP addition assignment to dense matrices***************************************************
647  template< typename MT2 // Type of the target dense matrix
648  , bool SO2 > // Storage order of the target dense matrix
649  friend inline EnableIf_< UseSMPAssign<MT2> >
651  {
653 
654  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
655  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
656 
657  smpAddAssign( ~lhs, rhs.dm_ );
658  }
660  //**********************************************************************************************
661 
662  //**SMP addition assignment to sparse matrices**************************************************
674  template< typename MT2 // Type of the target sparse matrix
675  , bool SO2 > // Storage order of the target dense matrix
676  friend inline EnableIf_< UseSMPAssign<MT2> >
678  {
680 
681  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
682  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
683 
684  smpAddAssign( ~lhs, rhs.dm_ );
685  }
687  //**********************************************************************************************
688 
689  //**SMP subtraction assignment to dense matrices************************************************
701  template< typename MT2 // Type of the target dense matrix
702  , bool SO2 > // Storage order of the target dense matrix
703  friend inline EnableIf_< UseSMPAssign<MT2> >
705  {
707 
708  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
709  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
710 
711  smpSubAssign( ~lhs, rhs.dm_ );
712  }
714  //**********************************************************************************************
715 
716  //**SMP subtraction assignment to sparse matrices***********************************************
728  template< typename MT2 // Type of the target sparse matrix
729  , bool SO2 > // Storage order of the target dense matrix
730  friend inline EnableIf_< UseSMPAssign<MT2> >
732  {
734 
735  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
736  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
737 
738  smpSubAssign( ~lhs, rhs.dm_ );
739  }
741  //**********************************************************************************************
742 
743  //**SMP multiplication assignment to dense matrices*********************************************
756  template< typename MT2 // Type of the target dense matrix
757  , bool SO2 > // Storage order of the target dense matrix
758  friend inline EnableIf_< UseSMPAssign<MT2> >
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  smpMultAssign( ~lhs, rhs.dm_ );
767  }
769  //**********************************************************************************************
770 
771  //**SMP multiplication assignment to sparse matrices********************************************
784  template< typename MT2 // Type of the target sparse matrix
785  , bool SO2 > // Storage order of the target dense matrix
786  friend inline EnableIf_< UseSMPAssign<MT2> >
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  smpMultAssign( ~lhs, rhs.dm_ );
795  }
797  //**********************************************************************************************
798 
799  //**Compile time checks*************************************************************************
806  //**********************************************************************************************
807 };
808 //*************************************************************************************************
809 
810 
811 
812 
813 //=================================================================================================
814 //
815 // GLOBAL FUNCTIONS
816 //
817 //=================================================================================================
818 
819 //*************************************************************************************************
838 template< typename MT // Type of the dense matrix
839  , bool SO > // Storage order
842 {
844 
845  if( !isSquare( ~dm ) ) {
846  BLAZE_THROW_INVALID_ARGUMENT( "Invalid diagonal matrix specification" );
847  }
848 
849  return DMatDeclDiagExpr<MT,SO>( ~dm );
850 }
851 //*************************************************************************************************
852 
853 
854 //*************************************************************************************************
864 template< typename MT // Type of the dense matrix
865  , bool SO > // Storage order
866 inline EnableIf_< IsDiagonal<MT>, const MT& >
868 {
870 
871  return ~dm;
872 }
873 //*************************************************************************************************
874 
875 
876 
877 
878 //=================================================================================================
879 //
880 // GLOBAL RESTRUCTURING FUNCTIONS
881 //
882 //=================================================================================================
883 
884 //*************************************************************************************************
898 template< typename MT // Type of the left-hand side dense matrix
899  , typename ST // Type of the right-hand side scalar value
900  , bool SO > // Storage order
901 inline const DisableIf_< IsDiagonal<MT>, MultExprTrait_< DeclDiagExprTrait_<MT>, ST > >
903 {
905 
906  if( !isSquare( dm ) ) {
907  BLAZE_THROW_INVALID_ARGUMENT( "Invalid diagonal matrix specification" );
908  }
909 
910  return decldiag( dm.leftOperand() ) * dm.rightOperand();
911 }
913 //*************************************************************************************************
914 
915 
916 
917 
918 //=================================================================================================
919 //
920 // ROWS SPECIALIZATIONS
921 //
922 //=================================================================================================
923 
924 //*************************************************************************************************
926 template< typename MT, bool SO >
927 struct Rows< DMatDeclDiagExpr<MT,SO> > : public Rows<MT>
928 {};
930 //*************************************************************************************************
931 
932 
933 
934 
935 //=================================================================================================
936 //
937 // COLUMNS SPECIALIZATIONS
938 //
939 //=================================================================================================
940 
941 //*************************************************************************************************
943 template< typename MT, bool SO >
944 struct Columns< DMatDeclDiagExpr<MT,SO> > : public Columns<MT>
945 {};
947 //*************************************************************************************************
948 
949 
950 
951 
952 //=================================================================================================
953 //
954 // ISALIGNED SPECIALIZATIONS
955 //
956 //=================================================================================================
957 
958 //*************************************************************************************************
960 template< typename MT, bool SO >
961 struct IsAligned< DMatDeclDiagExpr<MT,SO> >
962  : public BoolConstant< IsAligned<MT>::value >
963 {};
965 //*************************************************************************************************
966 
967 
968 
969 
970 //=================================================================================================
971 //
972 // ISSYMMETRIC SPECIALIZATIONS
973 //
974 //=================================================================================================
975 
976 //*************************************************************************************************
978 template< typename MT, bool SO >
979 struct IsSymmetric< DMatDeclDiagExpr<MT,SO> >
980  : public TrueType
981 {};
983 //*************************************************************************************************
984 
985 
986 
987 
988 //=================================================================================================
989 //
990 // ISHERMITIAN SPECIALIZATIONS
991 //
992 //=================================================================================================
993 
994 //*************************************************************************************************
996 template< typename MT, bool SO >
997 struct IsHermitian< DMatDeclDiagExpr<MT,SO> >
998  : public BoolConstant< IsHermitian<MT>::value >
999 {};
1001 //*************************************************************************************************
1002 
1003 
1004 
1005 
1006 //=================================================================================================
1007 //
1008 // ISLOWER SPECIALIZATIONS
1009 //
1010 //=================================================================================================
1011 
1012 //*************************************************************************************************
1014 template< typename MT, bool SO >
1015 struct IsLower< DMatDeclDiagExpr<MT,SO> >
1016  : public TrueType
1017 {};
1019 //*************************************************************************************************
1020 
1021 
1022 
1023 
1024 //=================================================================================================
1025 //
1026 // ISUNILOWER SPECIALIZATIONS
1027 //
1028 //=================================================================================================
1029 
1030 //*************************************************************************************************
1032 template< typename MT, bool SO >
1033 struct IsUniLower< DMatDeclDiagExpr<MT,SO> >
1034  : public BoolConstant< IsUniLower<MT>::value >
1035 {};
1037 //*************************************************************************************************
1038 
1039 
1040 
1041 
1042 //=================================================================================================
1043 //
1044 // ISSTRICTLYLOWER SPECIALIZATIONS
1045 //
1046 //=================================================================================================
1047 
1048 //*************************************************************************************************
1050 template< typename MT, bool SO >
1051 struct IsStrictlyLower< DMatDeclDiagExpr<MT,SO> >
1052  : public BoolConstant< IsStrictlyLower<MT>::value >
1053 {};
1055 //*************************************************************************************************
1056 
1057 
1058 
1059 
1060 //=================================================================================================
1061 //
1062 // ISUPPER SPECIALIZATIONS
1063 //
1064 //=================================================================================================
1065 
1066 //*************************************************************************************************
1068 template< typename MT, bool SO >
1069 struct IsUpper< DMatDeclDiagExpr<MT,SO> >
1070  : public TrueType
1071 {};
1073 //*************************************************************************************************
1074 
1075 
1076 
1077 
1078 //=================================================================================================
1079 //
1080 // ISUNIUPPER SPECIALIZATIONS
1081 //
1082 //=================================================================================================
1083 
1084 //*************************************************************************************************
1086 template< typename MT, bool SO >
1087 struct IsUniUpper< DMatDeclDiagExpr<MT,SO> >
1088  : public BoolConstant< IsUniUpper<MT>::value >
1089 {};
1091 //*************************************************************************************************
1092 
1093 
1094 
1095 
1096 //=================================================================================================
1097 //
1098 // ISSTRICTLYUPPER SPECIALIZATIONS
1099 //
1100 //=================================================================================================
1101 
1102 //*************************************************************************************************
1104 template< typename MT, bool SO >
1105 struct IsStrictlyUpper< DMatDeclDiagExpr<MT,SO> >
1106  : public BoolConstant< IsStrictlyUpper<MT>::value >
1107 {};
1109 //*************************************************************************************************
1110 
1111 
1112 
1113 
1114 //=================================================================================================
1115 //
1116 // EXPRESSION TRAIT SPECIALIZATIONS
1117 //
1118 //=================================================================================================
1119 
1120 //*************************************************************************************************
1122 template< typename MT, typename ST >
1123 struct DMatDeclDiagExprTrait< DMatScalarMultExpr<MT,ST,false> >
1124 {
1125  public:
1126  //**********************************************************************************************
1128  , MultExprTrait_< DeclDiagExprTrait_<MT>, ST >
1129  , INVALID_TYPE >;
1130  //**********************************************************************************************
1131 };
1133 //*************************************************************************************************
1134 
1135 
1136 //*************************************************************************************************
1138 template< typename MT, typename ST >
1139 struct TDMatDeclDiagExprTrait< DMatScalarMultExpr<MT,ST,true> >
1140 {
1141  public:
1142  //**********************************************************************************************
1144  , MultExprTrait_< DeclDiagExprTrait_<MT>, ST >
1145  , INVALID_TYPE >;
1146  //**********************************************************************************************
1147 };
1149 //*************************************************************************************************
1150 
1151 
1152 //*************************************************************************************************
1154 template< typename MT, bool SO, bool AF >
1155 struct SubmatrixExprTrait< DMatDeclDiagExpr<MT,SO>, AF >
1156 {
1157  public:
1158  //**********************************************************************************************
1159  using Type = SubmatrixExprTrait_<const MT,AF>;
1160  //**********************************************************************************************
1161 };
1163 //*************************************************************************************************
1164 
1165 
1166 //*************************************************************************************************
1168 template< typename MT, bool SO >
1169 struct RowExprTrait< DMatDeclDiagExpr<MT,SO> >
1170 {
1171  public:
1172  //**********************************************************************************************
1173  using Type = RowExprTrait_<const MT>;
1174  //**********************************************************************************************
1175 };
1177 //*************************************************************************************************
1178 
1179 
1180 //*************************************************************************************************
1182 template< typename MT, bool SO >
1183 struct ColumnExprTrait< DMatDeclDiagExpr<MT,SO> >
1184 {
1185  public:
1186  //**********************************************************************************************
1187  using Type = ColumnExprTrait_<const MT>;
1188  //**********************************************************************************************
1189 };
1191 //*************************************************************************************************
1192 
1193 } // namespace blaze
1194 
1195 #endif
typename SubmatrixExprTrait< MT, AF >::Type SubmatrixExprTrait_
Auxiliary alias declaration for the SubmatrixExprTrait type trait.The SubmatrixExprTrait_ alias decla...
Definition: SubmatrixExprTrait.h:134
#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.
Compile time check for numeric types.This type trait tests whether or not the given template paramete...
Definition: IsNumeric.h:79
Header file for the Rows type trait.
Header file for the IsUniUpper type trait.
Compile time type selection.The If class template selects one of the two given types T2 and T3 depend...
Definition: If.h:132
Header file for basic type definitions.
Header file for the DMatDeclDiagExprTrait class template.
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:160
BLAZE_ALWAYS_INLINE auto load(size_t i, size_t j) const noexcept
Access to the SIMD elements of the matrix.
Definition: DMatDeclDiagExpr.h:245
#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
#define BLAZE_CONSTRAINT_MUST_BE_DENSE_MATRIX_TYPE(T)
Constraint on the data type.In case the given data type T is not a dense, N-dimensional matrix type...
Definition: DenseMatrix.h:61
Header file for the ColumnExprTrait class template.
Header file for the IsColumnMajorMatrix type trait.
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:223
size_t columns() const noexcept
Returns the current number of columns of the matrix.
Definition: DMatDeclDiagExpr.h:301
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
Header file for the Computation base class.
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 TDMatDeclDiagExprTrait class template.
Header file for the RequiresEvaluation type trait.
Expression object for the explicit diagonal declaration of dense matrices.The DMatDeclDiagExpr class ...
Definition: DMatDeclDiagExpr.h:109
Header file for the SIMD trait.
Header file for the IsUniLower type trait.
typename T::ResultType ResultType_
Alias declaration for nested ResultType type definitions.The ResultType_ alias declaration provides a...
Definition: Aliases.h:323
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:129
Base class for dense matrices.The DenseMatrix class is a base class for all dense matrix classes...
Definition: DenseMatrix.h:71
Base class for sparse matrices.The SparseMatrix class is a base class for all sparse matrix classes...
Definition: Forward.h:119
ElementType_< MT > ElementType
Resulting element type.
Definition: DMatDeclDiagExpr.h:169
Base class for all decldiag expression templates.The DeclDiagExpr class serves as a tag for all expre...
Definition: DeclDiagExpr.h:65
typename T::ReturnType ReturnType_
Alias declaration for nested ReturnType type definitions.The ReturnType_ alias declaration provides a...
Definition: Aliases.h:343
Compile time check for the alignment of data types.This type trait tests whether the given data type ...
Definition: IsAligned.h:87
Constraint on the data type.
typename MultExprTrait< T1, T2 >::Type MultExprTrait_
Auxiliary alias declaration for the MultExprTrait class template.The MultExprTrait_ alias declaration...
Definition: MultExprTrait.h:344
Header file for the MultExprTrait class template.
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
ResultType_< MT > ResultType
Result type for expression template evaluations.
Definition: DMatDeclDiagExpr.h:166
Header file for the DisableIf class template.
typename RowExprTrait< MT >::Type RowExprTrait_
Auxiliary alias declaration for the RowExprTrait type trait.The RowExprTrait_ alias declaration provi...
Definition: RowExprTrait.h:134
Header file for the DeclDiagExprTrait class template.
Header file for the IsStrictlyUpper type trait.
Header file for the IsSymmetric type trait.
ReturnType operator()(size_t i, size_t j) const
2D-access to the matrix elements.
Definition: DMatDeclDiagExpr.h:212
Namespace of the Blaze C++ math library.
Definition: Blaze.h:57
#define BLAZE_ALWAYS_INLINE
Platform dependent setup of an enforced inline keyword.
Definition: Inline.h:85
Header file for the If class template.
Compile time check for row-major matrix types.This type trait tests whether or not the given template...
Definition: IsRowMajorMatrix.h:83
Header file for the DeclDiagExpr base class.
If_< IsExpression< MT >, const MT, const MT &> Operand
Composite data type of the dense matrix expression.
Definition: DMatDeclDiagExpr.h:179
const Element * ConstIterator
Iterator over constant elements.
Definition: CompressedMatrix.h:2939
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:98
bool canSMPAssign() const noexcept
Returns whether the expression can be used in SMP assignments.
Definition: DMatDeclDiagExpr.h:355
Expression object for dense matrix-scalar multiplications.The DMatScalarMultExpr class represents the...
Definition: DMatScalarMultExpr.h:123
If_< RequiresEvaluation< MT >, const ResultType, const DMatDeclDiagExpr &> CompositeType
Data type for composite expression templates.
Definition: DMatDeclDiagExpr.h:173
#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 DenseMatrix base class.
Header file for the Columns type trait.
typename T::ElementType ElementType_
Alias declaration for nested ElementType type definitions.The ElementType_ alias declaration provides...
Definition: Aliases.h:163
Evaluation of the expression type of a dense matrix decldiag operation.Via this type trait it is poss...
Definition: TDMatDeclDiagExprTrait.h:75
#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
Evaluation of the expression type type of a submatrix operation.Via this type trait it is possible to...
Definition: SubmatrixExprTrait.h:80
Header file for the IsLower type trait.
Header file for the IsAligned type trait.
typename ColumnExprTrait< MT >::Type ColumnExprTrait_
Auxiliary alias declaration for the ColumnExprTrait type trait.The ColumnExprTrait_ alias declaration...
Definition: ColumnExprTrait.h:133
ReturnType_< MT > ReturnType
Return type for expression template evaluations.
Definition: DMatDeclDiagExpr.h:170
#define BLAZE_CONSTRAINT_MUST_NOT_BE_MATMATMULTEXPR_TYPE(T)
Constraint on the data type.In case the given data type T is a matrix/matrix multiplication expressio...
Definition: MatMatMultExpr.h:89
RightOperand rightOperand() const noexcept
Returns the right-hand side scalar operand.
Definition: DMatScalarMultExpr.h:580
bool isAligned() const noexcept
Returns whether the operands of the expression are properly aligned in memory.
Definition: DMatDeclDiagExpr.h:345
Constraints on the storage order of matrix types.
Operand operand() const noexcept
Returns the dense matrix operand.
Definition: DMatDeclDiagExpr.h:311
const ElementType * data() const noexcept
Low-level data access to the matrix elements.
Definition: DMatDeclDiagExpr.h:259
Compile time check for symmetric matrices.This type trait tests whether or not the given template par...
Definition: IsSymmetric.h:85
DMatDeclDiagExpr(const MT &dm) noexcept
Constructor for the DMatDeclDiagExpr class.
Definition: DMatDeclDiagExpr.h:200
DMatDeclDiagExpr< MT, SO > This
Type of this DMatDeclDiagExpr instance.
Definition: DMatDeclDiagExpr.h:165
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
Evaluation of the expression type type of a row operation.Via this type trait it is possible to evalu...
Definition: RowExprTrait.h:79
Header file for the RowExprTrait class template.
Header file for all forward declarations for expression class templates.
Header file for the IsDenseMatrix type trait.
size_t rows() const noexcept
Returns the current number of rows of the matrix.
Definition: DMatDeclDiagExpr.h:291
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 SubmatrixExprTrait class template.
Header file for run time assertion macros.
Compile time check for column-major matrix types.This type trait tests whether or not the given templ...
Definition: IsColumnMajorMatrix.h:83
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:160
SIMD characteristics of data types.The SIMDTrait class template provides the SIMD characteristics of ...
Definition: SIMDTrait.h:296
#define BLAZE_FUNCTION_TRACE
Function trace macro.This macro can be used to reliably trace function calls. In case function tracin...
Definition: FunctionTrace.h:93
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:223
typename T::OppositeType OppositeType_
Alias declaration for nested OppositeType type definitions.The OppositeType_ alias declaration provid...
Definition: Aliases.h:243
GetConstIterator< MT >::Type ConstIterator
Iterator over the elements of the dense matrix.
Definition: DMatDeclDiagExpr.h:176
ConstIterator begin(size_t i) const
Returns an iterator to the first non-zero element of row/column i.
Definition: DMatDeclDiagExpr.h:270
Compile time check for strictly lower triangular matrices.This type trait tests whether or not the gi...
Definition: IsStrictlyLower.h:86
bool isAliased(const T *alias) const noexcept
Returns whether the expression is aliased with the given address alias.
Definition: DMatDeclDiagExpr.h:335
ReturnType at(size_t i, size_t j) const
Checked access to the matrix elements.
Definition: DMatDeclDiagExpr.h:227
Header file for the IsRowMajorMatrix type trait.
Operand dm_
Dense matrix of the decldiag expression.
Definition: DMatDeclDiagExpr.h:362
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:76
ConstIterator end(size_t i) const
Returns an iterator just past the last non-zero element of row/column i.
Definition: DMatDeclDiagExpr.h:281
Evaluation of the expression type of a dense matrix decldiag operation.Via this type trait it is poss...
Definition: DMatDeclDiagExprTrait.h:75
Compile time evaluation of the number of rows of a matrix.The Rows type trait evaluates the number of...
Definition: Rows.h:76
typename T::TransposeType TransposeType_
Alias declaration for nested TransposeType type definitions.The TransposeType_ alias declaration prov...
Definition: Aliases.h:403
Header file for the IsUpper type trait.
bool canAlias(const T *alias) const noexcept
Returns whether the expression can alias with the given address alias.
Definition: DMatDeclDiagExpr.h:323
Constraint on the data type.
Header file for the empty type.
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:677
LeftOperand leftOperand() const noexcept
Returns the left-hand side dense matrix operand.
Definition: DMatScalarMultExpr.h:570
DisableIf_< IsDiagonal< MT >, const DMatDeclDiagExpr< MT, SO > > decldiag(const DenseMatrix< MT, SO > &dm)
Declares the given non-diagonal dense matrix expression dm as diagonal.
Definition: DMatDeclDiagExpr.h:841
Evaluation of the expression type type of a column operation.Via this type trait it is possible to ev...
Definition: ColumnExprTrait.h:78
#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
Header file for the TrueType type/value trait base class.
OppositeType_< MT > OppositeType
Result type with opposite storage order for expression template evaluations.
Definition: DMatDeclDiagExpr.h:167
Header file for the IsExpression type trait class.
Header file for the function trace functionality.
TransposeType_< MT > TransposeType
Transpose type for expression template evaluations.
Definition: DMatDeclDiagExpr.h:168