All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
DMatTDMatSubExpr.h
Go to the documentation of this file.
1 //=================================================================================================
33 //=================================================================================================
34 
35 #ifndef _BLAZE_MATH_EXPRESSIONS_DMATTDMATSUBEXPR_H_
36 #define _BLAZE_MATH_EXPRESSIONS_DMATTDMATSUBEXPR_H_
37 
38 
39 //*************************************************************************************************
40 // Includes
41 //*************************************************************************************************
42 
43 #include <stdexcept>
58 #include <blaze/util/Assert.h>
61 #include <blaze/util/SelectType.h>
62 #include <blaze/util/Types.h>
63 
64 
65 namespace blaze {
66 
67 //=================================================================================================
68 //
69 // CLASS DMATTDMATSUBEXPR
70 //
71 //=================================================================================================
72 
73 //*************************************************************************************************
80 template< typename MT1 // Type of the left-hand side dense matrix
81  , typename MT2 > // Type of the right-hand side dense matrix
82 class DMatTDMatSubExpr : public DenseMatrix< DMatTDMatSubExpr<MT1,MT2>, false >
83  , private MatMatSubExpr
84  , private Computation
85 {
86  private:
87  //**Type definitions****************************************************************************
88  typedef typename MT1::ResultType RT1;
89  typedef typename MT2::ResultType RT2;
90  typedef typename MT1::ReturnType RN1;
91  typedef typename MT2::ReturnType RN2;
92  typedef typename MT1::CompositeType CT1;
93  typedef typename MT2::CompositeType CT2;
94  //**********************************************************************************************
95 
96  //**Return type evaluation**********************************************************************
98 
103  enum { returnExpr = !IsTemporary<RN1>::value && !IsTemporary<RN2>::value };
104 
107  //**********************************************************************************************
108 
109  public:
110  //**Type definitions****************************************************************************
116 
119 
121  typedef const ResultType CompositeType;
122 
124  typedef typename SelectType< IsExpression<MT1>::value, const MT1, const MT1& >::Type LeftOperand;
125 
127  typedef typename SelectType< IsExpression<MT2>::value, const MT2, const MT2& >::Type RightOperand;
128  //**********************************************************************************************
129 
130  //**Compilation flags***************************************************************************
132  enum { vectorizable = 0 };
133  //**********************************************************************************************
134 
135  //**Constructor*********************************************************************************
141  explicit inline DMatTDMatSubExpr( const MT1& lhs, const MT2& rhs )
142  : lhs_( lhs ) // Left-hand side dense matrix of the subtraction expression
143  , rhs_( rhs ) // Right-hand side dense matrix of the subtraction expression
144  {
145  BLAZE_INTERNAL_ASSERT( lhs.rows() == rhs.rows() , "Invalid number of rows" );
146  BLAZE_INTERNAL_ASSERT( lhs.columns() == rhs.columns(), "Invalid number of columns" );
147  }
148  //**********************************************************************************************
149 
150  //**Access operator*****************************************************************************
157  inline ReturnType operator()( size_t i, size_t j ) const {
158  BLAZE_INTERNAL_ASSERT( i < lhs_.rows() , "Invalid row access index" );
159  BLAZE_INTERNAL_ASSERT( j < lhs_.columns(), "Invalid column access index" );
160  return lhs_(i,j) - rhs_(i,j);
161  }
162  //**********************************************************************************************
163 
164  //**Rows function*******************************************************************************
169  inline size_t rows() const {
170  return lhs_.rows();
171  }
172  //**********************************************************************************************
173 
174  //**Columns function****************************************************************************
179  inline size_t columns() const {
180  return lhs_.columns();
181  }
182  //**********************************************************************************************
183 
184  //**Left operand access*************************************************************************
189  inline LeftOperand leftOperand() const {
190  return lhs_;
191  }
192  //**********************************************************************************************
193 
194  //**Right operand access************************************************************************
199  inline RightOperand rightOperand() const {
200  return rhs_;
201  }
202  //**********************************************************************************************
203 
204  //**********************************************************************************************
210  template< typename T >
211  inline bool canAlias( const T* alias ) const {
212  return ( IsExpression<MT1>::value && ( RequiresEvaluation<MT1>::value ? lhs_.isAliased( alias ) : lhs_.canAlias( alias ) ) ) ||
213  ( IsExpression<MT2>::value && ( RequiresEvaluation<MT2>::value ? rhs_.isAliased( alias ) : rhs_.canAlias( alias ) ) );
214  }
215  //**********************************************************************************************
216 
217  //**********************************************************************************************
223  template< typename T >
224  inline bool isAliased( const T* alias ) const {
225  return ( lhs_.isAliased( alias ) || rhs_.isAliased( alias ) );
226  }
227  //**********************************************************************************************
228 
229  private:
230  //**Member variables****************************************************************************
233  //**********************************************************************************************
234 
235  //**Assignment to dense matrices****************************************************************
247  template< typename MT // Type of the target dense matrix
248  , bool SO2 > // Storage order of the target dense matrix
249  friend inline void assign( DenseMatrix<MT,SO2>& lhs, const DMatTDMatSubExpr& rhs )
250  {
252 
253  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
254  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
255 
256  // In case non of the two dense operands requires an intermediate evaluation, the
257  // addition expression is assigned directly in a cache-efficient manner.
259  {
260  const size_t m( rhs.rows() );
261  const size_t n( rhs.columns() );
262  const size_t block( 16UL );
263 
264  for( size_t ii=0UL; ii<m; ii+=block ) {
265  const size_t iend( ( m < ii+block )?( m ):( ii+block ) );
266  for( size_t jj=0UL; jj<n; jj+=block ) {
267  const size_t jend( ( n < jj+block )?( n ):( jj+block ) );
268  for( size_t i=ii; i<iend; ++i ) {
269  for( size_t j=jj; j<jend; ++j ) {
270  (~lhs)(i,j) = rhs.lhs_(i,j) - rhs.rhs_(i,j);
271  }
272  }
273  }
274  }
275  }
276 
277  // In case either of the two dense operands requires an intermediate evaluation, the
278  // expression is evaluated in a one- or two-step approach (depending on whether any
279  // of the operands is aliased with the target matrix).
280  else if( !IsExpression<MT1>::value && (~lhs).isAliased( &rhs.lhs_ ) ) {
281  subAssign( ~lhs, rhs.rhs_ );
282  }
283  else {
284  assign ( ~lhs, rhs.lhs_ );
285  subAssign( ~lhs, rhs.rhs_ );
286  }
287  }
289  //**********************************************************************************************
290 
291  //**Assignment to sparse matrices***************************************************************
303  template< typename MT // Type of the target sparse matrix
304  , bool SO2 > // Storage order of the target sparse matrix
305  friend inline void assign( SparseMatrix<MT,SO2>& lhs, const DMatTDMatSubExpr& rhs )
306  {
308 
309  typedef typename SelectType< SO2, OppositeType, ResultType >::Type TmpType;
310 
317 
318  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
319  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
320 
321  const TmpType tmp( rhs );
322  assign( ~lhs, tmp );
323  }
325  //**********************************************************************************************
326 
327  //**Addition assignment to dense matrices*******************************************************
340  template< typename MT // Type of the target dense matrix
341  , bool SO2 > // Storage order of the target dense matrix
342  friend inline void addAssign( DenseMatrix<MT,SO2>& lhs, const DMatTDMatSubExpr& rhs )
343  {
345 
346  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
347  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
348 
349  // In case non of the two dense operands requires an intermediate evaluation, the
350  // addition expression is assigned directly in a cache-efficient manner.
351  if( !RequiresEvaluation<MT1>::value && !RequiresEvaluation<MT2>::value )
352  {
353  const size_t m( rhs.rows() );
354  const size_t n( rhs.columns() );
355  const size_t block( 16UL );
356 
357  for( size_t ii=0UL; ii<m; ii+=block ) {
358  const size_t iend( ( m < ii+block )?( m ):( ii+block ) );
359  for( size_t jj=0UL; jj<n; jj+=block ) {
360  const size_t jend( ( n < jj+block )?( n ):( jj+block ) );
361  for( size_t i=ii; i<iend; ++i ) {
362  for( size_t j=jj; j<jend; ++j ) {
363  (~lhs)(i,j) += rhs.lhs_(i,j) - rhs.rhs_(i,j);
364  }
365  }
366  }
367  }
368  }
369 
370  // In case either of the two dense operands requires an intermediate evaluation, the
371  // expression is evaluated in a two-step approach.
372  else
373  {
374  addAssign( ~lhs, rhs.lhs_ );
375  subAssign( ~lhs, rhs.rhs_ );
376  }
377  }
379  //**********************************************************************************************
380 
381  //**Addition assignment to sparse matrices******************************************************
382  // No special implementation for the addition assignment to sparse matrices.
383  //**********************************************************************************************
384 
385  //**Subtraction assignment to dense matrices****************************************************
398  template< typename MT // Type of the target dense matrix
399  , bool SO2 > // Storage order of the target dense matrix
400  friend inline void subAssign( DenseMatrix<MT,SO2>& lhs, const DMatTDMatSubExpr& rhs )
401  {
403 
404  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
405  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
406 
407  // In case non of the two dense operands requires an intermediate evaluation, the
408  // addition expression is assigned directly in a cache-efficient manner.
409  if( !RequiresEvaluation<MT1>::value && !RequiresEvaluation<MT2>::value )
410  {
411  const size_t m( rhs.rows() );
412  const size_t n( rhs.columns() );
413  const size_t block( 16UL );
414 
415  for( size_t ii=0UL; ii<m; ii+=block ) {
416  const size_t iend( ( m < ii+block )?( m ):( ii+block ) );
417  for( size_t jj=0UL; jj<n; jj+=block ) {
418  const size_t jend( ( n < jj+block )?( n ):( jj+block ) );
419  for( size_t i=ii; i<iend; ++i ) {
420  for( size_t j=jj; j<jend; ++j ) {
421  (~lhs)(i,j) -= rhs.lhs_(i,j) - rhs.rhs_(i,j);
422  }
423  }
424  }
425  }
426  }
427 
428  // In case either of the two dense operands requires an intermediate evaluation, the
429  // expression is evaluated in a two-step approach.
430  else
431  {
432  subAssign( ~lhs, rhs.lhs_ );
433  addAssign( ~lhs, rhs.rhs_ );
434  }
435  }
437  //**********************************************************************************************
438 
439  //**Subtraction assignment to sparse matrices***************************************************
440  // No special implementation for the subtraction assignment to sparse matrices.
441  //**********************************************************************************************
442 
443  //**Multiplication assignment to dense matrices*************************************************
444  // No special implementation for the multiplication assignment to dense matrices.
445  //**********************************************************************************************
446 
447  //**Multiplication assignment to sparse matrices************************************************
448  // No special implementation for the multiplication assignment to sparse matrices.
449  //**********************************************************************************************
450 
451  //**Compile time checks*************************************************************************
457  //**********************************************************************************************
458 };
459 //*************************************************************************************************
460 
461 
462 
463 
464 //=================================================================================================
465 //
466 // GLOBAL BINARY ARITHMETIC OPERATORS
467 //
468 //=================================================================================================
469 
470 //*************************************************************************************************
499 template< typename T1 // Type of the left-hand side dense matrix
500  , typename T2 > // Type of the right-hand side dense matrix
501 inline const DMatTDMatSubExpr<T1,T2>
503 {
505 
506  if( (~lhs).rows() != (~rhs).rows() || (~lhs).columns() != (~rhs).columns() )
507  throw std::invalid_argument( "Matrix sizes do not match" );
508 
509  return DMatTDMatSubExpr<T1,T2>( ~lhs, ~rhs );
510 }
511 //*************************************************************************************************
512 
513 
514 //*************************************************************************************************
543 template< typename T1 // Type of the left-hand side dense matrix
544  , typename T2 > // Type of the right-hand side dense matrix
545 inline const DMatTDMatSubExpr<T1,T2>
547 {
549 
550  if( (~lhs).rows() != (~rhs).rows() || (~lhs).columns() != (~rhs).columns() )
551  throw std::invalid_argument( "Matrix sizes do not match" );
552 
553  return DMatTDMatSubExpr<T1,T2>( ~lhs, ~rhs );
554 }
555 //*************************************************************************************************
556 
557 
558 
559 
560 //=================================================================================================
561 //
562 // EXPRESSION TRAIT SPECIALIZATIONS
563 //
564 //=================================================================================================
565 
566 //*************************************************************************************************
568 template< typename MT1, typename MT2 >
569 struct SubmatrixExprTrait< DMatTDMatSubExpr<MT1,MT2> >
570 {
571  public:
572  //**********************************************************************************************
573  typedef typename SubExprTrait< typename SubmatrixExprTrait<const MT1>::Type
574  , typename SubmatrixExprTrait<const MT2>::Type >::Type Type;
575  //**********************************************************************************************
576 };
578 //*************************************************************************************************
579 
580 
581 //*************************************************************************************************
583 template< typename MT1, typename MT2 >
584 struct RowExprTrait< DMatTDMatSubExpr<MT1,MT2> >
585 {
586  public:
587  //**********************************************************************************************
588  typedef typename SubExprTrait< typename RowExprTrait<const MT1>::Type
589  , typename RowExprTrait<const MT2>::Type >::Type Type;
590  //**********************************************************************************************
591 };
593 //*************************************************************************************************
594 
595 
596 //*************************************************************************************************
598 template< typename MT1, typename MT2 >
599 struct ColumnExprTrait< DMatTDMatSubExpr<MT1,MT2> >
600 {
601  public:
602  //**********************************************************************************************
603  typedef typename SubExprTrait< typename ColumnExprTrait<const MT1>::Type
604  , typename ColumnExprTrait<const MT2>::Type >::Type Type;
605  //**********************************************************************************************
606 };
608 //*************************************************************************************************
609 
610 } // namespace blaze
611 
612 #endif
MT2::ReturnType RN2
Return type of the right-hand side dense matrix expression.
Definition: DMatTDMatSubExpr.h:91
bool canAlias(const T *alias) const
Returns whether the expression can alias with the given address alias.
Definition: DMatTDMatSubExpr.h:211
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.
ResultType::TransposeType TransposeType
Transpose type for expression template evaluations.
Definition: DMatTDMatSubExpr.h:114
Efficient implementation of a compressed matrix.The CompressedMatrix class template is the represent...
Definition: CompressedMatrix.h:196
#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.
SubExprTrait< RN1, RN2 >::Type ExprReturnType
Expression return type for the subscript operator.
Definition: DMatTDMatSubExpr.h:106
const This & CompositeType
Data type for composite expression templates.
Definition: CompressedMatrix.h:2375
Type ElementType
Type of the sparse matrix elements.
Definition: CompressedMatrix.h:248
LeftOperand lhs_
Left-hand side dense matrix of the subtraction expression.
Definition: DMatTDMatSubExpr.h:231
MT1::CompositeType CT1
Composite type of the left-hand side dense matrix expression.
Definition: DMatTDMatSubExpr.h:92
Header file for the Computation base class.
Header file for the RequiresEvaluation type trait.
MT1::ReturnType RN1
Return type of the left-hand side dense matrix expression.
Definition: DMatTDMatSubExpr.h:90
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:104
Constraint on the data type.
const SelectType< returnExpr, ExprReturnType, ElementType >::Type ReturnType
Return type for expression template evaluations.
Definition: DMatTDMatSubExpr.h:118
MT2::ResultType RT2
Result type of the right-hand side dense matrix expression.
Definition: DMatTDMatSubExpr.h:89
Constraint on the data type.
Compile time check to query the requirement to evaluate an expression.Via this type trait it is possi...
Definition: RequiresEvaluation.h:90
Expression object for dense matrix-transpose dense matrix subtractions.The DMatTDMatSubExpr class rep...
Definition: DMatTDMatSubExpr.h:82
const ResultType CompositeType
Data type for composite expression templates.
Definition: DMatTDMatSubExpr.h:121
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.
MT1::ResultType RT1
Result type of the left-hand side dense matrix expression.
Definition: DMatTDMatSubExpr.h:88
Base class for all matrix/matrix subtraction expression templates.The MatMatSubExpr class serves as a...
Definition: MatMatSubExpr.h:65
#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
bool isAliased(const T *alias) const
Returns whether the expression is aliased with the given address alias.
Definition: DMatTDMatSubExpr.h:224
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:179
ResultType::ElementType ElementType
Resulting element type.
Definition: DMatTDMatSubExpr.h:115
Header file for the MatMatSubExpr base class.
DMatTDMatSubExpr(const MT1 &lhs, const MT2 &rhs)
Constructor for the DMatTDMatSubExpr class.
Definition: DMatTDMatSubExpr.h:141
RightOperand rhs_
Right-hand side dense matrix of the subtraction expression.
Definition: DMatTDMatSubExpr.h:232
SubTrait< RT1, RT2 >::Type ResultType
Result type for expression template evaluations.
Definition: DMatTDMatSubExpr.h:112
#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.
#define BLAZE_CONSTRAINT_MATRICES_MUST_HAVE_DIFFERENT_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:325
MT2::CompositeType CT2
Composite type of the right-hand side dense matrix expression.
Definition: DMatTDMatSubExpr.h:93
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:2374
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:209
DMatTDMatSubExpr< MT1, MT2 > This
Type of this DMatTDMatSubExpr instance.
Definition: DMatTDMatSubExpr.h:111
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:239
ReturnType operator()(size_t i, size_t j) const
2D-access to the matrix elements.
Definition: DMatTDMatSubExpr.h:157
size_t rows() const
Returns the current number of rows of the matrix.
Definition: DMatTDMatSubExpr.h:169
SelectType< IsExpression< MT1 >::value, const MT1, const MT1 & >::Type LeftOperand
Composite type of the left-hand side dense matrix expression.
Definition: DMatTDMatSubExpr.h:124
#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 dense matrix expression.
Definition: DMatTDMatSubExpr.h:127
Base class for all compute expression templates.The Computation class serves as a tag for all computa...
Definition: Computation.h:59
#define BLAZE_FUNCTION_TRACE
Function trace macro.This macro can be used to reliably trace function calls. In case function tracin...
Definition: FunctionTrace.h:157
LeftOperand leftOperand() const
Returns the left-hand side dense matrix operand.
Definition: DMatTDMatSubExpr.h:189
This ResultType
Result type for expression template evaluations.
Definition: CompressedMatrix.h:2370
size_t columns(const Matrix< MT, SO > &m)
Returns the current number of columns of the matrix.
Definition: Matrix.h:154
RightOperand rightOperand() const
Returns the right-hand side transpose dense matrix operand.
Definition: DMatTDMatSubExpr.h:199
Header file for basic type definitions.
Base template for the SubTrait class.
Definition: SubTrait.h:141
ResultType::OppositeType OppositeType
Result type with opposite storage order for expression template evaluations.
Definition: DMatTDMatSubExpr.h:113
size_t columns() const
Returns the current number of columns of the matrix.
Definition: DMatTDMatSubExpr.h:179
Header file for the SubExprTrait class template.
size_t rows(const Matrix< MT, SO > &m)
Returns the current number of rows of the matrix.
Definition: Matrix.h:138
#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
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.