All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
DMatSMatSubExpr.h
Go to the documentation of this file.
1 //=================================================================================================
33 //=================================================================================================
34 
35 #ifndef _BLAZE_MATH_EXPRESSIONS_DMATSMATSUBEXPR_H_
36 #define _BLAZE_MATH_EXPRESSIONS_DMATSMATSUBEXPR_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 DMATSMATSUBEXPR
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 DMatSMatSubExpr : public DenseMatrix< DMatSMatSubExpr<MT1,MT2,SO>, SO >
99  , private MatMatSubExpr
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 DMatSMatSubExpr( const MT1& lhs, const MT2& rhs )
173  : lhs_( lhs ) // Left-hand side dense matrix of the subtraction expression
174  , rhs_( rhs ) // Right-hand side sparse matrix of the subtraction 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 DMatSMatSubExpr& 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  subAssign( ~lhs, rhs.rhs_ );
289  }
290  else {
291  assign ( ~lhs, rhs.lhs_ );
292  subAssign( ~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 DMatSMatSubExpr& 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 DMatSMatSubExpr& 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  subAssign( ~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 DMatSMatSubExpr& 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  addAssign( ~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 DMatSMatSubExpr& 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  smpSubAssign( ~lhs, rhs.rhs_ );
430  }
431  else {
432  smpAssign ( ~lhs, rhs.lhs_ );
433  smpSubAssign( ~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 DMatSMatSubExpr& 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 DMatSMatSubExpr& 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  smpSubAssign( ~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 DMatSMatSubExpr& 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  smpAddAssign( ~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 //*************************************************************************************************
603 template< typename T1 // Type of the left-hand side dense matrix
604  , typename T2 // Type of the right-hand side sparse matrix
605  , bool SO > // Storage order
606 inline const DMatSMatSubExpr<T1,T2,SO>
608 {
610 
611  if( (~lhs).rows() != (~rhs).rows() || (~lhs).columns() != (~rhs).columns() )
612  throw std::invalid_argument( "Matrix sizes do not match" );
613 
614  return DMatSMatSubExpr<T1,T2,SO>( ~lhs, ~rhs );
615 }
616 //*************************************************************************************************
617 
618 
619 
620 
621 //=================================================================================================
622 //
623 // GLOBAL RESTRUCTURING BINARY ARITHMETIC OPERATORS
624 //
625 //=================================================================================================
626 
627 //*************************************************************************************************
640 template< typename T1 // Type of the dense matrix of the left-hand side expression
641  , typename T2 // Type of the sparse matrix of the left-hand side expression
642  , bool SO1 // Storage order of the left-hand side expression
643  , typename T3 // Type of the right-hand side dense matrix
644  , bool SO2 > // Storage order of the right-hand side dense matrix
645 inline const typename AddExprTrait< DMatSMatSubExpr<T1,T2,SO1>, T3 >::Type
646  operator+( const DMatSMatSubExpr<T1,T2,SO1>& lhs, const DenseMatrix<T3,SO2>& rhs )
647 {
649 
650  return ( lhs.leftOperand() + (~rhs) ) - lhs.rightOperand();
651 }
653 //*************************************************************************************************
654 
655 
656 //*************************************************************************************************
669 template< typename T1 // Type of the dense matrix of the left-hand side expression
670  , typename T2 // Type of the sparse matrix of the left-hand side expression
671  , bool SO1 // Storage order of the left-hand side expression
672  , typename T3 // Type of the right-hand side dense matrix
673  , bool SO2 > // Storage order of the right-hand side dense matrix
674 inline const typename SubExprTrait< DMatSMatSubExpr<T1,T2,SO1>, T3 >::Type
675  operator-( const DMatSMatSubExpr<T1,T2,SO1>& lhs, const DenseMatrix<T3,SO2>& rhs )
676 {
678 
679  return ( lhs.leftOperand() - (~rhs) ) - lhs.rightOperand();
680 }
682 //*************************************************************************************************
683 
684 
685 
686 
687 //=================================================================================================
688 //
689 // ROWS SPECIALIZATIONS
690 //
691 //=================================================================================================
692 
693 //*************************************************************************************************
695 template< typename MT1, typename MT2, bool SO >
696 struct Rows< DMatSMatSubExpr<MT1,MT2,SO> >
697  : public Max< Rows<MT1>, Rows<MT2> >::Type
698 {};
700 //*************************************************************************************************
701 
702 
703 
704 
705 //=================================================================================================
706 //
707 // COLUMNS SPECIALIZATIONS
708 //
709 //=================================================================================================
710 
711 //*************************************************************************************************
713 template< typename MT1, typename MT2, bool SO >
714 struct Columns< DMatSMatSubExpr<MT1,MT2,SO> >
715  : public Max< Columns<MT1>, Columns<MT2> >::Type
716 {};
718 //*************************************************************************************************
719 
720 
721 
722 
723 //=================================================================================================
724 //
725 // ISSYMMETRIC SPECIALIZATIONS
726 //
727 //=================================================================================================
728 
729 //*************************************************************************************************
731 template< typename MT1, typename MT2, bool SO >
732 struct IsSymmetric< DMatSMatSubExpr<MT1,MT2,SO> >
733  : public IsTrue< IsSymmetric<MT1>::value && IsSymmetric<MT2>::value >
734 {};
736 //*************************************************************************************************
737 
738 
739 
740 
741 //=================================================================================================
742 //
743 // ISLOWER SPECIALIZATIONS
744 //
745 //=================================================================================================
746 
747 //*************************************************************************************************
749 template< typename MT1, typename MT2, bool SO >
750 struct IsLower< DMatSMatSubExpr<MT1,MT2,SO> >
751  : public IsTrue< IsLower<MT1>::value && IsLower<MT2>::value >
752 {};
754 //*************************************************************************************************
755 
756 
757 
758 
759 //=================================================================================================
760 //
761 // ISUPPER SPECIALIZATIONS
762 //
763 //=================================================================================================
764 
765 //*************************************************************************************************
767 template< typename MT1, typename MT2, bool SO >
768 struct IsUpper< DMatSMatSubExpr<MT1,MT2,SO> >
769  : public IsTrue< IsUpper<MT1>::value && IsUpper<MT2>::value >
770 {};
772 //*************************************************************************************************
773 
774 
775 
776 
777 //=================================================================================================
778 //
779 // EXPRESSION TRAIT SPECIALIZATIONS
780 //
781 //=================================================================================================
782 
783 //*************************************************************************************************
785 template< typename MT1, typename MT2, typename MT3 >
786 struct DMatDMatAddExprTrait< DMatSMatSubExpr<MT1,MT2,false>, MT3 >
787 {
788  public:
789  //**********************************************************************************************
791  typedef typename SelectType< IsDenseMatrix<MT1>::value && IsRowMajorMatrix<MT1>::value &&
792  IsSparseMatrix<MT2>::value && IsRowMajorMatrix<MT2>::value &&
793  IsDenseMatrix<MT3>::value && IsRowMajorMatrix<MT3>::value
794  , typename DMatSMatSubExprTrait< typename DMatDMatAddExprTrait<MT1,MT3>::Type, MT2 >::Type
795  , INVALID_TYPE >::Type Type;
797  //**********************************************************************************************
798 };
800 //*************************************************************************************************
801 
802 
803 //*************************************************************************************************
805 template< typename MT1, typename MT2, typename MT3 >
806 struct DMatTDMatAddExprTrait< DMatSMatSubExpr<MT1,MT2,false>, MT3 >
807 {
808  public:
809  //**********************************************************************************************
811  typedef typename SelectType< IsDenseMatrix<MT1>::value && IsRowMajorMatrix<MT1>::value &&
812  IsSparseMatrix<MT2>::value && IsRowMajorMatrix<MT2>::value &&
813  IsDenseMatrix<MT3>::value && IsColumnMajorMatrix<MT3>::value
814  , typename DMatSMatSubExprTrait< typename DMatTDMatAddExprTrait<MT1,MT3>::Type, MT2 >::Type
815  , INVALID_TYPE >::Type Type;
817  //**********************************************************************************************
818 };
820 //*************************************************************************************************
821 
822 
823 //*************************************************************************************************
825 template< typename MT1, typename MT2, typename MT3 >
826 struct TDMatDMatAddExprTrait< DMatSMatSubExpr<MT1,MT2,true>, MT3 >
827 {
828  public:
829  //**********************************************************************************************
831  typedef typename SelectType< IsDenseMatrix<MT1>::value && IsColumnMajorMatrix<MT1>::value &&
832  IsSparseMatrix<MT2>::value && IsColumnMajorMatrix<MT2>::value &&
833  IsDenseMatrix<MT3>::value && IsRowMajorMatrix<MT3>::value
834  , typename DMatTSMatSubExprTrait< typename TDMatDMatAddExprTrait<MT1,MT3>::Type, MT2 >::Type
835  , INVALID_TYPE >::Type Type;
837  //**********************************************************************************************
838 };
840 //*************************************************************************************************
841 
842 
843 //*************************************************************************************************
845 template< typename MT1, typename MT2, typename MT3 >
846 struct TDMatTDMatAddExprTrait< DMatSMatSubExpr<MT1,MT2,true>, MT3 >
847 {
848  public:
849  //**********************************************************************************************
851  typedef typename SelectType< IsDenseMatrix<MT1>::value && IsColumnMajorMatrix<MT1>::value &&
852  IsSparseMatrix<MT2>::value && IsColumnMajorMatrix<MT2>::value &&
853  IsDenseMatrix<MT3>::value && IsColumnMajorMatrix<MT3>::value
854  , typename TDMatTSMatSubExprTrait< typename TDMatTDMatAddExprTrait<MT1,MT3>::Type, MT2 >::Type
855  , INVALID_TYPE >::Type Type;
857  //**********************************************************************************************
858 };
860 //*************************************************************************************************
861 
862 
863 //*************************************************************************************************
865 template< typename MT1, typename MT2, typename MT3 >
866 struct DMatDMatSubExprTrait< DMatSMatSubExpr<MT1,MT2,false>, MT3 >
867 {
868  public:
869  //**********************************************************************************************
871  typedef typename SelectType< IsDenseMatrix<MT1>::value && IsRowMajorMatrix<MT1>::value &&
872  IsSparseMatrix<MT2>::value && IsRowMajorMatrix<MT2>::value &&
873  IsDenseMatrix<MT3>::value && IsRowMajorMatrix<MT3>::value
874  , typename DMatSMatSubExprTrait< typename DMatDMatSubExprTrait<MT1,MT3>::Type, MT2 >::Type
875  , INVALID_TYPE >::Type Type;
877  //**********************************************************************************************
878 };
880 //*************************************************************************************************
881 
882 
883 //*************************************************************************************************
885 template< typename MT1, typename MT2, typename MT3 >
886 struct DMatTDMatSubExprTrait< DMatSMatSubExpr<MT1,MT2,false>, MT3 >
887 {
888  public:
889  //**********************************************************************************************
891  typedef typename SelectType< IsDenseMatrix<MT1>::value && IsRowMajorMatrix<MT1>::value &&
892  IsSparseMatrix<MT2>::value && IsRowMajorMatrix<MT2>::value &&
893  IsDenseMatrix<MT3>::value && IsColumnMajorMatrix<MT3>::value
894  , typename DMatSMatSubExprTrait< typename DMatTDMatSubExprTrait<MT1,MT3>::Type, MT2 >::Type
895  , INVALID_TYPE >::Type Type;
897  //**********************************************************************************************
898 };
900 //*************************************************************************************************
901 
902 
903 //*************************************************************************************************
905 template< typename MT1, typename MT2, typename MT3 >
906 struct TDMatDMatSubExprTrait< DMatSMatSubExpr<MT1,MT2,true>, MT3 >
907 {
908  public:
909  //**********************************************************************************************
911  typedef typename SelectType< IsDenseMatrix<MT1>::value && IsColumnMajorMatrix<MT1>::value &&
912  IsSparseMatrix<MT2>::value && IsColumnMajorMatrix<MT2>::value &&
913  IsDenseMatrix<MT3>::value && IsRowMajorMatrix<MT3>::value
914  , typename DMatTSMatSubExprTrait< typename TDMatDMatSubExprTrait<MT1,MT3>::Type, MT2 >::Type
915  , INVALID_TYPE >::Type Type;
917  //**********************************************************************************************
918 };
920 //*************************************************************************************************
921 
922 
923 //*************************************************************************************************
925 template< typename MT1, typename MT2, typename MT3 >
926 struct TDMatTDMatSubExprTrait< DMatSMatSubExpr<MT1,MT2,true>, MT3 >
927 {
928  public:
929  //**********************************************************************************************
931  typedef typename SelectType< IsDenseMatrix<MT1>::value && IsColumnMajorMatrix<MT1>::value &&
932  IsSparseMatrix<MT2>::value && IsColumnMajorMatrix<MT2>::value &&
933  IsDenseMatrix<MT3>::value && IsColumnMajorMatrix<MT3>::value
934  , typename TDMatTSMatSubExprTrait< typename TDMatTDMatSubExprTrait<MT1,MT3>::Type, MT2 >::Type
935  , INVALID_TYPE >::Type Type;
937  //**********************************************************************************************
938 };
940 //*************************************************************************************************
941 
942 
943 //*************************************************************************************************
945 template< typename MT1, typename MT2, bool SO, bool AF >
946 struct SubmatrixExprTrait< DMatSMatSubExpr<MT1,MT2,SO>, AF >
947 {
948  public:
949  //**********************************************************************************************
950  typedef typename SubExprTrait< typename SubmatrixExprTrait<const MT1,AF>::Type
951  , typename SubmatrixExprTrait<const MT2,AF>::Type >::Type Type;
952  //**********************************************************************************************
953 };
955 //*************************************************************************************************
956 
957 
958 //*************************************************************************************************
960 template< typename MT1, typename MT2, bool SO >
961 struct RowExprTrait< DMatSMatSubExpr<MT1,MT2,SO> >
962 {
963  public:
964  //**********************************************************************************************
965  typedef typename SubExprTrait< typename RowExprTrait<const MT1>::Type
966  , typename RowExprTrait<const MT2>::Type >::Type Type;
967  //**********************************************************************************************
968 };
970 //*************************************************************************************************
971 
972 
973 //*************************************************************************************************
975 template< typename MT1, typename MT2, bool SO >
976 struct ColumnExprTrait< DMatSMatSubExpr<MT1,MT2,SO> >
977 {
978  public:
979  //**********************************************************************************************
980  typedef typename SubExprTrait< typename ColumnExprTrait<const MT1>::Type
981  , typename ColumnExprTrait<const MT2>::Type >::Type Type;
982  //**********************************************************************************************
983 };
985 //*************************************************************************************************
986 
987 } // namespace blaze
988 
989 #endif
Constraint on the data type.
RightOperand rhs_
Right-hand side sparse matrix of the subtraction expression.
Definition: DMatSMatSubExpr.h:263
Header file for the Max class template.
MT2::ReturnType RN2
Return type of the right-hand side sparse matrix expression.
Definition: DMatSMatSubExpr.h:107
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 subtraction trait.
SubTrait< RT1, RT2 >::Type ResultType
Result type for expression template evaluations.
Definition: DMatSMatSubExpr.h:140
Header file for the IsSparseMatrix type trait.
ResultType::ElementType ElementType
Resulting element type.
Definition: DMatSMatSubExpr.h:143
#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.
Header file for the IsColumnMajorMatrix type trait.
MT2::ResultType RT2
Result type of the right-hand side sparse matrix expression.
Definition: DMatSMatSubExpr.h:105
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
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
Header file for the Computation base class.
bool canAlias(const T *alias) const
Returns whether the expression can alias with the given address alias.
Definition: DMatSMatSubExpr.h:242
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.
ReturnType operator()(size_t i, size_t j) const
2D-access to the matrix elements.
Definition: DMatSMatSubExpr.h:188
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.
LeftOperand lhs_
Left-hand side dense matrix of the subtraction expression.
Definition: DMatSMatSubExpr.h:262
Header file for the IsSymmetric type trait.
Base class for all matrix/matrix subtraction expression templates.The MatMatSubExpr class serves as a...
Definition: MatMatSubExpr.h:65
DMatSMatSubExpr(const MT1 &lhs, const MT2 &rhs)
Constructor for the DMatSMatSubExpr class.
Definition: DMatSMatSubExpr.h:172
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.
Header file for the MatMatSubExpr base class.
const DenseIterator< Type > operator+(const DenseIterator< Type > &it, ptrdiff_t inc)
Addition between a DenseIterator and an integral value.
Definition: DenseIterator.h:556
const ResultType CompositeType
Data type for composite expression templates.
Definition: DMatSMatSubExpr.h:149
Header file for the IsLower type trait.
size_t columns() const
Returns the current number of columns of the matrix.
Definition: DMatSMatSubExpr.h:210
#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
Constraints on the storage order of matrix types.
Evaluation of the return type of a subtraction expression.Via this type trait it is possible to evalu...
Definition: SubExprTrait.h:104
MT1::ReturnType RN1
Return type of the left-hand side dense matrix expression.
Definition: DMatSMatSubExpr.h:106
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.
bool isAliased(const T *alias) const
Returns whether the expression is aliased with the given address alias.
Definition: DMatSMatSubExpr.h:255
Header file for the serial shim.
SelectType< IsExpression< MT2 >::value, const MT2, const MT2 & >::Type RightOperand
Composite type of the right-hand side sparse matrix expression.
Definition: DMatSMatSubExpr.h:155
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
ResultType::OppositeType OppositeType
Result type with opposite storage order for expression template evaluations.
Definition: DMatSMatSubExpr.h:141
DMatSMatSubExpr< MT1, MT2, SO > This
Type of this DMatSMatSubExpr instance.
Definition: DMatSMatSubExpr.h:139
Header file for run time assertion macros.
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
Expression object for dense matrix-sparse matrix subtractions.The DMatSMatSubExpr class represents th...
Definition: DMatSMatSubExpr.h:98
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
const DenseIterator< Type > operator-(const DenseIterator< Type > &it, ptrdiff_t inc)
Subtraction between a DenseIterator and an integral value.
Definition: DenseIterator.h:585
ResultType::TransposeType TransposeType
Transpose type for expression template evaluations.
Definition: DMatSMatSubExpr.h:142
SubExprTrait< RN1, RN2 >::Type ExprReturnType
Expression return type for the subscript operator.
Definition: DMatSMatSubExpr.h:120
RightOperand rightOperand() const
Returns the right-hand side dense matrix operand.
Definition: DMatSMatSubExpr.h:230
MT1::ResultType RT1
Result type of the left-hand side dense matrix expression.
Definition: DMatSMatSubExpr.h:104
SelectType< IsExpression< MT1 >::value, const MT1, const MT1 & >::Type LeftOperand
Composite type of the left-hand side dense matrix expression.
Definition: DMatSMatSubExpr.h:152
LeftOperand leftOperand() const
Returns the left-hand side dense matrix operand.
Definition: DMatSMatSubExpr.h:220
#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
Header file for the IsRowMajorMatrix type trait.
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
#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.
#define BLAZE_CONSTRAINT_MUST_FORM_VALID_MATMATSUBEXPR(T1, T2)
Constraint on the data type.In case the given data types T1 and T2 do not form a valid matrix/matrix ...
Definition: MatMatSubExpr.h:165
Base template for the SubTrait class.
Definition: SubTrait.h:142
Header file for the IsUpper type trait.
Header file for the SubExprTrait class template.
const SelectType< returnExpr, ExprReturnType, ElementType >::Type ReturnType
Return type for expression template evaluations.
Definition: DMatSMatSubExpr.h:146
#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
size_t rows() const
Returns the current number of rows of the matrix.
Definition: DMatSMatSubExpr.h:200
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