DMatDeclLowExpr.h
Go to the documentation of this file.
1 //=================================================================================================
33 //=================================================================================================
34 
35 #ifndef _BLAZE_MATH_EXPRESSIONS_DMATDECLLOWEXPR_H_
36 #define _BLAZE_MATH_EXPRESSIONS_DMATDECLLOWEXPR_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/mpl/Or.h>
88 #include <blaze/util/TrueType.h>
89 #include <blaze/util/Types.h>
91 
92 
93 namespace blaze {
94 
95 //=================================================================================================
96 //
97 // CLASS DMATDECLLOWEXPR
98 //
99 //=================================================================================================
100 
101 //*************************************************************************************************
108 template< typename MT // Type of the dense matrix
109  , bool SO > // Storage order
110 class DMatDeclLowExpr : public DenseMatrix< DMatDeclLowExpr<MT,SO>, SO >
111  , private DeclLowExpr
112  , private If< IsComputation<MT>, Computation, EmptyType >::Type
113 {
114  private:
115  //**Serial evaluation strategy******************************************************************
117 
123  enum : bool { useAssign = RequiresEvaluation<MT>::value };
124 
126  template< typename MT2 >
128  struct UseAssign {
129  enum : bool { value = useAssign };
130  };
132  //**********************************************************************************************
133 
134  //**Parallel evaluation strategy****************************************************************
136 
141  template< typename MT2 >
142  struct UseSMPAssign {
143  enum : bool { value = MT2::smpAssignable && useAssign };
144  };
146  //**********************************************************************************************
147 
148  //**********************************************************************************************
150 
154  template< typename MT2 >
155  struct GetConstIterator {
157  struct Success { using Type = typename MT2::ConstIterator; };
158  struct Failure { using Type = INVALID_TYPE; };
159  using Type = typename If_< HasConstIterator<MT2>, Success, Failure >::Type;
160  };
162  //**********************************************************************************************
163 
164  public:
165  //**Type definitions****************************************************************************
172 
175 
177  typedef typename GetConstIterator<MT>::Type ConstIterator;
178 
180  typedef If_< IsExpression<MT>, const MT, const MT& > Operand;
181  //**********************************************************************************************
182 
183  //**Compilation flags***************************************************************************
185  enum : bool { simdEnabled = MT::simdEnabled };
186 
188  enum : bool { smpAssignable = MT::smpAssignable };
189  //**********************************************************************************************
190 
191  //**SIMD properties*****************************************************************************
193  enum : size_t { SIMDSIZE = SIMDTrait<ElementType>::size };
194  //**********************************************************************************************
195 
196  //**Constructor*********************************************************************************
201  explicit inline DMatDeclLowExpr( const MT& dm ) noexcept
202  : dm_( dm ) // Dense matrix of the decllow expression
203  {}
204  //**********************************************************************************************
205 
206  //**Access operator*****************************************************************************
213  inline ReturnType operator()( size_t i, size_t j ) const {
214  BLAZE_INTERNAL_ASSERT( i < dm_.rows() , "Invalid row access index" );
215  BLAZE_INTERNAL_ASSERT( j < dm_.columns(), "Invalid column access index" );
216  return dm_(i,j);
217  }
218  //**********************************************************************************************
219 
220  //**At function*********************************************************************************
228  inline ReturnType at( size_t i, size_t j ) const {
229  if( i >= dm_.rows() ) {
230  BLAZE_THROW_OUT_OF_RANGE( "Invalid row access index" );
231  }
232  if( j >= dm_.columns() ) {
233  BLAZE_THROW_OUT_OF_RANGE( "Invalid column access index" );
234  }
235  return (*this)(i,j);
236  }
237  //**********************************************************************************************
238 
239  //**Load function*******************************************************************************
246  BLAZE_ALWAYS_INLINE auto load( size_t i, size_t j ) const noexcept {
247  BLAZE_INTERNAL_ASSERT( i < dm_.columns(), "Invalid row access index" );
248  BLAZE_INTERNAL_ASSERT( j < dm_.rows() , "Invalid column access index" );
249  BLAZE_INTERNAL_ASSERT( !SO || ( i % SIMDSIZE == 0UL ), "Invalid row access index" );
250  BLAZE_INTERNAL_ASSERT( SO || ( j % SIMDSIZE == 0UL ), "Invalid column access index" );
251  return dm_.load(i,j);
252  }
253  //**********************************************************************************************
254 
255  //**Low-level data access***********************************************************************
260  inline const ElementType* data() const noexcept {
261  return dm_.data();
262  }
263  //**********************************************************************************************
264 
265  //**Begin function******************************************************************************
271  inline ConstIterator begin( size_t i ) const {
272  return ConstIterator( dm_.begin(i) );
273  }
274  //**********************************************************************************************
275 
276  //**End function********************************************************************************
282  inline ConstIterator end( size_t i ) const {
283  return ConstIterator( dm_.end(i) );
284  }
285  //**********************************************************************************************
286 
287  //**Rows function*******************************************************************************
292  inline size_t rows() const noexcept {
293  return dm_.rows();
294  }
295  //**********************************************************************************************
296 
297  //**Columns function****************************************************************************
302  inline size_t columns() const noexcept {
303  return dm_.columns();
304  }
305  //**********************************************************************************************
306 
307  //**Operand access******************************************************************************
312  inline Operand operand() const noexcept {
313  return dm_;
314  }
315  //**********************************************************************************************
316 
317  //**********************************************************************************************
323  template< typename T >
324  inline bool canAlias( const T* alias ) const noexcept {
325  return dm_.canAlias( alias );
326  }
327  //**********************************************************************************************
328 
329  //**********************************************************************************************
335  template< typename T >
336  inline bool isAliased( const T* alias ) const noexcept {
337  return dm_.isAliased( alias );
338  }
339  //**********************************************************************************************
340 
341  //**********************************************************************************************
346  inline bool isAligned() const noexcept {
347  return dm_.isAligned();
348  }
349  //**********************************************************************************************
350 
351  //**********************************************************************************************
356  inline bool canSMPAssign() const noexcept {
357  return dm_.canSMPAssign();
358  }
359  //**********************************************************************************************
360 
361  private:
362  //**Member variables****************************************************************************
363  Operand dm_;
364  //**********************************************************************************************
365 
366  //**Assignment to dense matrices****************************************************************
378  template< typename MT2 // Type of the target dense matrix
379  , bool SO2 > // Storage order of the target dense matrix
380  friend inline EnableIf_< UseAssign<MT2> >
381  assign( DenseMatrix<MT2,SO2>& lhs, const DMatDeclLowExpr& 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.dm_ );
389  }
391  //**********************************************************************************************
392 
393  //**Assignment to sparse matrices***************************************************************
405  template< typename MT2 // Type of the target sparse matrix
406  , bool SO2 > // Storage order of the target dense matrix
407  friend inline EnableIf_< UseAssign<MT2> >
408  assign( SparseMatrix<MT2,SO2>& lhs, const DMatDeclLowExpr& 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  assign( ~lhs, rhs.dm_ );
416  }
418  //**********************************************************************************************
419 
420  //**Addition assignment to dense matrices*******************************************************
432  template< typename MT2 // Type of the target dense matrix
433  , bool SO2 > // Storage order of the target dense matrix
434  friend inline EnableIf_< UseAssign<MT2> >
435  addAssign( DenseMatrix<MT2,SO2>& lhs, const DMatDeclLowExpr& 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.dm_ );
443  }
445  //**********************************************************************************************
446 
447  //**Addition assignment to sparse matrices******************************************************
459  template< typename MT2 // Type of the target sparse matrix
460  , bool SO2 > // Storage order of the target dense matrix
461  friend inline EnableIf_< UseAssign<MT2> >
462  addAssign( SparseMatrix<MT2,SO2>& lhs, const DMatDeclLowExpr& 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  addAssign( ~lhs, rhs.dm_ );
470  }
472  //**********************************************************************************************
473 
474  //**Subtraction assignment to dense matrices****************************************************
486  template< typename MT2 // Type of the target dense matrix
487  , bool SO2 > // Storage order of the target dense matrix
488  friend inline EnableIf_< UseAssign<MT2> >
489  subAssign( DenseMatrix<MT2,SO2>& lhs, const DMatDeclLowExpr& 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.dm_ );
497  }
499  //**********************************************************************************************
500 
501  //**Subtraction assignment to sparse matrices***************************************************
513  template< typename MT2 // Type of the target sparse matrix
514  , bool SO2 > // Storage order of the target dense matrix
515  friend inline EnableIf_< UseAssign<MT2> >
516  subAssign( SparseMatrix<MT2,SO2>& lhs, const DMatDeclLowExpr& 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  subAssign( ~lhs, rhs.dm_ );
524  }
526  //**********************************************************************************************
527 
528  //**Multiplication assignment to dense matrices*************************************************
540  template< typename MT2 // Type of the target dense matrix
541  , bool SO2 > // Storage order of the target dense matrix
542  friend inline EnableIf_< UseAssign<MT2> >
543  multAssign( DenseMatrix<MT2,SO2>& lhs, const DMatDeclLowExpr& 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  multAssign( ~lhs, rhs.dm_ );
551  }
553  //**********************************************************************************************
554 
555  //**Multiplication assignment to sparse matrices************************************************
567  template< typename MT2 // Type of the target sparse matrix
568  , bool SO2 > // Storage order of the target dense matrix
569  friend inline EnableIf_< UseAssign<MT2> >
570  multAssign( SparseMatrix<MT2,SO2>& lhs, const DMatDeclLowExpr& 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.dm_ );
578  }
580  //**********************************************************************************************
581 
582  //**SMP assignment to dense matrices************************************************************
594  template< typename MT2 // Type of the target dense matrix
595  , bool SO2 > // Storage order of the target dense matrix
596  friend inline EnableIf_< UseSMPAssign<MT2> >
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  smpAssign( ~lhs, rhs.dm_ );
605  }
607  //**********************************************************************************************
608 
609  //**SMP assignment to sparse matrices***********************************************************
621  template< typename MT2 // Type of the target sparse matrix
622  , bool SO2 > // Storage order of the target dense matrix
623  friend inline EnableIf_< UseSMPAssign<MT2> >
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.dm_ );
632  }
634  //**********************************************************************************************
635 
636  //**SMP addition assignment to dense matrices***************************************************
648  template< typename MT2 // Type of the target dense matrix
649  , bool SO2 > // Storage order of the target dense matrix
650  friend inline EnableIf_< UseSMPAssign<MT2> >
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  smpAddAssign( ~lhs, rhs.dm_ );
659  }
661  //**********************************************************************************************
662 
663  //**SMP addition assignment to sparse matrices**************************************************
675  template< typename MT2 // Type of the target sparse matrix
676  , bool SO2 > // Storage order of the target dense matrix
677  friend inline EnableIf_< UseSMPAssign<MT2> >
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.dm_ );
686  }
688  //**********************************************************************************************
689 
690  //**SMP subtraction assignment to dense matrices************************************************
702  template< typename MT2 // Type of the target dense matrix
703  , bool SO2 > // Storage order of the target dense matrix
704  friend inline EnableIf_< UseSMPAssign<MT2> >
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  smpSubAssign( ~lhs, rhs.dm_ );
713  }
715  //**********************************************************************************************
716 
717  //**SMP subtraction assignment to sparse matrices***********************************************
729  template< typename MT2 // Type of the target sparse matrix
730  , bool SO2 > // Storage order of the target dense matrix
731  friend inline EnableIf_< UseSMPAssign<MT2> >
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.dm_ );
740  }
742  //**********************************************************************************************
743 
744  //**SMP multiplication assignment to dense matrices*********************************************
757  template< typename MT2 // Type of the target dense matrix
758  , bool SO2 > // Storage order of the target dense matrix
759  friend inline EnableIf_< UseSMPAssign<MT2> >
761  {
763 
764  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
765  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
766 
767  smpMultAssign( ~lhs, rhs.dm_ );
768  }
770  //**********************************************************************************************
771 
772  //**SMP multiplication assignment to sparse matrices********************************************
785  template< typename MT2 // Type of the target sparse matrix
786  , bool SO2 > // Storage order of the target dense matrix
787  friend inline EnableIf_< UseSMPAssign<MT2> >
789  {
791 
792  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
793  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
794 
795  smpMultAssign( ~lhs, rhs.dm_ );
796  }
798  //**********************************************************************************************
799 
800  //**Compile time checks*************************************************************************
807  //**********************************************************************************************
808 };
809 //*************************************************************************************************
810 
811 
812 
813 
814 //=================================================================================================
815 //
816 // GLOBAL FUNCTIONS
817 //
818 //=================================================================================================
819 
820 //*************************************************************************************************
839 template< typename MT // Type of the dense matrix
840  , bool SO > // Storage order
843 {
845 
846  if( !isSquare( ~dm ) ) {
847  BLAZE_THROW_INVALID_ARGUMENT( "Invalid lower matrix specification" );
848  }
849 
850  return DMatDeclLowExpr<MT,SO>( ~dm );
851 }
852 //*************************************************************************************************
853 
854 
855 //*************************************************************************************************
865 template< typename MT // Type of the dense matrix
866  , bool SO > // Storage order
867 inline EnableIf_< IsLower<MT>, const MT& >
869 {
871 
872  return ~dm;
873 }
874 //*************************************************************************************************
875 
876 
877 
878 
879 //=================================================================================================
880 //
881 // GLOBAL RESTRUCTURING FUNCTIONS
882 //
883 //=================================================================================================
884 
885 //*************************************************************************************************
899 template< typename MT // Type of the left-hand side dense matrix
900  , typename ST // Type of the right-hand side scalar value
901  , bool SO > // Storage order
902 inline const DisableIf_< IsLower<MT>, MultExprTrait_< DeclLowExprTrait_<MT>, ST > >
904 {
906 
907  if( !isSquare( ~dm ) ) {
908  BLAZE_THROW_INVALID_ARGUMENT( "Invalid lower matrix specification" );
909  }
910 
911  return decllow( dm.leftOperand() ) * dm.rightOperand();
912 }
914 //*************************************************************************************************
915 
916 
917 
918 
919 //=================================================================================================
920 //
921 // ROWS SPECIALIZATIONS
922 //
923 //=================================================================================================
924 
925 //*************************************************************************************************
927 template< typename MT, bool SO >
928 struct Rows< DMatDeclLowExpr<MT,SO> > : public Rows<MT>
929 {};
931 //*************************************************************************************************
932 
933 
934 
935 
936 //=================================================================================================
937 //
938 // COLUMNS SPECIALIZATIONS
939 //
940 //=================================================================================================
941 
942 //*************************************************************************************************
944 template< typename MT, bool SO >
945 struct Columns< DMatDeclLowExpr<MT,SO> > : public Columns<MT>
946 {};
948 //*************************************************************************************************
949 
950 
951 
952 
953 //=================================================================================================
954 //
955 // ISALIGNED SPECIALIZATIONS
956 //
957 //=================================================================================================
958 
959 //*************************************************************************************************
961 template< typename MT, bool SO >
962 struct IsAligned< DMatDeclLowExpr<MT,SO> >
963  : public BoolConstant< IsAligned<MT>::value >
964 {};
966 //*************************************************************************************************
967 
968 
969 
970 
971 //=================================================================================================
972 //
973 // ISSYMMETRIC SPECIALIZATIONS
974 //
975 //=================================================================================================
976 
977 //*************************************************************************************************
979 template< typename MT, bool SO >
980 struct IsSymmetric< DMatDeclLowExpr<MT,SO> >
981  : public BoolConstant< IsSymmetric<MT>::value >
982 {};
984 //*************************************************************************************************
985 
986 
987 
988 
989 //=================================================================================================
990 //
991 // ISHERMITIAN SPECIALIZATIONS
992 //
993 //=================================================================================================
994 
995 //*************************************************************************************************
997 template< typename MT, bool SO >
998 struct IsHermitian< DMatDeclLowExpr<MT,SO> >
999  : public BoolConstant< IsHermitian<MT>::value >
1000 {};
1002 //*************************************************************************************************
1003 
1004 
1005 
1006 
1007 //=================================================================================================
1008 //
1009 // ISLOWER SPECIALIZATIONS
1010 //
1011 //=================================================================================================
1012 
1013 //*************************************************************************************************
1015 template< typename MT, bool SO >
1016 struct IsLower< DMatDeclLowExpr<MT,SO> >
1017  : public TrueType
1018 {};
1020 //*************************************************************************************************
1021 
1022 
1023 
1024 
1025 //=================================================================================================
1026 //
1027 // ISUNILOWER SPECIALIZATIONS
1028 //
1029 //=================================================================================================
1030 
1031 //*************************************************************************************************
1033 template< typename MT, bool SO >
1034 struct IsUniLower< DMatDeclLowExpr<MT,SO> >
1035  : public BoolConstant< IsUniLower<MT>::value >
1036 {};
1038 //*************************************************************************************************
1039 
1040 
1041 
1042 
1043 //=================================================================================================
1044 //
1045 // ISSTRICTLYLOWER SPECIALIZATIONS
1046 //
1047 //=================================================================================================
1048 
1049 //*************************************************************************************************
1051 template< typename MT, bool SO >
1052 struct IsStrictlyLower< DMatDeclLowExpr<MT,SO> >
1053  : public BoolConstant< IsStrictlyLower<MT>::value >
1054 {};
1056 //*************************************************************************************************
1057 
1058 
1059 
1060 
1061 //=================================================================================================
1062 //
1063 // ISUPPER SPECIALIZATIONS
1064 //
1065 //=================================================================================================
1066 
1067 //*************************************************************************************************
1069 template< typename MT, bool SO >
1070 struct IsUpper< DMatDeclLowExpr<MT,SO> >
1071  : public BoolConstant< Or< IsSymmetric<MT>, IsHermitian<MT>, IsUpper<MT> >::value >
1072 {};
1074 //*************************************************************************************************
1075 
1076 
1077 
1078 
1079 //=================================================================================================
1080 //
1081 // ISUNIUPPER SPECIALIZATIONS
1082 //
1083 //=================================================================================================
1084 
1085 //*************************************************************************************************
1087 template< typename MT, bool SO >
1088 struct IsUniUpper< DMatDeclLowExpr<MT,SO> >
1089  : public BoolConstant< IsUniUpper<MT>::value >
1090 {};
1092 //*************************************************************************************************
1093 
1094 
1095 
1096 
1097 //=================================================================================================
1098 //
1099 // ISSTRICTLYUPPER SPECIALIZATIONS
1100 //
1101 //=================================================================================================
1102 
1103 //*************************************************************************************************
1105 template< typename MT, bool SO >
1106 struct IsStrictlyUpper< DMatDeclLowExpr<MT,SO> >
1107  : public BoolConstant< IsStrictlyUpper<MT>::value >
1108 {};
1110 //*************************************************************************************************
1111 
1112 
1113 
1114 
1115 //=================================================================================================
1116 //
1117 // EXPRESSION TRAIT SPECIALIZATIONS
1118 //
1119 //=================================================================================================
1120 
1121 //*************************************************************************************************
1123 template< typename MT, typename ST >
1124 struct DMatDeclLowExprTrait< DMatScalarMultExpr<MT,ST,false> >
1125 {
1126  public:
1127  //**********************************************************************************************
1129  , MultExprTrait_< DeclLowExprTrait_<MT>, ST >
1130  , INVALID_TYPE >;
1131  //**********************************************************************************************
1132 };
1134 //*************************************************************************************************
1135 
1136 
1137 //*************************************************************************************************
1139 template< typename MT, typename ST >
1140 struct TDMatDeclLowExprTrait< DMatScalarMultExpr<MT,ST,true> >
1141 {
1142  public:
1143  //**********************************************************************************************
1145  , MultExprTrait_< DeclLowExprTrait_<MT>, ST >
1146  , INVALID_TYPE >;
1147  //**********************************************************************************************
1148 };
1150 //*************************************************************************************************
1151 
1152 
1153 //*************************************************************************************************
1155 template< typename MT, bool SO, bool AF >
1156 struct SubmatrixExprTrait< DMatDeclLowExpr<MT,SO>, AF >
1157 {
1158  public:
1159  //**********************************************************************************************
1160  using Type = SubmatrixExprTrait_<const MT,AF>;
1161  //**********************************************************************************************
1162 };
1164 //*************************************************************************************************
1165 
1166 
1167 //*************************************************************************************************
1169 template< typename MT, bool SO >
1170 struct RowExprTrait< DMatDeclLowExpr<MT,SO> >
1171 {
1172  public:
1173  //**********************************************************************************************
1174  using Type = RowExprTrait_<const MT>;
1175  //**********************************************************************************************
1176 };
1178 //*************************************************************************************************
1179 
1180 
1181 //*************************************************************************************************
1183 template< typename MT, bool SO >
1184 struct ColumnExprTrait< DMatDeclLowExpr<MT,SO> >
1185 {
1186  public:
1187  //**********************************************************************************************
1188  using Type = ColumnExprTrait_<const MT>;
1189  //**********************************************************************************************
1190 };
1192 //*************************************************************************************************
1193 
1194 } // namespace blaze
1195 
1196 #endif
OppositeType_< MT > OppositeType
Result type with opposite storage order for expression template evaluations.
Definition: DMatDeclLowExpr.h:168
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
Evaluation of the expression type of a dense matrix decllow operation.Via this type trait it is possi...
Definition: TDMatDeclLowExprTrait.h:75
bool isAligned() const noexcept
Returns whether the operands of the expression are properly aligned in memory.
Definition: DMatDeclLowExpr.h:346
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.
size_t columns() const noexcept
Returns the current number of columns of the matrix.
Definition: DMatDeclLowExpr.h:302
DMatDeclLowExpr< MT, SO > This
Type of this DMatDeclLowExpr instance.
Definition: DMatDeclLowExpr.h:166
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
#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
ReturnType_< MT > ReturnType
Return type for expression template evaluations.
Definition: DMatDeclLowExpr.h:171
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
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
Expression object for the explicit lower declaration of dense matrices.The DMatDeclLowExpr class repr...
Definition: DMatDeclLowExpr.h:110
If_< IsExpression< MT >, const MT, const MT &> Operand
Composite data type of the dense matrix expression.
Definition: DMatDeclLowExpr.h:180
Header file for the Computation base class.
Operand operand() const noexcept
Returns the dense matrix operand.
Definition: DMatDeclLowExpr.h:312
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.
Constraint on the data type.
Header file for the SIMD trait.
Header file for the IsUniLower type trait.
If_< RequiresEvaluation< MT >, const ResultType, const DMatDeclLowExpr &> CompositeType
Data type for composite expression templates.
Definition: DMatDeclLowExpr.h:174
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
bool canAlias(const T *alias) const noexcept
Returns whether the expression can alias with the given address alias.
Definition: DMatDeclLowExpr.h:324
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
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
GetConstIterator< MT >::Type ConstIterator
Iterator over the elements of the dense matrix.
Definition: DMatDeclLowExpr.h:177
Header file for the DisableIf class template.
bool canSMPAssign() const noexcept
Returns whether the expression can be used in SMP assignments.
Definition: DMatDeclLowExpr.h:356
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 IsStrictlyUpper type trait.
Header file for the IsSymmetric type trait.
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
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
Header file for the Or class template.
Expression object for dense matrix-scalar multiplications.The DMatScalarMultExpr class represents the...
Definition: DMatScalarMultExpr.h:123
#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
ConstIterator begin(size_t i) const
Returns an iterator to the first non-zero element of row/column i.
Definition: DMatDeclLowExpr.h:271
Header file for the DenseMatrix base class.
Header file for the DMatDeclLowExprTrait class template.
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 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
#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
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.
DisableIf_< IsLower< MT >, const DMatDeclLowExpr< MT, SO > > decllow(const DenseMatrix< MT, SO > &dm)
Declares the given non-lower dense matrix expression dm as lower.
Definition: DMatDeclLowExpr.h:842
BLAZE_ALWAYS_INLINE auto load(size_t i, size_t j) const noexcept
Access to the SIMD elements of the matrix.
Definition: DMatDeclLowExpr.h:246
Compile time check for strictly upper triangular matrices.This type trait tests whether or not the gi...
Definition: IsStrictlyUpper.h:86
Header file for the DeclLowExpr base class.
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.
TransposeType_< MT > TransposeType
Transpose type for expression template evaluations.
Definition: DMatDeclLowExpr.h:169
Header file for the EnableIf class template.
Header file for the IsStrictlyLower type trait.
Base class for all decllow expression templates.The DeclLowExpr class serves as a tag for all express...
Definition: DeclLowExpr.h:65
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.
ReturnType operator()(size_t i, size_t j) const
2D-access to the matrix elements.
Definition: DMatDeclLowExpr.h:213
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.
Header file for the TDMatDeclLowExprTrait class template.
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
ConstIterator end(size_t i) const
Returns an iterator just past the last non-zero element of row/column i.
Definition: DMatDeclLowExpr.h:282
ReturnType at(size_t i, size_t j) const
Checked access to the matrix elements.
Definition: DMatDeclLowExpr.h:228
bool isAliased(const T *alias) const noexcept
Returns whether the expression is aliased with the given address alias.
Definition: DMatDeclLowExpr.h:336
#define BLAZE_CONSTRAINT_MUST_NOT_BE_LOWER_MATRIX_TYPE(T)
Constraint on the data type.In case the given data type T is a lower triangular matrix type...
Definition: Lower.h:81
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
DMatDeclLowExpr(const MT &dm) noexcept
Constructor for the DMatDeclLowExpr class.
Definition: DMatDeclLowExpr.h:201
Compile time check for Hermitian matrices.This type trait tests whether or not the given template par...
Definition: IsHermitian.h:85
Header file for the HasMember type traits.
typename EnableIf< Condition, T >::Type EnableIf_
Auxiliary alias declaration for the EnableIf class template.The EnableIf_ alias declaration provides ...
Definition: EnableIf.h:223
typename T::OppositeType OppositeType_
Alias declaration for nested OppositeType type definitions.The OppositeType_ alias declaration provid...
Definition: Aliases.h:243
Compile time check for strictly lower triangular matrices.This type trait tests whether or not the gi...
Definition: IsStrictlyLower.h:86
size_t rows() const noexcept
Returns the current number of rows of the matrix.
Definition: DMatDeclLowExpr.h:292
Header file for the IsRowMajorMatrix type trait.
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
Evaluation of the expression type of a dense matrix decllow operation.Via this type trait it is possi...
Definition: DMatDeclLowExprTrait.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
Operand dm_
Dense matrix of the decllow expression.
Definition: DMatDeclLowExpr.h:363
typename T::TransposeType TransposeType_
Alias declaration for nested TransposeType type definitions.The TransposeType_ alias declaration prov...
Definition: Aliases.h:403
ResultType_< MT > ResultType
Result type for expression template evaluations.
Definition: DMatDeclLowExpr.h:167
Header file for the IsUpper type trait.
ElementType_< MT > ElementType
Resulting element type.
Definition: DMatDeclLowExpr.h:170
Header file for the DeclLowExprTrait class template.
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
const ElementType * data() const noexcept
Low-level data access to the matrix elements.
Definition: DMatDeclLowExpr.h:260
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.
Header file for the IsExpression type trait class.
Header file for the function trace functionality.