TDMatSMatSubExpr.h
Go to the documentation of this file.
1 //=================================================================================================
33 //=================================================================================================
34 
35 #ifndef _BLAZE_MATH_EXPRESSIONS_TDMATSMATSUBEXPR_H_
36 #define _BLAZE_MATH_EXPRESSIONS_TDMATSMATSUBEXPR_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/And.h>
75 #include <blaze/util/mpl/Max.h>
76 #include <blaze/util/SelectType.h>
77 #include <blaze/util/Types.h>
79 
80 
81 namespace blaze {
82 
83 //=================================================================================================
84 //
85 // CLASS TDMATSMATSUBEXPR
86 //
87 //=================================================================================================
88 
89 //*************************************************************************************************
96 template< typename MT1 // Type of the left-hand side dense matrix
97  , typename MT2 > // Type of the right-hand side sparse matrix
98 class TDMatSMatSubExpr : public DenseMatrix< TDMatSMatSubExpr<MT1,MT2>, true >
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 TDMatSMatSubExpr( 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****************************************************************************
262  LeftOperand lhs_;
263  RightOperand rhs_;
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 TDMatSMatSubExpr& 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 TDMatSMatSubExpr& rhs )
313  {
315 
316  typedef typename SelectType< SO2, ResultType, OppositeType >::Type TmpType;
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*******************************************************
347  template< typename MT // Type of the target dense matrix
348  , bool SO2 > // Storage order of the target dense matrix
349  friend inline void addAssign( DenseMatrix<MT,SO2>& lhs, const TDMatSMatSubExpr& rhs )
350  {
352 
353  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
354  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
355 
356  addAssign( ~lhs, rhs.lhs_ );
357  subAssign( ~lhs, rhs.rhs_ );
358  }
360  //**********************************************************************************************
361 
362  //**Addition assignment to sparse matrices******************************************************
363  // No special implementation for the addition assignment to sparse matrices.
364  //**********************************************************************************************
365 
366  //**Subtraction assignment to dense matrices****************************************************
379  template< typename MT // Type of the target dense matrix
380  , bool SO2 > // Storage order of the target dense matrix
381  friend inline void subAssign( DenseMatrix<MT,SO2>& lhs, const TDMatSMatSubExpr& rhs )
382  {
384 
385  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
386  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
387 
388  subAssign( ~lhs, rhs.lhs_ );
389  addAssign( ~lhs, rhs.rhs_ );
390  }
392  //**********************************************************************************************
393 
394  //**Subtraction assignment to sparse matrices***************************************************
395  // No special implementation for the subtraction assignment to sparse matrices.
396  //**********************************************************************************************
397 
398  //**Multiplication assignment to dense matrices*************************************************
399  // No special implementation for the multiplication assignment to dense matrices.
400  //**********************************************************************************************
401 
402  //**Multiplication assignment to sparse matrices************************************************
403  // No special implementation for the multiplication assignment to sparse matrices.
404  //**********************************************************************************************
405 
406  //**SMP assignment to dense matrices************************************************************
420  template< typename MT // Type of the target dense matrix
421  , bool SO2 > // Storage order of the target dense matrix
422  friend inline typename EnableIf< UseSMPAssign<MT> >::Type
423  smpAssign( DenseMatrix<MT,SO2>& lhs, const TDMatSMatSubExpr& rhs )
424  {
426 
427  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
428  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
429 
430  if( !IsExpression<MT1>::value && isSame( ~lhs, rhs.lhs_ ) ) {
431  smpSubAssign( ~lhs, rhs.rhs_ );
432  }
433  else {
434  smpAssign ( ~lhs, rhs.lhs_ );
435  smpSubAssign( ~lhs, rhs.rhs_ );
436  }
437  }
439  //**********************************************************************************************
440 
441  //**SMP assignment to sparse matrices***********************************************************
455  template< typename MT // Type of the target sparse matrix
456  , bool SO2 > // Storage order of the target sparse matrix
457  friend inline typename EnableIf< UseSMPAssign<MT> >::Type
458  smpAssign( SparseMatrix<MT,SO2>& lhs, const TDMatSMatSubExpr& rhs )
459  {
461 
462  typedef typename SelectType< SO2, ResultType, OppositeType >::Type TmpType;
463 
470 
471  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
472  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
473 
474  const TmpType tmp( rhs );
475  smpAssign( ~lhs, tmp );
476  }
478  //**********************************************************************************************
479 
480  //**SMP addition assignment to dense matrices***************************************************
495  template< typename MT // Type of the target dense matrix
496  , bool SO2 > // Storage order of the target dense matrix
497  friend inline typename EnableIf< UseSMPAssign<MT> >::Type
498  smpAddAssign( DenseMatrix<MT,SO2>& lhs, const TDMatSMatSubExpr& rhs )
499  {
501 
502  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
503  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
504 
505  smpAddAssign( ~lhs, rhs.lhs_ );
506  smpSubAssign( ~lhs, rhs.rhs_ );
507  }
509  //**********************************************************************************************
510 
511  //**SMP addition assignment to sparse matrices**************************************************
512  // No special implementation for the SMP addition assignment to sparse matrices.
513  //**********************************************************************************************
514 
515  //**SMP subtraction assignment to dense matrices************************************************
530  template< typename MT // Type of the target dense matrix
531  , bool SO2 > // Storage order of the target dense matrix
532  friend inline typename EnableIf< UseSMPAssign<MT> >::Type
533  smpSubAssign( DenseMatrix<MT,SO2>& lhs, const TDMatSMatSubExpr& rhs )
534  {
536 
537  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
538  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
539 
540  smpSubAssign( ~lhs, rhs.lhs_ );
541  smpAddAssign( ~lhs, rhs.rhs_ );
542  }
544  //**********************************************************************************************
545 
546  //**SMP subtraction assignment to sparse matrices***********************************************
547  // No special implementation for the SMP subtraction assignment to sparse matrices.
548  //**********************************************************************************************
549 
550  //**SMP multiplication assignment to dense matrices*********************************************
551  // No special implementation for the SMP multiplication assignment to dense matrices.
552  //**********************************************************************************************
553 
554  //**SMP multiplication assignment to sparse matrices********************************************
555  // No special implementation for the SMP multiplication assignment to sparse matrices.
556  //**********************************************************************************************
557 
558  //**Compile time checks*************************************************************************
566  //**********************************************************************************************
567 };
568 //*************************************************************************************************
569 
570 
571 
572 
573 //=================================================================================================
574 //
575 // GLOBAL BINARY ARITHMETIC OPERATORS
576 //
577 //=================================================================================================
578 
579 //*************************************************************************************************
610 template< typename T1 // Type of the left-hand side dense matrix
611  , typename T2 > // Type of the right-hand side sparse matrix
612 inline const TDMatSMatSubExpr<T1,T2>
614 {
616 
617  if( (~lhs).rows() != (~rhs).rows() || (~lhs).columns() != (~rhs).columns() )
618  throw std::invalid_argument( "Matrix sizes do not match" );
619 
620  return TDMatSMatSubExpr<T1,T2>( ~lhs, ~rhs );
621 }
622 //*************************************************************************************************
623 
624 
625 
626 
627 //=================================================================================================
628 //
629 // GLOBAL RESTRUCTURING BINARY ARITHMETIC OPERATORS
630 //
631 //=================================================================================================
632 
633 //*************************************************************************************************
646 template< typename T1 // Type of the dense matrix of the left-hand side expression
647  , typename T2 // Type of the sparse matrix of the left-hand side expression
648  , typename T3 // Type of the right-hand side dense matrix
649  , bool SO > // Storage order of the right-hand side dense matrix
650 inline const typename AddExprTrait< TDMatSMatSubExpr<T1,T2>, T3 >::Type
651  operator+( const TDMatSMatSubExpr<T1,T2>& lhs, const DenseMatrix<T3,SO>& rhs )
652 {
654 
655  return ( lhs.leftOperand() + (~rhs) ) - lhs.rightOperand();
656 }
658 //*************************************************************************************************
659 
660 
661 //*************************************************************************************************
674 template< typename T1 // Type of the dense matrix of the left-hand side expression
675  , typename T2 // Type of the sparse matrix of the left-hand side expression
676  , typename T3 // Type of the right-hand side dense matrix
677  , bool SO > // Storage order of the right-hand side dense matrix
678 inline const typename SubExprTrait< TDMatSMatSubExpr<T1,T2>, T3 >::Type
679  operator-( const TDMatSMatSubExpr<T1,T2>& lhs, const DenseMatrix<T3,SO>& rhs )
680 {
682 
683  return ( lhs.leftOperand() - (~rhs) ) - lhs.rightOperand();
684 }
686 //*************************************************************************************************
687 
688 
689 
690 
691 //=================================================================================================
692 //
693 // ROWS SPECIALIZATIONS
694 //
695 //=================================================================================================
696 
697 //*************************************************************************************************
699 template< typename MT1, typename MT2 >
700 struct Rows< TDMatSMatSubExpr<MT1,MT2> >
701  : public Max< Rows<MT1>, Rows<MT2> >::Type
702 {};
704 //*************************************************************************************************
705 
706 
707 
708 
709 //=================================================================================================
710 //
711 // COLUMNS SPECIALIZATIONS
712 //
713 //=================================================================================================
714 
715 //*************************************************************************************************
717 template< typename MT1, typename MT2 >
718 struct Columns< TDMatSMatSubExpr<MT1,MT2> >
719  : public Max< Columns<MT1>, Columns<MT2> >::Type
720 {};
722 //*************************************************************************************************
723 
724 
725 
726 
727 //=================================================================================================
728 //
729 // ISSYMMETRIC SPECIALIZATIONS
730 //
731 //=================================================================================================
732 
733 //*************************************************************************************************
735 template< typename MT1, typename MT2 >
736 struct IsSymmetric< TDMatSMatSubExpr<MT1,MT2> >
737  : public IsTrue< IsSymmetric<MT1>::value && IsSymmetric<MT2>::value >
738 {};
740 //*************************************************************************************************
741 
742 
743 
744 
745 //=================================================================================================
746 //
747 // ISLOWER SPECIALIZATIONS
748 //
749 //=================================================================================================
750 
751 //*************************************************************************************************
753 template< typename MT1, typename MT2 >
754 struct IsLower< TDMatSMatSubExpr<MT1,MT2> >
755  : public IsTrue< And< IsLower<MT1>, IsLower<MT2> >::value >
756 {};
758 //*************************************************************************************************
759 
760 
761 
762 
763 //=================================================================================================
764 //
765 // ISUNILOWER SPECIALIZATIONS
766 //
767 //=================================================================================================
768 
769 //*************************************************************************************************
771 template< typename MT1, typename MT2 >
772 struct IsUniLower< TDMatSMatSubExpr<MT1,MT2> >
773  : public IsTrue< And< IsUniLower<MT1>, IsStrictlyLower<MT2> >::value >
774 {};
776 //*************************************************************************************************
777 
778 
779 
780 
781 //=================================================================================================
782 //
783 // ISSTRICTLYLOWER SPECIALIZATIONS
784 //
785 //=================================================================================================
786 
787 //*************************************************************************************************
789 template< typename MT1, typename MT2 >
790 struct IsStrictlyLower< TDMatSMatSubExpr<MT1,MT2> >
791  : public IsTrue< And< IsStrictlyLower<MT1>, IsStrictlyLower<MT2> >::value >
792 {};
794 //*************************************************************************************************
795 
796 
797 
798 
799 //=================================================================================================
800 //
801 // ISUPPER SPECIALIZATIONS
802 //
803 //=================================================================================================
804 
805 //*************************************************************************************************
807 template< typename MT1, typename MT2 >
808 struct IsUpper< TDMatSMatSubExpr<MT1,MT2> >
809  : public IsTrue< And< IsUpper<MT1>, IsUpper<MT2> >::value >
810 {};
812 //*************************************************************************************************
813 
814 
815 
816 
817 //=================================================================================================
818 //
819 // ISUNIUPPER SPECIALIZATIONS
820 //
821 //=================================================================================================
822 
823 //*************************************************************************************************
825 template< typename MT1, typename MT2 >
826 struct IsUniUpper< TDMatSMatSubExpr<MT1,MT2> >
827  : public IsTrue< And< IsUniUpper<MT1>, IsStrictlyUpper<MT2> >::value >
828 {};
830 //*************************************************************************************************
831 
832 
833 
834 
835 //=================================================================================================
836 //
837 // ISSTRICTLYUPPER SPECIALIZATIONS
838 //
839 //=================================================================================================
840 
841 //*************************************************************************************************
843 template< typename MT1, typename MT2 >
844 struct IsStrictlyUpper< TDMatSMatSubExpr<MT1,MT2> >
845  : public IsTrue< And< IsStrictlyUpper<MT1>, IsStrictlyUpper<MT2> >::value >
846 {};
848 //*************************************************************************************************
849 
850 
851 
852 
853 //=================================================================================================
854 //
855 // EXPRESSION TRAIT SPECIALIZATIONS
856 //
857 //=================================================================================================
858 
859 //*************************************************************************************************
861 template< typename MT1, typename MT2, typename MT3 >
862 struct DMatDMatAddExprTrait< TDMatSMatSubExpr<MT1,MT2>, MT3 >
863 {
864  public:
865  //**********************************************************************************************
867  typedef typename SelectType< IsDenseMatrix<MT1>::value && IsColumnMajorMatrix<MT1>::value &&
868  IsSparseMatrix<MT2>::value && IsRowMajorMatrix<MT2>::value &&
869  IsDenseMatrix<MT3>::value && IsRowMajorMatrix<MT3>::value
870  , typename DMatSMatSubExprTrait< typename TDMatDMatAddExprTrait<MT1,MT3>::Type, MT2 >::Type
871  , INVALID_TYPE >::Type Type;
873  //**********************************************************************************************
874 };
876 //*************************************************************************************************
877 
878 
879 //*************************************************************************************************
881 template< typename MT1, typename MT2, typename MT3 >
882 struct DMatTDMatAddExprTrait< TDMatSMatSubExpr<MT1,MT2>, MT3 >
883 {
884  public:
885  //**********************************************************************************************
887  typedef typename SelectType< IsDenseMatrix<MT1>::value && IsColumnMajorMatrix<MT1>::value &&
888  IsSparseMatrix<MT2>::value && IsRowMajorMatrix<MT2>::value &&
889  IsDenseMatrix<MT3>::value && IsColumnMajorMatrix<MT3>::value
890  , typename TDMatSMatSubExprTrait< typename TDMatTDMatAddExprTrait<MT1,MT3>::Type, MT2 >::Type
891  , INVALID_TYPE >::Type Type;
893  //**********************************************************************************************
894 };
896 //*************************************************************************************************
897 
898 
899 //*************************************************************************************************
901 template< typename MT1, typename MT2, typename MT3 >
902 struct DMatDMatSubExprTrait< TDMatSMatSubExpr<MT1,MT2>, MT3 >
903 {
904  public:
905  //**********************************************************************************************
907  typedef typename SelectType< IsDenseMatrix<MT1>::value && IsColumnMajorMatrix<MT1>::value &&
908  IsSparseMatrix<MT2>::value && IsRowMajorMatrix<MT2>::value &&
909  IsDenseMatrix<MT3>::value && IsRowMajorMatrix<MT3>::value
910  , typename DMatSMatSubExprTrait< typename TDMatDMatSubExprTrait<MT1,MT3>::Type, MT2 >::Type
911  , INVALID_TYPE >::Type Type;
913  //**********************************************************************************************
914 };
916 //*************************************************************************************************
917 
918 
919 //*************************************************************************************************
921 template< typename MT1, typename MT2, typename MT3 >
922 struct DMatTDMatSubExprTrait< TDMatSMatSubExpr<MT1,MT2>, MT3 >
923 {
924  public:
925  //**********************************************************************************************
927  typedef typename SelectType< IsDenseMatrix<MT1>::value && IsColumnMajorMatrix<MT1>::value &&
928  IsSparseMatrix<MT2>::value && IsRowMajorMatrix<MT2>::value &&
929  IsDenseMatrix<MT3>::value && IsColumnMajorMatrix<MT3>::value
930  , typename TDMatSMatSubExprTrait< typename TDMatTDMatSubExprTrait<MT1,MT3>::Type, MT2 >::Type
931  , INVALID_TYPE >::Type Type;
933  //**********************************************************************************************
934 };
936 //*************************************************************************************************
937 
938 
939 //*************************************************************************************************
941 template< typename MT1, typename MT2, bool AF >
942 struct SubmatrixExprTrait< TDMatSMatSubExpr<MT1,MT2>, AF >
943 {
944  public:
945  //**********************************************************************************************
946  typedef typename SubExprTrait< typename SubmatrixExprTrait<const MT1,AF>::Type
947  , typename SubmatrixExprTrait<const MT2,AF>::Type >::Type Type;
948  //**********************************************************************************************
949 };
951 //*************************************************************************************************
952 
953 
954 //*************************************************************************************************
956 template< typename MT1, typename MT2 >
957 struct RowExprTrait< TDMatSMatSubExpr<MT1,MT2> >
958 {
959  public:
960  //**********************************************************************************************
961  typedef typename SubExprTrait< typename RowExprTrait<const MT1>::Type
962  , typename RowExprTrait<const MT2>::Type >::Type Type;
963  //**********************************************************************************************
964 };
966 //*************************************************************************************************
967 
968 
969 //*************************************************************************************************
971 template< typename MT1, typename MT2 >
972 struct ColumnExprTrait< TDMatSMatSubExpr<MT1,MT2> >
973 {
974  public:
975  //**********************************************************************************************
976  typedef typename SubExprTrait< typename ColumnExprTrait<const MT1>::Type
977  , typename ColumnExprTrait<const MT2>::Type >::Type Type;
978  //**********************************************************************************************
979 };
981 //*************************************************************************************************
982 
983 } // namespace blaze
984 
985 #endif
Constraint on the data type.
Header file for the Max class template.
LeftOperand lhs_
Left-hand side dense matrix of the subtraction expression.
Definition: TDMatSMatSubExpr.h:262
size_t columns() const
Returns the current number of columns of the matrix.
Definition: TDMatSMatSubExpr.h:210
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.
const ResultType CompositeType
Data type for composite expression templates.
Definition: TDMatSMatSubExpr.h:149
SelectType< IsExpression< MT2 >::value, const MT2, const MT2 & >::Type RightOperand
Composite type of the right-hand side sparse matrix expression.
Definition: TDMatSMatSubExpr.h:155
Efficient implementation of a compressed matrix.The CompressedMatrix class template is the represent...
Definition: CompressedMatrix.h:209
SubExprTrait< RN1, RN2 >::Type ExprReturnType
Expression return type for the subscript operator.
Definition: TDMatSMatSubExpr.h:120
#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.
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
ReturnType operator()(size_t i, size_t j) const
2D-access to the matrix elements.
Definition: TDMatSMatSubExpr.h:188
Header file for the And class template.
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:699
Header file for the Computation base class.
bool isAliased(const T *alias) const
Returns whether the expression is aliased with the given address alias.
Definition: TDMatSMatSubExpr.h:255
Header file for the IsUniLower type trait.
MT1::ResultType RT1
Result type of the left-hand side dense matrix expression.
Definition: TDMatSMatSubExpr.h:104
LeftOperand leftOperand() const
Returns the left-hand side transpose dense matrix operand.
Definition: TDMatSMatSubExpr.h:220
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.
Constraint on the data type.
Constraint on the data type.
SubTrait< RT1, RT2 >::Type ResultType
Result type for expression template evaluations.
Definition: TDMatSMatSubExpr.h:140
RightOperand rhs_
Right-hand side sparse matrix of the subtraction expression.
Definition: TDMatSMatSubExpr.h:263
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.
MT2::ReturnType RN2
Return type of the right-hand side sparse matrix expression.
Definition: TDMatSMatSubExpr.h:107
Header file for the IsSymmetric type trait.
Namespace of the Blaze C++ math library.
Definition: Blaze.h:57
#define BLAZE_CONSTRAINT_MUST_BE_COLUMN_MAJOR_MATRIX_TYPE(T)
Constraint on the data type.In case the given data type T is not a column-major dense or sparse matri...
Definition: StorageOrder.h:161
ResultType::ElementType ElementType
Resulting element type.
Definition: TDMatSMatSubExpr.h:143
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.
TDMatSMatSubExpr< MT1, MT2 > This
Type of this TDMatSMatSubExpr instance.
Definition: TDMatSMatSubExpr.h:139
const DenseIterator< Type > operator+(const DenseIterator< Type > &it, ptrdiff_t inc)
Addition between a DenseIterator and an integral value.
Definition: DenseIterator.h:556
size_t rows() const
Returns the current number of rows of the matrix.
Definition: TDMatSMatSubExpr.h:200
Header file for the IsLower type trait.
#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 SelectType< returnExpr, ExprReturnType, ElementType >::Type ReturnType
Return type for expression template evaluations.
Definition: TDMatSMatSubExpr.h:146
MT2::ResultType RT2
Result type of the right-hand side sparse matrix expression.
Definition: TDMatSMatSubExpr.h:105
MT1::ReturnType RN1
Return type of the left-hand side dense matrix expression.
Definition: TDMatSMatSubExpr.h:106
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
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 EnableIf class template.
Header file for the IsStrictlyLower type trait.
Header file for the serial shim.
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
bool canAlias(const T *alias) const
Returns whether the expression can alias with the given address alias.
Definition: TDMatSMatSubExpr.h:242
Header file for the SubmatrixExprTrait class template.
#define BLAZE_CONSTRAINT_MUST_BE_ROW_MAJOR_MATRIX_TYPE(T)
Constraint on the data type.In case the given data type T is not a row-major dense or sparse matrix t...
Definition: StorageOrder.h:81
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
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
SelectType< IsExpression< MT1 >::value, const MT1, const MT1 & >::Type LeftOperand
Composite type of the left-hand side dense matrix expression.
Definition: TDMatSMatSubExpr.h:152
#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
ResultType::TransposeType TransposeType
Transpose type for expression template evaluations.
Definition: TDMatSMatSubExpr.h:142
ResultType::OppositeType OppositeType
Result type with opposite storage order for expression template evaluations.
Definition: TDMatSMatSubExpr.h:141
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:2502
Header file for the IsTrue value trait.
#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
TDMatSMatSubExpr(const MT1 &lhs, const MT2 &rhs)
Constructor for the TDMatSMatSubExpr class.
Definition: TDMatSMatSubExpr.h:172
Header file for the IsUpper type trait.
Header file for the SubExprTrait class template.
RightOperand rightOperand() const
Returns the right-hand side sparse matrix operand.
Definition: TDMatSMatSubExpr.h:230
#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
Expression object for transpose dense matrix-sparse matrix subtractions.The TDMatSMatSubExpr class re...
Definition: Forward.h:129
#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