All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
DMatDMatAddExpr.h
Go to the documentation of this file.
1 //=================================================================================================
33 //=================================================================================================
34 
35 #ifndef _BLAZE_MATH_EXPRESSIONS_DMATDMATADDEXPR_H_
36 #define _BLAZE_MATH_EXPRESSIONS_DMATDMATADDEXPR_H_
37 
38 
39 //*************************************************************************************************
40 // Includes
41 //*************************************************************************************************
42 
43 #include <stdexcept>
50 #include <blaze/math/Intrinsics.h>
62 #include <blaze/util/Assert.h>
64 #include <blaze/util/EnableIf.h>
66 #include <blaze/util/SelectType.h>
67 #include <blaze/util/Types.h>
69 
70 
71 namespace blaze {
72 
73 //=================================================================================================
74 //
75 // CLASS DMATDMATADDEXPR
76 //
77 //=================================================================================================
78 
79 //*************************************************************************************************
86 template< typename MT1 // Type of the left-hand side dense matrix
87  , typename MT2 // Type of the right-hand side dense matrix
88  , bool SO > // Storage order
89 class DMatDMatAddExpr : public DenseMatrix< DMatDMatAddExpr<MT1,MT2,SO>, SO >
90  , private MatMatAddExpr
91  , private Computation
92 {
93  private:
94  //**Type definitions****************************************************************************
95  typedef typename MT1::ResultType RT1;
96  typedef typename MT2::ResultType RT2;
97  typedef typename MT1::ReturnType RN1;
98  typedef typename MT2::ReturnType RN2;
99  typedef typename MT1::CompositeType CT1;
100  typedef typename MT2::CompositeType CT2;
101  typedef typename MT1::ElementType ET1;
102  typedef typename MT2::ElementType ET2;
103  //**********************************************************************************************
104 
105  //**Return type evaluation**********************************************************************
107 
112  enum { returnExpr = !IsTemporary<RN1>::value && !IsTemporary<RN2>::value };
113 
116  //**********************************************************************************************
117 
118  //**Evaluation strategy*************************************************************************
120 
126  enum { useAssign = RequiresEvaluation<MT1>::value || RequiresEvaluation<MT2>::value || !returnExpr };
127 
129  template< typename VT >
131  struct UseAssign {
132  enum { value = useAssign };
133  };
135  //**********************************************************************************************
136 
137  public:
138  //**Type definitions****************************************************************************
145 
148 
151 
153  typedef typename SelectType< IsExpression<MT1>::value, const MT1, const MT1& >::Type LeftOperand;
154 
156  typedef typename SelectType< IsExpression<MT2>::value, const MT2, const MT2& >::Type RightOperand;
157  //**********************************************************************************************
158 
159  //**ConstIterator class definition**************************************************************
163  {
164  public:
165  //**Type definitions*************************************************************************
166  typedef std::random_access_iterator_tag IteratorCategory;
171 
172  // STL iterator requirements
178 
181 
184  //*******************************************************************************************
185 
186  //**Constructor******************************************************************************
192  explicit inline ConstIterator( LeftIteratorType left, RightIteratorType right )
193  : left_ ( left ) // Iterator to the current left-hand side element
194  , right_( right ) // Iterator to the current right-hand side element
195  {}
196  //*******************************************************************************************
197 
198  //**Addition assignment operator*************************************************************
204  inline ConstIterator& operator+=( size_t inc ) {
205  left_ += inc;
206  right_ += inc;
207  return *this;
208  }
209  //*******************************************************************************************
210 
211  //**Subtraction assignment operator**********************************************************
217  inline ConstIterator& operator-=( size_t dec ) {
218  left_ -= dec;
219  right_ -= dec;
220  return *this;
221  }
222  //*******************************************************************************************
223 
224  //**Prefix increment operator****************************************************************
230  ++left_;
231  ++right_;
232  return *this;
233  }
234  //*******************************************************************************************
235 
236  //**Postfix increment operator***************************************************************
241  inline const ConstIterator operator++( int ) {
242  return ConstIterator( left_++, right_++ );
243  }
244  //*******************************************************************************************
245 
246  //**Prefix decrement operator****************************************************************
252  --left_;
253  --right_;
254  return *this;
255  }
256  //*******************************************************************************************
257 
258  //**Postfix decrement operator***************************************************************
263  inline const ConstIterator operator--( int ) {
264  return ConstIterator( left_--, right_-- );
265  }
266  //*******************************************************************************************
267 
268  //**Element access operator******************************************************************
273  inline ReturnType operator*() const {
274  return (*left_) + (*right_);
275  }
276  //*******************************************************************************************
277 
278  //**Load function****************************************************************************
283  inline IntrinsicType load() const {
284  return left_.load() + right_.load();
285  }
286  //*******************************************************************************************
287 
288  //**Equality operator************************************************************************
294  inline bool operator==( const ConstIterator& rhs ) const {
295  return left_ == rhs.left_;
296  }
297  //*******************************************************************************************
298 
299  //**Inequality operator**********************************************************************
305  inline bool operator!=( const ConstIterator& rhs ) const {
306  return left_ != rhs.left_;
307  }
308  //*******************************************************************************************
309 
310  //**Less-than operator***********************************************************************
316  inline bool operator<( const ConstIterator& rhs ) const {
317  return left_ < rhs.left_;
318  }
319  //*******************************************************************************************
320 
321  //**Greater-than operator********************************************************************
327  inline bool operator>( const ConstIterator& rhs ) const {
328  return left_ > rhs.left_;
329  }
330  //*******************************************************************************************
331 
332  //**Less-or-equal-than operator**************************************************************
338  inline bool operator<=( const ConstIterator& rhs ) const {
339  return left_ <= rhs.left_;
340  }
341  //*******************************************************************************************
342 
343  //**Greater-or-equal-than operator***********************************************************
349  inline bool operator>=( const ConstIterator& rhs ) const {
350  return left_ >= rhs.left_;
351  }
352  //*******************************************************************************************
353 
354  //**Subtraction operator*********************************************************************
360  inline DifferenceType operator-( const ConstIterator& rhs ) const {
361  return left_ - rhs.left_;
362  }
363  //*******************************************************************************************
364 
365  //**Addition operator************************************************************************
372  friend inline const ConstIterator operator+( const ConstIterator& it, size_t inc ) {
373  return ConstIterator( it.left_ + inc, it.right_ + inc );
374  }
375  //*******************************************************************************************
376 
377  //**Addition operator************************************************************************
384  friend inline const ConstIterator operator+( size_t inc, const ConstIterator& it ) {
385  return ConstIterator( it.left_ + inc, it.right_ + inc );
386  }
387  //*******************************************************************************************
388 
389  //**Subtraction operator*********************************************************************
396  friend inline const ConstIterator operator-( const ConstIterator& it, size_t dec ) {
397  return ConstIterator( it.left_ - dec, it.right_ - dec );
398  }
399  //*******************************************************************************************
400 
401  private:
402  //**Member variables*************************************************************************
405  //*******************************************************************************************
406  };
407  //**********************************************************************************************
408 
409  //**Compilation flags***************************************************************************
411  enum { vectorizable = MT1::vectorizable && MT2::vectorizable &&
414 
416  enum { smpAssignable = MT1::smpAssignable && MT2::smpAssignable };
417  //**********************************************************************************************
418 
419  //**Constructor*********************************************************************************
425  explicit inline DMatDMatAddExpr( const MT1& lhs, const MT2& rhs )
426  : lhs_( lhs ) // Left-hand side dense matrix of the addition expression
427  , rhs_( rhs ) // Right-hand side dense matrix of the addition expression
428  {
429  BLAZE_INTERNAL_ASSERT( lhs.rows() == rhs.rows() , "Invalid number of rows" );
430  BLAZE_INTERNAL_ASSERT( lhs.columns() == rhs.columns(), "Invalid number of columns" );
431  }
432  //**********************************************************************************************
433 
434  //**Access operator*****************************************************************************
441  inline ReturnType operator()( size_t i, size_t j ) const {
442  BLAZE_INTERNAL_ASSERT( i < lhs_.rows() , "Invalid row access index" );
443  BLAZE_INTERNAL_ASSERT( j < lhs_.columns(), "Invalid column access index" );
444  return lhs_(i,j) + rhs_(i,j);
445  }
446  //**********************************************************************************************
447 
448  //**Load function*******************************************************************************
455  inline IntrinsicType load( size_t i, size_t j ) const {
456  typedef IntrinsicTrait<ElementType> IT;
457  BLAZE_INTERNAL_ASSERT( i < lhs_.rows() , "Invalid row access index" );
458  BLAZE_INTERNAL_ASSERT( j < lhs_.columns(), "Invalid column access index" );
459  BLAZE_INTERNAL_ASSERT( !SO || ( i % IT::size == 0UL ), "Invalid row access index" );
460  BLAZE_INTERNAL_ASSERT( SO || ( j % IT::size == 0UL ), "Invalid column access index" );
461  return lhs_.load(i,j) + rhs_.load(i,j);
462  }
463  //**********************************************************************************************
464 
465  //**Begin function******************************************************************************
471  inline ConstIterator begin( size_t i ) const {
472  return ConstIterator( lhs_.begin(i), rhs_.begin(i) );
473  }
474  //**********************************************************************************************
475 
476  //**End function********************************************************************************
482  inline ConstIterator end( size_t i ) const {
483  return ConstIterator( lhs_.end(i), rhs_.end(i) );
484  }
485  //**********************************************************************************************
486 
487  //**Rows function*******************************************************************************
492  inline size_t rows() const {
493  return lhs_.rows();
494  }
495  //**********************************************************************************************
496 
497  //**Columns function****************************************************************************
502  inline size_t columns() const {
503  return lhs_.columns();
504  }
505  //**********************************************************************************************
506 
507  //**Left operand access*************************************************************************
512  inline LeftOperand leftOperand() const {
513  return lhs_;
514  }
515  //**********************************************************************************************
516 
517  //**Right operand access************************************************************************
522  inline RightOperand rightOperand() const {
523  return rhs_;
524  }
525  //**********************************************************************************************
526 
527  //**********************************************************************************************
533  template< typename T >
534  inline bool canAlias( const T* alias ) const {
535  return ( IsExpression<MT1>::value && ( RequiresEvaluation<MT1>::value ? lhs_.isAliased( alias ) : lhs_.canAlias( alias ) ) ) ||
536  ( IsExpression<MT2>::value && ( RequiresEvaluation<MT2>::value ? rhs_.isAliased( alias ) : rhs_.canAlias( alias ) ) );
537  }
538  //**********************************************************************************************
539 
540  //**********************************************************************************************
546  template< typename T >
547  inline bool isAliased( const T* alias ) const {
548  return ( lhs_.isAliased( alias ) || rhs_.isAliased( alias ) );
549  }
550  //**********************************************************************************************
551 
552  //**********************************************************************************************
557  inline bool isAligned() const {
558  return lhs_.isAligned() && rhs_.isAligned();
559  }
560  //**********************************************************************************************
561 
562  //**********************************************************************************************
567  inline bool canSMPAssign() const {
568  return lhs_.canSMPAssign() || rhs_.canSMPAssign() ||
569  ( ( ( SO == rowMajor ) ? rows() : columns() ) > SMP_DMATDMATADD_THRESHOLD );
570  }
571  //**********************************************************************************************
572 
573  private:
574  //**Member variables****************************************************************************
577  //**********************************************************************************************
578 
579  //**Assignment to dense matrices****************************************************************
593  template< typename MT // Type of the target dense matrix
594  , bool SO2 > // Storage order of the target dense matrix
595  friend inline typename EnableIf< UseAssign<MT> >::Type
596  assign( DenseMatrix<MT,SO2>& lhs, const DMatDMatAddExpr& rhs )
597  {
599 
600  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
601  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
602 
603  if( !IsExpression<MT1>::value && (~lhs).isAliased( &rhs.lhs_ ) ) {
604  smpAddAssign( ~lhs, rhs.rhs_ );
605  }
606  else if( !IsExpression<MT2>::value && (~lhs).isAliased( &rhs.rhs_ ) ) {
607  smpAddAssign( ~lhs, rhs.lhs_ );
608  }
609  else {
610  smpAssign ( ~lhs, rhs.lhs_ );
611  smpAddAssign( ~lhs, rhs.rhs_ );
612  }
613  }
615  //**********************************************************************************************
616 
617  //**Assignment to sparse matrices***************************************************************
631  template< typename MT // Type of the target sparse matrix
632  , bool SO2 > // Storage order of the target sparse matrix
633  friend inline typename EnableIf< UseAssign<MT> >::Type
634  assign( SparseMatrix<MT,SO2>& lhs, const DMatDMatAddExpr& rhs )
635  {
637 
639 
646 
647  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
648  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
649 
650  const TmpType tmp( rhs );
651  smpAssign( ~lhs, tmp );
652  }
654  //**********************************************************************************************
655 
656  //**Addition assignment to dense matrices*******************************************************
670  template< typename MT // Type of the target dense matrix
671  , bool SO2 > // Storage order of the target dense matrix
672  friend inline typename EnableIf< UseAssign<MT> >::Type
673  addAssign( DenseMatrix<MT,SO2>& lhs, const DMatDMatAddExpr& rhs )
674  {
676 
677  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
678  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
679 
680  smpAddAssign( ~lhs, rhs.lhs_ );
681  smpAddAssign( ~lhs, rhs.rhs_ );
682  }
684  //**********************************************************************************************
685 
686  //**Addition assignment to sparse matrices******************************************************
687  // No special implementation for the addition assignment to sparse matrices.
688  //**********************************************************************************************
689 
690  //**Subtraction assignment to dense matrices****************************************************
704  template< typename MT // Type of the target dense matrix
705  , bool SO2 > // Storage order of the target dense matrix
706  friend inline typename EnableIf< UseAssign<MT> >::Type
707  subAssign( DenseMatrix<MT,SO2>& lhs, const DMatDMatAddExpr& rhs )
708  {
710 
711  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
712  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
713 
714  smpSubAssign( ~lhs, rhs.lhs_ );
715  smpSubAssign( ~lhs, rhs.rhs_ );
716  }
718  //**********************************************************************************************
719 
720  //**Subtraction assignment to sparse matrices***************************************************
721  // No special implementation for the subtraction assignment to sparse matrices.
722  //**********************************************************************************************
723 
724  //**Multiplication assignment to dense matrices*************************************************
725  // No special implementation for the multiplication assignment to dense matrices.
726  //**********************************************************************************************
727 
728  //**Multiplication assignment to sparse matrices************************************************
729  // No special implementation for the multiplication assignment to sparse matrices.
730  //**********************************************************************************************
731 
732  //**Compile time checks*************************************************************************
738  //**********************************************************************************************
739 };
740 //*************************************************************************************************
741 
742 
743 
744 
745 //=================================================================================================
746 //
747 // GLOBAL BINARY ARITHMETIC OPERATORS
748 //
749 //=================================================================================================
750 
751 //*************************************************************************************************
778 template< typename T1 // Type of the left-hand side dense matrix
779  , typename T2 // Type of the right-hand side dense matrix
780  , bool SO > // Storage order
781 inline const DMatDMatAddExpr<T1,T2,SO>
783 {
785 
786  if( (~lhs).rows() != (~rhs).rows() || (~lhs).columns() != (~rhs).columns() )
787  throw std::invalid_argument( "Matrix sizes do not match" );
788 
789  return DMatDMatAddExpr<T1,T2,SO>( ~lhs, ~rhs );
790 }
791 //*************************************************************************************************
792 
793 
794 
795 
796 //=================================================================================================
797 //
798 // EXPRESSION TRAIT SPECIALIZATIONS
799 //
800 //=================================================================================================
801 
802 //*************************************************************************************************
804 template< typename MT1, typename MT2, bool SO, bool AF >
805 struct SubmatrixExprTrait< DMatDMatAddExpr<MT1,MT2,SO>, AF >
806 {
807  public:
808  //**********************************************************************************************
809  typedef typename AddExprTrait< typename SubmatrixExprTrait<const MT1,AF>::Type
810  , typename SubmatrixExprTrait<const MT2,AF>::Type >::Type Type;
811  //**********************************************************************************************
812 };
814 //*************************************************************************************************
815 
816 
817 //*************************************************************************************************
819 template< typename MT1, typename MT2, bool SO >
820 struct RowExprTrait< DMatDMatAddExpr<MT1,MT2,SO> >
821 {
822  public:
823  //**********************************************************************************************
824  typedef typename AddExprTrait< typename RowExprTrait<const MT1>::Type
825  , typename RowExprTrait<const MT2>::Type >::Type Type;
826  //**********************************************************************************************
827 };
829 //*************************************************************************************************
830 
831 
832 //*************************************************************************************************
834 template< typename MT1, typename MT2, bool SO >
835 struct ColumnExprTrait< DMatDMatAddExpr<MT1,MT2,SO> >
836 {
837  public:
838  //**********************************************************************************************
839  typedef typename AddExprTrait< typename ColumnExprTrait<const MT1>::Type
840  , typename ColumnExprTrait<const MT2>::Type >::Type Type;
841  //**********************************************************************************************
842 };
844 //*************************************************************************************************
845 
846 } // namespace blaze
847 
848 #endif
ConstIterator end(size_t i) const
Returns an iterator just past the last non-zero element of row i.
Definition: DMatDMatAddExpr.h:482
Pointer difference type of the Blaze library.
bool operator>(const ConstIterator &rhs) const
Greater-than comparison between two ConstIterator objects.
Definition: DMatDMatAddExpr.h:327
ConstIterator & operator++()
Pre-increment operator.
Definition: DMatDMatAddExpr.h:229
ConstIterator & operator+=(size_t inc)
Addition assignment operator.
Definition: DMatDMatAddExpr.h:204
ConstIterator(LeftIteratorType left, RightIteratorType right)
Constructor for the ConstIterator class.
Definition: DMatDMatAddExpr.h:192
RightOperand rightOperand() const
Returns the right-hand side dense matrix operand.
Definition: DMatDMatAddExpr.h:522
Evaluation of the return type of an addition expression.Via this type trait it is possible to evaluat...
Definition: AddExprTrait.h:103
PointerType pointer
Pointer return type.
Definition: DMatDMatAddExpr.h:175
ConstIterator & operator-=(size_t dec)
Subtraction assignment operator.
Definition: DMatDMatAddExpr.h:217
ptrdiff_t DifferenceType
Difference between two iterators.
Definition: DMatDMatAddExpr.h:170
Compile time check whether the given type is a temporary vector or matrix type.This type trait class ...
Definition: IsTemporary.h:87
bool operator<=(const ConstIterator &rhs) const
Less-than comparison between two ConstIterator objects.
Definition: DMatDMatAddExpr.h:338
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:151
MT1::ElementType ET1
Element type of the left-hand side dense matrix expression.
Definition: DMatDMatAddExpr.h:101
#define BLAZE_CONSTRAINT_MUST_BE_MATRIX_WITH_STORAGE_ORDER(T, SO)
Constraint on the data type.In case the given data type T is not a dense or sparse matrix type and in...
Definition: StorageOrder.h:242
Efficient implementation of a compressed matrix.The CompressedMatrix class template is the represent...
Definition: CompressedMatrix.h:197
#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
ReturnType operator*() const
Direct access to the element at the current iterator position.
Definition: DMatDMatAddExpr.h:273
Header file for the ColumnExprTrait class template.
Header file for the IsSame and IsStrictlySame type traits.
IntrinsicType load(size_t i, size_t j) const
Access to the intrinsic elements of the matrix.
Definition: DMatDMatAddExpr.h:455
bool operator!=(const ConstIterator &rhs) const
Inequality comparison between two ConstIterator objects.
Definition: DMatDMatAddExpr.h:305
Header file for the sparse matrix SMP implementation.
MT2::ResultType RT2
Result type of the right-hand side dense matrix expression.
Definition: DMatDMatAddExpr.h:96
const This & CompositeType
Data type for composite expression templates.
Definition: CompressedMatrix.h:2384
Type ElementType
Type of the sparse matrix elements.
Definition: CompressedMatrix.h:249
MT2::ConstIterator RightIteratorType
ConstIterator type of the right-hand side dense matrix expression.
Definition: DMatDMatAddExpr.h:183
ElementType * PointerType
Pointer return type.
Definition: DMatDMatAddExpr.h:168
Header file for the AddExprTrait class template.
std::random_access_iterator_tag IteratorCategory
The iterator category.
Definition: DMatDMatAddExpr.h:166
bool canSMPAssign() const
Returns whether the expression can be used in SMP assignments.
Definition: DMatDMatAddExpr.h:567
Header file for the Computation base class.
Type relationship analysis.This class tests if the two data types A and B are equal. For this type comparison, the cv-qualifiers of both data types are ignored. If A and B are the same data type (ignoring the cv-qualifiers), then the value member enumeration is set to 1, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to 0, Type is FalseType, and the class derives from FalseType.
Definition: IsSame.h:158
Header file for the RequiresEvaluation type trait.
ResultType::ElementType ElementType
Resulting element type.
Definition: DMatDMatAddExpr.h:143
Base class for dense matrices.The DenseMatrix class is a base class for all dense matrix classes...
Definition: DenseMatrix.h:70
MT2::ReturnType RN2
Return type of the right-hand side dense matrix expression.
Definition: DMatDMatAddExpr.h:98
Base class for sparse matrices.The SparseMatrix class is a base class for all sparse matrix classes...
Definition: Forward.h:104
IntrinsicType load() const
Access to the intrinsic elements of the matrix.
Definition: DMatDMatAddExpr.h:283
Constraint on the data type.
Iterator over the elements of the dense matrix.
Definition: DMatDMatAddExpr.h:162
ResultType::TransposeType TransposeType
Transpose type for expression template evaluations.
Definition: DMatDMatAddExpr.h:142
Constraint on the data type.
const size_t SMP_DMATDMATADD_THRESHOLD
SMP row-major dense matrix/row-major dense matrix addition threshold.This threshold represents the sy...
Definition: Thresholds.h:362
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:121
Compile time check to query the requirement to evaluate an expression.Via this type trait it is possi...
Definition: RequiresEvaluation.h:90
RightIteratorType right_
Iterator to the current right-hand side element.
Definition: DMatDMatAddExpr.h:404
Expression object for dense matrix-dense matrix additions.The DMatDMatAddExpr class represents the co...
Definition: DMatDMatAddExpr.h:89
MT1::ResultType RT1
Result type of the left-hand side dense matrix expression.
Definition: DMatDMatAddExpr.h:95
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.
ConstIterator begin(size_t i) const
Returns an iterator to the first non-zero element of row i.
Definition: DMatDMatAddExpr.h:471
const ConstIterator operator--(int)
Post-decrement operator.
Definition: DMatDMatAddExpr.h:263
AddExprTrait< RN1, RN2 >::Type ExprReturnType
Expression return type for the subscript operator.
Definition: DMatDMatAddExpr.h:115
AddTrait< RT1, RT2 >::Type ResultType
Result type for expression template evaluations.
Definition: DMatDMatAddExpr.h:140
const Element * ConstIterator
Iterator over constant elements.
Definition: CompressedMatrix.h:2388
SelectType< useAssign, const ResultType, const DMatDMatAddExpr & >::Type CompositeType
Data type for composite expression templates.
Definition: DMatDMatAddExpr.h:150
Header file for the dense matrix SMP implementation.
bool isAliased(const T *alias) const
Returns whether the expression is aliased with the given address alias.
Definition: DMatDMatAddExpr.h:547
ConstIterator & operator--()
Pre-decrement operator.
Definition: DMatDMatAddExpr.h:251
IntrinsicTrait< ElementType >::Type IntrinsicType
Resulting intrinsic element type.
Definition: DMatDMatAddExpr.h:144
Header file for the DenseMatrix base class.
friend const ConstIterator operator+(const ConstIterator &it, size_t inc)
Addition between a ConstIterator and an integral value.
Definition: DMatDMatAddExpr.h:372
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
Base class for all matrix/matrix addition expression templates.The MatMatAddExpr class serves as a ta...
Definition: MatMatAddExpr.h:65
ReferenceType reference
Reference return type.
Definition: DMatDMatAddExpr.h:176
const DenseIterator< Type > operator+(const DenseIterator< Type > &it, ptrdiff_t inc)
Addition between a DenseIterator and an integral value.
Definition: DenseIterator.h:556
MT2::CompositeType CT2
Composite type of the right-hand side dense matrix expression.
Definition: DMatDMatAddExpr.h:100
ResultType::OppositeType OppositeType
Result type with opposite storage order for expression template evaluations.
Definition: DMatDMatAddExpr.h:141
bool operator<(const ConstIterator &rhs) const
Less-than comparison between two ConstIterator objects.
Definition: DMatDMatAddExpr.h:316
DMatDMatAddExpr(const MT1 &lhs, const MT2 &rhs)
Constructor for the DMatDMatAddExpr class.
Definition: DMatDMatAddExpr.h:425
#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.
bool operator==(const ConstIterator &rhs) const
Equality comparison between two ConstIterator objects.
Definition: DMatDMatAddExpr.h:294
Type ElementType
Type of the sparse matrix elements.
Definition: CompressedMatrix.h:2382
MT1::ConstIterator LeftIteratorType
ConstIterator type of the left-hand side dense matrix expression.
Definition: DMatDMatAddExpr.h:180
Header file for the SelectType class template.
Header file for the RowExprTrait class template.
Header file for all forward declarations for expression class templates.
RightOperand rhs_
Right-hand side dense matrix of the addition expression.
Definition: DMatDMatAddExpr.h:576
Header file for the EnableIf class template.
DifferenceType operator-(const ConstIterator &rhs) const
Calculating the number of elements between two iterators.
Definition: DMatDMatAddExpr.h:360
size_t columns() const
Returns the current number of columns of the matrix.
Definition: DMatDMatAddExpr.h:502
bool canAlias(const T *alias) const
Returns whether the expression can alias with the given address alias.
Definition: DMatDMatAddExpr.h:534
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:91
MT2::ElementType ET2
Element type of the right-hand side dense matrix expression.
Definition: DMatDMatAddExpr.h:102
Header file for the SubmatrixExprTrait class template.
const Type & ReturnType
Return type for expression template evaluations.
Definition: CompressedMatrix.h:2383
Intrinsic characteristics of data types.The IntrinsicTrait class template provides the intrinsic char...
Definition: IntrinsicTrait.h:748
Header file for run time assertion macros.
Base template for the AddTrait class.
Definition: AddTrait.h:141
size_t rows() const
Returns the current number of rows of the matrix.
Definition: DMatDMatAddExpr.h:492
Header file for the addition trait.
ElementType & ReferenceType
Reference return type.
Definition: DMatDMatAddExpr.h:169
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
Substitution Failure Is Not An Error (SFINAE) class.The EnableIf class template is an auxiliary tool ...
Definition: EnableIf.h:184
ElementType ValueType
Type of the underlying elements.
Definition: DMatDMatAddExpr.h:167
const SelectType< returnExpr, ExprReturnType, ElementType >::Type ReturnType
Return type for expression template evaluations.
Definition: DMatDMatAddExpr.h:147
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
bool isAligned() const
Returns whether the operands of the expression are properly aligned in memory.
Definition: DMatDMatAddExpr.h:557
Header file for the MatMatAddExpr base class.
const ConstIterator operator++(int)
Post-increment operator.
Definition: DMatDMatAddExpr.h:241
MT1::CompositeType CT1
Composite type of the left-hand side dense matrix expression.
Definition: DMatDMatAddExpr.h:99
#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
friend const ConstIterator operator+(size_t inc, const ConstIterator &it)
Addition between an integral value and a ConstIterator.
Definition: DMatDMatAddExpr.h:384
Header file for all intrinsic functionality.
SelectType< IsExpression< MT2 >::value, const MT2, const MT2 & >::Type RightOperand
Composite type of the right-hand side dense matrix expression.
Definition: DMatDMatAddExpr.h:156
LeftIteratorType left_
Iterator to the current left-hand side element.
Definition: DMatDMatAddExpr.h:403
const bool rowMajor
Storage order flag for row-major matrices.
Definition: StorageOrder.h:71
Base class for all compute expression templates.The Computation class serves as a tag for all computa...
Definition: Computation.h:59
IteratorCategory iterator_category
The iterator category.
Definition: DMatDMatAddExpr.h:173
LeftOperand lhs_
Left-hand side dense matrix of the addition expression.
Definition: DMatDMatAddExpr.h:575
LeftOperand leftOperand() const
Returns the left-hand side dense matrix operand.
Definition: DMatDMatAddExpr.h:512
#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:2379
size_t columns(const Matrix< MT, SO > &m)
Returns the current number of columns of the matrix.
Definition: Matrix.h:154
Header file for basic type definitions.
friend const ConstIterator operator-(const ConstIterator &it, size_t dec)
Subtraction between a ConstIterator and an integral value.
Definition: DMatDMatAddExpr.h:396
bool operator>=(const ConstIterator &rhs) const
Greater-than comparison between two ConstIterator objects.
Definition: DMatDMatAddExpr.h:349
ReturnType operator()(size_t i, size_t j) const
2D-access to the matrix elements.
Definition: DMatDMatAddExpr.h:441
MT1::ReturnType RN1
Return type of the left-hand side dense matrix expression.
Definition: DMatDMatAddExpr.h:97
Header file for the thresholds for matrix/vector and matrix/matrix multiplications.
DifferenceType difference_type
Difference between two iterators.
Definition: DMatDMatAddExpr.h:177
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
DMatDMatAddExpr< MT1, MT2, SO > This
Type of this DMatDMatAdd instance.
Definition: DMatDMatAddExpr.h:139
SelectType< IsExpression< MT1 >::value, const MT1, const MT1 & >::Type LeftOperand
Composite type of the left-hand side dense matrix expression.
Definition: DMatDMatAddExpr.h:153
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.
ValueType value_type
Type of the underlying elements.
Definition: DMatDMatAddExpr.h:174