All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
TSMatDMatSubExpr.h
Go to the documentation of this file.
1 //=================================================================================================
33 //=================================================================================================
34 
35 #ifndef _BLAZE_MATH_EXPRESSIONS_TSMATDMATSUBEXPR_H_
36 #define _BLAZE_MATH_EXPRESSIONS_TSMATDMATSUBEXPR_H_
37 
38 
39 //*************************************************************************************************
40 // Includes
41 //*************************************************************************************************
42 
43 #include <stdexcept>
60 #include <blaze/util/Assert.h>
63 #include <blaze/util/SelectType.h>
64 #include <blaze/util/Types.h>
65 
66 
67 namespace blaze {
68 
69 //=================================================================================================
70 //
71 // CLASS SMATTDMATSUBEXPR
72 //
73 //=================================================================================================
74 
75 //*************************************************************************************************
82 template< typename MT1 // Type of the left-hand side sparse matrix
83  , typename MT2 > // Type of the right-hand side dense matrix
84 class TSMatDMatSubExpr : public DenseMatrix< TSMatDMatSubExpr<MT1,MT2>, false >
85  , private MatMatSubExpr
86  , private Computation
87 {
88  private:
89  //**Type definitions****************************************************************************
90  typedef typename MT1::ResultType RT1;
91  typedef typename MT2::ResultType RT2;
92  typedef typename MT1::ReturnType RN1;
93  typedef typename MT2::ReturnType RN2;
94  //**********************************************************************************************
95 
96  //**Return type evaluation**********************************************************************
98 
103  enum { returnExpr = !IsTemporary<RN1>::value && !IsTemporary<RN2>::value };
104 
107  //**********************************************************************************************
108 
109  //**Parallel evaluation strategy****************************************************************
111 
116  template< typename MT >
117  struct UseSMPAssign {
118  enum { value = ( !MT1::smpAssignable || !MT2::smpAssignable ) };
119  };
121  //**********************************************************************************************
122 
123  public:
124  //**Type definitions****************************************************************************
130 
133 
135  typedef const ResultType CompositeType;
136 
138  typedef typename SelectType< IsExpression<MT1>::value, const MT1, const MT1& >::Type LeftOperand;
139 
141  typedef typename SelectType< IsExpression<MT2>::value, const MT2, const MT2& >::Type RightOperand;
142  //**********************************************************************************************
143 
144  //**Compilation flags***************************************************************************
146  enum { vectorizable = 0 };
147 
149  enum { smpAssignable = 0 };
150  //**********************************************************************************************
151 
152  //**Constructor*********************************************************************************
158  explicit inline TSMatDMatSubExpr( const MT1& lhs, const MT2& rhs )
159  : lhs_( lhs ) // Left-hand side sparse matrix of the subtraction expression
160  , rhs_( rhs ) // Right-hand side dense matrix of the subtraction expression
161  {
162  BLAZE_INTERNAL_ASSERT( lhs.rows() == rhs.rows() , "Invalid number of rows" );
163  BLAZE_INTERNAL_ASSERT( lhs.columns() == rhs.columns(), "Invalid number of columns" );
164  }
165  //**********************************************************************************************
166 
167  //**Access operator*****************************************************************************
174  inline ReturnType operator()( size_t i, size_t j ) const {
175  BLAZE_INTERNAL_ASSERT( i < lhs_.rows() , "Invalid row access index" );
176  BLAZE_INTERNAL_ASSERT( j < lhs_.columns(), "Invalid column access index" );
177  return lhs_(i,j) - rhs_(i,j);
178  }
179  //**********************************************************************************************
180 
181  //**Rows function*******************************************************************************
186  inline size_t rows() const {
187  return lhs_.rows();
188  }
189  //**********************************************************************************************
190 
191  //**Columns function****************************************************************************
196  inline size_t columns() const {
197  return lhs_.columns();
198  }
199  //**********************************************************************************************
200 
201  //**Left operand access*************************************************************************
206  inline LeftOperand leftOperand() const {
207  return lhs_;
208  }
209  //**********************************************************************************************
210 
211  //**Right operand access************************************************************************
216  inline RightOperand rightOperand() const {
217  return rhs_;
218  }
219  //**********************************************************************************************
220 
221  //**********************************************************************************************
227  template< typename T >
228  inline bool canAlias( const T* alias ) const {
229  return ( lhs_.canAlias( alias ) ) ||
230  ( IsExpression<MT2>::value && rhs_.canAlias( alias ) );
231  }
232  //**********************************************************************************************
233 
234  //**********************************************************************************************
240  template< typename T >
241  inline bool isAliased( const T* alias ) const {
242  return lhs_.isAliased( alias ) || rhs_.isAliased( alias );
243  }
244  //**********************************************************************************************
245 
246  private:
247  //**Member variables****************************************************************************
250  //**********************************************************************************************
251 
252  //**Assignment to dense matrices****************************************************************
264  template< typename MT // Type of the target dense matrix
265  , bool SO2 > // Storage order of the target dense matrix
266  friend inline void assign( DenseMatrix<MT,SO2>& lhs, const TSMatDMatSubExpr& rhs )
267  {
269 
270  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
271  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
272 
273  assign ( ~lhs, -rhs.rhs_ );
274  addAssign( ~lhs, rhs.lhs_ );
275  }
277  //**********************************************************************************************
278 
279  //**Assignment to sparse matrices***************************************************************
291  template< typename MT // Type of the target sparse matrix
292  , bool SO2 > // Storage order of the target sparse matrix
293  friend inline void assign( SparseMatrix<MT,SO2>& lhs, const TSMatDMatSubExpr& rhs )
294  {
296 
297  typedef typename SelectType< SO2, OppositeType, ResultType >::Type TmpType;
298 
305 
306  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
307  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
308 
309  const TmpType tmp( serial( rhs ) );
310  assign( ~lhs, tmp );
311  }
313  //**********************************************************************************************
314 
315  //**Addition assignment to dense matrices*******************************************************
328  template< typename MT // Type of the target dense matrix
329  , bool SO2 > // Storage order of the target dense matrix
330  friend inline void addAssign( DenseMatrix<MT,SO2>& lhs, const TSMatDMatSubExpr& rhs )
331  {
333 
334  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
335  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
336 
337  subAssign( ~lhs, rhs.rhs_ );
338  addAssign( ~lhs, rhs.lhs_ );
339  }
341  //**********************************************************************************************
342 
343  //**Addition assignment to sparse matrices******************************************************
344  // No special implementation for the addition assignment to sparse matrices.
345  //**********************************************************************************************
346 
347  //**Subtraction assignment to dense matrices****************************************************
360  template< typename MT // Type of the target dense matrix
361  , bool SO2 > // Storage order of the target dense matrix
362  friend inline void subAssign( DenseMatrix<MT,SO2>& lhs, const TSMatDMatSubExpr& rhs )
363  {
365 
366  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
367  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
368 
369  addAssign( ~lhs, rhs.rhs_ );
370  subAssign( ~lhs, rhs.lhs_ );
371  }
373  //**********************************************************************************************
374 
375  //**Subtraction assignment to sparse matrices***************************************************
376  // No special implementation for the subtraction assignment to sparse matrices.
377  //**********************************************************************************************
378 
379  //**Multiplication assignment to dense matrices*************************************************
380  // No special implementation for the multiplication assignment to dense matrices.
381  //**********************************************************************************************
382 
383  //**Multiplication assignment to sparse matrices************************************************
384  // No special implementation for the multiplication assignment to sparse matrices.
385  //**********************************************************************************************
386 
387  //**SMP assignment to dense matrices************************************************************
401  template< typename MT // Type of the target dense matrix
402  , bool SO2 > // Storage order of the target dense matrix
403  friend inline typename EnableIf< UseSMPAssign<MT> >::Type
404  smpAssign( DenseMatrix<MT,SO2>& lhs, const TSMatDMatSubExpr& rhs )
405  {
407 
408  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
409  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
410 
411  smpAssign ( ~lhs, -rhs.rhs_ );
412  smpAddAssign( ~lhs, rhs.lhs_ );
413  }
415  //**********************************************************************************************
416 
417  //**SMP assignment to sparse matrices***********************************************************
431  template< typename MT // Type of the target sparse matrix
432  , bool SO2 > // Storage order of the target sparse matrix
433  friend inline typename EnableIf< UseSMPAssign<MT> >::Type
434  smpAssign( SparseMatrix<MT,SO2>& lhs, const TSMatDMatSubExpr& rhs )
435  {
437 
438  typedef typename SelectType< SO2, OppositeType, ResultType >::Type TmpType;
439 
446 
447  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
448  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
449 
450  const TmpType tmp( rhs );
451  smpAssign( ~lhs, tmp );
452  }
454  //**********************************************************************************************
455 
456  //**SMP addition assignment to dense matrices***************************************************
471  template< typename MT // Type of the target dense matrix
472  , bool SO2 > // Storage order of the target dense matrix
473  friend inline typename EnableIf< UseSMPAssign<MT> >::Type
474  smpAddAssign( DenseMatrix<MT,SO2>& lhs, const TSMatDMatSubExpr& rhs )
475  {
477 
478  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
479  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
480 
481  smpSubAssign( ~lhs, rhs.rhs_ );
482  smpAddAssign( ~lhs, rhs.lhs_ );
483  }
485  //**********************************************************************************************
486 
487  //**SMP addition assignment to sparse matrices**************************************************
488  // No special implementation for the SMP addition assignment to sparse matrices.
489  //**********************************************************************************************
490 
491  //**SMP subtraction assignment to dense matrices************************************************
506  template< typename MT // Type of the target dense matrix
507  , bool SO2 > // Storage order of the target dense matrix
508  friend inline typename EnableIf< UseSMPAssign<MT> >::Type
509  smpSubAssign( DenseMatrix<MT,SO2>& lhs, const TSMatDMatSubExpr& rhs )
510  {
512 
513  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
514  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
515 
516  smpAddAssign( ~lhs, rhs.rhs_ );
517  smpSubAssign( ~lhs, rhs.lhs_ );
518  }
520  //**********************************************************************************************
521 
522  //**SMP subtraction assignment to sparse matrices***********************************************
523  // No special implementation for the SMP subtraction assignment to sparse matrices.
524  //**********************************************************************************************
525 
526  //**SMP multiplication assignment to dense matrices*********************************************
527  // No special implementation for the SMP multiplication assignment to dense matrices.
528  //**********************************************************************************************
529 
530  //**SMP multiplication assignment to sparse matrices********************************************
531  // No special implementation for the SMP multiplication assignment to sparse matrices.
532  //**********************************************************************************************
533 
534  //**Compile time checks*************************************************************************
541  //**********************************************************************************************
542 };
543 //*************************************************************************************************
544 
545 
546 
547 
548 //=================================================================================================
549 //
550 // GLOBAL BINARY ARITHMETIC OPERATORS
551 //
552 //=================================================================================================
553 
554 //*************************************************************************************************
584 template< typename T1 // Type of the left-hand side sparse matrix
585  , typename T2 > // Type of the right-hand side dense matrix
586 inline const TSMatDMatSubExpr<T1,T2>
588 {
590 
591  if( (~lhs).rows() != (~rhs).rows() || (~lhs).columns() != (~rhs).columns() )
592  throw std::invalid_argument( "Matrix sizes do not match" );
593 
594  return TSMatDMatSubExpr<T1,T2>( ~lhs, ~rhs );
595 }
596 //*************************************************************************************************
597 
598 
599 
600 
601 //=================================================================================================
602 //
603 // GLOBAL RESTRUCTURING BINARY ARITHMETIC OPERATORS
604 //
605 //=================================================================================================
606 
607 //*************************************************************************************************
620 template< typename T1 // Type of the sparse matrix of the left-hand side expression
621  , typename T2 // Type of the dense matrix of the left-hand side expression
622  , typename T3 // Type of the right-hand side dense matrix
623  , bool SO > // Storage order of the right-hand side dense matrix
624 inline const typename AddExprTrait< TSMatDMatSubExpr<T1,T2>, T3 >::Type
625  operator+( const TSMatDMatSubExpr<T1,T2>& lhs, const DenseMatrix<T3,SO>& rhs )
626 {
628 
629  return ( (~rhs) - lhs.rightOperand() ) + lhs.leftOperand();
630 }
632 //*************************************************************************************************
633 
634 
635 //*************************************************************************************************
648 template< typename T1 // Type of the sparse matrix of the left-hand side expression
649  , typename T2 // Type of the dense matrix of the left-hand side expression
650  , typename T3 // Type of the right-hand side dense matrix
651  , bool SO > // Storage order of the right-hand side dense matrix
652 inline const typename SubExprTrait< TSMatDMatSubExpr<T1,T2>, T3 >::Type
653  operator-( const TSMatDMatSubExpr<T1,T2>& lhs, const DenseMatrix<T3,SO>& rhs )
654 {
656 
657  return lhs.leftOperand() - ( lhs.rightOperand() + (~rhs) );
658 }
660 //*************************************************************************************************
661 
662 
663 
664 
665 //=================================================================================================
666 //
667 // EXPRESSION TRAIT SPECIALIZATIONS
668 //
669 //=================================================================================================
670 
671 //*************************************************************************************************
673 template< typename MT1, typename MT2, typename MT3 >
674 struct DMatDMatAddExprTrait< TSMatDMatSubExpr<MT1,MT2>, MT3 >
675 {
676  public:
677  //**********************************************************************************************
679  typedef typename SelectType< IsSparseMatrix<MT1>::value && IsColumnMajorMatrix<MT1>::value &&
680  IsDenseMatrix<MT2>::value && IsRowMajorMatrix<MT2>::value &&
681  IsDenseMatrix<MT3>::value && IsRowMajorMatrix<MT3>::value
682  , typename DMatTSMatAddExprTrait< typename DMatDMatSubExprTrait<MT3,MT2>::Type, MT1 >::Type
683  , INVALID_TYPE >::Type Type;
685  //**********************************************************************************************
686 };
688 //*************************************************************************************************
689 
690 
691 //*************************************************************************************************
693 template< typename MT1, typename MT2, typename MT3 >
694 struct DMatTDMatAddExprTrait< TSMatDMatSubExpr<MT1,MT2>, MT3 >
695 {
696  public:
697  //**********************************************************************************************
699  typedef typename SelectType< IsSparseMatrix<MT1>::value && IsColumnMajorMatrix<MT1>::value &&
700  IsDenseMatrix<MT2>::value && IsRowMajorMatrix<MT2>::value &&
701  IsDenseMatrix<MT3>::value && IsColumnMajorMatrix<MT3>::value
702  , typename DMatTSMatAddExprTrait< typename TDMatDMatSubExprTrait<MT3,MT2>::Type, MT1 >::Type
703  , INVALID_TYPE >::Type Type;
705  //**********************************************************************************************
706 };
708 //*************************************************************************************************
709 
710 
711 //*************************************************************************************************
713 template< typename MT1, typename MT2, typename MT3 >
714 struct DMatDMatSubExprTrait< TSMatDMatSubExpr<MT1,MT2>, MT3 >
715 {
716  public:
717  //**********************************************************************************************
719  typedef typename SelectType< IsSparseMatrix<MT1>::value && IsColumnMajorMatrix<MT1>::value &&
720  IsDenseMatrix<MT2>::value && IsRowMajorMatrix<MT2>::value &&
721  IsDenseMatrix<MT3>::value && IsRowMajorMatrix<MT3>::value
722  , typename TSMatDMatSubExprTrait< MT1, typename DMatDMatAddExprTrait<MT2,MT3>::Type >::Type
723  , INVALID_TYPE >::Type Type;
725  //**********************************************************************************************
726 };
728 //*************************************************************************************************
729 
730 
731 //*************************************************************************************************
733 template< typename MT1, typename MT2, typename MT3 >
734 struct DMatTDMatSubExprTrait< TSMatDMatSubExpr<MT1,MT2>, MT3 >
735 {
736  public:
737  //**********************************************************************************************
739  typedef typename SelectType< IsSparseMatrix<MT1>::value && IsColumnMajorMatrix<MT1>::value &&
740  IsDenseMatrix<MT2>::value && IsRowMajorMatrix<MT2>::value &&
741  IsDenseMatrix<MT3>::value && IsColumnMajorMatrix<MT3>::value
742  , typename TSMatDMatSubExprTrait< MT1, typename DMatTDMatAddExprTrait<MT2,MT3>::Type >::Type
743  , INVALID_TYPE >::Type Type;
745  //**********************************************************************************************
746 };
748 //*************************************************************************************************
749 
750 
751 //*************************************************************************************************
753 template< typename MT1, typename MT2, bool AF >
754 struct SubmatrixExprTrait< TSMatDMatSubExpr<MT1,MT2>, AF >
755 {
756  public:
757  //**********************************************************************************************
758  typedef typename SubExprTrait< typename SubmatrixExprTrait<const MT1,AF>::Type
759  , typename SubmatrixExprTrait<const MT2,AF>::Type >::Type Type;
760  //**********************************************************************************************
761 };
763 //*************************************************************************************************
764 
765 
766 //*************************************************************************************************
768 template< typename MT1, typename MT2 >
769 struct RowExprTrait< TSMatDMatSubExpr<MT1,MT2> >
770 {
771  public:
772  //**********************************************************************************************
773  typedef typename SubExprTrait< typename RowExprTrait<const MT1>::Type
774  , typename RowExprTrait<const MT2>::Type >::Type Type;
775  //**********************************************************************************************
776 };
778 //*************************************************************************************************
779 
780 
781 //*************************************************************************************************
783 template< typename MT1, typename MT2 >
784 struct ColumnExprTrait< TSMatDMatSubExpr<MT1,MT2> >
785 {
786  public:
787  //**********************************************************************************************
788  typedef typename SubExprTrait< typename ColumnExprTrait<const MT1>::Type
789  , typename ColumnExprTrait<const MT2>::Type >::Type Type;
790  //**********************************************************************************************
791 };
793 //*************************************************************************************************
794 
795 } // namespace blaze
796 
797 #endif
bool canAlias(const T *alias) const
Returns whether the expression can alias with the given address alias.
Definition: TSMatDMatSubExpr.h:228
Compile time check whether the given type is a temporary vector or matrix type.This type trait class ...
Definition: IsTemporary.h:87
size_t columns() const
Returns the current number of columns of the matrix.
Definition: TSMatDMatSubExpr.h:196
ReturnType operator()(size_t i, size_t j) const
2D-access to the matrix elements.
Definition: TSMatDMatSubExpr.h:174
Header file for the subtraction trait.
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
Efficient implementation of a compressed matrix.The CompressedMatrix class template is the represent...
Definition: CompressedMatrix.h:199
MT1::ResultType RT1
Result type of the left-hand side sparse matrix expression.
Definition: TSMatDMatSubExpr.h:90
#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.
RightOperand rightOperand() const
Returns the right-hand side dense matrix operand.
Definition: TSMatDMatSubExpr.h:216
ResultType::OppositeType OppositeType
Result type with opposite storage order for expression template evaluations.
Definition: TSMatDMatSubExpr.h:127
LeftOperand leftOperand() const
Returns the left-hand side transpose sparse matrix operand.
Definition: TSMatDMatSubExpr.h:206
RightOperand rhs_
Right-hand side dense matrix of the subtraction expression.
Definition: TSMatDMatSubExpr.h:249
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.
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 ResultType CompositeType
Data type for composite expression templates.
Definition: TSMatDMatSubExpr.h:135
MT2::ReturnType RN2
Return type of the right-hand side dense matrix expression.
Definition: TSMatDMatSubExpr.h:93
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.
#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
LeftOperand lhs_
Left-hand side sparse matrix of the subtraction expression.
Definition: TSMatDMatSubExpr.h:248
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
ResultType::TransposeType TransposeType
Transpose type for expression template evaluations.
Definition: TSMatDMatSubExpr.h:128
#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
Header file for the SelectType class template.
Header file for the RowExprTrait class template.
Header file for all forward declarations for expression class templates.
bool isAliased(const T *alias) const
Returns whether the expression is aliased with the given address alias.
Definition: TSMatDMatSubExpr.h:241
Header file for the serial shim.
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.
#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:2407
Header file for run time assertion macros.
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
Expression object for transpose sparse matrix-dense matrix subtractions.The TSMatDMatSubExpr class re...
Definition: Forward.h:138
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
MT1::ReturnType RN1
Return type of the left-hand side sparse matrix expression.
Definition: TSMatDMatSubExpr.h:92
MT2::ResultType RT2
Result type of the right-hand side dense matrix expression.
Definition: TSMatDMatSubExpr.h:91
SelectType< IsExpression< MT2 >::value, const MT2, const MT2 & >::Type RightOperand
Composite type of the right-hand side sparse matrix expression.
Definition: TSMatDMatSubExpr.h:141
#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
TSMatDMatSubExpr(const MT1 &lhs, const MT2 &rhs)
Constructor for the TSMatDMatSubExpr class.
Definition: TSMatDMatSubExpr.h:158
ResultType::ElementType ElementType
Resulting element type.
Definition: TSMatDMatSubExpr.h:129
SubTrait< RT1, RT2 >::Type ResultType
Result type for expression template evaluations.
Definition: TSMatDMatSubExpr.h:126
const SelectType< returnExpr, ExprReturnType, ElementType >::Type ReturnType
Return type for expression template evaluations.
Definition: TSMatDMatSubExpr.h:132
SelectType< IsExpression< MT1 >::value, const MT1, const MT1 & >::Type LeftOperand
Composite type of the left-hand side dense matrix expression.
Definition: TSMatDMatSubExpr.h:138
#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
SubExprTrait< RN1, RN2 >::Type ExprReturnType
Expression return type for the subscript operator.
Definition: TSMatDMatSubExpr.h:106
Header file for basic type definitions.
Base template for the SubTrait class.
Definition: SubTrait.h:141
size_t rows() const
Returns the current number of rows of the matrix.
Definition: TSMatDMatSubExpr.h:186
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.
TSMatDMatSubExpr< MT1, MT2 > This
Type of this TSMatDMatSubExpr instance.
Definition: TSMatDMatSubExpr.h:125
Header file for the FunctionTrace class.