All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
TDMatSMatAddExpr.h
Go to the documentation of this file.
1 //=================================================================================================
33 //=================================================================================================
34 
35 #ifndef _BLAZE_MATH_EXPRESSIONS_TDMATSMATADDEXPR_H_
36 #define _BLAZE_MATH_EXPRESSIONS_TDMATSMATADDEXPR_H_
37 
38 
39 //*************************************************************************************************
40 // Includes
41 //*************************************************************************************************
42 
43 #include <stdexcept>
60 #include <blaze/util/Assert.h>
63 #include <blaze/util/SelectType.h>
64 #include <blaze/util/Types.h>
65 
66 
67 namespace blaze {
68 
69 //=================================================================================================
70 //
71 // CLASS TDMATSMATADDEXPR
72 //
73 //=================================================================================================
74 
75 //*************************************************************************************************
82 template< typename MT1 // Type of the left-hand side dense matrix
83  , typename MT2 > // Type of the right-hand side sparse matrix
84 class TDMatSMatAddExpr : public DenseMatrix< TDMatSMatAddExpr<MT1,MT2>, false >
85  , private MatMatAddExpr
86  , private Computation
87 {
88  private:
89  //**Type definitions****************************************************************************
90  typedef typename MT1::ResultType RT1;
91  typedef typename MT2::ResultType RT2;
92  typedef typename MT1::ReturnType RN1;
93  typedef typename MT2::ReturnType RN2;
94  //**********************************************************************************************
95 
96  //**Return type evaluation**********************************************************************
98 
103  enum { returnExpr = !IsTemporary<RN1>::value && !IsTemporary<RN2>::value };
104 
107  //**********************************************************************************************
108 
109  //**Parallel evaluation strategy****************************************************************
111 
116  template< typename MT >
117  struct UseSMPAssign {
118  enum { value = ( !MT1::smpAssignable || !MT2::smpAssignable ) };
119  };
121  //**********************************************************************************************
122 
123  public:
124  //**Type definitions****************************************************************************
130 
133 
135  typedef const ResultType CompositeType;
136 
138  typedef typename SelectType< IsExpression<MT1>::value, const MT1, const MT1& >::Type LeftOperand;
139 
141  typedef typename SelectType< IsExpression<MT2>::value, const MT2, const MT2& >::Type RightOperand;
142  //**********************************************************************************************
143 
144  //**Compilation flags***************************************************************************
146  enum { vectorizable = 0 };
147 
149  enum { smpAssignable = 0 };
150  //**********************************************************************************************
151 
152  //**Constructor*********************************************************************************
158  explicit inline TDMatSMatAddExpr( const MT1& lhs, const MT2& rhs )
159  : lhs_( lhs ) // Left-hand side dense matrix of the addition expression
160  , rhs_( rhs ) // Right-hand side sparse matrix of the addition expression
161  {
162  BLAZE_INTERNAL_ASSERT( lhs.rows() == rhs.rows() , "Invalid number of rows" );
163  BLAZE_INTERNAL_ASSERT( lhs.columns() == rhs.columns(), "Invalid number of columns" );
164  }
165  //**********************************************************************************************
166 
167  //**Access operator*****************************************************************************
174  inline ReturnType operator()( size_t i, size_t j ) const {
175  BLAZE_INTERNAL_ASSERT( i < lhs_.rows() , "Invalid row access index" );
176  BLAZE_INTERNAL_ASSERT( j < lhs_.columns(), "Invalid column access index" );
177  return lhs_(i,j) + rhs_(i,j);
178  }
179  //**********************************************************************************************
180 
181  //**Rows function*******************************************************************************
186  inline size_t rows() const {
187  return lhs_.rows();
188  }
189  //**********************************************************************************************
190 
191  //**Columns function****************************************************************************
196  inline size_t columns() const {
197  return lhs_.columns();
198  }
199  //**********************************************************************************************
200 
201  //**Left operand access*************************************************************************
206  inline LeftOperand leftOperand() const {
207  return lhs_;
208  }
209  //**********************************************************************************************
210 
211  //**Right operand access************************************************************************
216  inline RightOperand rightOperand() const {
217  return rhs_;
218  }
219  //**********************************************************************************************
220 
221  //**********************************************************************************************
227  template< typename T >
228  inline bool canAlias( const T* alias ) const {
229  return ( IsExpression<MT1>::value && lhs_.canAlias( alias ) ) ||
230  ( rhs_.canAlias( alias ) );
231  }
232  //**********************************************************************************************
233 
234  //**********************************************************************************************
240  template< typename T >
241  inline bool isAliased( const T* alias ) const {
242  return ( lhs_.isAliased( alias ) || rhs_.isAliased( alias ) );
243  }
244  //**********************************************************************************************
245 
246  private:
247  //**Member variables****************************************************************************
250  //**********************************************************************************************
251 
252  //**Assignment to dense matrices****************************************************************
264  template< typename MT // Type of the target dense matrix
265  , bool SO2 > // Storage order of the target dense matrix
266  friend inline void assign( DenseMatrix<MT,SO2>& lhs, const TDMatSMatAddExpr& rhs )
267  {
269 
270  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
271  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
272 
273  if( !IsExpression<MT1>::value && isSame( ~lhs, rhs.lhs_ ) ) {
274  addAssign( ~lhs, rhs.rhs_ );
275  }
276  else {
277  assign ( ~lhs, rhs.lhs_ );
278  addAssign( ~lhs, rhs.rhs_ );
279  }
280  }
282  //**********************************************************************************************
283 
284  //**Assignment to sparse matrices***************************************************************
296  template< typename MT // Type of the target sparse matrix
297  , bool SO2 > // Storage order of the target sparse matrix
298  friend inline void assign( SparseMatrix<MT,SO2>& lhs, const TDMatSMatAddExpr& rhs )
299  {
301 
302  typedef typename SelectType< SO2, OppositeType, ResultType >::Type TmpType;
303 
310 
311  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
312  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
313 
314  const TmpType tmp( serial( rhs ) );
315  assign( ~lhs, tmp );
316  }
318  //**********************************************************************************************
319 
320  //**Addition assignment to dense matrices*******************************************************
333  template< typename MT // Type of the target dense matrix
334  , bool SO2 > // Storage order of the target dense matrix
335  friend inline void addAssign( DenseMatrix<MT,SO2>& lhs, const TDMatSMatAddExpr& rhs )
336  {
338 
339  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
340  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
341 
342  addAssign( ~lhs, rhs.lhs_ );
343  addAssign( ~lhs, rhs.rhs_ );
344  }
346  //**********************************************************************************************
347 
348  //**Addition assignment to sparse matrices******************************************************
349  // No special implementation for the addition assignment to sparse matrices.
350  //**********************************************************************************************
351 
352  //**Subtraction assignment to dense matrices****************************************************
365  template< typename MT // Type of the target dense matrix
366  , bool SO2 > // Storage order of the target dense matrix
367  friend inline void subAssign( DenseMatrix<MT,SO2>& lhs, const TDMatSMatAddExpr& rhs )
368  {
370 
371  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
372  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
373 
374  subAssign( ~lhs, rhs.lhs_ );
375  subAssign( ~lhs, rhs.rhs_ );
376  }
378  //**********************************************************************************************
379 
380  //**Subtraction assignment to sparse matrices***************************************************
381  // No special implementation for the subtraction assignment to sparse matrices.
382  //**********************************************************************************************
383 
384  //**Multiplication assignment to dense matrices*************************************************
385  // No special implementation for the multiplication assignment to dense matrices.
386  //**********************************************************************************************
387 
388  //**Multiplication assignment to sparse matrices************************************************
389  // No special implementation for the multiplication assignment to sparse matrices.
390  //**********************************************************************************************
391 
392  //**SMP assignment to dense matrices************************************************************
406  template< typename MT // Type of the target dense matrix
407  , bool SO2 > // Storage order of the target dense matrix
408  friend inline typename EnableIf< UseSMPAssign<MT> >::Type
409  smpAssign( DenseMatrix<MT,SO2>& lhs, const TDMatSMatAddExpr& rhs )
410  {
412 
413  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
414  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
415 
416  if( !IsExpression<MT1>::value && isSame( ~lhs, rhs.lhs_ ) ) {
417  smpAddAssign( ~lhs, rhs.rhs_ );
418  }
419  else {
420  smpAssign ( ~lhs, rhs.lhs_ );
421  smpAddAssign( ~lhs, rhs.rhs_ );
422  }
423  }
425  //**********************************************************************************************
426 
427  //**SMP assignment to sparse matrices***********************************************************
441  template< typename MT // Type of the target sparse matrix
442  , bool SO2 > // Storage order of the target sparse matrix
443  friend inline typename EnableIf< UseSMPAssign<MT> >::Type
444  smpAssign( SparseMatrix<MT,SO2>& lhs, const TDMatSMatAddExpr& rhs )
445  {
447 
448  typedef typename SelectType< SO2, OppositeType, ResultType >::Type TmpType;
449 
456 
457  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
458  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
459 
460  const TmpType tmp( rhs );
461  smpAssign( ~lhs, tmp );
462  }
464  //**********************************************************************************************
465 
466  //**SMP addition assignment to dense matrices***************************************************
481  template< typename MT // Type of the target dense matrix
482  , bool SO2 > // Storage order of the target dense matrix
483  friend inline typename EnableIf< UseSMPAssign<MT> >::Type
484  smpAddAssign( DenseMatrix<MT,SO2>& lhs, const TDMatSMatAddExpr& rhs )
485  {
487 
488  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
489  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
490 
491  smpAddAssign( ~lhs, rhs.lhs_ );
492  smpAddAssign( ~lhs, rhs.rhs_ );
493  }
495  //**********************************************************************************************
496 
497  //**SMP addition assignment to sparse matrices**************************************************
498  // No special implementation for the SMP addition assignment to sparse matrices.
499  //**********************************************************************************************
500 
501  //**SMP subtraction assignment to dense matrices************************************************
516  template< typename MT // Type of the target dense matrix
517  , bool SO2 > // Storage order of the target dense matrix
518  friend inline typename EnableIf< UseSMPAssign<MT> >::Type
519  smpSubAssign( DenseMatrix<MT,SO2>& lhs, const TDMatSMatAddExpr& rhs )
520  {
522 
523  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
524  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
525 
526  smpSubAssign( ~lhs, rhs.lhs_ );
527  smpSubAssign( ~lhs, rhs.rhs_ );
528  }
530  //**********************************************************************************************
531 
532  //**SMP subtraction assignment to sparse matrices***********************************************
533  // No special implementation for the SMP subtraction assignment to sparse matrices.
534  //**********************************************************************************************
535 
536  //**SMP multiplication assignment to dense matrices*********************************************
537  // No special implementation for the SMP multiplication assignment to dense matrices.
538  //**********************************************************************************************
539 
540  //**SMP multiplication assignment to sparse matrices********************************************
541  // No special implementation for the SMP multiplication assignment to sparse matrices.
542  //**********************************************************************************************
543 
544  //**Compile time checks*************************************************************************
551  //**********************************************************************************************
552 };
553 //*************************************************************************************************
554 
555 
556 
557 
558 //=================================================================================================
559 //
560 // GLOBAL BINARY ARITHMETIC OPERATORS
561 //
562 //=================================================================================================
563 
564 //*************************************************************************************************
595 template< typename T1 // Type of the left-hand side dense matrix
596  , typename T2 > // Type of the right-hand side sparse matrix
597 const TDMatSMatAddExpr<T1,T2>
599 {
601 
602  if( (~lhs).rows() != (~rhs).rows() || (~lhs).columns() != (~rhs).columns() )
603  throw std::invalid_argument( "Matrix sizes do not match" );
604 
605  return TDMatSMatAddExpr<T1,T2>( ~lhs, ~rhs );
606 }
607 //*************************************************************************************************
608 
609 
610 //*************************************************************************************************
641 template< typename T1 // Type of the left-hand side dense matrix
642  , typename T2 > // Type of the right-hand side sparse matrix
643 const TDMatSMatAddExpr<T1,T2>
645 {
647 
648  if( (~lhs).rows() != (~rhs).rows() || (~lhs).columns() != (~rhs).columns() )
649  throw std::invalid_argument( "Matrix sizes do not match" );
650 
651  return TDMatSMatAddExpr<T1,T2>( ~rhs, ~lhs );
652 }
653 //*************************************************************************************************
654 
655 
656 
657 
658 //=================================================================================================
659 //
660 // GLOBAL RESTRUCTURING BINARY ARITHMETIC OPERATORS
661 //
662 //=================================================================================================
663 
664 //*************************************************************************************************
677 template< typename T1 // Type of the dense matrix of the left-hand side expression
678  , typename T2 // Type of the sparse matrix of the left-hand side expression
679  , typename T3 // Type of the right-hand side dense matrix
680  , bool SO > // Storage order of the right-hand side dense matrix
681 inline const typename AddExprTrait< TDMatSMatAddExpr<T1,T2>, T3 >::Type
682  operator+( const TDMatSMatAddExpr<T1,T2>& lhs, const DenseMatrix<T3,SO>& rhs )
683 {
685 
686  return ( lhs.leftOperand() + (~rhs) ) + lhs.rightOperand();
687 }
689 //*************************************************************************************************
690 
691 
692 //*************************************************************************************************
705 template< typename T1 // Type of the dense matrix of the left-hand side expression
706  , typename T2 // Type of the sparse matrix of the left-hand side expression
707  , typename T3 // Type of the right-hand side dense matrix
708  , bool SO > // Storage order of the right-hand side dense matrix
709 inline const typename SubExprTrait< TDMatSMatAddExpr<T1,T2>, T3 >::Type
710  operator-( const TDMatSMatAddExpr<T1,T2>& lhs, const DenseMatrix<T3,SO>& rhs )
711 {
713 
714  return ( lhs.leftOperand() - (~rhs) ) + lhs.rightOperand();
715 }
717 //*************************************************************************************************
718 
719 
720 
721 
722 //=================================================================================================
723 //
724 // EXPRESSION TRAIT SPECIALIZATIONS
725 //
726 //=================================================================================================
727 
728 //*************************************************************************************************
730 template< typename MT1, typename MT2, typename MT3 >
731 struct DMatDMatAddExprTrait< TDMatSMatAddExpr<MT1,MT2>, MT3 >
732 {
733  public:
734  //**********************************************************************************************
736  typedef typename SelectType< IsDenseMatrix<MT1>::value && IsColumnMajorMatrix<MT1>::value &&
737  IsSparseMatrix<MT2>::value && IsRowMajorMatrix<MT2>::value &&
738  IsDenseMatrix<MT3>::value && IsRowMajorMatrix<MT3>::value
739  , typename DMatSMatAddExprTrait< typename TDMatDMatAddExprTrait<MT1,MT3>::Type, MT2 >::Type
740  , INVALID_TYPE >::Type Type;
742  //**********************************************************************************************
743 };
745 //*************************************************************************************************
746 
747 
748 //*************************************************************************************************
750 template< typename MT1, typename MT2, typename MT3 >
751 struct DMatTDMatAddExprTrait< TDMatSMatAddExpr<MT1,MT2>, MT3 >
752 {
753  public:
754  //**********************************************************************************************
756  typedef typename SelectType< IsDenseMatrix<MT1>::value && IsColumnMajorMatrix<MT1>::value &&
757  IsSparseMatrix<MT2>::value && IsRowMajorMatrix<MT2>::value &&
758  IsDenseMatrix<MT3>::value && IsColumnMajorMatrix<MT3>::value
759  , typename TDMatSMatAddExprTrait< typename TDMatTDMatAddExprTrait<MT1,MT3>::Type, MT2 >::Type
760  , INVALID_TYPE >::Type Type;
762  //**********************************************************************************************
763 };
765 //*************************************************************************************************
766 
767 
768 //*************************************************************************************************
770 template< typename MT1, typename MT2, typename MT3 >
771 struct DMatDMatSubExprTrait< TDMatSMatAddExpr<MT1,MT2>, MT3 >
772 {
773  public:
774  //**********************************************************************************************
776  typedef typename SelectType< IsDenseMatrix<MT1>::value && IsColumnMajorMatrix<MT1>::value &&
777  IsSparseMatrix<MT2>::value && IsRowMajorMatrix<MT2>::value &&
778  IsDenseMatrix<MT3>::value && IsRowMajorMatrix<MT3>::value
779  , typename DMatSMatAddExprTrait< typename TDMatDMatSubExprTrait<MT1,MT3>::Type, MT2 >::Type
780  , INVALID_TYPE >::Type Type;
782  //**********************************************************************************************
783 };
785 //*************************************************************************************************
786 
787 
788 //*************************************************************************************************
790 template< typename MT1, typename MT2, typename MT3 >
791 struct DMatTDMatSubExprTrait< TDMatSMatAddExpr<MT1,MT2>, MT3 >
792 {
793  public:
794  //**********************************************************************************************
796  typedef typename SelectType< IsDenseMatrix<MT1>::value && IsColumnMajorMatrix<MT1>::value &&
797  IsSparseMatrix<MT2>::value && IsRowMajorMatrix<MT2>::value &&
798  IsDenseMatrix<MT3>::value && IsColumnMajorMatrix<MT3>::value
799  , typename TDMatSMatAddExprTrait< typename TDMatTDMatSubExprTrait<MT1,MT3>::Type, MT2 >::Type
800  , INVALID_TYPE >::Type Type;
802  //**********************************************************************************************
803 };
805 //*************************************************************************************************
806 
807 
808 //*************************************************************************************************
810 template< typename MT1, typename MT2, bool AF >
811 struct SubmatrixExprTrait< TDMatSMatAddExpr<MT1,MT2>, AF >
812 {
813  public:
814  //**********************************************************************************************
815  typedef typename AddExprTrait< typename SubmatrixExprTrait<const MT1,AF>::Type
816  , typename SubmatrixExprTrait<const MT2,AF>::Type >::Type Type;
817  //**********************************************************************************************
818 };
820 //*************************************************************************************************
821 
822 
823 //*************************************************************************************************
825 template< typename MT1, typename MT2 >
826 struct RowExprTrait< TDMatSMatAddExpr<MT1,MT2> >
827 {
828  public:
829  //**********************************************************************************************
830  typedef typename AddExprTrait< typename RowExprTrait<const MT1>::Type
831  , typename RowExprTrait<const MT2>::Type >::Type Type;
832  //**********************************************************************************************
833 };
835 //*************************************************************************************************
836 
837 
838 //*************************************************************************************************
840 template< typename MT1, typename MT2 >
841 struct ColumnExprTrait< TDMatSMatAddExpr<MT1,MT2> >
842 {
843  public:
844  //**********************************************************************************************
845  typedef typename AddExprTrait< typename ColumnExprTrait<const MT1>::Type
846  , typename ColumnExprTrait<const MT2>::Type >::Type Type;
847  //**********************************************************************************************
848 };
850 //*************************************************************************************************
851 
852 } // namespace blaze
853 
854 #endif
Evaluation of the return type of an addition expression.Via this type trait it is possible to evaluat...
Definition: AddExprTrait.h:103
Compile time check whether the given type is a temporary vector or matrix type.This type trait class ...
Definition: IsTemporary.h:87
MT2::ResultType RT2
Result type of the right-hand side sparse matrix expression.
Definition: TDMatSMatAddExpr.h:91
size_t columns() const
Returns the current number of columns of the matrix.
Definition: TDMatSMatAddExpr.h:196
MT1::ReturnType RN1
Return type of the left-hand side dense matrix expression.
Definition: TDMatSMatAddExpr.h:92
LeftOperand leftOperand() const
Returns the left-hand side transpose dense matrix operand.
Definition: TDMatSMatAddExpr.h:206
void smpSubAssign(DenseMatrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the SMP subtraction assignment of a matrix to dense matrix.
Definition: DenseMatrix.h:152
Efficient implementation of a compressed matrix.The CompressedMatrix class template is the represent...
Definition: CompressedMatrix.h:199
#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.
bool isAliased(const T *alias) const
Returns whether the expression is aliased with the given address alias.
Definition: TDMatSMatAddExpr.h:241
const This & CompositeType
Data type for composite expression templates.
Definition: CompressedMatrix.h:2408
Type ElementType
Type of the sparse matrix elements.
Definition: CompressedMatrix.h:251
Header file for the AddExprTrait class template.
LeftOperand lhs_
Left-hand side dense matrix of the addition expression.
Definition: TDMatSMatAddExpr.h:248
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.
RightOperand rhs_
Right-hand side sparse matrix of the addition expression.
Definition: TDMatSMatAddExpr.h:249
ReturnType operator()(size_t i, size_t j) const
2D-access to the matrix elements.
Definition: TDMatSMatAddExpr.h:174
TDMatSMatAddExpr(const MT1 &lhs, const MT2 &rhs)
Constructor for the TDMatSMatAddExpr class.
Definition: TDMatSMatAddExpr.h:158
bool isSame(const Matrix< MT1, SO1 > &a, const Matrix< MT2, SO2 > &b)
Returns whether the two given matrices represent the same observable state.
Definition: Matrix.h:409
Base class for dense matrices.The DenseMatrix class is a base class for all dense matrix classes...
Definition: DenseMatrix.h:70
Base class for sparse matrices.The SparseMatrix class is a base class for all sparse matrix classes...
Definition: Forward.h:107
Constraint on the data type.
ResultType::OppositeType OppositeType
Result type with opposite storage order for expression template evaluations.
Definition: TDMatSMatAddExpr.h:127
SelectType< IsExpression< MT2 >::value, const MT2, const MT2 & >::Type RightOperand
Composite type of the right-hand side sparse matrix expression.
Definition: TDMatSMatAddExpr.h:141
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
MT1::ResultType RT1
Result type of the left-hand side dense matrix expression.
Definition: TDMatSMatAddExpr.h:90
Compile time type selection.The SelectType class template selects one of the two given types T1 and T...
Definition: SelectType.h:59
Header file for the IsTemporary type trait class.
#define BLAZE_CONSTRAINT_MUST_BE_COLUMN_MAJOR_MATRIX_TYPE(T)
Constraint on the data type.In case the given data type T is not a column-major dense or sparse matri...
Definition: StorageOrder.h:161
const SelectType< returnExpr, ExprReturnType, ElementType >::Type ReturnType
Return type for expression template evaluations.
Definition: TDMatSMatAddExpr.h:132
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
const DenseIterator< Type > operator+(const DenseIterator< Type > &it, ptrdiff_t inc)
Addition between a DenseIterator and an integral value.
Definition: DenseIterator.h:556
#define BLAZE_CONSTRAINT_MUST_BE_REFERENCE_TYPE(T)
Constraint on the data type.In case the given data type T is not a reference type, a compilation error is created.
Definition: Reference.h:78
Constraints on the storage order of matrix types.
Header file for the SelectType class template.
Header file for the RowExprTrait class template.
Header file for all forward declarations for expression class templates.
AddTrait< RT1, RT2 >::Type ResultType
Result type for expression template evaluations.
Definition: TDMatSMatAddExpr.h:126
Header file for the serial shim.
void smpAssign(DenseMatrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the SMP assignment of a matrix to a dense matrix.
Definition: DenseMatrix.h:92
Header file for the SubmatrixExprTrait class template.
#define BLAZE_CONSTRAINT_MUST_BE_ROW_MAJOR_MATRIX_TYPE(T)
Constraint on the data type.In case the given data type T is not a row-major dense or sparse matrix t...
Definition: StorageOrder.h:81
const Type & ReturnType
Return type for expression template evaluations.
Definition: CompressedMatrix.h:2407
Header file for run time assertion macros.
Base template for the AddTrait class.
Definition: AddTrait.h:141
Header file for the addition trait.
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
AddExprTrait< RN1, RN2 >::Type ExprReturnType
Expression return type for the subscript operator.
Definition: TDMatSMatAddExpr.h:106
const DenseIterator< Type > operator-(const DenseIterator< Type > &it, ptrdiff_t inc)
Subtraction between a DenseIterator and an integral value.
Definition: DenseIterator.h:585
const ResultType CompositeType
Data type for composite expression templates.
Definition: TDMatSMatAddExpr.h:135
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
Header file for the MatMatAddExpr base class.
#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
ResultType::TransposeType TransposeType
Transpose type for expression template evaluations.
Definition: TDMatSMatAddExpr.h:128
size_t rows() const
Returns the current number of rows of the matrix.
Definition: TDMatSMatAddExpr.h:186
bool canAlias(const T *alias) const
Returns whether the expression can alias with the given address alias.
Definition: TDMatSMatAddExpr.h:228
RightOperand rightOperand() const
Returns the right-hand side sparse matrix operand.
Definition: TDMatSMatAddExpr.h:216
Expression object for dense matrix-sparse matrix additions.The TDMatSMatAddExpr class represents the ...
Definition: Forward.h:127
#define BLAZE_FUNCTION_TRACE
Function trace macro.This macro can be used to reliably trace function calls. In case function tracin...
Definition: FunctionTrace.h:157
This ResultType
Result type for expression template evaluations.
Definition: CompressedMatrix.h:2403
TDMatSMatAddExpr< MT1, MT2 > This
Type of this TDMatSMatAddExpr instance.
Definition: TDMatSMatAddExpr.h:125
Header file for basic type definitions.
SelectType< IsExpression< MT1 >::value, const MT1, const MT1 & >::Type LeftOperand
Composite type of the left-hand side dense matrix expression.
Definition: TDMatSMatAddExpr.h:138
MT2::ReturnType RN2
Return type of the right-hand side sparse matrix expression.
Definition: TDMatSMatAddExpr.h:93
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
ResultType::ElementType ElementType
Resulting element type.
Definition: TDMatSMatAddExpr.h:129
Header file for the IsExpression type trait class.
Header file for the FunctionTrace class.