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>
64 #include <blaze/util/Assert.h>
67 #include <blaze/util/SelectType.h>
68 #include <blaze/util/Types.h>
69 
70 
71 namespace blaze {
72 
73 //=================================================================================================
74 //
75 // CLASS DMATSMATSUBEXPR
76 //
77 //=================================================================================================
78 
79 //*************************************************************************************************
86 template< typename MT1 // Type of the left-hand side dense matrix
87  , typename MT2 // Type of the right-hand side sparse matrix
88  , bool SO > // Storage order
89 class DMatSMatSubExpr : public DenseMatrix< DMatSMatSubExpr<MT1,MT2,SO>, SO >
90  , private MatMatSubExpr
91  , private Computation
92 {
93  private:
94  //**Type definitions****************************************************************************
95  typedef typename MT1::ResultType RT1;
96  typedef typename MT2::ResultType RT2;
97  typedef typename MT1::ReturnType RN1;
98  typedef typename MT2::ReturnType RN2;
99  //**********************************************************************************************
100 
101  //**Return type evaluation**********************************************************************
103 
108  enum { returnExpr = !IsTemporary<RN1>::value && !IsTemporary<RN2>::value };
109 
112  //**********************************************************************************************
113 
114  //**Parallel evaluation strategy****************************************************************
116 
121  template< typename MT >
122  struct UseSMPAssign {
123  enum { value = ( !MT1::smpAssignable || !MT2::smpAssignable ) };
124  };
126  //**********************************************************************************************
127 
128  public:
129  //**Type definitions****************************************************************************
135 
138 
140  typedef const ResultType CompositeType;
141 
143  typedef typename SelectType< IsExpression<MT1>::value, const MT1, const MT1& >::Type LeftOperand;
144 
146  typedef typename SelectType< IsExpression<MT2>::value, const MT2, const MT2& >::Type RightOperand;
147  //**********************************************************************************************
148 
149  //**Compilation flags***************************************************************************
151  enum { vectorizable = 0 };
152 
154  enum { smpAssignable = 0 };
155  //**********************************************************************************************
156 
157  //**Constructor*********************************************************************************
163  explicit inline DMatSMatSubExpr( const MT1& lhs, const MT2& rhs )
164  : lhs_( lhs ) // Left-hand side dense matrix of the subtraction expression
165  , rhs_( rhs ) // Right-hand side sparse matrix of the subtraction expression
166  {
167  BLAZE_INTERNAL_ASSERT( lhs.rows() == rhs.rows() , "Invalid number of rows" );
168  BLAZE_INTERNAL_ASSERT( lhs.columns() == rhs.columns(), "Invalid number of columns" );
169  }
170  //**********************************************************************************************
171 
172  //**Access operator*****************************************************************************
179  inline ReturnType operator()( size_t i, size_t j ) const {
180  BLAZE_INTERNAL_ASSERT( i < lhs_.rows() , "Invalid row access index" );
181  BLAZE_INTERNAL_ASSERT( j < lhs_.columns(), "Invalid column access index" );
182  return lhs_(i,j) - rhs_(i,j);
183  }
184  //**********************************************************************************************
185 
186  //**Rows function*******************************************************************************
191  inline size_t rows() const {
192  return lhs_.rows();
193  }
194  //**********************************************************************************************
195 
196  //**Columns function****************************************************************************
201  inline size_t columns() const {
202  return lhs_.columns();
203  }
204  //**********************************************************************************************
205 
206  //**Left operand access*************************************************************************
211  inline LeftOperand leftOperand() const {
212  return lhs_;
213  }
214  //**********************************************************************************************
215 
216  //**Right operand access************************************************************************
221  inline RightOperand rightOperand() const {
222  return rhs_;
223  }
224  //**********************************************************************************************
225 
226  //**********************************************************************************************
232  template< typename T >
233  inline bool canAlias( const T* alias ) const {
234  return ( IsExpression<MT1>::value && lhs_.canAlias( alias ) ) ||
235  ( rhs_.canAlias( alias ) );
236  }
237  //**********************************************************************************************
238 
239  //**********************************************************************************************
245  template< typename T >
246  inline bool isAliased( const T* alias ) const {
247  return ( lhs_.isAliased( alias ) || rhs_.isAliased( alias ) );
248  }
249  //**********************************************************************************************
250 
251  private:
252  //**Member variables****************************************************************************
255  //**********************************************************************************************
256 
257  //**Assignment to dense matrices****************************************************************
269  template< typename MT // Type of the target dense matrix
270  , bool SO2 > // Storage order of the target dense matrix
271  friend inline void assign( DenseMatrix<MT,SO2>& lhs, const DMatSMatSubExpr& rhs )
272  {
274 
275  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
276  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
277 
278  if( !IsExpression<MT1>::value && isSame( ~lhs, rhs.lhs_ ) ) {
279  subAssign( ~lhs, rhs.rhs_ );
280  }
281  else {
282  assign ( ~lhs, rhs.lhs_ );
283  subAssign( ~lhs, rhs.rhs_ );
284  }
285  }
287  //**********************************************************************************************
288 
289  //**Assignment to sparse matrices***************************************************************
301  template< typename MT // Type of the target sparse matrix
302  , bool SO2 > // Storage order of the target sparse matrix
303  friend inline void assign( SparseMatrix<MT,SO2>& lhs, const DMatSMatSubExpr& rhs )
304  {
306 
308 
315 
316  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
317  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
318 
319  const TmpType tmp( serial( rhs ) );
320  assign( ~lhs, tmp );
321  }
323  //**********************************************************************************************
324 
325  //**Addition assignment to dense matrices*******************************************************
337  template< typename MT // Type of the target dense matrix
338  , bool SO2 > // Storage order of the target dense matrix
339  friend inline void addAssign( DenseMatrix<MT,SO2>& lhs, const DMatSMatSubExpr& rhs )
340  {
342 
343  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
344  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
345 
346  addAssign( ~lhs, rhs.lhs_ );
347  subAssign( ~lhs, rhs.rhs_ );
348  }
350  //**********************************************************************************************
351 
352  //**Addition assignment to sparse matrices******************************************************
353  // No special implementation for the addition assignment to sparse matrices.
354  //**********************************************************************************************
355 
356  //**Subtraction assignment to dense matrices****************************************************
368  template< typename MT // Type of the target dense matrix
369  , bool SO2 > // Storage order of the target dense matrix
370  friend inline void subAssign( DenseMatrix<MT,SO2>& lhs, const DMatSMatSubExpr& rhs )
371  {
373 
374  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
375  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
376 
377  subAssign( ~lhs, rhs.lhs_ );
378  addAssign( ~lhs, rhs.rhs_ );
379  }
381  //**********************************************************************************************
382 
383  //**Subtraction assignment to sparse matrices***************************************************
384  // No special implementation for the subtraction assignment to sparse matrices.
385  //**********************************************************************************************
386 
387  //**Multiplication assignment to dense matrices*************************************************
388  // No special implementation for the multiplication assignment to dense matrices.
389  //**********************************************************************************************
390 
391  //**Multiplication assignment to sparse matrices************************************************
392  // No special implementation for the multiplication assignment to sparse matrices.
393  //**********************************************************************************************
394 
395  //**SMP assignment to dense matrices************************************************************
409  template< typename MT // Type of the target dense matrix
410  , bool SO2 > // Storage order of the target dense matrix
411  friend inline typename EnableIf< UseSMPAssign<MT> >::Type
412  smpAssign( DenseMatrix<MT,SO2>& lhs, const DMatSMatSubExpr& rhs )
413  {
415 
416  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
417  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
418 
419  if( !IsExpression<MT1>::value && isSame( ~lhs, rhs.lhs_ ) ) {
420  smpSubAssign( ~lhs, rhs.rhs_ );
421  }
422  else {
423  smpAssign ( ~lhs, rhs.lhs_ );
424  smpSubAssign( ~lhs, rhs.rhs_ );
425  }
426  }
428  //**********************************************************************************************
429 
430  //**SMP assignment to sparse matrices***********************************************************
444  template< typename MT // Type of the target sparse matrix
445  , bool SO2 > // Storage order of the target sparse matrix
446  friend inline typename EnableIf< UseSMPAssign<MT> >::Type
447  smpAssign( SparseMatrix<MT,SO2>& lhs, const DMatSMatSubExpr& rhs )
448  {
450 
451  typedef typename SelectType< SO == SO2, ResultType, OppositeType >::Type TmpType;
452 
459 
460  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
461  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
462 
463  const TmpType tmp( rhs );
464  smpAssign( ~lhs, tmp );
465  }
467  //**********************************************************************************************
468 
469  //**SMP addition assignment to dense matrices***************************************************
483  template< typename MT // Type of the target dense matrix
484  , bool SO2 > // Storage order of the target dense matrix
485  friend inline typename EnableIf< UseSMPAssign<MT> >::Type
486  smpAddAssign( DenseMatrix<MT,SO2>& lhs, const DMatSMatSubExpr& rhs )
487  {
489 
490  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
491  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
492 
493  smpAddAssign( ~lhs, rhs.lhs_ );
494  smpSubAssign( ~lhs, rhs.rhs_ );
495  }
497  //**********************************************************************************************
498 
499  //**SMP addition assignment to sparse matrices**************************************************
500  // No special implementation for the SMP addition assignment to sparse matrices.
501  //**********************************************************************************************
502 
503  //**SMP subtraction assignment to dense matrices************************************************
517  template< typename MT // Type of the target dense matrix
518  , bool SO2 > // Storage order of the target dense matrix
519  friend inline typename EnableIf< UseSMPAssign<MT> >::Type
520  smpSubAssign( DenseMatrix<MT,SO2>& lhs, const DMatSMatSubExpr& rhs )
521  {
523 
524  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
525  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
526 
527  smpSubAssign( ~lhs, rhs.lhs_ );
528  smpAddAssign( ~lhs, rhs.rhs_ );
529  }
531  //**********************************************************************************************
532 
533  //**SMP subtraction assignment to sparse matrices***********************************************
534  // No special implementation for the SMP subtraction assignment to sparse matrices.
535  //**********************************************************************************************
536 
537  //**SMP multiplication assignment to dense matrices*********************************************
538  // No special implementation for the SMP multiplication assignment to dense matrices.
539  //**********************************************************************************************
540 
541  //**SMP multiplication assignment to sparse matrices************************************************
542  // No special implementation for the SMP multiplication assignment to sparse matrices.
543  //**********************************************************************************************
544 
545  //**Compile time checks*************************************************************************
551  //**********************************************************************************************
552 };
553 //*************************************************************************************************
554 
555 
556 
557 
558 //=================================================================================================
559 //
560 // GLOBAL BINARY ARITHMETIC OPERATORS
561 //
562 //=================================================================================================
563 
564 //*************************************************************************************************
593 template< typename T1 // Type of the left-hand side dense matrix
594  , typename T2 // Type of the right-hand side sparse matrix
595  , bool SO > // Storage order
596 inline const DMatSMatSubExpr<T1,T2,SO>
598 {
600 
601  if( (~lhs).rows() != (~rhs).rows() || (~lhs).columns() != (~rhs).columns() )
602  throw std::invalid_argument( "Matrix sizes do not match" );
603 
604  return DMatSMatSubExpr<T1,T2,SO>( ~lhs, ~rhs );
605 }
606 //*************************************************************************************************
607 
608 
609 
610 
611 //=================================================================================================
612 //
613 // GLOBAL RESTRUCTURING BINARY ARITHMETIC OPERATORS
614 //
615 //=================================================================================================
616 
617 //*************************************************************************************************
630 template< typename T1 // Type of the dense matrix of the left-hand side expression
631  , typename T2 // Type of the sparse matrix of the left-hand side expression
632  , bool SO1 // Storage order of the left-hand side expression
633  , typename T3 // Type of the right-hand side dense matrix
634  , bool SO2 > // Storage order of the right-hand side dense matrix
635 inline const typename AddExprTrait< DMatSMatSubExpr<T1,T2,SO1>, T3 >::Type
636  operator+( const DMatSMatSubExpr<T1,T2,SO1>& lhs, const DenseMatrix<T3,SO2>& rhs )
637 {
639 
640  return ( lhs.leftOperand() + (~rhs) ) - lhs.rightOperand();
641 }
643 //*************************************************************************************************
644 
645 
646 //*************************************************************************************************
659 template< typename T1 // Type of the dense matrix of the left-hand side expression
660  , typename T2 // Type of the sparse matrix of the left-hand side expression
661  , bool SO1 // Storage order of the left-hand side expression
662  , typename T3 // Type of the right-hand side dense matrix
663  , bool SO2 > // Storage order of the right-hand side dense matrix
664 inline const typename SubExprTrait< DMatSMatSubExpr<T1,T2,SO1>, T3 >::Type
665  operator-( const DMatSMatSubExpr<T1,T2,SO1>& lhs, const DenseMatrix<T3,SO2>& rhs )
666 {
668 
669  return ( lhs.leftOperand() - (~rhs) ) - lhs.rightOperand();
670 }
672 //*************************************************************************************************
673 
674 
675 
676 
677 //=================================================================================================
678 //
679 // EXPRESSION TRAIT SPECIALIZATIONS
680 //
681 //=================================================================================================
682 
683 //*************************************************************************************************
685 template< typename MT1, typename MT2, typename MT3 >
686 struct DMatDMatAddExprTrait< DMatSMatSubExpr<MT1,MT2,false>, MT3 >
687 {
688  public:
689  //**********************************************************************************************
691  typedef typename SelectType< IsDenseMatrix<MT1>::value && IsRowMajorMatrix<MT1>::value &&
692  IsSparseMatrix<MT2>::value && IsRowMajorMatrix<MT2>::value &&
693  IsDenseMatrix<MT3>::value && IsRowMajorMatrix<MT3>::value
694  , typename DMatSMatSubExprTrait< typename DMatDMatAddExprTrait<MT1,MT3>::Type, MT2 >::Type
695  , INVALID_TYPE >::Type Type;
697  //**********************************************************************************************
698 };
700 //*************************************************************************************************
701 
702 
703 //*************************************************************************************************
705 template< typename MT1, typename MT2, typename MT3 >
706 struct DMatTDMatAddExprTrait< DMatSMatSubExpr<MT1,MT2,false>, MT3 >
707 {
708  public:
709  //**********************************************************************************************
711  typedef typename SelectType< IsDenseMatrix<MT1>::value && IsRowMajorMatrix<MT1>::value &&
712  IsSparseMatrix<MT2>::value && IsRowMajorMatrix<MT2>::value &&
713  IsDenseMatrix<MT3>::value && IsColumnMajorMatrix<MT3>::value
714  , typename DMatSMatSubExprTrait< typename DMatTDMatAddExprTrait<MT1,MT3>::Type, MT2 >::Type
715  , INVALID_TYPE >::Type Type;
717  //**********************************************************************************************
718 };
720 //*************************************************************************************************
721 
722 
723 //*************************************************************************************************
725 template< typename MT1, typename MT2, typename MT3 >
726 struct TDMatDMatAddExprTrait< DMatSMatSubExpr<MT1,MT2,true>, MT3 >
727 {
728  public:
729  //**********************************************************************************************
731  typedef typename SelectType< IsDenseMatrix<MT1>::value && IsColumnMajorMatrix<MT1>::value &&
732  IsSparseMatrix<MT2>::value && IsColumnMajorMatrix<MT2>::value &&
733  IsDenseMatrix<MT3>::value && IsRowMajorMatrix<MT3>::value
734  , typename DMatTSMatSubExprTrait< typename TDMatDMatAddExprTrait<MT1,MT3>::Type, MT2 >::Type
735  , INVALID_TYPE >::Type Type;
737  //**********************************************************************************************
738 };
740 //*************************************************************************************************
741 
742 
743 //*************************************************************************************************
745 template< typename MT1, typename MT2, typename MT3 >
746 struct TDMatTDMatAddExprTrait< DMatSMatSubExpr<MT1,MT2,true>, MT3 >
747 {
748  public:
749  //**********************************************************************************************
751  typedef typename SelectType< IsDenseMatrix<MT1>::value && IsColumnMajorMatrix<MT1>::value &&
752  IsSparseMatrix<MT2>::value && IsColumnMajorMatrix<MT2>::value &&
753  IsDenseMatrix<MT3>::value && IsColumnMajorMatrix<MT3>::value
754  , typename TDMatTSMatSubExprTrait< typename TDMatTDMatAddExprTrait<MT1,MT3>::Type, MT2 >::Type
755  , INVALID_TYPE >::Type Type;
757  //**********************************************************************************************
758 };
760 //*************************************************************************************************
761 
762 
763 //*************************************************************************************************
765 template< typename MT1, typename MT2, typename MT3 >
766 struct DMatDMatSubExprTrait< DMatSMatSubExpr<MT1,MT2,false>, MT3 >
767 {
768  public:
769  //**********************************************************************************************
771  typedef typename SelectType< IsDenseMatrix<MT1>::value && IsRowMajorMatrix<MT1>::value &&
772  IsSparseMatrix<MT2>::value && IsRowMajorMatrix<MT2>::value &&
773  IsDenseMatrix<MT3>::value && IsRowMajorMatrix<MT3>::value
774  , typename DMatSMatSubExprTrait< typename DMatDMatSubExprTrait<MT1,MT3>::Type, MT2 >::Type
775  , INVALID_TYPE >::Type Type;
777  //**********************************************************************************************
778 };
780 //*************************************************************************************************
781 
782 
783 //*************************************************************************************************
785 template< typename MT1, typename MT2, typename MT3 >
786 struct DMatTDMatSubExprTrait< 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 && IsColumnMajorMatrix<MT3>::value
794  , typename DMatSMatSubExprTrait< typename DMatTDMatSubExprTrait<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 TDMatDMatSubExprTrait< DMatSMatSubExpr<MT1,MT2,true>, MT3 >
807 {
808  public:
809  //**********************************************************************************************
811  typedef typename SelectType< IsDenseMatrix<MT1>::value && IsColumnMajorMatrix<MT1>::value &&
812  IsSparseMatrix<MT2>::value && IsColumnMajorMatrix<MT2>::value &&
813  IsDenseMatrix<MT3>::value && IsRowMajorMatrix<MT3>::value
814  , typename DMatTSMatSubExprTrait< typename TDMatDMatSubExprTrait<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 TDMatTDMatSubExprTrait< 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 && IsColumnMajorMatrix<MT3>::value
834  , typename TDMatTSMatSubExprTrait< typename TDMatTDMatSubExprTrait<MT1,MT3>::Type, MT2 >::Type
835  , INVALID_TYPE >::Type Type;
837  //**********************************************************************************************
838 };
840 //*************************************************************************************************
841 
842 
843 //*************************************************************************************************
845 template< typename MT1, typename MT2, bool SO, bool AF >
846 struct SubmatrixExprTrait< DMatSMatSubExpr<MT1,MT2,SO>, AF >
847 {
848  public:
849  //**********************************************************************************************
850  typedef typename SubExprTrait< typename SubmatrixExprTrait<const MT1,AF>::Type
851  , typename SubmatrixExprTrait<const MT2,AF>::Type >::Type Type;
852  //**********************************************************************************************
853 };
855 //*************************************************************************************************
856 
857 
858 //*************************************************************************************************
860 template< typename MT1, typename MT2, bool SO >
861 struct RowExprTrait< DMatSMatSubExpr<MT1,MT2,SO> >
862 {
863  public:
864  //**********************************************************************************************
865  typedef typename SubExprTrait< typename RowExprTrait<const MT1>::Type
866  , typename RowExprTrait<const MT2>::Type >::Type Type;
867  //**********************************************************************************************
868 };
870 //*************************************************************************************************
871 
872 
873 //*************************************************************************************************
875 template< typename MT1, typename MT2, bool SO >
876 struct ColumnExprTrait< DMatSMatSubExpr<MT1,MT2,SO> >
877 {
878  public:
879  //**********************************************************************************************
880  typedef typename SubExprTrait< typename ColumnExprTrait<const MT1>::Type
881  , typename ColumnExprTrait<const MT2>::Type >::Type Type;
882  //**********************************************************************************************
883 };
885 //*************************************************************************************************
886 
887 } // namespace blaze
888 
889 #endif
RightOperand rhs_
Right-hand side sparse matrix of the subtraction expression.
Definition: DMatSMatSubExpr.h:254
MT2::ReturnType RN2
Return type of the right-hand side sparse matrix expression.
Definition: DMatSMatSubExpr.h:98
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 subtraction trait.
SubTrait< RT1, RT2 >::Type ResultType
Result type for expression template evaluations.
Definition: DMatSMatSubExpr.h:131
void smpSubAssign(DenseMatrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the SMP subtraction assignment of a matrix to dense matrix.
Definition: DenseMatrix.h:152
Header file for the IsSparseMatrix type trait.
ResultType::ElementType ElementType
Resulting element type.
Definition: DMatSMatSubExpr.h:134
#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:199
#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.
MT2::ResultType RT2
Result type of the right-hand side sparse matrix expression.
Definition: DMatSMatSubExpr.h:96
const This & CompositeType
Data type for composite expression templates.
Definition: CompressedMatrix.h:2408
Type ElementType
Type of the sparse matrix elements.
Definition: CompressedMatrix.h:251
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:690
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:233
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:409
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:179
Constraint on the data type.
Constraint on the data type.
void smpAddAssign(DenseMatrix< 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:122
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:253
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:163
Header file for the DenseMatrix base class.
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:271
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:140
size_t columns() const
Returns the current number of columns of the matrix.
Definition: DMatSMatSubExpr.h:201
#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:103
MT1::ReturnType RN1
Return type of the left-hand side dense matrix expression.
Definition: DMatSMatSubExpr.h:97
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.
bool isAliased(const T *alias) const
Returns whether the expression is aliased with the given address alias.
Definition: DMatSMatSubExpr.h:246
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:146
void smpAssign(DenseMatrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the SMP assignment of a matrix to a dense matrix.
Definition: DenseMatrix.h:92
Header file for the SubmatrixExprTrait class template.
const Type & ReturnType
Return type for expression template evaluations.
Definition: CompressedMatrix.h:2407
ResultType::OppositeType OppositeType
Result type with opposite storage order for expression template evaluations.
Definition: DMatSMatSubExpr.h:132
DMatSMatSubExpr< MT1, MT2, SO > This
Type of this DMatSMatSubExpr instance.
Definition: DMatSMatSubExpr.h:130
Header file for run time assertion macros.
Expression object for dense matrix-sparse matrix subtractions.The DMatSMatSubExpr class represents th...
Definition: DMatSMatSubExpr.h:89
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:301
const DenseIterator< Type > operator-(const DenseIterator< Type > &it, ptrdiff_t inc)
Subtraction between a DenseIterator and an integral value.
Definition: DenseIterator.h:585
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:331
ResultType::TransposeType TransposeType
Transpose type for expression template evaluations.
Definition: DMatSMatSubExpr.h:133
SubExprTrait< RN1, RN2 >::Type ExprReturnType
Expression return type for the subscript operator.
Definition: DMatSMatSubExpr.h:111
RightOperand rightOperand() const
Returns the right-hand side dense matrix operand.
Definition: DMatSMatSubExpr.h:221
MT1::ResultType RT1
Result type of the left-hand side dense matrix expression.
Definition: DMatSMatSubExpr.h:95
SelectType< IsExpression< MT1 >::value, const MT1, const MT1 & >::Type LeftOperand
Composite type of the left-hand side dense matrix expression.
Definition: DMatSMatSubExpr.h:143
LeftOperand leftOperand() const
Returns the left-hand side dense matrix operand.
Definition: DMatSMatSubExpr.h:211
#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
#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:2403
Header file for basic type definitions.
Base template for the SubTrait class.
Definition: SubTrait.h:141
Header file for the SubExprTrait class template.
const SelectType< returnExpr, ExprReturnType, ElementType >::Type ReturnType
Return type for expression template evaluations.
Definition: DMatSMatSubExpr.h:137
#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:191
Header file for the IsExpression type trait class.
Header file for the FunctionTrace class.