All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
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>
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 TDMATSMATSUBEXPR
72 //
73 //=================================================================================================
74 
75 //*************************************************************************************************
82 template< typename MT1 // Type of the left-hand side dense matrix
83  , typename MT2 > // Type of the right-hand side sparse matrix
84 class TDMatSMatSubExpr : public DenseMatrix< TDMatSMatSubExpr<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 TDMatSMatSubExpr( const MT1& lhs, const MT2& rhs )
159  : lhs_( lhs ) // Left-hand side dense matrix of the subtraction expression
160  , rhs_( rhs ) // Right-hand side sparse 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 ( IsExpression<MT1>::value && lhs_.canAlias( alias ) ) ||
230  ( 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 TDMatSMatSubExpr& 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  if( !IsExpression<MT1>::value && isSame( ~lhs, rhs.lhs_ ) ) {
274  subAssign( ~lhs, rhs.rhs_ );
275  }
276  else {
277  assign ( ~lhs, rhs.lhs_ );
278  subAssign( ~lhs, rhs.rhs_ );
279  }
280  }
282  //**********************************************************************************************
283 
284  //**Assignment to sparse matrices***************************************************************
296  template< typename MT // Type of the target sparse matrix
297  , bool SO2 > // Storage order of the target sparse matrix
298  friend inline void assign( SparseMatrix<MT,SO2>& lhs, const TDMatSMatSubExpr& rhs )
299  {
301 
302  typedef typename SelectType< SO2, OppositeType, ResultType >::Type TmpType;
303 
310 
311  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
312  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
313 
314  const TmpType tmp( serial( rhs ) );
315  assign( ~lhs, tmp );
316  }
318  //**********************************************************************************************
319 
320  //**Addition assignment to dense matrices*******************************************************
333  template< typename MT // Type of the target dense matrix
334  , bool SO2 > // Storage order of the target dense matrix
335  friend inline void addAssign( DenseMatrix<MT,SO2>& lhs, const TDMatSMatSubExpr& rhs )
336  {
338 
339  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
340  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
341 
342  addAssign( ~lhs, rhs.lhs_ );
343  subAssign( ~lhs, rhs.rhs_ );
344  }
346  //**********************************************************************************************
347 
348  //**Addition assignment to sparse matrices******************************************************
349  // No special implementation for the addition assignment to sparse matrices.
350  //**********************************************************************************************
351 
352  //**Subtraction assignment to dense matrices****************************************************
365  template< typename MT // Type of the target dense matrix
366  , bool SO2 > // Storage order of the target dense matrix
367  friend inline void subAssign( DenseMatrix<MT,SO2>& lhs, const TDMatSMatSubExpr& rhs )
368  {
370 
371  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
372  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
373 
374  subAssign( ~lhs, rhs.lhs_ );
375  addAssign( ~lhs, rhs.rhs_ );
376  }
378  //**********************************************************************************************
379 
380  //**Subtraction assignment to sparse matrices***************************************************
381  // No special implementation for the subtraction assignment to sparse matrices.
382  //**********************************************************************************************
383 
384  //**Multiplication assignment to dense matrices*************************************************
385  // No special implementation for the multiplication assignment to dense matrices.
386  //**********************************************************************************************
387 
388  //**Multiplication assignment to sparse matrices************************************************
389  // No special implementation for the multiplication assignment to sparse matrices.
390  //**********************************************************************************************
391 
392  //**SMP assignment to dense matrices************************************************************
406  template< typename MT // Type of the target dense matrix
407  , bool SO2 > // Storage order of the target dense matrix
408  friend inline typename EnableIf< UseSMPAssign<MT> >::Type
409  smpAssign( DenseMatrix<MT,SO2>& lhs, const TDMatSMatSubExpr& rhs )
410  {
412 
413  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
414  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
415 
416  if( !IsExpression<MT1>::value && isSame( ~lhs, rhs.lhs_ ) ) {
417  smpSubAssign( ~lhs, rhs.rhs_ );
418  }
419  else {
420  smpAssign ( ~lhs, rhs.lhs_ );
421  smpSubAssign( ~lhs, rhs.rhs_ );
422  }
423  }
425  //**********************************************************************************************
426 
427  //**SMP assignment to sparse matrices***********************************************************
441  template< typename MT // Type of the target sparse matrix
442  , bool SO2 > // Storage order of the target sparse matrix
443  friend inline typename EnableIf< UseSMPAssign<MT> >::Type
444  smpAssign( SparseMatrix<MT,SO2>& lhs, const TDMatSMatSubExpr& rhs )
445  {
447 
448  typedef typename SelectType< SO2, OppositeType, ResultType >::Type TmpType;
449 
456 
457  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
458  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
459 
460  const TmpType tmp( rhs );
461  smpAssign( ~lhs, tmp );
462  }
464  //**********************************************************************************************
465 
466  //**SMP addition assignment to dense matrices***************************************************
481  template< typename MT // Type of the target dense matrix
482  , bool SO2 > // Storage order of the target dense matrix
483  friend inline typename EnableIf< UseSMPAssign<MT> >::Type
484  smpAddAssign( DenseMatrix<MT,SO2>& lhs, const TDMatSMatSubExpr& rhs )
485  {
487 
488  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
489  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
490 
491  smpAddAssign( ~lhs, rhs.lhs_ );
492  smpSubAssign( ~lhs, rhs.rhs_ );
493  }
495  //**********************************************************************************************
496 
497  //**SMP addition assignment to sparse matrices**************************************************
498  // No special implementation for the SMP addition assignment to sparse matrices.
499  //**********************************************************************************************
500 
501  //**SMP subtraction assignment to dense matrices************************************************
516  template< typename MT // Type of the target dense matrix
517  , bool SO2 > // Storage order of the target dense matrix
518  friend inline typename EnableIf< UseSMPAssign<MT> >::Type
519  smpSubAssign( DenseMatrix<MT,SO2>& lhs, const TDMatSMatSubExpr& rhs )
520  {
522 
523  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
524  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
525 
526  smpSubAssign( ~lhs, rhs.lhs_ );
527  smpAddAssign( ~lhs, rhs.rhs_ );
528  }
530  //**********************************************************************************************
531 
532  //**SMP subtraction assignment to sparse matrices***********************************************
533  // No special implementation for the SMP subtraction assignment to sparse matrices.
534  //**********************************************************************************************
535 
536  //**SMP multiplication assignment to dense matrices*********************************************
537  // No special implementation for the SMP multiplication assignment to dense matrices.
538  //**********************************************************************************************
539 
540  //**SMP multiplication assignment to sparse matrices********************************************
541  // No special implementation for the SMP multiplication assignment to sparse matrices.
542  //**********************************************************************************************
543 
544  //**Compile time checks*************************************************************************
551  //**********************************************************************************************
552 };
553 //*************************************************************************************************
554 
555 
556 
557 
558 //=================================================================================================
559 //
560 // GLOBAL BINARY ARITHMETIC OPERATORS
561 //
562 //=================================================================================================
563 
564 //*************************************************************************************************
595 template< typename T1 // Type of the left-hand side dense matrix
596  , typename T2 > // Type of the right-hand side sparse matrix
597 inline const TDMatSMatSubExpr<T1,T2>
599 {
601 
602  if( (~lhs).rows() != (~rhs).rows() || (~lhs).columns() != (~rhs).columns() )
603  throw std::invalid_argument( "Matrix sizes do not match" );
604 
605  return TDMatSMatSubExpr<T1,T2>( ~lhs, ~rhs );
606 }
607 //*************************************************************************************************
608 
609 
610 
611 
612 //=================================================================================================
613 //
614 // GLOBAL RESTRUCTURING BINARY ARITHMETIC OPERATORS
615 //
616 //=================================================================================================
617 
618 //*************************************************************************************************
631 template< typename T1 // Type of the dense matrix of the left-hand side expression
632  , typename T2 // Type of the sparse matrix of the left-hand side expression
633  , typename T3 // Type of the right-hand side dense matrix
634  , bool SO > // Storage order of the right-hand side dense matrix
635 inline const typename AddExprTrait< TDMatSMatSubExpr<T1,T2>, T3 >::Type
636  operator+( const TDMatSMatSubExpr<T1,T2>& lhs, const DenseMatrix<T3,SO>& 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  , typename T3 // Type of the right-hand side dense matrix
662  , bool SO > // Storage order of the right-hand side dense matrix
663 inline const typename SubExprTrait< TDMatSMatSubExpr<T1,T2>, T3 >::Type
664  operator-( const TDMatSMatSubExpr<T1,T2>& lhs, const DenseMatrix<T3,SO>& rhs )
665 {
667 
668  return ( lhs.leftOperand() - (~rhs) ) - lhs.rightOperand();
669 }
671 //*************************************************************************************************
672 
673 
674 
675 
676 //=================================================================================================
677 //
678 // EXPRESSION TRAIT SPECIALIZATIONS
679 //
680 //=================================================================================================
681 
682 //*************************************************************************************************
684 template< typename MT1, typename MT2, typename MT3 >
685 struct DMatDMatAddExprTrait< TDMatSMatSubExpr<MT1,MT2>, MT3 >
686 {
687  public:
688  //**********************************************************************************************
690  typedef typename SelectType< IsDenseMatrix<MT1>::value && IsColumnMajorMatrix<MT1>::value &&
691  IsSparseMatrix<MT2>::value && IsRowMajorMatrix<MT2>::value &&
692  IsDenseMatrix<MT3>::value && IsRowMajorMatrix<MT3>::value
693  , typename DMatSMatSubExprTrait< typename TDMatDMatAddExprTrait<MT1,MT3>::Type, MT2 >::Type
694  , INVALID_TYPE >::Type Type;
696  //**********************************************************************************************
697 };
699 //*************************************************************************************************
700 
701 
702 //*************************************************************************************************
704 template< typename MT1, typename MT2, typename MT3 >
705 struct DMatTDMatAddExprTrait< TDMatSMatSubExpr<MT1,MT2>, MT3 >
706 {
707  public:
708  //**********************************************************************************************
710  typedef typename SelectType< IsDenseMatrix<MT1>::value && IsColumnMajorMatrix<MT1>::value &&
711  IsSparseMatrix<MT2>::value && IsRowMajorMatrix<MT2>::value &&
712  IsDenseMatrix<MT3>::value && IsColumnMajorMatrix<MT3>::value
713  , typename TDMatSMatSubExprTrait< typename TDMatTDMatAddExprTrait<MT1,MT3>::Type, MT2 >::Type
714  , INVALID_TYPE >::Type Type;
716  //**********************************************************************************************
717 };
719 //*************************************************************************************************
720 
721 
722 //*************************************************************************************************
724 template< typename MT1, typename MT2, typename MT3 >
725 struct DMatDMatSubExprTrait< TDMatSMatSubExpr<MT1,MT2>, MT3 >
726 {
727  public:
728  //**********************************************************************************************
730  typedef typename SelectType< IsDenseMatrix<MT1>::value && IsColumnMajorMatrix<MT1>::value &&
731  IsSparseMatrix<MT2>::value && IsRowMajorMatrix<MT2>::value &&
732  IsDenseMatrix<MT3>::value && IsRowMajorMatrix<MT3>::value
733  , typename DMatSMatSubExprTrait< typename TDMatDMatSubExprTrait<MT1,MT3>::Type, MT2 >::Type
734  , INVALID_TYPE >::Type Type;
736  //**********************************************************************************************
737 };
739 //*************************************************************************************************
740 
741 
742 //*************************************************************************************************
744 template< typename MT1, typename MT2, typename MT3 >
745 struct DMatTDMatSubExprTrait< TDMatSMatSubExpr<MT1,MT2>, MT3 >
746 {
747  public:
748  //**********************************************************************************************
750  typedef typename SelectType< IsDenseMatrix<MT1>::value && IsColumnMajorMatrix<MT1>::value &&
751  IsSparseMatrix<MT2>::value && IsRowMajorMatrix<MT2>::value &&
752  IsDenseMatrix<MT3>::value && IsColumnMajorMatrix<MT3>::value
753  , typename TDMatSMatSubExprTrait< typename TDMatTDMatSubExprTrait<MT1,MT3>::Type, MT2 >::Type
754  , INVALID_TYPE >::Type Type;
756  //**********************************************************************************************
757 };
759 //*************************************************************************************************
760 
761 
762 //*************************************************************************************************
764 template< typename MT1, typename MT2, bool AF >
765 struct SubmatrixExprTrait< TDMatSMatSubExpr<MT1,MT2>, AF >
766 {
767  public:
768  //**********************************************************************************************
769  typedef typename SubExprTrait< typename SubmatrixExprTrait<const MT1,AF>::Type
770  , typename SubmatrixExprTrait<const MT2,AF>::Type >::Type Type;
771  //**********************************************************************************************
772 };
774 //*************************************************************************************************
775 
776 
777 //*************************************************************************************************
779 template< typename MT1, typename MT2 >
780 struct RowExprTrait< TDMatSMatSubExpr<MT1,MT2> >
781 {
782  public:
783  //**********************************************************************************************
784  typedef typename SubExprTrait< typename RowExprTrait<const MT1>::Type
785  , typename RowExprTrait<const MT2>::Type >::Type Type;
786  //**********************************************************************************************
787 };
789 //*************************************************************************************************
790 
791 
792 //*************************************************************************************************
794 template< typename MT1, typename MT2 >
795 struct ColumnExprTrait< TDMatSMatSubExpr<MT1,MT2> >
796 {
797  public:
798  //**********************************************************************************************
799  typedef typename SubExprTrait< typename ColumnExprTrait<const MT1>::Type
800  , typename ColumnExprTrait<const MT2>::Type >::Type Type;
801  //**********************************************************************************************
802 };
804 //*************************************************************************************************
805 
806 } // namespace blaze
807 
808 #endif
RightOperand rightOperand() const
Returns the right-hand side sparse matrix operand.
Definition: TDMatSMatSubExpr.h:216
MT2::ReturnType RN2
Return type of the right-hand side sparse matrix expression.
Definition: TDMatSMatSubExpr.h:93
ResultType::TransposeType TransposeType
Transpose type for expression template evaluations.
Definition: TDMatSMatSubExpr.h:128
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.
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
const ResultType CompositeType
Data type for composite expression templates.
Definition: TDMatSMatSubExpr.h:135
Efficient implementation of a compressed matrix.The CompressedMatrix class template is the represent...
Definition: CompressedMatrix.h:199
TDMatSMatSubExpr< MT1, MT2 > This
Type of this TDMatSMatSubExpr instance.
Definition: TDMatSMatSubExpr.h:125
#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.
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 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.
ResultType::OppositeType OppositeType
Result type with opposite storage order for expression template evaluations.
Definition: TDMatSMatSubExpr.h:127
ResultType::ElementType ElementType
Resulting element type.
Definition: TDMatSMatSubExpr.h:129
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.
SubExprTrait< RN1, RN2 >::Type ExprReturnType
Expression return type for the subscript operator.
Definition: TDMatSMatSubExpr.h:106
MT2::ResultType RT2
Result type of the right-hand side sparse matrix expression.
Definition: TDMatSMatSubExpr.h:91
SelectType< IsExpression< MT1 >::value, const MT1, const MT1 & >::Type LeftOperand
Composite type of the left-hand side dense matrix expression.
Definition: TDMatSMatSubExpr.h:138
#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 dense matrix of the subtraction expression.
Definition: TDMatSMatSubExpr.h:248
MT1::ReturnType RN1
Return type of the left-hand side dense matrix expression.
Definition: TDMatSMatSubExpr.h:92
Header file for the DenseMatrix base class.
bool isAliased(const T *alias) const
Returns whether the expression is aliased with the given address alias.
Definition: TDMatSMatSubExpr.h:241
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
#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
size_t columns() const
Returns the current number of columns of the matrix.
Definition: TDMatSMatSubExpr.h:196
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
size_t rows() const
Returns the current number of rows of the matrix.
Definition: TDMatSMatSubExpr.h:186
Header file for the SelectType class template.
Header file for the RowExprTrait class template.
Header file for all forward declarations for expression class templates.
TDMatSMatSubExpr(const MT1 &lhs, const MT2 &rhs)
Constructor for the TDMatSMatSubExpr class.
Definition: TDMatSMatSubExpr.h:158
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
LeftOperand leftOperand() const
Returns the left-hand side transpose dense matrix operand.
Definition: TDMatSMatSubExpr.h:206
Header file for run time assertion macros.
SubTrait< RT1, RT2 >::Type ResultType
Result type for expression template evaluations.
Definition: TDMatSMatSubExpr.h:126
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
SelectType< IsExpression< MT2 >::value, const MT2, const MT2 & >::Type RightOperand
Composite type of the right-hand side sparse matrix expression.
Definition: TDMatSMatSubExpr.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
#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
MT1::ResultType RT1
Result type of the left-hand side dense matrix expression.
Definition: TDMatSMatSubExpr.h:90
RightOperand rhs_
Right-hand side sparse matrix of the subtraction expression.
Definition: TDMatSMatSubExpr.h:249
Header file for basic type definitions.
bool canAlias(const T *alias) const
Returns whether the expression can alias with the given address alias.
Definition: TDMatSMatSubExpr.h:228
Base template for the SubTrait class.
Definition: SubTrait.h:141
const SelectType< returnExpr, ExprReturnType, ElementType >::Type ReturnType
Return type for expression template evaluations.
Definition: TDMatSMatSubExpr.h:132
ReturnType operator()(size_t i, size_t j) const
2D-access to the matrix elements.
Definition: TDMatSMatSubExpr.h:174
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
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.