DMatSMatAddExpr.h
Go to the documentation of this file.
1 //=================================================================================================
33 //=================================================================================================
34 
35 #ifndef _BLAZE_MATH_EXPRESSIONS_DMATSMATADDEXPR_H_
36 #define _BLAZE_MATH_EXPRESSIONS_DMATSMATADDEXPR_H_
37 
38 
39 //*************************************************************************************************
40 // Includes
41 //*************************************************************************************************
42 
43 #include <blaze/math/Aliases.h>
48 #include <blaze/math/Exception.h>
76 #include <blaze/util/Assert.h>
78 #include <blaze/util/EnableIf.h>
80 #include <blaze/util/InvalidType.h>
82 #include <blaze/util/mpl/And.h>
83 #include <blaze/util/mpl/If.h>
84 #include <blaze/util/mpl/Max.h>
85 #include <blaze/util/mpl/Or.h>
86 #include <blaze/util/Types.h>
87 
88 
89 namespace blaze {
90 
91 //=================================================================================================
92 //
93 // CLASS DMATSMATADDEXPR
94 //
95 //=================================================================================================
96 
97 //*************************************************************************************************
104 template< typename MT1 // Type of the left-hand side dense matrix
105  , typename MT2 // Type of the right-hand side sparse matrix
106  , bool SO > // Storage order
107 class DMatSMatAddExpr : public DenseMatrix< DMatSMatAddExpr<MT1,MT2,SO>, SO >
108  , private MatMatAddExpr
109  , private Computation
110 {
111  private:
112  //**Type definitions****************************************************************************
117  //**********************************************************************************************
118 
119  //**Return type evaluation**********************************************************************
121 
126  enum : bool { returnExpr = !IsTemporary<RN1>::value && !IsTemporary<RN2>::value };
127 
130  //**********************************************************************************************
131 
132  //**Parallel evaluation strategy****************************************************************
134 
139  template< typename MT >
140  struct UseSMPAssign {
141  enum : bool { value = ( !MT1::smpAssignable || !MT2::smpAssignable ) };
142  };
144  //**********************************************************************************************
145 
146  public:
147  //**Type definitions****************************************************************************
153 
156 
158  typedef const ResultType CompositeType;
159 
161  typedef If_< IsExpression<MT1>, const MT1, const MT1& > LeftOperand;
162 
164  typedef If_< IsExpression<MT2>, const MT2, const MT2& > RightOperand;
165  //**********************************************************************************************
166 
167  //**Compilation flags***************************************************************************
169  enum : bool { simdEnabled = false };
170 
172  enum : bool { smpAssignable = false };
173  //**********************************************************************************************
174 
175  //**Constructor*********************************************************************************
181  explicit inline DMatSMatAddExpr( const MT1& lhs, const MT2& rhs ) noexcept
182  : lhs_( lhs ) // Left-hand side dense matrix of the addition expression
183  , rhs_( rhs ) // Right-hand side sparse matrix of the addition expression
184  {
185  BLAZE_INTERNAL_ASSERT( lhs.rows() == rhs.rows() , "Invalid number of rows" );
186  BLAZE_INTERNAL_ASSERT( lhs.columns() == rhs.columns(), "Invalid number of columns" );
187  }
188  //**********************************************************************************************
189 
190  //**Access operator*****************************************************************************
197  inline ReturnType operator()( size_t i, size_t j ) const {
198  BLAZE_INTERNAL_ASSERT( i < lhs_.rows() , "Invalid row access index" );
199  BLAZE_INTERNAL_ASSERT( j < lhs_.columns(), "Invalid column access index" );
200  return lhs_(i,j) + rhs_(i,j);
201  }
202  //**********************************************************************************************
203 
204  //**At function*********************************************************************************
212  inline ReturnType at( size_t i, size_t j ) const {
213  if( i >= lhs_.rows() ) {
214  BLAZE_THROW_OUT_OF_RANGE( "Invalid row access index" );
215  }
216  if( j >= lhs_.columns() ) {
217  BLAZE_THROW_OUT_OF_RANGE( "Invalid column access index" );
218  }
219  return (*this)(i,j);
220  }
221  //**********************************************************************************************
222 
223  //**Rows function*******************************************************************************
228  inline size_t rows() const noexcept {
229  return lhs_.rows();
230  }
231  //**********************************************************************************************
232 
233  //**Columns function****************************************************************************
238  inline size_t columns() const noexcept {
239  return lhs_.columns();
240  }
241  //**********************************************************************************************
242 
243  //**Left operand access*************************************************************************
248  inline LeftOperand leftOperand() const {
249  return lhs_;
250  }
251  //**********************************************************************************************
252 
253  //**Right operand access************************************************************************
258  inline RightOperand rightOperand() const noexcept {
259  return rhs_;
260  }
261  //**********************************************************************************************
262 
263  //**********************************************************************************************
269  template< typename T >
270  inline bool canAlias( const T* alias ) const noexcept {
271  return ( IsExpression<MT1>::value && lhs_.canAlias( alias ) ) ||
272  ( rhs_.canAlias( alias ) );
273  }
274  //**********************************************************************************************
275 
276  //**********************************************************************************************
282  template< typename T >
283  inline bool isAliased( const T* alias ) const noexcept {
284  return ( lhs_.isAliased( alias ) || rhs_.isAliased( alias ) );
285  }
286  //**********************************************************************************************
287 
288  private:
289  //**Member variables****************************************************************************
290  LeftOperand lhs_;
291  RightOperand rhs_;
292  //**********************************************************************************************
293 
294  //**Assignment to dense matrices****************************************************************
306  template< typename MT // Type of the target dense matrix
307  , bool SO2 > // Storage order of the target dense matrix
308  friend inline void assign( DenseMatrix<MT,SO2>& lhs, const DMatSMatAddExpr& rhs )
309  {
311 
312  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
313  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
314 
315  if( !IsExpression<MT1>::value && isSame( ~lhs, rhs.lhs_ ) ) {
316  addAssign( ~lhs, rhs.rhs_ );
317  }
318  else {
319  assign ( ~lhs, rhs.lhs_ );
320  addAssign( ~lhs, rhs.rhs_ );
321  }
322  }
324  //**********************************************************************************************
325 
326  //**Assignment to sparse matrices***************************************************************
338  template< typename MT // Type of the target sparse matrix
339  , bool SO2 > // Storage order of the target sparse matrix
340  friend inline void assign( SparseMatrix<MT,SO2>& lhs, const DMatSMatAddExpr& rhs )
341  {
343 
345 
352 
353  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
354  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
355 
356  const TmpType tmp( serial( rhs ) );
357  assign( ~lhs, tmp );
358  }
360  //**********************************************************************************************
361 
362  //**Addition assignment to dense matrices*******************************************************
374  template< typename MT // Type of the target dense matrix
375  , bool SO2 > // Storage order of the target dense matrix
376  friend inline void addAssign( DenseMatrix<MT,SO2>& lhs, const DMatSMatAddExpr& rhs )
377  {
379 
380  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
381  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
382 
383  addAssign( ~lhs, rhs.lhs_ );
384  addAssign( ~lhs, rhs.rhs_ );
385  }
387  //**********************************************************************************************
388 
389  //**Addition assignment to sparse matrices******************************************************
390  // No special implementation for the addition assignment to sparse matrices.
391  //**********************************************************************************************
392 
393  //**Subtraction assignment to dense matrices****************************************************
405  template< typename MT // Type of the target dense matrix
406  , bool SO2 > // Storage order of the target dense matrix
407  friend inline void subAssign( DenseMatrix<MT,SO2>& lhs, const DMatSMatAddExpr& 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  subAssign( ~lhs, rhs.lhs_ );
415  subAssign( ~lhs, rhs.rhs_ );
416  }
418  //**********************************************************************************************
419 
420  //**Subtraction assignment to sparse matrices***************************************************
421  // No special implementation for the subtraction assignment to sparse matrices.
422  //**********************************************************************************************
423 
424  //**Multiplication assignment to dense matrices*************************************************
425  // No special implementation for the multiplication assignment to dense matrices.
426  //**********************************************************************************************
427 
428  //**Multiplication assignment to sparse matrices************************************************
429  // No special implementation for the multiplication assignment to sparse matrices.
430  //**********************************************************************************************
431 
432  //**SMP assignment to dense matrices************************************************************
446  template< typename MT // Type of the target dense matrix
447  , bool SO2 > // Storage order of the target dense matrix
448  friend inline EnableIf_< UseSMPAssign<MT> >
449  smpAssign( DenseMatrix<MT,SO2>& lhs, const DMatSMatAddExpr& rhs )
450  {
452 
453  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
454  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
455 
456  if( !IsExpression<MT1>::value && isSame( ~lhs, rhs.lhs_ ) ) {
457  smpAddAssign( ~lhs, rhs.rhs_ );
458  }
459  else {
460  smpAssign ( ~lhs, rhs.lhs_ );
461  smpAddAssign( ~lhs, rhs.rhs_ );
462  }
463  }
465  //**********************************************************************************************
466 
467  //**SMP assignment to sparse matrices***********************************************************
481  template< typename MT // Type of the target sparse matrix
482  , bool SO2 > // Storage order of the target sparse matrix
483  friend inline EnableIf_< UseSMPAssign<MT> >
484  smpAssign( SparseMatrix<MT,SO2>& lhs, const DMatSMatAddExpr& rhs )
485  {
487 
488  typedef IfTrue_< SO == SO2, ResultType, OppositeType > TmpType;
489 
495  BLAZE_CONSTRAINT_MUST_BE_REFERENCE_TYPE( CompositeType_<TmpType> );
496 
497  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
498  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
499 
500  const TmpType tmp( rhs );
501  smpAssign( ~lhs, tmp );
502  }
504  //**********************************************************************************************
505 
506  //**SMP addition assignment to dense matrices***************************************************
520  template< typename MT // Type of the target dense matrix
521  , bool SO2 > // Storage order of the target dense matrix
522  friend inline EnableIf_< UseSMPAssign<MT> >
523  smpAddAssign( DenseMatrix<MT,SO2>& lhs, const DMatSMatAddExpr& rhs )
524  {
526 
527  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
528  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
529 
530  smpAddAssign( ~lhs, rhs.lhs_ );
531  smpAddAssign( ~lhs, rhs.rhs_ );
532  }
534  //**********************************************************************************************
535 
536  //**SMP addition assignment to sparse matrices**************************************************
537  // No special implementation for the SMP addition assignment to sparse matrices.
538  //**********************************************************************************************
539 
540  //**SMP subtraction assignment to dense matrices************************************************
554  template< typename MT // Type of the target dense matrix
555  , bool SO2 > // Storage order of the target dense matrix
556  friend inline EnableIf_< UseSMPAssign<MT> >
557  smpSubAssign( DenseMatrix<MT,SO2>& lhs, const DMatSMatAddExpr& rhs )
558  {
560 
561  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
562  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
563 
564  smpSubAssign( ~lhs, rhs.lhs_ );
565  smpSubAssign( ~lhs, rhs.rhs_ );
566  }
568  //**********************************************************************************************
569 
570  //**SMP subtraction assignment to sparse matrices***********************************************
571  // No special implementation for the SMP subtraction assignment to sparse matrices.
572  //**********************************************************************************************
573 
574  //**SMP multiplication assignment to dense matrices*********************************************
575  // No special implementation for the SMP multiplication assignment to dense matrices.
576  //**********************************************************************************************
577 
578  //**SMP multiplication assignment to sparse matrices********************************************
579  // No special implementation for the SMP multiplication assignment to sparse matrices.
580  //**********************************************************************************************
581 
582  //**Compile time checks*************************************************************************
589  //**********************************************************************************************
590 };
591 //*************************************************************************************************
592 
593 
594 
595 
596 //=================================================================================================
597 //
598 // GLOBAL BINARY ARITHMETIC OPERATORS
599 //
600 //=================================================================================================
601 
602 //*************************************************************************************************
628 template< typename T1 // Type of the left-hand side dense matrix
629  , typename T2 // Type of the right-hand side sparse matrix
630  , bool SO > // Storage order
631 inline const DMatSMatAddExpr<T1,T2,SO>
633 {
635 
636  if( (~lhs).rows() != (~rhs).rows() || (~lhs).columns() != (~rhs).columns() ) {
637  BLAZE_THROW_INVALID_ARGUMENT( "Matrix sizes do not match" );
638  }
639 
640  return DMatSMatAddExpr<T1,T2,SO>( ~lhs, ~rhs );
641 }
642 //*************************************************************************************************
643 
644 
645 //*************************************************************************************************
671 template< typename T1 // Type of the left-hand side sparse matrix
672  , typename T2 // Type of the right-hand side dense matrix
673  , bool SO > // Storage order
674 inline const DMatSMatAddExpr<T2,T1,SO>
676 {
678 
679  if( (~lhs).rows() != (~rhs).rows() || (~lhs).columns() != (~rhs).columns() ) {
680  BLAZE_THROW_INVALID_ARGUMENT( "Matrix sizes do not match" );
681  }
682 
683  return DMatSMatAddExpr<T2,T1,SO>( ~rhs, ~lhs );
684 }
685 //*************************************************************************************************
686 
687 
688 
689 
690 //=================================================================================================
691 //
692 // GLOBAL RESTRUCTURING BINARY ARITHMETIC OPERATORS
693 //
694 //=================================================================================================
695 
696 //*************************************************************************************************
709 template< typename T1 // Type of the dense matrix of the left-hand side expression
710  , typename T2 // Type of the sparse matrix of the left-hand side expression
711  , bool SO1 // Storage order of the left-hand side expression
712  , typename T3 // Type of the right-hand side dense matrix
713  , bool SO2 > // Storage order of the right-hand side dense matrix
714 inline const AddExprTrait_< DMatSMatAddExpr<T1,T2,SO1>, T3 >
715  operator+( const DMatSMatAddExpr<T1,T2,SO1>& lhs, const DenseMatrix<T3,SO2>& rhs )
716 {
718 
719  return ( lhs.leftOperand() + (~rhs) ) + lhs.rightOperand();
720 }
722 //*************************************************************************************************
723 
724 
725 //*************************************************************************************************
738 template< typename T1 // Type of the dense matrix of the left-hand side expression
739  , typename T2 // Type of the sparse matrix of the left-hand side expression
740  , bool SO1 // Storage order of the left-hand side expression
741  , typename T3 // Type of the right-hand side dense matrix
742  , bool SO2 > // Storage order of the right-hand side dense matrix
743 inline const SubExprTrait_< DMatSMatAddExpr<T1,T2,SO1>, T3 >
744  operator-( const DMatSMatAddExpr<T1,T2,SO1>& lhs, const DenseMatrix<T3,SO2>& rhs )
745 {
747 
748  return ( lhs.leftOperand() - (~rhs) ) + lhs.rightOperand();
749 }
751 //*************************************************************************************************
752 
753 
754 
755 
756 //=================================================================================================
757 //
758 // ROWS SPECIALIZATIONS
759 //
760 //=================================================================================================
761 
762 //*************************************************************************************************
764 template< typename MT1, typename MT2, bool SO >
765 struct Rows< DMatSMatAddExpr<MT1,MT2,SO> >
766  : public Max< Rows<MT1>, Rows<MT2> >
767 {};
769 //*************************************************************************************************
770 
771 
772 
773 
774 //=================================================================================================
775 //
776 // COLUMNS SPECIALIZATIONS
777 //
778 //=================================================================================================
779 
780 //*************************************************************************************************
782 template< typename MT1, typename MT2, bool SO >
783 struct Columns< DMatSMatAddExpr<MT1,MT2,SO> >
784  : public Max< Columns<MT1>, Columns<MT2> >
785 {};
787 //*************************************************************************************************
788 
789 
790 
791 
792 //=================================================================================================
793 //
794 // ISSYMMETRIC SPECIALIZATIONS
795 //
796 //=================================================================================================
797 
798 //*************************************************************************************************
800 template< typename MT1, typename MT2, bool SO >
801 struct IsSymmetric< DMatSMatAddExpr<MT1,MT2,SO> >
802  : public BoolConstant< IsSymmetric<MT1>::value && IsSymmetric<MT2>::value >
803 {};
805 //*************************************************************************************************
806 
807 
808 
809 
810 //=================================================================================================
811 //
812 // ISHERMITIAN SPECIALIZATIONS
813 //
814 //=================================================================================================
815 
816 //*************************************************************************************************
818 template< typename MT1, typename MT2, bool SO >
819 struct IsHermitian< DMatSMatAddExpr<MT1,MT2,SO> >
820  : public BoolConstant< IsHermitian<MT1>::value && IsHermitian<MT2>::value >
821 {};
823 //*************************************************************************************************
824 
825 
826 
827 
828 //=================================================================================================
829 //
830 // ISLOWER SPECIALIZATIONS
831 //
832 //=================================================================================================
833 
834 //*************************************************************************************************
836 template< typename MT1, typename MT2, bool SO >
837 struct IsLower< DMatSMatAddExpr<MT1,MT2,SO> >
838  : public BoolConstant< And< IsLower<MT1>, IsLower<MT2> >::value >
839 {};
841 //*************************************************************************************************
842 
843 
844 
845 
846 //=================================================================================================
847 //
848 // ISUNILOWER SPECIALIZATIONS
849 //
850 //=================================================================================================
851 
852 //*************************************************************************************************
854 template< typename MT1, typename MT2, bool SO >
855 struct IsUniLower< DMatSMatAddExpr<MT1,MT2,SO> >
856  : public BoolConstant< Or< And< IsUniLower<MT1>, IsStrictlyLower<MT2> >
857  , And< IsUniLower<MT2>, IsStrictlyLower<MT1> > >::value >
858 {};
860 //*************************************************************************************************
861 
862 
863 
864 
865 //=================================================================================================
866 //
867 // ISSTRICTLYLOWER SPECIALIZATIONS
868 //
869 //=================================================================================================
870 
871 //*************************************************************************************************
873 template< typename MT1, typename MT2, bool SO >
874 struct IsStrictlyLower< DMatSMatAddExpr<MT1,MT2,SO> >
875  : public BoolConstant< And< IsStrictlyLower<MT1>, IsStrictlyLower<MT2> >::value >
876 {};
878 //*************************************************************************************************
879 
880 
881 
882 
883 //=================================================================================================
884 //
885 // ISUPPER SPECIALIZATIONS
886 //
887 //=================================================================================================
888 
889 //*************************************************************************************************
891 template< typename MT1, typename MT2, bool SO >
892 struct IsUpper< DMatSMatAddExpr<MT1,MT2,SO> >
893  : public BoolConstant< And< IsUpper<MT1>, IsUpper<MT2> >::value >
894 {};
896 //*************************************************************************************************
897 
898 
899 
900 
901 //=================================================================================================
902 //
903 // ISUNIUPPER SPECIALIZATIONS
904 //
905 //=================================================================================================
906 
907 //*************************************************************************************************
909 template< typename MT1, typename MT2, bool SO >
910 struct IsUniUpper< DMatSMatAddExpr<MT1,MT2,SO> >
911  : public BoolConstant< Or< And< IsUniUpper<MT1>, IsStrictlyUpper<MT2> >
912  , And< IsUniUpper<MT2>, IsStrictlyUpper<MT1> > >::value >
913 {};
915 //*************************************************************************************************
916 
917 
918 
919 
920 //=================================================================================================
921 //
922 // ISSTRICTLYUPPER SPECIALIZATIONS
923 //
924 //=================================================================================================
925 
926 //*************************************************************************************************
928 template< typename MT1, typename MT2, bool SO >
929 struct IsStrictlyUpper< DMatSMatAddExpr<MT1,MT2,SO> >
930  : public BoolConstant< And< IsStrictlyUpper<MT1>, IsStrictlyUpper<MT2> >::value >
931 {};
933 //*************************************************************************************************
934 
935 
936 
937 
938 //=================================================================================================
939 //
940 // EXPRESSION TRAIT SPECIALIZATIONS
941 //
942 //=================================================================================================
943 
944 //*************************************************************************************************
946 template< typename MT1, typename MT2, typename MT3 >
947 struct DMatDMatAddExprTrait< DMatSMatAddExpr<MT1,MT2,false>, MT3 >
948 {
949  public:
950  //**********************************************************************************************
952  using Type = If_< And< IsDenseMatrix<MT1>, IsRowMajorMatrix<MT1>
953  , IsSparseMatrix<MT2>, IsRowMajorMatrix<MT2>
954  , IsDenseMatrix<MT3>, IsRowMajorMatrix<MT3> >
955  , DMatSMatAddExprTrait_< DMatDMatAddExprTrait_<MT1,MT3>, MT2 >
956  , INVALID_TYPE >;
958  //**********************************************************************************************
959 };
961 //*************************************************************************************************
962 
963 
964 //*************************************************************************************************
966 template< typename MT1, typename MT2, typename MT3 >
967 struct DMatTDMatAddExprTrait< DMatSMatAddExpr<MT1,MT2,false>, MT3 >
968 {
969  public:
970  //**********************************************************************************************
972  using Type = If_< And< IsDenseMatrix <MT1>, IsRowMajorMatrix<MT1>
973  , IsSparseMatrix<MT2>, IsRowMajorMatrix<MT2>
974  , IsDenseMatrix <MT3>, IsColumnMajorMatrix<MT3> >
975  , DMatSMatAddExprTrait_< DMatTDMatAddExprTrait_<MT1,MT3>, MT2 >
976  , INVALID_TYPE >;
978  //**********************************************************************************************
979 };
981 //*************************************************************************************************
982 
983 
984 //*************************************************************************************************
986 template< typename MT1, typename MT2, typename MT3 >
987 struct TDMatDMatAddExprTrait< DMatSMatAddExpr<MT1,MT2,true>, MT3 >
988 {
989  public:
990  //**********************************************************************************************
992  using Type = If_< And< IsDenseMatrix <MT1>, IsColumnMajorMatrix<MT1>
993  , IsSparseMatrix<MT2>, IsColumnMajorMatrix<MT2>
994  , IsDenseMatrix <MT3>, IsRowMajorMatrix<MT3> >
995  , DMatTSMatAddExprTrait_< TDMatDMatAddExprTrait_<MT1,MT3>, MT2 >
996  , INVALID_TYPE >;
998  //**********************************************************************************************
999 };
1001 //*************************************************************************************************
1002 
1003 
1004 //*************************************************************************************************
1006 template< typename MT1, typename MT2, typename MT3 >
1007 struct TDMatTDMatAddExprTrait< DMatSMatAddExpr<MT1,MT2,true>, MT3 >
1008 {
1009  public:
1010  //**********************************************************************************************
1012  using Type = If_< And< IsDenseMatrix <MT1>, IsColumnMajorMatrix<MT1>
1013  , IsSparseMatrix<MT2>, IsColumnMajorMatrix<MT2>
1014  , IsDenseMatrix <MT3>, IsColumnMajorMatrix<MT3> >
1015  , TDMatTSMatAddExprTrait_< TDMatTDMatAddExprTrait_<MT1,MT3>, MT2 >
1016  , INVALID_TYPE >;
1018  //**********************************************************************************************
1019 };
1021 //*************************************************************************************************
1022 
1023 
1024 //*************************************************************************************************
1026 template< typename MT1, typename MT2, typename MT3 >
1027 struct DMatDMatSubExprTrait< DMatSMatAddExpr<MT1,MT2,false>, MT3 >
1028 {
1029  public:
1030  //**********************************************************************************************
1032  using Type = If_< And< IsDenseMatrix<MT1>, IsRowMajorMatrix<MT1>
1033  , IsSparseMatrix<MT2>, IsRowMajorMatrix<MT2>
1034  , IsDenseMatrix<MT3>, IsRowMajorMatrix<MT3> >
1035  , DMatSMatAddExprTrait_< DMatDMatSubExprTrait_<MT1,MT3>, MT2 >
1036  , INVALID_TYPE >;
1038  //**********************************************************************************************
1039 };
1041 //*************************************************************************************************
1042 
1043 
1044 //*************************************************************************************************
1046 template< typename MT1, typename MT2, typename MT3 >
1047 struct DMatTDMatSubExprTrait< DMatSMatAddExpr<MT1,MT2,false>, MT3 >
1048 {
1049  public:
1050  //**********************************************************************************************
1052  using Type = If_< And< IsDenseMatrix<MT1>, IsRowMajorMatrix<MT1>
1053  , IsSparseMatrix<MT2>, IsRowMajorMatrix<MT2>
1054  , IsDenseMatrix<MT3>, IsColumnMajorMatrix<MT3> >
1055  , DMatSMatAddExprTrait_< DMatTDMatSubExprTrait_<MT1,MT3>, MT2 >
1056  , INVALID_TYPE >;
1058  //**********************************************************************************************
1059 };
1061 //*************************************************************************************************
1062 
1063 
1064 //*************************************************************************************************
1066 template< typename MT1, typename MT2, typename MT3 >
1067 struct TDMatDMatSubExprTrait< DMatSMatAddExpr<MT1,MT2,true>, MT3 >
1068 {
1069  public:
1070  //**********************************************************************************************
1072  using Type = If_< And< IsDenseMatrix<MT1>, IsColumnMajorMatrix<MT1>
1073  , IsSparseMatrix<MT2>, IsColumnMajorMatrix<MT2>
1074  , IsDenseMatrix<MT3>, IsRowMajorMatrix<MT3> >
1075  , DMatTSMatAddExprTrait_< TDMatDMatSubExprTrait_<MT1,MT3>, MT2 >
1076  , INVALID_TYPE >;
1078  //**********************************************************************************************
1079 };
1081 //*************************************************************************************************
1082 
1083 
1084 //*************************************************************************************************
1086 template< typename MT1, typename MT2, typename MT3 >
1087 struct TDMatTDMatSubExprTrait< DMatSMatAddExpr<MT1,MT2,true>, MT3 >
1088 {
1089  public:
1090  //**********************************************************************************************
1092  using Type = If_< And< IsDenseMatrix<MT1>, IsColumnMajorMatrix<MT1>
1093  , IsSparseMatrix<MT2>, IsColumnMajorMatrix<MT2>
1094  , IsDenseMatrix<MT3>, IsColumnMajorMatrix<MT3> >
1095  , TDMatTSMatAddExprTrait_< TDMatTDMatSubExprTrait_<MT1,MT3>, MT2 >
1096  , INVALID_TYPE >;
1098  //**********************************************************************************************
1099 };
1101 //*************************************************************************************************
1102 
1103 
1104 //*************************************************************************************************
1106 template< typename MT1, typename MT2, bool SO, bool AF >
1107 struct SubmatrixExprTrait< DMatSMatAddExpr<MT1,MT2,SO>, AF >
1108 {
1109  public:
1110  //**********************************************************************************************
1111  using Type = AddExprTrait_< SubmatrixExprTrait_<const MT1,AF>
1112  , SubmatrixExprTrait_<const MT2,AF> >;
1113  //**********************************************************************************************
1114 };
1116 //*************************************************************************************************
1117 
1118 
1119 //*************************************************************************************************
1121 template< typename MT1, typename MT2, bool SO >
1122 struct RowExprTrait< DMatSMatAddExpr<MT1,MT2,SO> >
1123 {
1124  public:
1125  //**********************************************************************************************
1126  using Type = AddExprTrait_< RowExprTrait_<const MT1>
1127  , RowExprTrait_<const MT2> >;
1128  //**********************************************************************************************
1129 };
1131 //*************************************************************************************************
1132 
1133 
1134 //*************************************************************************************************
1136 template< typename MT1, typename MT2, bool SO >
1137 struct ColumnExprTrait< DMatSMatAddExpr<MT1,MT2,SO> >
1138 {
1139  public:
1140  //**********************************************************************************************
1141  using Type = AddExprTrait_< ColumnExprTrait_<const MT1>
1142  , ColumnExprTrait_<const MT2> >;
1143  //**********************************************************************************************
1144 };
1146 //*************************************************************************************************
1147 
1148 } // namespace blaze
1149 
1150 #endif
#define BLAZE_THROW_INVALID_ARGUMENT(MESSAGE)
Macro for the emission of a std::invalid_argument exception.This macro encapsulates the default way o...
Definition: Exception.h:235
ReturnType operator()(size_t i, size_t j) const
2D-access to the matrix elements.
Definition: DMatSMatAddExpr.h:197
Header file for auxiliary alias declarations.
Header file for the Max class template.
LeftOperand lhs_
Left-hand side dense matrix of the addition expression.
Definition: DMatSMatAddExpr.h:290
Compile time check whether the given type is a temporary vector or matrix type.This type trait class ...
Definition: IsTemporary.h:70
Header file for the Rows type trait.
Header file for the IsUniUpper type trait.
BLAZE_ALWAYS_INLINE bool isSame(const Matrix< MT1, SO1 > &a, const Matrix< MT2, SO2 > &b) noexcept
Returns whether the two given matrices represent the same observable state.
Definition: Matrix.h:653
Header file for basic type definitions.
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
Header file for the IsSparseMatrix type trait.
Header file for the serial shim.
#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
#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.
bool isAliased(const T *alias) const noexcept
Returns whether the expression is aliased with the given address alias.
Definition: DMatSMatAddExpr.h:283
const DenseIterator< Type, AF > operator+(const DenseIterator< Type, AF > &it, ptrdiff_t inc) noexcept
Addition between a DenseIterator and an integral value.
Definition: DenseIterator.h:699
ReturnType_< MT2 > RN2
Return type of the right-hand side sparse matrix expression.
Definition: DMatSMatAddExpr.h:116
Header file for the And class template.
ReturnType at(size_t i, size_t j) const
Checked access to the matrix elements.
Definition: DMatSMatAddExpr.h:212
If_< IsExpression< MT1 >, const MT1, const MT1 & > LeftOperand
Composite type of the left-hand side dense matrix expression.
Definition: DMatSMatAddExpr.h:161
Header file for the AddExprTrait class template.
const DMatSerialExpr< MT, SO > serial(const DenseMatrix< MT, SO > &dm)
Forces the serial evaluation of the given dense matrix expression dm.
Definition: DMatSerialExpr.h:723
Header file for the Computation base class.
const DenseIterator< Type, AF > operator-(const DenseIterator< Type, AF > &it, ptrdiff_t inc) noexcept
Subtraction between a DenseIterator and an integral value.
Definition: DenseIterator.h:731
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:70
Base class for sparse matrices.The SparseMatrix class is a base class for all sparse matrix classes...
Definition: Forward.h:109
Constraint on the data type.
typename IfTrue< Condition, T1, T2 >::Type IfTrue_
Auxiliary alias declaration for the IfTrue class template.The IfTrue_ alias declaration provides a co...
Definition: If.h:109
const IfTrue_< returnExpr, ExprReturnType, ElementType > ReturnType
Return type for expression template evaluations.
Definition: DMatSMatAddExpr.h:155
typename T::ReturnType ReturnType_
Alias declaration for nested ReturnType type definitions.The ReturnType_ alias declaration provides a...
Definition: Aliases.h:343
RightOperand rhs_
Right-hand side sparse matrix of the addition expression.
Definition: DMatSMatAddExpr.h:291
Constraint on the data type.
Constraint on the data type.
typename T::CompositeType CompositeType_
Alias declaration for nested CompositeType type definitions.The CompositeType_ alias declaration prov...
Definition: Aliases.h:83
Header file for the IsTemporary type trait class.
Header file for the IsStrictlyUpper type trait.
Header file for the IsSymmetric type trait.
typename AddExprTrait< T1, T2 >::Type AddExprTrait_
Auxiliary alias declaration for the AddExprTrait class template.The AddExprTrait_ alias declaration p...
Definition: AddExprTrait.h:219
Namespace of the Blaze C++ math library.
Definition: Blaze.h:57
RightOperand rightOperand() const noexcept
Returns the right-hand side sparse matrix operand.
Definition: DMatSMatAddExpr.h:258
Header file for the If class template.
EnableIf_< IsDenseMatrix< MT1 > > smpAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the SMP assignment of a matrix to a dense matrix.
Definition: DenseMatrix.h:98
Header file for the Or class template.
#define BLAZE_THROW_OUT_OF_RANGE(MESSAGE)
Macro for the emission of a std::out_of_range exception.This macro encapsulates the default way of Bl...
Definition: Exception.h:331
Header file for the DenseMatrix base class.
Header file for the Columns type trait.
DMatSMatAddExpr< MT1, MT2, SO > This
Type of this DMatSMatAddExpr instance.
Definition: DMatSMatAddExpr.h:148
typename T::ElementType ElementType_
Alias declaration for nested ElementType type definitions.The ElementType_ alias declaration provides...
Definition: Aliases.h:163
Base class for all matrix/matrix addition expression templates.The MatMatAddExpr class serves as a ta...
Definition: MatMatAddExpr.h:65
size_t columns() const noexcept
Returns the current number of columns of the matrix.
Definition: DMatSMatAddExpr.h:238
Header file for the IsLower type trait.
bool canAlias(const T *alias) const noexcept
Returns whether the expression can alias with the given address alias.
Definition: DMatSMatAddExpr.h:270
AddExprTrait_< RN1, RN2 > ExprReturnType
Expression return type for the subscript operator.
Definition: DMatSMatAddExpr.h:129
TransposeType_< ResultType > TransposeType
Transpose type for expression template evaluations.
Definition: DMatSMatAddExpr.h:151
#define BLAZE_CONSTRAINT_MUST_BE_REFERENCE_TYPE(T)
Constraint on the data type.In case the given data type T is not a reference type, a compilation error is created.
Definition: Reference.h:60
const ResultType CompositeType
Data type for composite expression templates.
Definition: DMatSMatAddExpr.h:158
Constraints on the storage order of matrix types.
Header file for the exception macros of the math module.
#define BLAZE_CONSTRAINT_MUST_FORM_VALID_MATMATADDEXPR(T1, T2)
Constraint on the data type.In case the given data types T1 and T2 do not form a valid matrix/matrix ...
Definition: MatMatAddExpr.h:109
Header file for the RowExprTrait class template.
Header file for all forward declarations for expression class templates.
ResultType_< MT1 > RT1
Result type of the left-hand side dense matrix expression.
Definition: DMatSMatAddExpr.h:113
Header file for the IsDenseMatrix type trait.
Header file for the EnableIf class template.
Header file for the IsStrictlyLower type trait.
DMatSMatAddExpr(const MT1 &lhs, const MT2 &rhs) noexcept
Constructor for the DMatSMatAddExpr class.
Definition: DMatSMatAddExpr.h:181
Header file for the SubmatrixExprTrait class template.
Header file for run time assertion macros.
Utility type for generic codes.
If_< IsExpression< MT2 >, const MT2, const MT2 & > RightOperand
Composite type of the right-hand side sparse matrix expression.
Definition: DMatSMatAddExpr.h:164
Header file for the addition trait.
ReturnType_< MT1 > RN1
Return type of the left-hand side dense matrix expression.
Definition: DMatSMatAddExpr.h:115
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
Constraint on the data type.
OppositeType_< ResultType > OppositeType
Result type with opposite storage order for expression template evaluations.
Definition: DMatSMatAddExpr.h:150
Header file for the MatMatAddExpr base class.
IntegralConstant< bool, B > BoolConstant
Generic wrapper for a compile time constant boolean value.The BoolConstant class template represents ...
Definition: IntegralConstant.h:100
typename T::OppositeType OppositeType_
Alias declaration for nested OppositeType type definitions.The OppositeType_ alias declaration provid...
Definition: Aliases.h:243
#define BLAZE_CONSTRAINT_MATRICES_MUST_HAVE_SAME_STORAGE_ORDER(T1, T2)
Constraint on the data type.In case either of the two given data types T1 or T2 is not a matrix type ...
Definition: StorageOrder.h:84
LeftOperand leftOperand() const
Returns the left-hand side dense matrix operand.
Definition: DMatSMatAddExpr.h:248
Header file for the IsRowMajorMatrix type trait.
Expression object for dense matrix-sparse matrix additions.The DMatSMatAddExpr class represents the c...
Definition: DMatSMatAddExpr.h:107
size_t rows() const noexcept
Returns the current number of rows of the matrix.
Definition: DMatSMatAddExpr.h:228
Base class for all compute expression templates.The Computation class serves as a tag for all computa...
Definition: Computation.h:59
#define BLAZE_FUNCTION_TRACE
Function trace macro.This macro can be used to reliably trace function calls. In case function tracin...
Definition: FunctionTrace.h:157
Header file for the IntegralConstant class template.
AddTrait_< RT1, RT2 > ResultType
Result type for expression template evaluations.
Definition: DMatSMatAddExpr.h:149
ElementType_< ResultType > ElementType
Resulting element type.
Definition: DMatSMatAddExpr.h:152
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.
Header file for the IsHermitian type trait.
Header file for the SubExprTrait class template.
ResultType_< MT2 > RT2
Result type of the right-hand side sparse matrix expression.
Definition: DMatSMatAddExpr.h:114
typename AddTrait< T1, T2 >::Type AddTrait_
Auxiliary alias declaration for the AddTrait class template.The AddTrait_ alias declaration provides ...
Definition: AddTrait.h:245
#define BLAZE_INTERNAL_ASSERT(expr, msg)
Run time assertion macro for internal checks.In case of an invalid run time expression, the program execution is terminated. The BLAZE_INTERNAL_ASSERT macro can be disabled by setting the BLAZE_USER_ASSERTION flag to zero or by defining NDEBUG during the compilation.
Definition: Assert.h:101
#define BLAZE_CONSTRAINT_MUST_BE_SPARSE_MATRIX_TYPE(T)
Constraint on the data type.In case the given data type T is not a sparse, N-dimensional matrix type...
Definition: SparseMatrix.h:61
Compile time check whether the given type is an expression template.This type trait class tests wheth...
Definition: IsExpression.h:71
Header file for the IsExpression type trait class.
Header file for the FunctionTrace class.