SMatDMatSubExpr.h
Go to the documentation of this file.
1 //=================================================================================================
33 //=================================================================================================
34 
35 #ifndef _BLAZE_MATH_EXPRESSIONS_SMATDMATSUBEXPR_H_
36 #define _BLAZE_MATH_EXPRESSIONS_SMATDMATSUBEXPR_H_
37 
38 
39 //*************************************************************************************************
40 // Includes
41 //*************************************************************************************************
42 
43 #include <stdexcept>
74 #include <blaze/util/Assert.h>
76 #include <blaze/util/EnableIf.h>
78 #include <blaze/util/mpl/And.h>
79 #include <blaze/util/mpl/Max.h>
80 #include <blaze/util/SelectType.h>
81 #include <blaze/util/Types.h>
83 
84 
85 namespace blaze {
86 
87 //=================================================================================================
88 //
89 // CLASS SMATDMATSUBEXPR
90 //
91 //=================================================================================================
92 
93 //*************************************************************************************************
100 template< typename MT1 // Type of the left-hand side sparse matrix
101  , typename MT2 // Type of the right-hand side dense matrix
102  , bool SO > // Storage order
103 class SMatDMatSubExpr : public DenseMatrix< SMatDMatSubExpr<MT1,MT2,SO>, SO >
104  , private MatMatSubExpr
105  , private Computation
106 {
107  private:
108  //**Type definitions****************************************************************************
109  typedef typename MT1::ResultType RT1;
110  typedef typename MT2::ResultType RT2;
111  typedef typename MT1::ReturnType RN1;
112  typedef typename MT2::ReturnType RN2;
113  //**********************************************************************************************
114 
115  //**Return type evaluation**********************************************************************
117 
122  enum { returnExpr = !IsTemporary<RN1>::value && !IsTemporary<RN2>::value };
123 
126  //**********************************************************************************************
127 
128  //**Parallel evaluation strategy****************************************************************
130 
135  template< typename MT >
136  struct UseSMPAssign {
137  enum { value = ( !MT1::smpAssignable || !MT2::smpAssignable ) };
138  };
140  //**********************************************************************************************
141 
142  public:
143  //**Type definitions****************************************************************************
149 
152 
154  typedef const ResultType CompositeType;
155 
157  typedef typename SelectType< IsExpression<MT1>::value, const MT1, const MT1& >::Type LeftOperand;
158 
160  typedef typename SelectType< IsExpression<MT2>::value, const MT2, const MT2& >::Type RightOperand;
161  //**********************************************************************************************
162 
163  //**Compilation flags***************************************************************************
165  enum { vectorizable = 0 };
166 
168  enum { smpAssignable = 0 };
169  //**********************************************************************************************
170 
171  //**Constructor*********************************************************************************
177  explicit inline SMatDMatSubExpr( const MT1& lhs, const MT2& rhs )
178  : lhs_( lhs ) // Left-hand side sparse matrix of the subtraction expression
179  , rhs_( rhs ) // Right-hand side dense matrix of the subtraction expression
180  {
181  BLAZE_INTERNAL_ASSERT( lhs.rows() == rhs.rows() , "Invalid number of rows" );
182  BLAZE_INTERNAL_ASSERT( lhs.columns() == rhs.columns(), "Invalid number of columns" );
183  }
184  //**********************************************************************************************
185 
186  //**Access operator*****************************************************************************
193  inline ReturnType operator()( size_t i, size_t j ) const {
194  BLAZE_INTERNAL_ASSERT( i < lhs_.rows() , "Invalid row access index" );
195  BLAZE_INTERNAL_ASSERT( j < lhs_.columns(), "Invalid column access index" );
196  return lhs_(i,j) - rhs_(i,j);
197  }
198  //**********************************************************************************************
199 
200  //**Rows function*******************************************************************************
205  inline size_t rows() const {
206  return lhs_.rows();
207  }
208  //**********************************************************************************************
209 
210  //**Columns function****************************************************************************
215  inline size_t columns() const {
216  return lhs_.columns();
217  }
218  //**********************************************************************************************
219 
220  //**Left operand access*************************************************************************
225  inline LeftOperand leftOperand() const {
226  return lhs_;
227  }
228  //**********************************************************************************************
229 
230  //**Right operand access************************************************************************
235  inline RightOperand rightOperand() const {
236  return rhs_;
237  }
238  //**********************************************************************************************
239 
240  //**********************************************************************************************
246  template< typename T >
247  inline bool canAlias( const T* alias ) const {
248  return ( lhs_.canAlias( alias ) ) ||
249  ( IsExpression<MT2>::value && rhs_.canAlias( alias ) );
250  }
251  //**********************************************************************************************
252 
253  //**********************************************************************************************
259  template< typename T >
260  inline bool isAliased( const T* alias ) const {
261  return lhs_.isAliased( alias ) || rhs_.isAliased( alias );
262  }
263  //**********************************************************************************************
264 
265  private:
266  //**Member variables****************************************************************************
267  LeftOperand lhs_;
268  RightOperand rhs_;
269  //**********************************************************************************************
270 
271  //**Assignment to dense matrices****************************************************************
283  template< typename MT // Type of the target dense matrix
284  , bool SO2 > // Storage order of the target dense matrix
285  friend inline void assign( DenseMatrix<MT,SO2>& lhs, const SMatDMatSubExpr& rhs )
286  {
288 
289  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
290  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
291 
292  assign ( ~lhs, -rhs.rhs_ );
293  addAssign( ~lhs, rhs.lhs_ );
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 SMatDMatSubExpr& 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 SMatDMatSubExpr& 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  subAssign( ~lhs, rhs.rhs_ );
356  addAssign( ~lhs, rhs.lhs_ );
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 SMatDMatSubExpr& 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  addAssign( ~lhs, rhs.rhs_ );
387  subAssign( ~lhs, rhs.lhs_ );
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 SMatDMatSubExpr& 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  smpAssign ( ~lhs, -rhs.rhs_ );
429  smpAddAssign( ~lhs, rhs.lhs_ );
430  }
432  //**********************************************************************************************
433 
434  //**SMP assignment to sparse matrices***********************************************************
448  template< typename MT // Type of the target sparse matrix
449  , bool SO2 > // Storage order of the target sparse matrix
450  friend inline typename EnableIf< UseSMPAssign<MT> >::Type
451  smpAssign( SparseMatrix<MT,SO2>& lhs, const SMatDMatSubExpr& rhs )
452  {
454 
455  typedef typename SelectType< SO == SO2, ResultType, OppositeType >::Type TmpType;
456 
463 
464  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
465  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
466 
467  const TmpType tmp( rhs );
468  smpAssign( ~lhs, tmp );
469  }
471  //**********************************************************************************************
472 
473  //**SMP addition assignment to dense matrices***************************************************
487  template< typename MT // Type of the target dense matrix
488  , bool SO2 > // Storage order of the target dense matrix
489  friend inline typename EnableIf< UseSMPAssign<MT> >::Type
490  smpAddAssign( DenseMatrix<MT,SO2>& lhs, const SMatDMatSubExpr& rhs )
491  {
493 
494  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
495  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
496 
497  smpSubAssign( ~lhs, rhs.rhs_ );
498  smpAddAssign( ~lhs, rhs.lhs_ );
499  }
501  //**********************************************************************************************
502 
503  //**SMP addition assignment to sparse matrices**************************************************
504  // No special implementation for the SMP addition assignment to sparse matrices.
505  //**********************************************************************************************
506 
507  //**SMP subtraction assignment to dense matrices************************************************
521  template< typename MT // Type of the target dense matrix
522  , bool SO2 > // Storage order of the target dense matrix
523  friend inline typename EnableIf< UseSMPAssign<MT> >::Type
524  smpSubAssign( DenseMatrix<MT,SO2>& lhs, const SMatDMatSubExpr& rhs )
525  {
527 
528  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
529  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
530 
531  smpAddAssign( ~lhs, rhs.rhs_ );
532  smpSubAssign( ~lhs, rhs.lhs_ );
533  }
535  //**********************************************************************************************
536 
537  //**SMP subtraction assignment to sparse matrices***********************************************
538  // No special implementation for the SMP subtraction assignment to sparse matrices.
539  //**********************************************************************************************
540 
541  //**SMP multiplication assignment to dense matrices*********************************************
542  // No special implementation for the SMP multiplication assignment to dense matrices.
543  //**********************************************************************************************
544 
545  //**SMP multiplication assignment to sparse matrices********************************************
546  // No special implementation for the SMP multiplication assignment to sparse matrices.
547  //**********************************************************************************************
548 
549  //**Compile time checks*************************************************************************
556  //**********************************************************************************************
557 };
558 //*************************************************************************************************
559 
560 
561 
562 
563 //=================================================================================================
564 //
565 // GLOBAL BINARY ARITHMETIC OPERATORS
566 //
567 //=================================================================================================
568 
569 //*************************************************************************************************
598 template< typename T1 // Type of the left-hand side sparse matrix
599  , typename T2 // Type of the right-hand side dense matrix
600  , bool SO > // Storage order
601 inline const SMatDMatSubExpr<T1,T2,SO>
603 {
605 
606  if( (~lhs).rows() != (~rhs).rows() || (~lhs).columns() != (~rhs).columns() )
607  throw std::invalid_argument( "Matrix sizes do not match" );
608 
609  return SMatDMatSubExpr<T1,T2,SO>( ~lhs, ~rhs );
610 }
611 //*************************************************************************************************
612 
613 
614 
615 
616 //=================================================================================================
617 //
618 // GLOBAL RESTRUCTURING BINARY ARITHMETIC OPERATORS
619 //
620 //=================================================================================================
621 
622 //*************************************************************************************************
635 template< typename T1 // Type of the sparse matrix of the left-hand side expression
636  , typename T2 // Type of the dense matrix of the left-hand side expression
637  , bool SO1 // Storage order of the left-hand side expression
638  , typename T3 // Type of the right-hand side dense matrix
639  , bool SO2 > // Storage order of the right-hand side dense matrix
640 inline const typename AddExprTrait< SMatDMatSubExpr<T1,T2,SO1>, T3 >::Type
641  operator+( const SMatDMatSubExpr<T1,T2,SO1>& lhs, const DenseMatrix<T3,SO2>& rhs )
642 {
644 
645  return ( (~rhs) - lhs.rightOperand() ) + lhs.leftOperand();
646 }
648 //*************************************************************************************************
649 
650 
651 //*************************************************************************************************
664 template< typename T1 // Type of the sparse matrix of the left-hand side expression
665  , typename T2 // Type of the dense matrix of the left-hand side expression
666  , bool SO1 // Storage order of the left-hand side expression
667  , typename T3 // Type of the right-hand side dense matrix
668  , bool SO2 > // Storage order of the right-hand side dense matrix
669 inline const typename SubExprTrait< SMatDMatSubExpr<T1,T2,SO1>, T3 >::Type
670  operator-( const SMatDMatSubExpr<T1,T2,SO1>& lhs, const DenseMatrix<T3,SO2>& rhs )
671 {
673 
674  return lhs.leftOperand() - ( lhs.rightOperand() + (~rhs) );
675 }
677 //*************************************************************************************************
678 
679 
680 
681 
682 //=================================================================================================
683 //
684 // ROWS SPECIALIZATIONS
685 //
686 //=================================================================================================
687 
688 //*************************************************************************************************
690 template< typename MT1, typename MT2, bool SO >
691 struct Rows< SMatDMatSubExpr<MT1,MT2,SO> >
692  : public Max< Rows<MT1>, Rows<MT2> >::Type
693 {};
695 //*************************************************************************************************
696 
697 
698 
699 
700 //=================================================================================================
701 //
702 // COLUMNS SPECIALIZATIONS
703 //
704 //=================================================================================================
705 
706 //*************************************************************************************************
708 template< typename MT1, typename MT2, bool SO >
709 struct Columns< SMatDMatSubExpr<MT1,MT2,SO> >
710  : public Max< Columns<MT1>, Columns<MT2> >::Type
711 {};
713 //*************************************************************************************************
714 
715 
716 
717 
718 //=================================================================================================
719 //
720 // ISSYMMETRIC SPECIALIZATIONS
721 //
722 //=================================================================================================
723 
724 //*************************************************************************************************
726 template< typename MT1, typename MT2, bool SO >
727 struct IsSymmetric< SMatDMatSubExpr<MT1,MT2,SO> >
728  : public IsTrue< IsSymmetric<MT1>::value && IsSymmetric<MT2>::value >
729 {};
731 //*************************************************************************************************
732 
733 
734 
735 
736 //=================================================================================================
737 //
738 // ISLOWER SPECIALIZATIONS
739 //
740 //=================================================================================================
741 
742 //*************************************************************************************************
744 template< typename MT1, typename MT2, bool SO >
745 struct IsLower< SMatDMatSubExpr<MT1,MT2,SO> >
746  : public IsTrue< And< IsLower<MT1>, IsLower<MT2> >::value >
747 {};
749 //*************************************************************************************************
750 
751 
752 
753 
754 //=================================================================================================
755 //
756 // ISUNILOWER SPECIALIZATIONS
757 //
758 //=================================================================================================
759 
760 //*************************************************************************************************
762 template< typename MT1, typename MT2, bool SO >
763 struct IsUniLower< SMatDMatSubExpr<MT1,MT2,SO> >
764  : public IsTrue< And< IsUniLower<MT1>, IsStrictlyLower<MT2> >::value >
765 {};
767 //*************************************************************************************************
768 
769 
770 
771 
772 //=================================================================================================
773 //
774 // ISSTRICTLYLOWER SPECIALIZATIONS
775 //
776 //=================================================================================================
777 
778 //*************************************************************************************************
780 template< typename MT1, typename MT2, bool SO >
781 struct IsStrictlyLower< SMatDMatSubExpr<MT1,MT2,SO> >
782  : public IsTrue< And< IsStrictlyLower<MT1>, IsStrictlyLower<MT2> >::value >
783 {};
785 //*************************************************************************************************
786 
787 
788 
789 
790 //=================================================================================================
791 //
792 // ISUPPER SPECIALIZATIONS
793 //
794 //=================================================================================================
795 
796 //*************************************************************************************************
798 template< typename MT1, typename MT2, bool SO >
799 struct IsUpper< SMatDMatSubExpr<MT1,MT2,SO> >
800  : public IsTrue< And< IsUpper<MT1>, IsUpper<MT2> >::value >
801 {};
803 //*************************************************************************************************
804 
805 
806 
807 
808 //=================================================================================================
809 //
810 // ISUNIUPPER SPECIALIZATIONS
811 //
812 //=================================================================================================
813 
814 //*************************************************************************************************
816 template< typename MT1, typename MT2, bool SO >
817 struct IsUniUpper< SMatDMatSubExpr<MT1,MT2,SO> >
818  : public IsTrue< And< IsUniUpper<MT1>, IsStrictlyUpper<MT2> >::value >
819 {};
821 //*************************************************************************************************
822 
823 
824 
825 
826 //=================================================================================================
827 //
828 // ISSTRICTLYUPPER SPECIALIZATIONS
829 //
830 //=================================================================================================
831 
832 //*************************************************************************************************
834 template< typename MT1, typename MT2, bool SO >
835 struct IsStrictlyUpper< SMatDMatSubExpr<MT1,MT2,SO> >
836  : public IsTrue< And< IsStrictlyUpper<MT1>, IsStrictlyUpper<MT2> >::value >
837 {};
839 //*************************************************************************************************
840 
841 
842 
843 
844 //=================================================================================================
845 //
846 // EXPRESSION TRAIT SPECIALIZATIONS
847 //
848 //=================================================================================================
849 
850 //*************************************************************************************************
852 template< typename MT1, typename MT2, typename MT3 >
853 struct DMatDMatAddExprTrait< SMatDMatSubExpr<MT1,MT2,false>, MT3 >
854 {
855  public:
856  //**********************************************************************************************
858  typedef typename SelectType< IsSparseMatrix<MT1>::value && IsRowMajorMatrix<MT1>::value &&
859  IsDenseMatrix<MT2>::value && IsRowMajorMatrix<MT2>::value &&
860  IsDenseMatrix<MT3>::value && IsRowMajorMatrix<MT3>::value
861  , typename DMatSMatAddExprTrait< typename DMatDMatSubExprTrait<MT3,MT2>::Type, MT1 >::Type
862  , INVALID_TYPE >::Type Type;
864  //**********************************************************************************************
865 };
867 //*************************************************************************************************
868 
869 
870 //*************************************************************************************************
872 template< typename MT1, typename MT2, typename MT3 >
873 struct DMatTDMatAddExprTrait< SMatDMatSubExpr<MT1,MT2,false>, MT3 >
874 {
875  public:
876  //**********************************************************************************************
878  typedef typename SelectType< IsSparseMatrix<MT1>::value && IsRowMajorMatrix<MT1>::value &&
879  IsDenseMatrix<MT2>::value && IsRowMajorMatrix<MT2>::value &&
880  IsDenseMatrix<MT3>::value && IsColumnMajorMatrix<MT3>::value
881  , typename DMatSMatAddExprTrait< typename TDMatDMatSubExprTrait<MT3,MT2>::Type, MT1 >::Type
882  , INVALID_TYPE >::Type Type;
884  //**********************************************************************************************
885 };
887 //*************************************************************************************************
888 
889 
890 //*************************************************************************************************
892 template< typename MT1, typename MT2, typename MT3 >
893 struct TDMatDMatAddExprTrait< SMatDMatSubExpr<MT1,MT2,true>, MT3 >
894 {
895  public:
896  //**********************************************************************************************
898  typedef typename SelectType< IsSparseMatrix<MT1>::value && IsColumnMajorMatrix<MT1>::value &&
899  IsDenseMatrix<MT2>::value && IsColumnMajorMatrix<MT2>::value &&
900  IsDenseMatrix<MT3>::value && IsRowMajorMatrix<MT3>::value
901  , typename DMatTSMatAddExprTrait< typename DMatTDMatSubExprTrait<MT3,MT2>::Type, MT1 >::Type
902  , INVALID_TYPE >::Type Type;
904  //**********************************************************************************************
905 };
907 //*************************************************************************************************
908 
909 
910 //*************************************************************************************************
912 template< typename MT1, typename MT2, typename MT3 >
913 struct TDMatTDMatAddExprTrait< SMatDMatSubExpr<MT1,MT2,true>, MT3 >
914 {
915  public:
916  //**********************************************************************************************
918  typedef typename SelectType< IsSparseMatrix<MT1>::value && IsColumnMajorMatrix<MT1>::value &&
919  IsDenseMatrix<MT2>::value && IsColumnMajorMatrix<MT2>::value &&
920  IsDenseMatrix<MT3>::value && IsColumnMajorMatrix<MT3>::value
921  , typename TDMatTSMatAddExprTrait< typename TDMatTDMatSubExprTrait<MT3,MT2>::Type, MT1 >::Type
922  , INVALID_TYPE >::Type Type;
924  //**********************************************************************************************
925 };
927 //*************************************************************************************************
928 
929 
930 //*************************************************************************************************
932 template< typename MT1, typename MT2, typename MT3 >
933 struct DMatDMatSubExprTrait< SMatDMatSubExpr<MT1,MT2,false>, MT3 >
934 {
935  public:
936  //**********************************************************************************************
938  typedef typename SelectType< IsSparseMatrix<MT1>::value && IsRowMajorMatrix<MT1>::value &&
939  IsDenseMatrix<MT2>::value && IsRowMajorMatrix<MT2>::value &&
940  IsDenseMatrix<MT3>::value && IsRowMajorMatrix<MT3>::value
941  , typename SMatDMatSubExprTrait< MT1, typename DMatDMatAddExprTrait<MT2,MT3>::Type >::Type
942  , INVALID_TYPE >::Type Type;
944  //**********************************************************************************************
945 };
947 //*************************************************************************************************
948 
949 
950 //*************************************************************************************************
952 template< typename MT1, typename MT2, typename MT3 >
953 struct DMatTDMatSubExprTrait< SMatDMatSubExpr<MT1,MT2,false>, MT3 >
954 {
955  public:
956  //**********************************************************************************************
958  typedef typename SelectType< IsSparseMatrix<MT1>::value && IsRowMajorMatrix<MT1>::value &&
959  IsDenseMatrix<MT2>::value && IsRowMajorMatrix<MT2>::value &&
960  IsDenseMatrix<MT3>::value && IsColumnMajorMatrix<MT3>::value
961  , typename SMatDMatSubExprTrait< MT1, typename DMatTDMatAddExprTrait<MT2,MT3>::Type >::Type
962  , INVALID_TYPE >::Type Type;
964  //**********************************************************************************************
965 };
967 //*************************************************************************************************
968 
969 
970 //*************************************************************************************************
972 template< typename MT1, typename MT2, typename MT3 >
973 struct TDMatDMatSubExprTrait< SMatDMatSubExpr<MT1,MT2,true>, MT3 >
974 {
975  public:
976  //**********************************************************************************************
978  typedef typename SelectType< IsSparseMatrix<MT1>::value && IsColumnMajorMatrix<MT1>::value &&
979  IsDenseMatrix<MT2>::value && IsColumnMajorMatrix<MT2>::value &&
980  IsDenseMatrix<MT3>::value && IsRowMajorMatrix<MT3>::value
981  , typename TSMatDMatSubExprTrait< MT1, typename TDMatDMatAddExprTrait<MT2,MT3>::Type >::Type
982  , INVALID_TYPE >::Type Type;
984  //**********************************************************************************************
985 };
987 //*************************************************************************************************
988 
989 
990 //*************************************************************************************************
992 template< typename MT1, typename MT2, typename MT3 >
993 struct TDMatTDMatSubExprTrait< SMatDMatSubExpr<MT1,MT2,true>, MT3 >
994 {
995  public:
996  //**********************************************************************************************
998  typedef typename SelectType< IsSparseMatrix<MT1>::value && IsColumnMajorMatrix<MT1>::value &&
999  IsDenseMatrix<MT2>::value && IsColumnMajorMatrix<MT2>::value &&
1000  IsDenseMatrix<MT3>::value && IsColumnMajorMatrix<MT3>::value
1001  , typename TSMatTDMatSubExprTrait< MT1, typename TDMatTDMatAddExprTrait<MT2,MT3>::Type >::Type
1002  , INVALID_TYPE >::Type Type;
1004  //**********************************************************************************************
1005 };
1007 //*************************************************************************************************
1008 
1009 
1010 //*************************************************************************************************
1012 template< typename MT1, typename MT2, bool SO, bool AF >
1013 struct SubmatrixExprTrait< SMatDMatSubExpr<MT1,MT2,SO>, AF >
1014 {
1015  public:
1016  //**********************************************************************************************
1017  typedef typename SubExprTrait< typename SubmatrixExprTrait<const MT1,AF>::Type
1018  , typename SubmatrixExprTrait<const MT2,AF>::Type >::Type Type;
1019  //**********************************************************************************************
1020 };
1022 //*************************************************************************************************
1023 
1024 
1025 //*************************************************************************************************
1027 template< typename MT1, typename MT2, bool SO >
1028 struct RowExprTrait< SMatDMatSubExpr<MT1,MT2,SO> >
1029 {
1030  public:
1031  //**********************************************************************************************
1032  typedef typename SubExprTrait< typename RowExprTrait<const MT1>::Type
1033  , typename RowExprTrait<const MT2>::Type >::Type Type;
1034  //**********************************************************************************************
1035 };
1037 //*************************************************************************************************
1038 
1039 
1040 //*************************************************************************************************
1042 template< typename MT1, typename MT2, bool SO >
1043 struct ColumnExprTrait< SMatDMatSubExpr<MT1,MT2,SO> >
1044 {
1045  public:
1046  //**********************************************************************************************
1047  typedef typename SubExprTrait< typename ColumnExprTrait<const MT1>::Type
1048  , typename ColumnExprTrait<const MT2>::Type >::Type Type;
1049  //**********************************************************************************************
1050 };
1052 //*************************************************************************************************
1053 
1054 } // namespace blaze
1055 
1056 #endif
Constraint on the data type.
ReturnType operator()(size_t i, size_t j) const
2D-access to the matrix elements.
Definition: SMatDMatSubExpr.h:193
ResultType::OppositeType OppositeType
Result type with opposite storage order for expression template evaluations.
Definition: SMatDMatSubExpr.h:146
Header file for the Max class template.
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.
Header file for the subtraction trait.
Header file for basic type definitions.
MT1::ResultType RT1
Result type of the left-hand side sparse matrix expression.
Definition: SMatDMatSubExpr.h:109
MT2::ReturnType RN2
Return type of the right-hand side dense matrix expression.
Definition: SMatDMatSubExpr.h:112
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:209
#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
Header file for the ColumnExprTrait class template.
Header file for the IsColumnMajorMatrix type trait.
const This & CompositeType
Data type for composite expression templates.
Definition: CompressedMatrix.h:2507
Type ElementType
Type of the sparse matrix elements.
Definition: CompressedMatrix.h:261
Header file for the And class template.
LeftOperand lhs_
Left-hand side sparse matrix of the subtraction expression.
Definition: SMatDMatSubExpr.h:267
Header file for the AddExprTrait class template.
RightOperand rhs_
Right-hand side dense matrix of the subtraction expression.
Definition: SMatDMatSubExpr.h:268
const DMatSerialExpr< MT, SO > serial(const DenseMatrix< MT, SO > &dm)
Forces the serial evaluation of the given dense matrix expression dm.
Definition: DMatSerialExpr.h:699
Header file for the Computation base class.
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:107
Constraint on the data type.
const SelectType< returnExpr, ExprReturnType, ElementType >::Type ReturnType
Return type for expression template evaluations.
Definition: SMatDMatSubExpr.h:151
Constraint on the data type.
Constraint on the data type.
Expression object for sparse matrix-dense matrix subtractions.The SMatDMatSubExpr class represents th...
Definition: Forward.h:90
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
MT2::ResultType RT2
Result type of the right-hand side dense matrix expression.
Definition: SMatDMatSubExpr.h:110
SubTrait< RT1, RT2 >::Type ResultType
Result type for expression template evaluations.
Definition: SMatDMatSubExpr.h:145
ResultType::ElementType ElementType
Resulting element type.
Definition: SMatDMatSubExpr.h:148
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.
SelectType< IsExpression< MT1 >::value, const MT1, const MT1 & >::Type LeftOperand
Composite type of the left-hand side dense matrix expression.
Definition: SMatDMatSubExpr.h:157
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
Header file for the IsLower type trait.
MT1::ReturnType RN1
Return type of the left-hand side sparse matrix expression.
Definition: SMatDMatSubExpr.h:111
#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
ResultType::TransposeType TransposeType
Transpose type for expression template evaluations.
Definition: SMatDMatSubExpr.h:147
SubExprTrait< RN1, RN2 >::Type ExprReturnType
Expression return type for the subscript operator.
Definition: SMatDMatSubExpr.h:125
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.
size_t rows() const
Returns the current number of rows of the matrix.
Definition: SMatDMatSubExpr.h:205
Header file for the EnableIf class template.
Header file for the IsStrictlyLower type trait.
Header file for the serial shim.
size_t columns() const
Returns the current number of columns of the matrix.
Definition: SMatDMatSubExpr.h:215
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:2506
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
SelectType< IsExpression< MT2 >::value, const MT2, const MT2 & >::Type RightOperand
Composite type of the right-hand side sparse matrix expression.
Definition: SMatDMatSubExpr.h:160
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
bool canAlias(const T *alias) const
Returns whether the expression can alias with the given address alias.
Definition: SMatDMatSubExpr.h:247
#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
SMatDMatSubExpr< MT1, MT2, SO > This
Type of this SMatDMatSubExpr instance.
Definition: SMatDMatSubExpr.h:144
Header file for the IsRowMajorMatrix type trait.
SMatDMatSubExpr(const MT1 &lhs, const MT2 &rhs)
Constructor for the SMatDMatSubExpr class.
Definition: SMatDMatSubExpr.h:177
RightOperand rightOperand() const
Returns the right-hand side dense matrix operand.
Definition: SMatDMatSubExpr.h:235
const ResultType CompositeType
Data type for composite expression templates.
Definition: SMatDMatSubExpr.h:154
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
LeftOperand leftOperand() const
Returns the left-hand side sparse matrix operand.
Definition: SMatDMatSubExpr.h:225
This ResultType
Result type for expression template evaluations.
Definition: CompressedMatrix.h:2502
Header file for the IsTrue value trait.
bool isAliased(const T *alias) const
Returns whether the expression is aliased with the given address alias.
Definition: SMatDMatSubExpr.h:260
#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:150
Header file for the IsUpper 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.
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