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 
74 #include <blaze/util/Assert.h>
76 #include <blaze/util/EnableIf.h>
77 #include <blaze/util/Exception.h>
78 #include <blaze/util/InvalidType.h>
80 #include <blaze/util/mpl/And.h>
81 #include <blaze/util/mpl/Max.h>
82 #include <blaze/util/mpl/Or.h>
83 #include <blaze/util/SelectType.h>
84 #include <blaze/util/Types.h>
86 
87 
88 namespace blaze {
89 
90 //=================================================================================================
91 //
92 // CLASS DMATSMATADDEXPR
93 //
94 //=================================================================================================
95 
96 //*************************************************************************************************
103 template< typename MT1 // Type of the left-hand side dense matrix
104  , typename MT2 // Type of the right-hand side sparse matrix
105  , bool SO > // Storage order
106 class DMatSMatAddExpr : public DenseMatrix< DMatSMatAddExpr<MT1,MT2,SO>, SO >
107  , private MatMatAddExpr
108  , private Computation
109 {
110  private:
111  //**Type definitions****************************************************************************
112  typedef typename MT1::ResultType RT1;
113  typedef typename MT2::ResultType RT2;
114  typedef typename MT1::ReturnType RN1;
115  typedef typename MT2::ReturnType RN2;
116  //**********************************************************************************************
117 
118  //**Return type evaluation**********************************************************************
120 
125  enum { returnExpr = !IsTemporary<RN1>::value && !IsTemporary<RN2>::value };
126 
129  //**********************************************************************************************
130 
131  //**Parallel evaluation strategy****************************************************************
133 
138  template< typename MT >
139  struct UseSMPAssign {
140  enum { value = ( !MT1::smpAssignable || !MT2::smpAssignable ) };
141  };
143  //**********************************************************************************************
144 
145  public:
146  //**Type definitions****************************************************************************
152 
155 
157  typedef const ResultType CompositeType;
158 
160  typedef typename SelectType< IsExpression<MT1>::value, const MT1, const MT1& >::Type LeftOperand;
161 
163  typedef typename SelectType< IsExpression<MT2>::value, const MT2, const MT2& >::Type RightOperand;
164  //**********************************************************************************************
165 
166  //**Compilation flags***************************************************************************
168  enum { vectorizable = 0 };
169 
171  enum { smpAssignable = 0 };
172  //**********************************************************************************************
173 
174  //**Constructor*********************************************************************************
180  explicit inline DMatSMatAddExpr( const MT1& lhs, const MT2& rhs )
181  : lhs_( lhs ) // Left-hand side dense matrix of the addition expression
182  , rhs_( rhs ) // Right-hand side sparse matrix of the addition expression
183  {
184  BLAZE_INTERNAL_ASSERT( lhs.rows() == rhs.rows() , "Invalid number of rows" );
185  BLAZE_INTERNAL_ASSERT( lhs.columns() == rhs.columns(), "Invalid number of columns" );
186  }
187  //**********************************************************************************************
188 
189  //**Access operator*****************************************************************************
196  inline ReturnType operator()( size_t i, size_t j ) const {
197  BLAZE_INTERNAL_ASSERT( i < lhs_.rows() , "Invalid row access index" );
198  BLAZE_INTERNAL_ASSERT( j < lhs_.columns(), "Invalid column access index" );
199  return lhs_(i,j) + rhs_(i,j);
200  }
201  //**********************************************************************************************
202 
203  //**At function*********************************************************************************
211  inline ReturnType at( size_t i, size_t j ) const {
212  if( i >= lhs_.rows() ) {
213  BLAZE_THROW_OUT_OF_RANGE( "Invalid row access index" );
214  }
215  if( j >= lhs_.columns() ) {
216  BLAZE_THROW_OUT_OF_RANGE( "Invalid column access index" );
217  }
218  return (*this)(i,j);
219  }
220  //**********************************************************************************************
221 
222  //**Rows function*******************************************************************************
227  inline size_t rows() const {
228  return lhs_.rows();
229  }
230  //**********************************************************************************************
231 
232  //**Columns function****************************************************************************
237  inline size_t columns() const {
238  return lhs_.columns();
239  }
240  //**********************************************************************************************
241 
242  //**Left operand access*************************************************************************
247  inline LeftOperand leftOperand() const {
248  return lhs_;
249  }
250  //**********************************************************************************************
251 
252  //**Right operand access************************************************************************
257  inline RightOperand rightOperand() const {
258  return rhs_;
259  }
260  //**********************************************************************************************
261 
262  //**********************************************************************************************
268  template< typename T >
269  inline bool canAlias( const T* alias ) const {
270  return ( IsExpression<MT1>::value && lhs_.canAlias( alias ) ) ||
271  ( rhs_.canAlias( alias ) );
272  }
273  //**********************************************************************************************
274 
275  //**********************************************************************************************
281  template< typename T >
282  inline bool isAliased( const T* alias ) const {
283  return ( lhs_.isAliased( alias ) || rhs_.isAliased( alias ) );
284  }
285  //**********************************************************************************************
286 
287  private:
288  //**Member variables****************************************************************************
289  LeftOperand lhs_;
290  RightOperand rhs_;
291  //**********************************************************************************************
292 
293  //**Assignment to dense matrices****************************************************************
305  template< typename MT // Type of the target dense matrix
306  , bool SO2 > // Storage order of the target dense matrix
307  friend inline void assign( DenseMatrix<MT,SO2>& lhs, const DMatSMatAddExpr& rhs )
308  {
310 
311  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
312  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
313 
314  if( !IsExpression<MT1>::value && isSame( ~lhs, rhs.lhs_ ) ) {
315  addAssign( ~lhs, rhs.rhs_ );
316  }
317  else {
318  assign ( ~lhs, rhs.lhs_ );
319  addAssign( ~lhs, rhs.rhs_ );
320  }
321  }
323  //**********************************************************************************************
324 
325  //**Assignment to sparse matrices***************************************************************
337  template< typename MT // Type of the target sparse matrix
338  , bool SO2 > // Storage order of the target sparse matrix
339  friend inline void assign( SparseMatrix<MT,SO2>& lhs, const DMatSMatAddExpr& rhs )
340  {
342 
344 
351 
352  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
353  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
354 
355  const TmpType tmp( serial( rhs ) );
356  assign( ~lhs, tmp );
357  }
359  //**********************************************************************************************
360 
361  //**Addition assignment to dense matrices*******************************************************
373  template< typename MT // Type of the target dense matrix
374  , bool SO2 > // Storage order of the target dense matrix
375  friend inline void addAssign( DenseMatrix<MT,SO2>& lhs, const DMatSMatAddExpr& rhs )
376  {
378 
379  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
380  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
381 
382  addAssign( ~lhs, rhs.lhs_ );
383  addAssign( ~lhs, rhs.rhs_ );
384  }
386  //**********************************************************************************************
387 
388  //**Addition assignment to sparse matrices******************************************************
389  // No special implementation for the addition assignment to sparse matrices.
390  //**********************************************************************************************
391 
392  //**Subtraction assignment to dense matrices****************************************************
404  template< typename MT // Type of the target dense matrix
405  , bool SO2 > // Storage order of the target dense matrix
406  friend inline void subAssign( DenseMatrix<MT,SO2>& lhs, const DMatSMatAddExpr& rhs )
407  {
409 
410  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
411  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
412 
413  subAssign( ~lhs, rhs.lhs_ );
414  subAssign( ~lhs, rhs.rhs_ );
415  }
417  //**********************************************************************************************
418 
419  //**Subtraction assignment to sparse matrices***************************************************
420  // No special implementation for the subtraction assignment to sparse matrices.
421  //**********************************************************************************************
422 
423  //**Multiplication assignment to dense matrices*************************************************
424  // No special implementation for the multiplication assignment to dense matrices.
425  //**********************************************************************************************
426 
427  //**Multiplication assignment to sparse matrices************************************************
428  // No special implementation for the multiplication assignment to sparse matrices.
429  //**********************************************************************************************
430 
431  //**SMP assignment to dense matrices************************************************************
445  template< typename MT // Type of the target dense matrix
446  , bool SO2 > // Storage order of the target dense matrix
447  friend inline typename EnableIf< UseSMPAssign<MT> >::Type
448  smpAssign( DenseMatrix<MT,SO2>& lhs, const DMatSMatAddExpr& rhs )
449  {
451 
452  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
453  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
454 
455  if( !IsExpression<MT1>::value && isSame( ~lhs, rhs.lhs_ ) ) {
456  smpAddAssign( ~lhs, rhs.rhs_ );
457  }
458  else {
459  smpAssign ( ~lhs, rhs.lhs_ );
460  smpAddAssign( ~lhs, rhs.rhs_ );
461  }
462  }
464  //**********************************************************************************************
465 
466  //**SMP assignment to sparse matrices***********************************************************
480  template< typename MT // Type of the target sparse matrix
481  , bool SO2 > // Storage order of the target sparse matrix
482  friend inline typename EnableIf< UseSMPAssign<MT> >::Type
483  smpAssign( SparseMatrix<MT,SO2>& lhs, const DMatSMatAddExpr& rhs )
484  {
486 
487  typedef typename SelectType< SO == SO2, ResultType, OppositeType >::Type TmpType;
488 
495 
496  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
497  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
498 
499  const TmpType tmp( rhs );
500  smpAssign( ~lhs, tmp );
501  }
503  //**********************************************************************************************
504 
505  //**SMP addition assignment to dense matrices***************************************************
519  template< typename MT // Type of the target dense matrix
520  , bool SO2 > // Storage order of the target dense matrix
521  friend inline typename EnableIf< UseSMPAssign<MT> >::Type
522  smpAddAssign( DenseMatrix<MT,SO2>& lhs, const DMatSMatAddExpr& rhs )
523  {
525 
526  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
527  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
528 
529  smpAddAssign( ~lhs, rhs.lhs_ );
530  smpAddAssign( ~lhs, rhs.rhs_ );
531  }
533  //**********************************************************************************************
534 
535  //**SMP addition assignment to sparse matrices**************************************************
536  // No special implementation for the SMP addition assignment to sparse matrices.
537  //**********************************************************************************************
538 
539  //**SMP subtraction assignment to dense matrices************************************************
553  template< typename MT // Type of the target dense matrix
554  , bool SO2 > // Storage order of the target dense matrix
555  friend inline typename EnableIf< UseSMPAssign<MT> >::Type
556  smpSubAssign( DenseMatrix<MT,SO2>& lhs, const DMatSMatAddExpr& rhs )
557  {
559 
560  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
561  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
562 
563  smpSubAssign( ~lhs, rhs.lhs_ );
564  smpSubAssign( ~lhs, rhs.rhs_ );
565  }
567  //**********************************************************************************************
568 
569  //**SMP subtraction assignment to sparse matrices***********************************************
570  // No special implementation for the SMP subtraction assignment to sparse matrices.
571  //**********************************************************************************************
572 
573  //**SMP multiplication assignment to dense matrices*********************************************
574  // No special implementation for the SMP multiplication assignment to dense matrices.
575  //**********************************************************************************************
576 
577  //**SMP multiplication assignment to sparse matrices********************************************
578  // No special implementation for the SMP multiplication assignment to sparse matrices.
579  //**********************************************************************************************
580 
581  //**Compile time checks*************************************************************************
588  //**********************************************************************************************
589 };
590 //*************************************************************************************************
591 
592 
593 
594 
595 //=================================================================================================
596 //
597 // GLOBAL BINARY ARITHMETIC OPERATORS
598 //
599 //=================================================================================================
600 
601 //*************************************************************************************************
627 template< typename T1 // Type of the left-hand side dense matrix
628  , typename T2 // Type of the right-hand side sparse matrix
629  , bool SO > // Storage order
630 inline const DMatSMatAddExpr<T1,T2,SO>
632 {
634 
635  if( (~lhs).rows() != (~rhs).rows() || (~lhs).columns() != (~rhs).columns() ) {
636  BLAZE_THROW_INVALID_ARGUMENT( "Matrix sizes do not match" );
637  }
638 
639  return DMatSMatAddExpr<T1,T2,SO>( ~lhs, ~rhs );
640 }
641 //*************************************************************************************************
642 
643 
644 //*************************************************************************************************
670 template< typename T1 // Type of the left-hand side sparse matrix
671  , typename T2 // Type of the right-hand side dense matrix
672  , bool SO > // Storage order
673 inline const DMatSMatAddExpr<T2,T1,SO>
675 {
677 
678  if( (~lhs).rows() != (~rhs).rows() || (~lhs).columns() != (~rhs).columns() ) {
679  BLAZE_THROW_INVALID_ARGUMENT( "Matrix sizes do not match" );
680  }
681 
682  return DMatSMatAddExpr<T2,T1,SO>( ~rhs, ~lhs );
683 }
684 //*************************************************************************************************
685 
686 
687 
688 
689 //=================================================================================================
690 //
691 // GLOBAL RESTRUCTURING BINARY ARITHMETIC OPERATORS
692 //
693 //=================================================================================================
694 
695 //*************************************************************************************************
708 template< typename T1 // Type of the dense matrix of the left-hand side expression
709  , typename T2 // Type of the sparse matrix of the left-hand side expression
710  , bool SO1 // Storage order of the left-hand side expression
711  , typename T3 // Type of the right-hand side dense matrix
712  , bool SO2 > // Storage order of the right-hand side dense matrix
713 inline const typename AddExprTrait< DMatSMatAddExpr<T1,T2,SO1>, T3 >::Type
714  operator+( const DMatSMatAddExpr<T1,T2,SO1>& lhs, const DenseMatrix<T3,SO2>& rhs )
715 {
717 
718  return ( lhs.leftOperand() + (~rhs) ) + lhs.rightOperand();
719 }
721 //*************************************************************************************************
722 
723 
724 //*************************************************************************************************
737 template< typename T1 // Type of the dense matrix of the left-hand side expression
738  , typename T2 // Type of the sparse matrix of the left-hand side expression
739  , bool SO1 // Storage order of the left-hand side expression
740  , typename T3 // Type of the right-hand side dense matrix
741  , bool SO2 > // Storage order of the right-hand side dense matrix
742 inline const typename SubExprTrait< DMatSMatAddExpr<T1,T2,SO1>, T3 >::Type
743  operator-( const DMatSMatAddExpr<T1,T2,SO1>& lhs, const DenseMatrix<T3,SO2>& rhs )
744 {
746 
747  return ( lhs.leftOperand() - (~rhs) ) + lhs.rightOperand();
748 }
750 //*************************************************************************************************
751 
752 
753 
754 
755 //=================================================================================================
756 //
757 // ROWS SPECIALIZATIONS
758 //
759 //=================================================================================================
760 
761 //*************************************************************************************************
763 template< typename MT1, typename MT2, bool SO >
764 struct Rows< DMatSMatAddExpr<MT1,MT2,SO> >
765  : public Max< Rows<MT1>, Rows<MT2> >
766 {};
768 //*************************************************************************************************
769 
770 
771 
772 
773 //=================================================================================================
774 //
775 // COLUMNS SPECIALIZATIONS
776 //
777 //=================================================================================================
778 
779 //*************************************************************************************************
781 template< typename MT1, typename MT2, bool SO >
782 struct Columns< DMatSMatAddExpr<MT1,MT2,SO> >
783  : public Max< Columns<MT1>, Columns<MT2> >
784 {};
786 //*************************************************************************************************
787 
788 
789 
790 
791 //=================================================================================================
792 //
793 // ISSYMMETRIC SPECIALIZATIONS
794 //
795 //=================================================================================================
796 
797 //*************************************************************************************************
799 template< typename MT1, typename MT2, bool SO >
800 struct IsSymmetric< DMatSMatAddExpr<MT1,MT2,SO> >
801  : public IsTrue< IsSymmetric<MT1>::value && IsSymmetric<MT2>::value >
802 {};
804 //*************************************************************************************************
805 
806 
807 
808 
809 //=================================================================================================
810 //
811 // ISHERMITIAN SPECIALIZATIONS
812 //
813 //=================================================================================================
814 
815 //*************************************************************************************************
817 template< typename MT1, typename MT2, bool SO >
818 struct IsHermitian< DMatSMatAddExpr<MT1,MT2,SO> >
819  : public IsTrue< IsHermitian<MT1>::value && IsHermitian<MT2>::value >
820 {};
822 //*************************************************************************************************
823 
824 
825 
826 
827 //=================================================================================================
828 //
829 // ISLOWER SPECIALIZATIONS
830 //
831 //=================================================================================================
832 
833 //*************************************************************************************************
835 template< typename MT1, typename MT2, bool SO >
836 struct IsLower< DMatSMatAddExpr<MT1,MT2,SO> >
837  : public IsTrue< And< IsLower<MT1>, IsLower<MT2> >::value >
838 {};
840 //*************************************************************************************************
841 
842 
843 
844 
845 //=================================================================================================
846 //
847 // ISUNILOWER SPECIALIZATIONS
848 //
849 //=================================================================================================
850 
851 //*************************************************************************************************
853 template< typename MT1, typename MT2, bool SO >
854 struct IsUniLower< DMatSMatAddExpr<MT1,MT2,SO> >
855  : public IsTrue< Or< And< IsUniLower<MT1>, IsStrictlyLower<MT2> >
856  , And< IsUniLower<MT2>, IsStrictlyLower<MT1> > >::value >
857 {};
859 //*************************************************************************************************
860 
861 
862 
863 
864 //=================================================================================================
865 //
866 // ISSTRICTLYLOWER SPECIALIZATIONS
867 //
868 //=================================================================================================
869 
870 //*************************************************************************************************
872 template< typename MT1, typename MT2, bool SO >
873 struct IsStrictlyLower< DMatSMatAddExpr<MT1,MT2,SO> >
874  : public IsTrue< And< IsStrictlyLower<MT1>, IsStrictlyLower<MT2> >::value >
875 {};
877 //*************************************************************************************************
878 
879 
880 
881 
882 //=================================================================================================
883 //
884 // ISUPPER SPECIALIZATIONS
885 //
886 //=================================================================================================
887 
888 //*************************************************************************************************
890 template< typename MT1, typename MT2, bool SO >
891 struct IsUpper< DMatSMatAddExpr<MT1,MT2,SO> >
892  : public IsTrue< And< IsUpper<MT1>, IsUpper<MT2> >::value >
893 {};
895 //*************************************************************************************************
896 
897 
898 
899 
900 //=================================================================================================
901 //
902 // ISUNIUPPER SPECIALIZATIONS
903 //
904 //=================================================================================================
905 
906 //*************************************************************************************************
908 template< typename MT1, typename MT2, bool SO >
909 struct IsUniUpper< DMatSMatAddExpr<MT1,MT2,SO> >
910  : public IsTrue< Or< And< IsUniUpper<MT1>, IsStrictlyUpper<MT2> >
911  , And< IsUniUpper<MT2>, IsStrictlyUpper<MT1> > >::value >
912 {};
914 //*************************************************************************************************
915 
916 
917 
918 
919 //=================================================================================================
920 //
921 // ISSTRICTLYUPPER SPECIALIZATIONS
922 //
923 //=================================================================================================
924 
925 //*************************************************************************************************
927 template< typename MT1, typename MT2, bool SO >
928 struct IsStrictlyUpper< DMatSMatAddExpr<MT1,MT2,SO> >
929  : public IsTrue< And< IsStrictlyUpper<MT1>, IsStrictlyUpper<MT2> >::value >
930 {};
932 //*************************************************************************************************
933 
934 
935 
936 
937 //=================================================================================================
938 //
939 // EXPRESSION TRAIT SPECIALIZATIONS
940 //
941 //=================================================================================================
942 
943 //*************************************************************************************************
945 template< typename MT1, typename MT2, typename MT3 >
946 struct DMatDMatAddExprTrait< DMatSMatAddExpr<MT1,MT2,false>, MT3 >
947 {
948  public:
949  //**********************************************************************************************
951  typedef typename SelectType< IsDenseMatrix<MT1>::value && IsRowMajorMatrix<MT1>::value &&
952  IsSparseMatrix<MT2>::value && IsRowMajorMatrix<MT2>::value &&
953  IsDenseMatrix<MT3>::value && IsRowMajorMatrix<MT3>::value
954  , typename DMatSMatAddExprTrait< typename DMatDMatAddExprTrait<MT1,MT3>::Type, MT2 >::Type
955  , INVALID_TYPE >::Type Type;
957  //**********************************************************************************************
958 };
960 //*************************************************************************************************
961 
962 
963 //*************************************************************************************************
965 template< typename MT1, typename MT2, typename MT3 >
966 struct DMatTDMatAddExprTrait< DMatSMatAddExpr<MT1,MT2,false>, MT3 >
967 {
968  public:
969  //**********************************************************************************************
971  typedef typename SelectType< IsDenseMatrix <MT1>::value && IsRowMajorMatrix<MT1>::value &&
972  IsSparseMatrix<MT2>::value && IsRowMajorMatrix<MT2>::value &&
973  IsDenseMatrix <MT3>::value && IsColumnMajorMatrix<MT3>::value
974  , typename DMatSMatAddExprTrait< typename DMatTDMatAddExprTrait<MT1,MT3>::Type, MT2 >::Type
975  , INVALID_TYPE >::Type Type;
977  //**********************************************************************************************
978 };
980 //*************************************************************************************************
981 
982 
983 //*************************************************************************************************
985 template< typename MT1, typename MT2, typename MT3 >
986 struct TDMatDMatAddExprTrait< DMatSMatAddExpr<MT1,MT2,true>, MT3 >
987 {
988  public:
989  //**********************************************************************************************
991  typedef typename SelectType< IsDenseMatrix <MT1>::value && IsColumnMajorMatrix<MT1>::value &&
992  IsSparseMatrix<MT2>::value && IsColumnMajorMatrix<MT2>::value &&
993  IsDenseMatrix <MT3>::value && IsRowMajorMatrix<MT3>::value
994  , typename DMatTSMatAddExprTrait< typename TDMatDMatAddExprTrait<MT1,MT3>::Type, MT2 >::Type
995  , INVALID_TYPE >::Type Type;
997  //**********************************************************************************************
998 };
1000 //*************************************************************************************************
1001 
1002 
1003 //*************************************************************************************************
1005 template< typename MT1, typename MT2, typename MT3 >
1006 struct TDMatTDMatAddExprTrait< DMatSMatAddExpr<MT1,MT2,true>, MT3 >
1007 {
1008  public:
1009  //**********************************************************************************************
1011  typedef typename SelectType< IsDenseMatrix <MT1>::value && IsColumnMajorMatrix<MT1>::value &&
1012  IsSparseMatrix<MT2>::value && IsColumnMajorMatrix<MT2>::value &&
1013  IsDenseMatrix <MT3>::value && IsColumnMajorMatrix<MT3>::value
1014  , typename TDMatTSMatAddExprTrait< typename TDMatTDMatAddExprTrait<MT1,MT3>::Type, MT2 >::Type
1015  , INVALID_TYPE >::Type Type;
1017  //**********************************************************************************************
1018 };
1020 //*************************************************************************************************
1021 
1022 
1023 //*************************************************************************************************
1025 template< typename MT1, typename MT2, typename MT3 >
1026 struct DMatDMatSubExprTrait< DMatSMatAddExpr<MT1,MT2,false>, MT3 >
1027 {
1028  public:
1029  //**********************************************************************************************
1031  typedef typename SelectType< IsDenseMatrix<MT1>::value && IsRowMajorMatrix<MT1>::value &&
1032  IsSparseMatrix<MT2>::value && IsRowMajorMatrix<MT2>::value &&
1033  IsDenseMatrix<MT3>::value && IsRowMajorMatrix<MT3>::value
1034  , typename DMatSMatAddExprTrait< typename DMatDMatSubExprTrait<MT1,MT3>::Type, MT2 >::Type
1035  , INVALID_TYPE >::Type Type;
1037  //**********************************************************************************************
1038 };
1040 //*************************************************************************************************
1041 
1042 
1043 //*************************************************************************************************
1045 template< typename MT1, typename MT2, typename MT3 >
1046 struct DMatTDMatSubExprTrait< DMatSMatAddExpr<MT1,MT2,false>, MT3 >
1047 {
1048  public:
1049  //**********************************************************************************************
1051  typedef typename SelectType< IsDenseMatrix<MT1>::value && IsRowMajorMatrix<MT1>::value &&
1052  IsSparseMatrix<MT2>::value && IsRowMajorMatrix<MT2>::value &&
1053  IsDenseMatrix<MT3>::value && IsColumnMajorMatrix<MT3>::value
1054  , typename DMatSMatAddExprTrait< typename DMatTDMatSubExprTrait<MT1,MT3>::Type, MT2 >::Type
1055  , INVALID_TYPE >::Type Type;
1057  //**********************************************************************************************
1058 };
1060 //*************************************************************************************************
1061 
1062 
1063 //*************************************************************************************************
1065 template< typename MT1, typename MT2, typename MT3 >
1066 struct TDMatDMatSubExprTrait< DMatSMatAddExpr<MT1,MT2,true>, MT3 >
1067 {
1068  public:
1069  //**********************************************************************************************
1071  typedef typename SelectType< IsDenseMatrix<MT1>::value && IsColumnMajorMatrix<MT1>::value &&
1072  IsSparseMatrix<MT2>::value && IsColumnMajorMatrix<MT2>::value &&
1073  IsDenseMatrix<MT3>::value && IsRowMajorMatrix<MT3>::value
1074  , typename DMatTSMatAddExprTrait< typename TDMatDMatSubExprTrait<MT1,MT3>::Type, MT2 >::Type
1075  , INVALID_TYPE >::Type Type;
1077  //**********************************************************************************************
1078 };
1080 //*************************************************************************************************
1081 
1082 
1083 //*************************************************************************************************
1085 template< typename MT1, typename MT2, typename MT3 >
1086 struct TDMatTDMatSubExprTrait< DMatSMatAddExpr<MT1,MT2,true>, MT3 >
1087 {
1088  public:
1089  //**********************************************************************************************
1091  typedef typename SelectType< IsDenseMatrix<MT1>::value && IsColumnMajorMatrix<MT1>::value &&
1092  IsSparseMatrix<MT2>::value && IsColumnMajorMatrix<MT2>::value &&
1093  IsDenseMatrix<MT3>::value && IsColumnMajorMatrix<MT3>::value
1094  , typename TDMatTSMatAddExprTrait< typename TDMatTDMatSubExprTrait<MT1,MT3>::Type, MT2 >::Type
1095  , INVALID_TYPE >::Type Type;
1097  //**********************************************************************************************
1098 };
1100 //*************************************************************************************************
1101 
1102 
1103 //*************************************************************************************************
1105 template< typename MT1, typename MT2, bool SO, bool AF >
1106 struct SubmatrixExprTrait< DMatSMatAddExpr<MT1,MT2,SO>, AF >
1107 {
1108  public:
1109  //**********************************************************************************************
1110  typedef typename AddExprTrait< typename SubmatrixExprTrait<const MT1,AF>::Type
1111  , typename SubmatrixExprTrait<const MT2,AF>::Type >::Type Type;
1112  //**********************************************************************************************
1113 };
1115 //*************************************************************************************************
1116 
1117 
1118 //*************************************************************************************************
1120 template< typename MT1, typename MT2, bool SO >
1121 struct RowExprTrait< DMatSMatAddExpr<MT1,MT2,SO> >
1122 {
1123  public:
1124  //**********************************************************************************************
1125  typedef typename AddExprTrait< typename RowExprTrait<const MT1>::Type
1126  , typename RowExprTrait<const MT2>::Type >::Type Type;
1127  //**********************************************************************************************
1128 };
1130 //*************************************************************************************************
1131 
1132 
1133 //*************************************************************************************************
1135 template< typename MT1, typename MT2, bool SO >
1136 struct ColumnExprTrait< DMatSMatAddExpr<MT1,MT2,SO> >
1137 {
1138  public:
1139  //**********************************************************************************************
1140  typedef typename AddExprTrait< typename ColumnExprTrait<const MT1>::Type
1141  , typename ColumnExprTrait<const MT2>::Type >::Type Type;
1142  //**********************************************************************************************
1143 };
1145 //*************************************************************************************************
1146 
1147 } // namespace blaze
1148 
1149 #endif
#define BLAZE_THROW_INVALID_ARGUMENT(MESSAGE)
Macro for the emission of a std::invalid_argument exceptionThis macro encapsulates the default way of...
Definition: Exception.h:187
ReturnType operator()(size_t i, size_t j) const
2D-access to the matrix elements.
Definition: DMatSMatAddExpr.h:196
AddTrait< RT1, RT2 >::Type ResultType
Result type for expression template evaluations.
Definition: DMatSMatAddExpr.h:148
Header file for the Max class template.
SelectType< IsExpression< MT2 >::value, const MT2, const MT2 & >::Type RightOperand
Composite type of the right-hand side sparse matrix expression.
Definition: DMatSMatAddExpr.h:163
ResultType::OppositeType OppositeType
Result type with opposite storage order for expression template evaluations.
Definition: DMatSMatAddExpr.h:149
Evaluation of the return type of an addition expression.Via this type trait it is possible to evaluat...
Definition: AddExprTrait.h:104
LeftOperand lhs_
Left-hand side dense matrix of the addition expression.
Definition: DMatSMatAddExpr.h:289
Compile time check whether the given type is a temporary vector or matrix type.This type trait class ...
Definition: IsTemporary.h:87
Header file for the Rows type trait.
Header file for the IsUniUpper type trait.
AddExprTrait< RN1, RN2 >::Type ExprReturnType
Expression return type for the subscript operator.
Definition: DMatSMatAddExpr.h:128
Header file for basic type definitions.
Header file for the IsSparseMatrix type trait.
#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:81
Efficient implementation of a compressed matrix.The CompressedMatrix class template is the represent...
Definition: CompressedMatrix.h:207
#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:79
BLAZE_ALWAYS_INLINE bool isSame(const Matrix< MT1, SO1 > &a, const Matrix< MT2, SO2 > &b)
Returns whether the two given matrices represent the same observable state.
Definition: Matrix.h:647
Header file for the ColumnExprTrait class template.
RightOperand rightOperand() const
Returns the right-hand side sparse matrix operand.
Definition: DMatSMatAddExpr.h:257
Header file for the IsColumnMajorMatrix type trait.
const This & CompositeType
Data type for composite expression templates.
Definition: CompressedMatrix.h:2588
Type ElementType
Type of the sparse matrix elements.
Definition: CompressedMatrix.h:259
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:211
ResultType::ElementType ElementType
Resulting element type.
Definition: DMatSMatAddExpr.h:151
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:721
MT2::ResultType RT2
Result type of the right-hand side sparse matrix expression.
Definition: DMatSMatAddExpr.h:113
Header file for the Computation base class.
MT1::ResultType RT1
Result type of the left-hand side dense matrix expression.
Definition: DMatSMatAddExpr.h:112
Header file for the IsUniLower type trait.
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:117
Constraint on the data type.
RightOperand rhs_
Right-hand side sparse matrix of the addition expression.
Definition: DMatSMatAddExpr.h:290
Constraint on the data type.
Constraint on the data type.
Compile time type selection.The SelectType class template selects one of the two given types T1 and T...
Definition: SelectType.h:59
Header file for the IsTemporary type trait class.
Header file for the IsStrictlyUpper type trait.
Header file for the IsSymmetric type trait.
Namespace of the Blaze C++ math library.
Definition: Blaze.h:57
Header file for the Or class template.
#define BLAZE_THROW_OUT_OF_RANGE(MESSAGE)
Macro for the emission of a std::out_of_range exceptionThis macro encapsulates the default way of Bla...
Definition: Exception.h:331
const DenseIterator< Type, AF > operator+(const DenseIterator< Type, AF > &it, ptrdiff_t inc)
Addition between a DenseIterator and an integral value.
Definition: DenseIterator.h:610
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:147
Base class for all matrix/matrix addition expression templates.The MatMatAddExpr class serves as a ta...
Definition: MatMatAddExpr.h:65
Header file for the IsLower type trait.
size_t rows() const
Returns the current number of rows of the matrix.
Definition: DMatSMatAddExpr.h:227
const DenseIterator< Type, AF > operator-(const DenseIterator< Type, AF > &it, ptrdiff_t inc)
Subtraction between a DenseIterator and an integral value.
Definition: DenseIterator.h:642
#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:78
const ResultType CompositeType
Data type for composite expression templates.
Definition: DMatSMatAddExpr.h:157
Constraints on the storage order of matrix types.
MT1::ReturnType RN1
Return type of the left-hand side dense matrix expression.
Definition: DMatSMatAddExpr.h:114
#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:165
Header file for the SelectType class template.
Header file for the RowExprTrait class template.
Header file for all forward declarations for expression class templates.
Header file for the IsDenseMatrix type trait.
Header file for the EnableIf class template.
Header file for the IsStrictlyLower type trait.
MT2::ReturnType RN2
Return type of the right-hand side sparse matrix expression.
Definition: DMatSMatAddExpr.h:115
Header file for the serial shim.
bool isAliased(const T *alias) const
Returns whether the expression is aliased with the given address alias.
Definition: DMatSMatAddExpr.h:282
EnableIf< IsDenseMatrix< MT1 > >::Type 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 SubmatrixExprTrait class template.
const Type & ReturnType
Return type for expression template evaluations.
Definition: CompressedMatrix.h:2587
Header file for run time assertion macros.
Base template for the AddTrait class.
Definition: AddTrait.h:138
EnableIf< IsDenseMatrix< MT1 > >::Type 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
Utility type for generic codes.
Header file for the addition trait.
Constraint on the data type.
Header file for the MatMatAddExpr base class.
const SelectType< returnExpr, ExprReturnType, ElementType >::Type ReturnType
Return type for expression template evaluations.
Definition: DMatSMatAddExpr.h:154
#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:122
SelectType< IsExpression< MT1 >::value, const MT1, const MT1 & >::Type LeftOperand
Composite type of the left-hand side dense matrix expression.
Definition: DMatSMatAddExpr.h:160
LeftOperand leftOperand() const
Returns the left-hand side dense matrix operand.
Definition: DMatSMatAddExpr.h:247
Header file for the IsRowMajorMatrix type trait.
Expression object for dense matrix-sparse matrix additions.The DMatSMatAddExpr class represents the c...
Definition: DMatSMatAddExpr.h:106
Base class for all compute expression templates.The Computation class serves as a tag for all computa...
Definition: Computation.h:59
EnableIf< IsDenseMatrix< MT1 > >::Type 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
Returns whether the expression can alias with the given address alias.
Definition: DMatSMatAddExpr.h:269
ResultType::TransposeType TransposeType
Transpose type for expression template evaluations.
Definition: DMatSMatAddExpr.h:150
#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
This ResultType
Result type for expression template evaluations.
Definition: CompressedMatrix.h:2583
Header file for the IsTrue value trait.
Header file for the IsUpper type trait.
Header file for exception macros.
size_t columns() const
Returns the current number of columns of the matrix.
Definition: DMatSMatAddExpr.h:237
Header file for the IsHermitian type trait.
Header file for the SubExprTrait class template.
#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:79
Compile time check whether the given type is an expression template.This type trait class tests wheth...
Definition: IsExpression.h:87
Header file for the IsExpression type trait class.
Header file for the FunctionTrace class.
DMatSMatAddExpr(const MT1 &lhs, const MT2 &rhs)
Constructor for the DMatSMatAddExpr class.
Definition: DMatSMatAddExpr.h:180