All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
SMatTDMatSubExpr.h
Go to the documentation of this file.
1 //=================================================================================================
33 //=================================================================================================
34 
35 #ifndef _BLAZE_MATH_EXPRESSIONS_SMATTDMATSUBEXPR_H_
36 #define _BLAZE_MATH_EXPRESSIONS_SMATTDMATSUBEXPR_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 SMATTDMATSUBEXPR
76 //
77 //=================================================================================================
78 
79 //*************************************************************************************************
86 template< typename MT1 // Type of the left-hand side sparse matrix
87  , typename MT2 > // Type of the right-hand side dense matrix
88 class SMatTDMatSubExpr : public DenseMatrix< SMatTDMatSubExpr<MT1,MT2>, false >
89  , private MatMatSubExpr
90  , private Computation
91 {
92  private:
93  //**Type definitions****************************************************************************
94  typedef typename MT1::ResultType RT1;
95  typedef typename MT2::ResultType RT2;
96  typedef typename MT1::ReturnType RN1;
97  typedef typename MT2::ReturnType RN2;
98  //**********************************************************************************************
99 
100  //**Return type evaluation**********************************************************************
102 
107  enum { returnExpr = !IsTemporary<RN1>::value && !IsTemporary<RN2>::value };
108 
111  //**********************************************************************************************
112 
113  //**Parallel evaluation strategy****************************************************************
115 
120  template< typename MT >
121  struct UseSMPAssign {
122  enum { value = ( !MT1::smpAssignable || !MT2::smpAssignable ) };
123  };
125  //**********************************************************************************************
126 
127  public:
128  //**Type definitions****************************************************************************
134 
137 
139  typedef const ResultType CompositeType;
140 
142  typedef typename SelectType< IsExpression<MT1>::value, const MT1, const MT1& >::Type LeftOperand;
143 
145  typedef typename SelectType< IsExpression<MT2>::value, const MT2, const MT2& >::Type RightOperand;
146  //**********************************************************************************************
147 
148  //**Compilation flags***************************************************************************
150  enum { vectorizable = 0 };
151 
153  enum { smpAssignable = 0 };
154  //**********************************************************************************************
155 
156  //**Constructor*********************************************************************************
162  explicit inline SMatTDMatSubExpr( const MT1& lhs, const MT2& rhs )
163  : lhs_( lhs ) // Left-hand side sparse matrix of the subtraction expression
164  , rhs_( rhs ) // Right-hand side dense matrix of the subtraction expression
165  {
166  BLAZE_INTERNAL_ASSERT( lhs.rows() == rhs.rows() , "Invalid number of rows" );
167  BLAZE_INTERNAL_ASSERT( lhs.columns() == rhs.columns(), "Invalid number of columns" );
168  }
169  //**********************************************************************************************
170 
171  //**Access operator*****************************************************************************
178  inline ReturnType operator()( size_t i, size_t j ) const {
179  BLAZE_INTERNAL_ASSERT( i < lhs_.rows() , "Invalid row access index" );
180  BLAZE_INTERNAL_ASSERT( j < lhs_.columns(), "Invalid column access index" );
181  return lhs_(i,j) - rhs_(i,j);
182  }
183  //**********************************************************************************************
184 
185  //**Rows function*******************************************************************************
190  inline size_t rows() const {
191  return lhs_.rows();
192  }
193  //**********************************************************************************************
194 
195  //**Columns function****************************************************************************
200  inline size_t columns() const {
201  return lhs_.columns();
202  }
203  //**********************************************************************************************
204 
205  //**Left operand access*************************************************************************
210  inline LeftOperand leftOperand() const {
211  return lhs_;
212  }
213  //**********************************************************************************************
214 
215  //**Right operand access************************************************************************
220  inline RightOperand rightOperand() const {
221  return rhs_;
222  }
223  //**********************************************************************************************
224 
225  //**********************************************************************************************
231  template< typename T >
232  inline bool canAlias( const T* alias ) const {
233  return ( lhs_.canAlias( alias ) ) ||
234  ( IsExpression<MT2>::value && rhs_.canAlias( alias ) );
235  }
236  //**********************************************************************************************
237 
238  //**********************************************************************************************
244  template< typename T >
245  inline bool isAliased( const T* alias ) const {
246  return lhs_.isAliased( alias ) && rhs_.isAliased( alias );
247  }
248  //**********************************************************************************************
249 
250  private:
251  //**Member variables****************************************************************************
254  //**********************************************************************************************
255 
256  //**Assignment to dense matrices****************************************************************
268  template< typename MT // Type of the target dense matrix
269  , bool SO2 > // Storage order of the target dense matrix
270  friend inline void assign( DenseMatrix<MT,SO2>& lhs, const SMatTDMatSubExpr& rhs )
271  {
273 
274  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
275  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
276 
277  assign ( ~lhs, -rhs.rhs_ );
278  addAssign( ~lhs, rhs.lhs_ );
279  }
281  //**********************************************************************************************
282 
283  //**Assignment to sparse matrices***************************************************************
295  template< typename MT // Type of the target sparse matrix
296  , bool SO2 > // Storage order of the target sparse matrix
297  friend inline void assign( SparseMatrix<MT,SO2>& lhs, const SMatTDMatSubExpr& rhs )
298  {
300 
301  typedef typename SelectType< SO2, OppositeType, ResultType >::Type TmpType;
302 
309 
310  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
311  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
312 
313  const TmpType tmp( serial( rhs ) );
314  assign( ~lhs, tmp );
315  }
317  //**********************************************************************************************
318 
319  //**Addition assignment to dense matrices*******************************************************
332  template< typename MT // Type of the target dense matrix
333  , bool SO2 > // Storage order of the target dense matrix
334  friend inline void addAssign( DenseMatrix<MT,SO2>& lhs, const SMatTDMatSubExpr& rhs )
335  {
337 
338  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
339  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
340 
341  subAssign( ~lhs, rhs.rhs_ );
342  addAssign( ~lhs, rhs.lhs_ );
343  }
345  //**********************************************************************************************
346 
347  //**Addition assignment to sparse matrices******************************************************
348  // No special implementation for the addition assignment to sparse matrices.
349  //**********************************************************************************************
350 
351  //**Subtraction assignment to dense matrices****************************************************
364  template< typename MT // Type of the target dense matrix
365  , bool SO2 > // Storage order of the target dense matrix
366  friend inline void subAssign( DenseMatrix<MT,SO2>& lhs, const SMatTDMatSubExpr& rhs )
367  {
369 
370  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
371  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
372 
373  addAssign( ~lhs, rhs.rhs_ );
374  subAssign( ~lhs, rhs.lhs_ );
375  }
377  //**********************************************************************************************
378 
379  //**Subtraction assignment to sparse matrices***************************************************
380  // No special implementation for the subtraction assignment to sparse matrices.
381  //**********************************************************************************************
382 
383  //**Multiplication assignment to dense matrices*************************************************
384  // No special implementation for the multiplication assignment to dense matrices.
385  //**********************************************************************************************
386 
387  //**Multiplication assignment to sparse matrices************************************************
388  // No special implementation for the multiplication assignment to sparse matrices.
389  //**********************************************************************************************
390 
391  //**SMP assignment to dense matrices************************************************************
405  template< typename MT // Type of the target dense matrix
406  , bool SO2 > // Storage order of the target dense matrix
407  friend inline typename EnableIf< UseSMPAssign<MT> >::Type
408  smpAssign( DenseMatrix<MT,SO2>& lhs, const SMatTDMatSubExpr& rhs )
409  {
411 
412  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
413  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
414 
415  smpAssign ( ~lhs, -rhs.rhs_ );
416  smpAddAssign( ~lhs, rhs.lhs_ );
417  }
419  //**********************************************************************************************
420 
421  //**SMP assignment to sparse matrices***********************************************************
435  template< typename MT // Type of the target sparse matrix
436  , bool SO2 > // Storage order of the target sparse matrix
437  friend inline typename EnableIf< UseSMPAssign<MT> >::Type
438  smpAssign( SparseMatrix<MT,SO2>& lhs, const SMatTDMatSubExpr& rhs )
439  {
441 
442  typedef typename SelectType< SO2, OppositeType, ResultType >::Type TmpType;
443 
450 
451  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
452  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
453 
454  const TmpType tmp( rhs );
455  smpAssign( ~lhs, tmp );
456  }
458  //**********************************************************************************************
459 
460  //**SMP addition assignment to dense matrices***************************************************
475  template< typename MT // Type of the target dense matrix
476  , bool SO2 > // Storage order of the target dense matrix
477  friend inline typename EnableIf< UseSMPAssign<MT> >::Type
478  smpAddAssign( DenseMatrix<MT,SO2>& lhs, const SMatTDMatSubExpr& rhs )
479  {
481 
482  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
483  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
484 
485  smpSubAssign( ~lhs, rhs.rhs_ );
486  smpAddAssign( ~lhs, rhs.lhs_ );
487  }
489  //**********************************************************************************************
490 
491  //**SMP addition assignment to sparse matrices**************************************************
492  // No special implementation for the SMP addition assignment to sparse matrices.
493  //**********************************************************************************************
494 
495  //**SMP subtraction assignment to dense matrices************************************************
510  template< typename MT // Type of the target dense matrix
511  , bool SO2 > // Storage order of the target dense matrix
512  friend inline typename EnableIf< UseSMPAssign<MT> >::Type
513  smpSubAssign( DenseMatrix<MT,SO2>& lhs, const SMatTDMatSubExpr& rhs )
514  {
516 
517  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
518  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
519 
520  smpAddAssign( ~lhs, rhs.rhs_ );
521  smpSubAssign( ~lhs, rhs.lhs_ );
522  }
524  //**********************************************************************************************
525 
526  //**SMP subtraction assignment to sparse matrices***********************************************
527  // No special implementation for the SMP subtraction assignment to sparse matrices.
528  //**********************************************************************************************
529 
530  //**SMP multiplication assignment to dense matrices*********************************************
531  // No special implementation for the SMP multiplication assignment to dense matrices.
532  //**********************************************************************************************
533 
534  //**SMP multiplication assignment to sparse matrices********************************************
535  // No special implementation for the SMP multiplication assignment to sparse matrices.
536  //**********************************************************************************************
537 
538  //**Compile time checks*************************************************************************
545  //**********************************************************************************************
546 };
547 //*************************************************************************************************
548 
549 
550 
551 
552 //=================================================================================================
553 //
554 // GLOBAL BINARY ARITHMETIC OPERATORS
555 //
556 //=================================================================================================
557 
558 //*************************************************************************************************
589 template< typename T1 // Type of the left-hand side sparse matrix
590  , typename T2 > // Type of the right-hand side dense matrix
591 inline const SMatTDMatSubExpr<T1,T2>
593 {
595 
596  if( (~lhs).rows() != (~rhs).rows() || (~lhs).columns() != (~rhs).columns() )
597  throw std::invalid_argument( "Matrix sizes do not match" );
598 
599  return SMatTDMatSubExpr<T1,T2>( ~lhs, ~rhs );
600 }
601 //*************************************************************************************************
602 
603 
604 
605 
606 //=================================================================================================
607 //
608 // GLOBAL RESTRUCTURING BINARY ARITHMETIC OPERATORS
609 //
610 //=================================================================================================
611 
612 //*************************************************************************************************
625 template< typename T1 // Type of the sparse matrix of the left-hand side expression
626  , typename T2 // Type of the dense matrix of the left-hand side expression
627  , typename T3 // Type of the right-hand side dense matrix
628  , bool SO > // Storage order of the right-hand side dense matrix
629 inline const typename AddExprTrait< SMatTDMatSubExpr<T1,T2>, T3 >::Type
630  operator+( const SMatTDMatSubExpr<T1,T2>& lhs, const DenseMatrix<T3,SO>& rhs )
631 {
633 
634  return ( (~rhs) - lhs.rightOperand() ) + lhs.leftOperand();
635 }
637 //*************************************************************************************************
638 
639 
640 //*************************************************************************************************
653 template< typename T1 // Type of the sparse matrix of the left-hand side expression
654  , typename T2 // Type of the dense matrix of the left-hand side expression
655  , typename T3 // Type of the right-hand side dense matrix
656  , bool SO > // Storage order of the right-hand side dense matrix
657 inline const typename SubExprTrait< SMatTDMatSubExpr<T1,T2>, T3 >::Type
658  operator-( const SMatTDMatSubExpr<T1,T2>& lhs, const DenseMatrix<T3,SO>& rhs )
659 {
661 
662  return lhs.leftOperand() - ( lhs.rightOperand() + (~rhs) );
663 }
665 //*************************************************************************************************
666 
667 
668 
669 
670 //=================================================================================================
671 //
672 // EXPRESSION TRAIT SPECIALIZATIONS
673 //
674 //=================================================================================================
675 
676 //*************************************************************************************************
678 template< typename MT1, typename MT2, typename MT3 >
679 struct DMatDMatAddExprTrait< SMatTDMatSubExpr<MT1,MT2>, MT3 >
680 {
681  public:
682  //**********************************************************************************************
684  typedef typename SelectType< IsSparseMatrix<MT1>::value && IsRowMajorMatrix<MT1>::value &&
685  IsDenseMatrix<MT2>::value && IsColumnMajorMatrix<MT2>::value &&
686  IsDenseMatrix<MT3>::value && IsRowMajorMatrix<MT3>::value
687  , typename DMatSMatAddExprTrait< typename DMatTDMatSubExprTrait<MT3,MT2>::Type, MT1 >::Type
688  , INVALID_TYPE >::Type Type;
690  //**********************************************************************************************
691 };
693 //*************************************************************************************************
694 
695 
696 //*************************************************************************************************
698 template< typename MT1, typename MT2, typename MT3 >
699 struct DMatTDMatAddExprTrait< SMatTDMatSubExpr<MT1,MT2>, MT3 >
700 {
701  public:
702  //**********************************************************************************************
704  typedef typename SelectType< IsSparseMatrix<MT1>::value && IsRowMajorMatrix<MT1>::value &&
705  IsDenseMatrix<MT2>::value && IsColumnMajorMatrix<MT2>::value &&
706  IsDenseMatrix<MT3>::value && IsColumnMajorMatrix<MT3>::value
707  , typename TDMatSMatAddExprTrait< typename TDMatTDMatSubExprTrait<MT3,MT2>::Type, MT1 >::Type
708  , INVALID_TYPE >::Type Type;
710  //**********************************************************************************************
711 };
713 //*************************************************************************************************
714 
715 
716 //*************************************************************************************************
718 template< typename MT1, typename MT2, typename MT3 >
719 struct DMatDMatSubExprTrait< SMatTDMatSubExpr<MT1,MT2>, MT3 >
720 {
721  public:
722  //**********************************************************************************************
724  typedef typename SelectType< IsSparseMatrix<MT1>::value && IsRowMajorMatrix<MT1>::value &&
725  IsDenseMatrix<MT2>::value && IsColumnMajorMatrix<MT2>::value &&
726  IsDenseMatrix<MT3>::value && IsRowMajorMatrix<MT3>::value
727  , typename SMatDMatSubExprTrait< MT1, typename TDMatDMatAddExprTrait<MT2,MT3>::Type >::Type
728  , INVALID_TYPE >::Type Type;
730  //**********************************************************************************************
731 };
733 //*************************************************************************************************
734 
735 
736 //*************************************************************************************************
738 template< typename MT1, typename MT2, typename MT3 >
739 struct DMatTDMatSubExprTrait< SMatTDMatSubExpr<MT1,MT2>, MT3 >
740 {
741  public:
742  //**********************************************************************************************
744  typedef typename SelectType< IsSparseMatrix<MT1>::value && IsRowMajorMatrix<MT1>::value &&
745  IsDenseMatrix<MT2>::value && IsColumnMajorMatrix<MT2>::value &&
746  IsDenseMatrix<MT3>::value && IsColumnMajorMatrix<MT3>::value
747  , typename SMatTDMatSubExprTrait< MT1, typename TDMatTDMatAddExprTrait<MT2,MT3>::Type >::Type
748  , INVALID_TYPE >::Type Type;
750  //**********************************************************************************************
751 };
753 //*************************************************************************************************
754 
755 
756 //*************************************************************************************************
758 template< typename MT1, typename MT2, bool AF >
759 struct SubmatrixExprTrait< SMatTDMatSubExpr<MT1,MT2>, AF >
760 {
761  public:
762  //**********************************************************************************************
763  typedef typename SubExprTrait< typename SubmatrixExprTrait<const MT1,AF>::Type
764  , typename SubmatrixExprTrait<const MT2,AF>::Type >::Type Type;
765  //**********************************************************************************************
766 };
768 //*************************************************************************************************
769 
770 
771 //*************************************************************************************************
773 template< typename MT1, typename MT2 >
774 struct RowExprTrait< SMatTDMatSubExpr<MT1,MT2> >
775 {
776  public:
777  //**********************************************************************************************
778  typedef typename SubExprTrait< typename RowExprTrait<const MT1>::Type
779  , typename RowExprTrait<const MT2>::Type >::Type Type;
780  //**********************************************************************************************
781 };
783 //*************************************************************************************************
784 
785 
786 //*************************************************************************************************
788 template< typename MT1, typename MT2 >
789 struct ColumnExprTrait< SMatTDMatSubExpr<MT1,MT2> >
790 {
791  public:
792  //**********************************************************************************************
793  typedef typename SubExprTrait< typename ColumnExprTrait<const MT1>::Type
794  , typename ColumnExprTrait<const MT2>::Type >::Type Type;
795  //**********************************************************************************************
796 };
798 //*************************************************************************************************
799 
800 } // namespace blaze
801 
802 #endif
SubTrait< RT1, RT2 >::Type ResultType
Result type for expression template evaluations.
Definition: SMatTDMatSubExpr.h:130
Compile time check whether the given type is a temporary vector or matrix type.This type trait class ...
Definition: IsTemporary.h:87
MT1::ReturnType RN1
Return type of the left-hand side sparse matrix expression.
Definition: SMatTDMatSubExpr.h:96
Header file for the subtraction trait.
const SelectType< returnExpr, ExprReturnType, ElementType >::Type ReturnType
Return type for expression template evaluations.
Definition: SMatTDMatSubExpr.h:136
MT2::ResultType RT2
Result type of the right-hand side dense matrix expression.
Definition: SMatTDMatSubExpr.h:95
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.
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.
MT2::ReturnType RN2
Return type of the right-hand side dense matrix expression.
Definition: SMatTDMatSubExpr.h:97
Header file for the IsColumnMajorMatrix type trait.
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
MT1::ResultType RT1
Result type of the left-hand side sparse matrix expression.
Definition: SMatTDMatSubExpr.h:94
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.
SubExprTrait< RN1, RN2 >::Type ExprReturnType
Expression return type for the subscript operator.
Definition: SMatTDMatSubExpr.h:110
ResultType::TransposeType TransposeType
Transpose type for expression template evaluations.
Definition: SMatTDMatSubExpr.h:132
Base class for dense matrices.The DenseMatrix class is a base class for all dense matrix classes...
Definition: DenseMatrix.h:70
Base class for sparse matrices.The SparseMatrix class is a base class for all sparse matrix classes...
Definition: Forward.h:107
Constraint on the data type.
Constraint on the data type.
Constraint on the data type.
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.
Expression object for sparse matrix-transpose dense matrix subtractions.The SMatTDMatSubExpr class re...
Definition: Forward.h:101
SMatTDMatSubExpr(const MT1 &lhs, const MT2 &rhs)
Constructor for the SMatTDMatSubExpr class.
Definition: SMatTDMatSubExpr.h:162
#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: SMatTDMatSubExpr.h:252
RightOperand rhs_
Right-hand side dense matrix of the subtraction expression.
Definition: SMatTDMatSubExpr.h:253
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
bool isAliased(const T *alias) const
Returns whether the expression is aliased with the given address alias.
Definition: SMatTDMatSubExpr.h:245
#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.
Header file for the IsDenseMatrix type trait.
Header file for the serial shim.
SMatTDMatSubExpr< MT1, MT2 > This
Type of this SMatTDMatSubExpr instance.
Definition: SMatTDMatSubExpr.h:129
ReturnType operator()(size_t i, size_t j) const
2D-access to the matrix elements.
Definition: SMatTDMatSubExpr.h:178
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
LeftOperand leftOperand() const
Returns the left-hand side sparse matrix operand.
Definition: SMatTDMatSubExpr.h:210
ResultType::OppositeType OppositeType
Result type with opposite storage order for expression template evaluations.
Definition: SMatTDMatSubExpr.h:131
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< MT1 >::value, const MT1, const MT1 & >::Type LeftOperand
Composite type of the left-hand side dense matrix expression.
Definition: SMatTDMatSubExpr.h:142
const ResultType CompositeType
Data type for composite expression templates.
Definition: SMatTDMatSubExpr.h:139
#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
SelectType< IsExpression< MT2 >::value, const MT2, const MT2 & >::Type RightOperand
Composite type of the right-hand side sparse matrix expression.
Definition: SMatTDMatSubExpr.h:145
Header file for the IsRowMajorMatrix type trait.
bool canAlias(const T *alias) const
Returns whether the expression can alias with the given address alias.
Definition: SMatTDMatSubExpr.h:232
size_t rows() const
Returns the current number of rows of the matrix.
Definition: SMatTDMatSubExpr.h:190
#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
ResultType::ElementType ElementType
Resulting element type.
Definition: SMatTDMatSubExpr.h:133
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
RightOperand rightOperand() const
Returns the right-hand side transpose dense matrix operand.
Definition: SMatTDMatSubExpr.h:220
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
size_t columns() const
Returns the current number of columns of the matrix.
Definition: SMatTDMatSubExpr.h:200
Header file for the IsExpression type trait class.
Header file for the FunctionTrace class.