All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
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 <stdexcept>
70 #include <blaze/util/Assert.h>
72 #include <blaze/util/EnableIf.h>
74 #include <blaze/util/mpl/Max.h>
75 #include <blaze/util/SelectType.h>
76 #include <blaze/util/Types.h>
78 
79 
80 namespace blaze {
81 
82 //=================================================================================================
83 //
84 // CLASS DMATSMATADDEXPR
85 //
86 //=================================================================================================
87 
88 //*************************************************************************************************
95 template< typename MT1 // Type of the left-hand side dense matrix
96  , typename MT2 // Type of the right-hand side sparse matrix
97  , bool SO > // Storage order
98 class DMatSMatAddExpr : public DenseMatrix< DMatSMatAddExpr<MT1,MT2,SO>, SO >
99  , private MatMatAddExpr
100  , private Computation
101 {
102  private:
103  //**Type definitions****************************************************************************
104  typedef typename MT1::ResultType RT1;
105  typedef typename MT2::ResultType RT2;
106  typedef typename MT1::ReturnType RN1;
107  typedef typename MT2::ReturnType RN2;
108  //**********************************************************************************************
109 
110  //**Return type evaluation**********************************************************************
112 
117  enum { returnExpr = !IsTemporary<RN1>::value && !IsTemporary<RN2>::value };
118 
121  //**********************************************************************************************
122 
123  //**Parallel evaluation strategy****************************************************************
125 
130  template< typename MT >
131  struct UseSMPAssign {
132  enum { value = ( !MT1::smpAssignable || !MT2::smpAssignable ) };
133  };
135  //**********************************************************************************************
136 
137  public:
138  //**Type definitions****************************************************************************
144 
147 
149  typedef const ResultType CompositeType;
150 
152  typedef typename SelectType< IsExpression<MT1>::value, const MT1, const MT1& >::Type LeftOperand;
153 
155  typedef typename SelectType< IsExpression<MT2>::value, const MT2, const MT2& >::Type RightOperand;
156  //**********************************************************************************************
157 
158  //**Compilation flags***************************************************************************
160  enum { vectorizable = 0 };
161 
163  enum { smpAssignable = 0 };
164  //**********************************************************************************************
165 
166  //**Constructor*********************************************************************************
172  explicit inline DMatSMatAddExpr( const MT1& lhs, const MT2& rhs )
173  : lhs_( lhs ) // Left-hand side dense matrix of the addition expression
174  , rhs_( rhs ) // Right-hand side sparse matrix of the addition expression
175  {
176  BLAZE_INTERNAL_ASSERT( lhs.rows() == rhs.rows() , "Invalid number of rows" );
177  BLAZE_INTERNAL_ASSERT( lhs.columns() == rhs.columns(), "Invalid number of columns" );
178  }
179  //**********************************************************************************************
180 
181  //**Access operator*****************************************************************************
188  inline ReturnType operator()( size_t i, size_t j ) const {
189  BLAZE_INTERNAL_ASSERT( i < lhs_.rows() , "Invalid row access index" );
190  BLAZE_INTERNAL_ASSERT( j < lhs_.columns(), "Invalid column access index" );
191  return lhs_(i,j) + rhs_(i,j);
192  }
193  //**********************************************************************************************
194 
195  //**Rows function*******************************************************************************
200  inline size_t rows() const {
201  return lhs_.rows();
202  }
203  //**********************************************************************************************
204 
205  //**Columns function****************************************************************************
210  inline size_t columns() const {
211  return lhs_.columns();
212  }
213  //**********************************************************************************************
214 
215  //**Left operand access*************************************************************************
220  inline LeftOperand leftOperand() const {
221  return lhs_;
222  }
223  //**********************************************************************************************
224 
225  //**Right operand access************************************************************************
230  inline RightOperand rightOperand() const {
231  return rhs_;
232  }
233  //**********************************************************************************************
234 
235  //**********************************************************************************************
241  template< typename T >
242  inline bool canAlias( const T* alias ) const {
243  return ( IsExpression<MT1>::value && lhs_.canAlias( alias ) ) ||
244  ( rhs_.canAlias( alias ) );
245  }
246  //**********************************************************************************************
247 
248  //**********************************************************************************************
254  template< typename T >
255  inline bool isAliased( const T* alias ) const {
256  return ( lhs_.isAliased( alias ) || rhs_.isAliased( alias ) );
257  }
258  //**********************************************************************************************
259 
260  private:
261  //**Member variables****************************************************************************
264  //**********************************************************************************************
265 
266  //**Assignment to dense matrices****************************************************************
278  template< typename MT // Type of the target dense matrix
279  , bool SO2 > // Storage order of the target dense matrix
280  friend inline void assign( DenseMatrix<MT,SO2>& lhs, const DMatSMatAddExpr& rhs )
281  {
283 
284  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
285  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
286 
287  if( !IsExpression<MT1>::value && isSame( ~lhs, rhs.lhs_ ) ) {
288  addAssign( ~lhs, rhs.rhs_ );
289  }
290  else {
291  assign ( ~lhs, rhs.lhs_ );
292  addAssign( ~lhs, rhs.rhs_ );
293  }
294  }
296  //**********************************************************************************************
297 
298  //**Assignment to sparse matrices***************************************************************
310  template< typename MT // Type of the target sparse matrix
311  , bool SO2 > // Storage order of the target sparse matrix
312  friend inline void assign( SparseMatrix<MT,SO2>& lhs, const DMatSMatAddExpr& rhs )
313  {
315 
317 
324 
325  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
326  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
327 
328  const TmpType tmp( serial( rhs ) );
329  assign( ~lhs, tmp );
330  }
332  //**********************************************************************************************
333 
334  //**Addition assignment to dense matrices*******************************************************
346  template< typename MT // Type of the target dense matrix
347  , bool SO2 > // Storage order of the target dense matrix
348  friend inline void addAssign( DenseMatrix<MT,SO2>& lhs, const DMatSMatAddExpr& rhs )
349  {
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  addAssign( ~lhs, rhs.lhs_ );
356  addAssign( ~lhs, rhs.rhs_ );
357  }
359  //**********************************************************************************************
360 
361  //**Addition assignment to sparse matrices******************************************************
362  // No special implementation for the addition assignment to sparse matrices.
363  //**********************************************************************************************
364 
365  //**Subtraction assignment to dense matrices****************************************************
377  template< typename MT // Type of the target dense matrix
378  , bool SO2 > // Storage order of the target dense matrix
379  friend inline void subAssign( DenseMatrix<MT,SO2>& lhs, const DMatSMatAddExpr& rhs )
380  {
382 
383  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
384  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
385 
386  subAssign( ~lhs, rhs.lhs_ );
387  subAssign( ~lhs, rhs.rhs_ );
388  }
390  //**********************************************************************************************
391 
392  //**Subtraction assignment to sparse matrices***************************************************
393  // No special implementation for the subtraction assignment to sparse matrices.
394  //**********************************************************************************************
395 
396  //**Multiplication assignment to dense matrices*************************************************
397  // No special implementation for the multiplication assignment to dense matrices.
398  //**********************************************************************************************
399 
400  //**Multiplication assignment to sparse matrices************************************************
401  // No special implementation for the multiplication assignment to sparse matrices.
402  //**********************************************************************************************
403 
404  //**SMP assignment to dense matrices************************************************************
418  template< typename MT // Type of the target dense matrix
419  , bool SO2 > // Storage order of the target dense matrix
420  friend inline typename EnableIf< UseSMPAssign<MT> >::Type
421  smpAssign( DenseMatrix<MT,SO2>& lhs, const DMatSMatAddExpr& rhs )
422  {
424 
425  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
426  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
427 
428  if( !IsExpression<MT1>::value && isSame( ~lhs, rhs.lhs_ ) ) {
429  smpAddAssign( ~lhs, rhs.rhs_ );
430  }
431  else {
432  smpAssign ( ~lhs, rhs.lhs_ );
433  smpAddAssign( ~lhs, rhs.rhs_ );
434  }
435  }
437  //**********************************************************************************************
438 
439  //**SMP assignment to sparse matrices***********************************************************
453  template< typename MT // Type of the target sparse matrix
454  , bool SO2 > // Storage order of the target sparse matrix
455  friend inline typename EnableIf< UseSMPAssign<MT> >::Type
456  smpAssign( SparseMatrix<MT,SO2>& lhs, const DMatSMatAddExpr& rhs )
457  {
459 
460  typedef typename SelectType< SO == SO2, ResultType, OppositeType >::Type TmpType;
461 
468 
469  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
470  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
471 
472  const TmpType tmp( rhs );
473  smpAssign( ~lhs, tmp );
474  }
476  //**********************************************************************************************
477 
478  //**SMP addition assignment to dense matrices***************************************************
492  template< typename MT // Type of the target dense matrix
493  , bool SO2 > // Storage order of the target dense matrix
494  friend inline typename EnableIf< UseSMPAssign<MT> >::Type
495  smpAddAssign( DenseMatrix<MT,SO2>& lhs, const DMatSMatAddExpr& rhs )
496  {
498 
499  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
500  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
501 
502  smpAddAssign( ~lhs, rhs.lhs_ );
503  smpAddAssign( ~lhs, rhs.rhs_ );
504  }
506  //**********************************************************************************************
507 
508  //**SMP addition assignment to sparse matrices**************************************************
509  // No special implementation for the SMP addition assignment to sparse matrices.
510  //**********************************************************************************************
511 
512  //**SMP subtraction assignment to dense matrices************************************************
526  template< typename MT // Type of the target dense matrix
527  , bool SO2 > // Storage order of the target dense matrix
528  friend inline typename EnableIf< UseSMPAssign<MT> >::Type
529  smpSubAssign( DenseMatrix<MT,SO2>& lhs, const DMatSMatAddExpr& rhs )
530  {
532 
533  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
534  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
535 
536  smpSubAssign( ~lhs, rhs.lhs_ );
537  smpSubAssign( ~lhs, rhs.rhs_ );
538  }
540  //**********************************************************************************************
541 
542  //**SMP subtraction assignment to sparse matrices***********************************************
543  // No special implementation for the SMP subtraction assignment to sparse matrices.
544  //**********************************************************************************************
545 
546  //**SMP multiplication assignment to dense matrices*********************************************
547  // No special implementation for the SMP multiplication assignment to dense matrices.
548  //**********************************************************************************************
549 
550  //**SMP multiplication assignment to sparse matrices********************************************
551  // No special implementation for the SMP multiplication assignment to sparse matrices.
552  //**********************************************************************************************
553 
554  //**Compile time checks*************************************************************************
561  //**********************************************************************************************
562 };
563 //*************************************************************************************************
564 
565 
566 
567 
568 //=================================================================================================
569 //
570 // GLOBAL BINARY ARITHMETIC OPERATORS
571 //
572 //=================================================================================================
573 
574 //*************************************************************************************************
600 template< typename T1 // Type of the left-hand side dense matrix
601  , typename T2 // Type of the right-hand side sparse matrix
602  , bool SO > // Storage order
603 inline const DMatSMatAddExpr<T1,T2,SO>
605 {
607 
608  if( (~lhs).rows() != (~rhs).rows() || (~lhs).columns() != (~rhs).columns() )
609  throw std::invalid_argument( "Matrix sizes do not match" );
610 
611  return DMatSMatAddExpr<T1,T2,SO>( ~lhs, ~rhs );
612 }
613 //*************************************************************************************************
614 
615 
616 //*************************************************************************************************
642 template< typename T1 // Type of the left-hand side sparse matrix
643  , typename T2 // Type of the right-hand side dense matrix
644  , bool SO > // Storage order
645 inline const DMatSMatAddExpr<T2,T1,SO>
647 {
649 
650  if( (~lhs).rows() != (~rhs).rows() || (~lhs).columns() != (~rhs).columns() )
651  throw std::invalid_argument( "Matrix sizes do not match" );
652 
653  return DMatSMatAddExpr<T2,T1,SO>( ~rhs, ~lhs );
654 }
655 //*************************************************************************************************
656 
657 
658 
659 
660 //=================================================================================================
661 //
662 // GLOBAL RESTRUCTURING BINARY ARITHMETIC OPERATORS
663 //
664 //=================================================================================================
665 
666 //*************************************************************************************************
679 template< typename T1 // Type of the dense matrix of the left-hand side expression
680  , typename T2 // Type of the sparse matrix of the left-hand side expression
681  , bool SO1 // Storage order of the left-hand side expression
682  , typename T3 // Type of the right-hand side dense matrix
683  , bool SO2 > // Storage order of the right-hand side dense matrix
684 inline const typename AddExprTrait< DMatSMatAddExpr<T1,T2,SO1>, T3 >::Type
685  operator+( const DMatSMatAddExpr<T1,T2,SO1>& lhs, const DenseMatrix<T3,SO2>& rhs )
686 {
688 
689  return ( lhs.leftOperand() + (~rhs) ) + lhs.rightOperand();
690 }
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 SubExprTrait< 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 
725 
726 //=================================================================================================
727 //
728 // ROWS SPECIALIZATIONS
729 //
730 //=================================================================================================
731 
732 //*************************************************************************************************
734 template< typename MT1, typename MT2, bool SO >
735 struct Rows< DMatSMatAddExpr<MT1,MT2,SO> >
736  : public Max< Rows<MT1>, Rows<MT2> >::Type
737 {};
739 //*************************************************************************************************
740 
741 
742 
743 
744 //=================================================================================================
745 //
746 // COLUMNS SPECIALIZATIONS
747 //
748 //=================================================================================================
749 
750 //*************************************************************************************************
752 template< typename MT1, typename MT2, bool SO >
753 struct Columns< DMatSMatAddExpr<MT1,MT2,SO> >
754  : public Max< Columns<MT1>, Columns<MT2> >::Type
755 {};
757 //*************************************************************************************************
758 
759 
760 
761 
762 //=================================================================================================
763 //
764 // ISSYMMETRIC SPECIALIZATIONS
765 //
766 //=================================================================================================
767 
768 //*************************************************************************************************
770 template< typename MT1, typename MT2, bool SO >
771 struct IsSymmetric< DMatSMatAddExpr<MT1,MT2,SO> >
772  : public IsTrue< IsSymmetric<MT1>::value && IsSymmetric<MT2>::value >
773 {};
775 //*************************************************************************************************
776 
777 
778 
779 
780 //=================================================================================================
781 //
782 // ISLOWER SPECIALIZATIONS
783 //
784 //=================================================================================================
785 
786 //*************************************************************************************************
788 template< typename MT1, typename MT2, bool SO >
789 struct IsLower< DMatSMatAddExpr<MT1,MT2,SO> >
790  : public IsTrue< IsLower<MT1>::value && IsLower<MT2>::value >
791 {};
793 //*************************************************************************************************
794 
795 
796 
797 
798 //=================================================================================================
799 //
800 // ISUPPER SPECIALIZATIONS
801 //
802 //=================================================================================================
803 
804 //*************************************************************************************************
806 template< typename MT1, typename MT2, bool SO >
807 struct IsUpper< DMatSMatAddExpr<MT1,MT2,SO> >
808  : public IsTrue< IsUpper<MT1>::value && IsUpper<MT2>::value >
809 {};
811 //*************************************************************************************************
812 
813 
814 
815 
816 //=================================================================================================
817 //
818 // EXPRESSION TRAIT SPECIALIZATIONS
819 //
820 //=================================================================================================
821 
822 //*************************************************************************************************
824 template< typename MT1, typename MT2, typename MT3 >
825 struct DMatDMatAddExprTrait< DMatSMatAddExpr<MT1,MT2,false>, MT3 >
826 {
827  public:
828  //**********************************************************************************************
830  typedef typename SelectType< IsDenseMatrix<MT1>::value && IsRowMajorMatrix<MT1>::value &&
831  IsSparseMatrix<MT2>::value && IsRowMajorMatrix<MT2>::value &&
832  IsDenseMatrix<MT3>::value && IsRowMajorMatrix<MT3>::value
833  , typename DMatSMatAddExprTrait< typename DMatDMatAddExprTrait<MT1,MT3>::Type, MT2 >::Type
834  , INVALID_TYPE >::Type Type;
836  //**********************************************************************************************
837 };
839 //*************************************************************************************************
840 
841 
842 //*************************************************************************************************
844 template< typename MT1, typename MT2, typename MT3 >
845 struct DMatTDMatAddExprTrait< DMatSMatAddExpr<MT1,MT2,false>, MT3 >
846 {
847  public:
848  //**********************************************************************************************
850  typedef typename SelectType< IsDenseMatrix <MT1>::value && IsRowMajorMatrix<MT1>::value &&
851  IsSparseMatrix<MT2>::value && IsRowMajorMatrix<MT2>::value &&
852  IsDenseMatrix <MT3>::value && IsColumnMajorMatrix<MT3>::value
853  , typename DMatSMatAddExprTrait< typename DMatTDMatAddExprTrait<MT1,MT3>::Type, MT2 >::Type
854  , INVALID_TYPE >::Type Type;
856  //**********************************************************************************************
857 };
859 //*************************************************************************************************
860 
861 
862 //*************************************************************************************************
864 template< typename MT1, typename MT2, typename MT3 >
865 struct TDMatDMatAddExprTrait< DMatSMatAddExpr<MT1,MT2,true>, MT3 >
866 {
867  public:
868  //**********************************************************************************************
870  typedef typename SelectType< IsDenseMatrix <MT1>::value && IsColumnMajorMatrix<MT1>::value &&
871  IsSparseMatrix<MT2>::value && IsColumnMajorMatrix<MT2>::value &&
872  IsDenseMatrix <MT3>::value && IsRowMajorMatrix<MT3>::value
873  , typename DMatTSMatAddExprTrait< typename TDMatDMatAddExprTrait<MT1,MT3>::Type, MT2 >::Type
874  , INVALID_TYPE >::Type Type;
876  //**********************************************************************************************
877 };
879 //*************************************************************************************************
880 
881 
882 //*************************************************************************************************
884 template< typename MT1, typename MT2, typename MT3 >
885 struct TDMatTDMatAddExprTrait< DMatSMatAddExpr<MT1,MT2,true>, MT3 >
886 {
887  public:
888  //**********************************************************************************************
890  typedef typename SelectType< IsDenseMatrix <MT1>::value && IsColumnMajorMatrix<MT1>::value &&
891  IsSparseMatrix<MT2>::value && IsColumnMajorMatrix<MT2>::value &&
892  IsDenseMatrix <MT3>::value && IsColumnMajorMatrix<MT3>::value
893  , typename TDMatTSMatAddExprTrait< typename TDMatTDMatAddExprTrait<MT1,MT3>::Type, MT2 >::Type
894  , INVALID_TYPE >::Type Type;
896  //**********************************************************************************************
897 };
899 //*************************************************************************************************
900 
901 
902 //*************************************************************************************************
904 template< typename MT1, typename MT2, typename MT3 >
905 struct DMatDMatSubExprTrait< DMatSMatAddExpr<MT1,MT2,false>, MT3 >
906 {
907  public:
908  //**********************************************************************************************
910  typedef typename SelectType< IsDenseMatrix<MT1>::value && IsRowMajorMatrix<MT1>::value &&
911  IsSparseMatrix<MT2>::value && IsRowMajorMatrix<MT2>::value &&
912  IsDenseMatrix<MT3>::value && IsRowMajorMatrix<MT3>::value
913  , typename DMatSMatAddExprTrait< typename DMatDMatSubExprTrait<MT1,MT3>::Type, MT2 >::Type
914  , INVALID_TYPE >::Type Type;
916  //**********************************************************************************************
917 };
919 //*************************************************************************************************
920 
921 
922 //*************************************************************************************************
924 template< typename MT1, typename MT2, typename MT3 >
925 struct DMatTDMatSubExprTrait< DMatSMatAddExpr<MT1,MT2,false>, MT3 >
926 {
927  public:
928  //**********************************************************************************************
930  typedef typename SelectType< IsDenseMatrix<MT1>::value && IsRowMajorMatrix<MT1>::value &&
931  IsSparseMatrix<MT2>::value && IsRowMajorMatrix<MT2>::value &&
932  IsDenseMatrix<MT3>::value && IsColumnMajorMatrix<MT3>::value
933  , typename DMatSMatAddExprTrait< typename DMatTDMatSubExprTrait<MT1,MT3>::Type, MT2 >::Type
934  , INVALID_TYPE >::Type Type;
936  //**********************************************************************************************
937 };
939 //*************************************************************************************************
940 
941 
942 //*************************************************************************************************
944 template< typename MT1, typename MT2, typename MT3 >
945 struct TDMatDMatSubExprTrait< DMatSMatAddExpr<MT1,MT2,true>, MT3 >
946 {
947  public:
948  //**********************************************************************************************
950  typedef typename SelectType< IsDenseMatrix<MT1>::value && IsColumnMajorMatrix<MT1>::value &&
951  IsSparseMatrix<MT2>::value && IsColumnMajorMatrix<MT2>::value &&
952  IsDenseMatrix<MT3>::value && IsRowMajorMatrix<MT3>::value
953  , typename DMatTSMatAddExprTrait< typename TDMatDMatSubExprTrait<MT1,MT3>::Type, MT2 >::Type
954  , INVALID_TYPE >::Type Type;
956  //**********************************************************************************************
957 };
959 //*************************************************************************************************
960 
961 
962 //*************************************************************************************************
964 template< typename MT1, typename MT2, typename MT3 >
965 struct TDMatTDMatSubExprTrait< DMatSMatAddExpr<MT1,MT2,true>, MT3 >
966 {
967  public:
968  //**********************************************************************************************
970  typedef typename SelectType< IsDenseMatrix<MT1>::value && IsColumnMajorMatrix<MT1>::value &&
971  IsSparseMatrix<MT2>::value && IsColumnMajorMatrix<MT2>::value &&
972  IsDenseMatrix<MT3>::value && IsColumnMajorMatrix<MT3>::value
973  , typename TDMatTSMatAddExprTrait< typename TDMatTDMatSubExprTrait<MT1,MT3>::Type, MT2 >::Type
974  , INVALID_TYPE >::Type Type;
976  //**********************************************************************************************
977 };
979 //*************************************************************************************************
980 
981 
982 //*************************************************************************************************
984 template< typename MT1, typename MT2, bool SO, bool AF >
985 struct SubmatrixExprTrait< DMatSMatAddExpr<MT1,MT2,SO>, AF >
986 {
987  public:
988  //**********************************************************************************************
989  typedef typename AddExprTrait< typename SubmatrixExprTrait<const MT1,AF>::Type
990  , typename SubmatrixExprTrait<const MT2,AF>::Type >::Type Type;
991  //**********************************************************************************************
992 };
994 //*************************************************************************************************
995 
996 
997 //*************************************************************************************************
999 template< typename MT1, typename MT2, bool SO >
1000 struct RowExprTrait< DMatSMatAddExpr<MT1,MT2,SO> >
1001 {
1002  public:
1003  //**********************************************************************************************
1004  typedef typename AddExprTrait< typename RowExprTrait<const MT1>::Type
1005  , typename RowExprTrait<const MT2>::Type >::Type Type;
1006  //**********************************************************************************************
1007 };
1009 //*************************************************************************************************
1010 
1011 
1012 //*************************************************************************************************
1014 template< typename MT1, typename MT2, bool SO >
1015 struct ColumnExprTrait< DMatSMatAddExpr<MT1,MT2,SO> >
1016 {
1017  public:
1018  //**********************************************************************************************
1019  typedef typename AddExprTrait< typename ColumnExprTrait<const MT1>::Type
1020  , typename ColumnExprTrait<const MT2>::Type >::Type Type;
1021  //**********************************************************************************************
1022 };
1024 //*************************************************************************************************
1025 
1026 } // namespace blaze
1027 
1028 #endif
ReturnType operator()(size_t i, size_t j) const
2D-access to the matrix elements.
Definition: DMatSMatAddExpr.h:188
AddTrait< RT1, RT2 >::Type ResultType
Result type for expression template evaluations.
Definition: DMatSMatAddExpr.h:140
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:155
ResultType::OppositeType OppositeType
Result type with opposite storage order for expression template evaluations.
Definition: DMatSMatAddExpr.h:141
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:262
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.
AddExprTrait< RN1, RN2 >::Type ExprReturnType
Expression return type for the subscript operator.
Definition: DMatSMatAddExpr.h:120
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:242
Efficient implementation of a compressed matrix.The CompressedMatrix class template is the represent...
Definition: CompressedMatrix.h:205
#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:946
Header file for the ColumnExprTrait class template.
RightOperand rightOperand() const
Returns the right-hand side sparse matrix operand.
Definition: DMatSMatAddExpr.h:230
Header file for the IsColumnMajorMatrix type trait.
const This & CompositeType
Data type for composite expression templates.
Definition: CompressedMatrix.h:2478
Type ElementType
Type of the sparse matrix elements.
Definition: CompressedMatrix.h:257
ResultType::ElementType ElementType
Resulting element type.
Definition: DMatSMatAddExpr.h:143
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:695
MT2::ResultType RT2
Result type of the right-hand side sparse matrix expression.
Definition: DMatSMatAddExpr.h:105
Header file for the Computation base class.
MT1::ResultType RT1
Result type of the left-hand side dense matrix expression.
Definition: DMatSMatAddExpr.h:104
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:107
Constraint on the data type.
RightOperand rhs_
Right-hand side sparse matrix of the addition expression.
Definition: DMatSMatAddExpr.h:263
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 IsSymmetric type trait.
Header file for the DenseMatrix base class.
BLAZE_ALWAYS_INLINE void assign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the assignment of a matrix to a matrix.
Definition: Matrix.h:635
Header file for the Columns type trait.
DMatSMatAddExpr< MT1, MT2, SO > This
Type of this DMatSMatAddExpr instance.
Definition: DMatSMatAddExpr.h:139
Base class for all matrix/matrix addition expression templates.The MatMatAddExpr class serves as a ta...
Definition: MatMatAddExpr.h:65
const DenseIterator< Type > operator+(const DenseIterator< Type > &it, ptrdiff_t inc)
Addition between a DenseIterator and an integral value.
Definition: DenseIterator.h:556
Header file for the IsLower type trait.
size_t rows() const
Returns the current number of rows of the matrix.
Definition: DMatSMatAddExpr.h:200
#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:149
Constraints on the storage order of matrix types.
MT1::ReturnType RN1
Return type of the left-hand side dense matrix expression.
Definition: DMatSMatAddExpr.h:106
#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.
MT2::ReturnType RN2
Return type of the right-hand side sparse matrix expression.
Definition: DMatSMatAddExpr.h:107
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:255
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:2477
Header file for run time assertion macros.
Base template for the AddTrait class.
Definition: AddTrait.h:142
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
Header file for the addition trait.
BLAZE_ALWAYS_INLINE void addAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the addition assignment of a matrix to a matrix.
Definition: Matrix.h:742
Constraint on the data type.
const DenseIterator< Type > operator-(const DenseIterator< Type > &it, ptrdiff_t inc)
Subtraction between a DenseIterator and an integral value.
Definition: DenseIterator.h:585
Header file for the MatMatAddExpr base class.
const SelectType< returnExpr, ExprReturnType, ElementType >::Type ReturnType
Return type for expression template evaluations.
Definition: DMatSMatAddExpr.h:146
#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:283
SelectType< IsExpression< MT1 >::value, const MT1, const MT1 & >::Type LeftOperand
Composite type of the left-hand side dense matrix expression.
Definition: DMatSMatAddExpr.h:152
LeftOperand leftOperand() const
Returns the left-hand side dense matrix operand.
Definition: DMatSMatAddExpr.h:220
Header file for the IsRowMajorMatrix type trait.
Expression object for dense matrix-sparse matrix additions.The DMatSMatAddExpr class represents the c...
Definition: DMatSMatAddExpr.h:98
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:242
ResultType::TransposeType TransposeType
Transpose type for expression template evaluations.
Definition: DMatSMatAddExpr.h:142
#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:2473
Header file for the IsTrue value trait.
Header file for basic type definitions.
Header file for the IsUpper type trait.
size_t columns() const
Returns the current number of columns of the matrix.
Definition: DMatSMatAddExpr.h:210
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.
BLAZE_ALWAYS_INLINE void subAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the subtraction assignment of a matrix to matrix.
Definition: Matrix.h:849
DMatSMatAddExpr(const MT1 &lhs, const MT2 &rhs)
Constructor for the DMatSMatAddExpr class.
Definition: DMatSMatAddExpr.h:172