All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
DMatTSMatMultExpr.h
Go to the documentation of this file.
1 //=================================================================================================
33 //=================================================================================================
34 
35 #ifndef _BLAZE_MATH_EXPRESSIONS_DMATTSMATMULTEXPR_H_
36 #define _BLAZE_MATH_EXPRESSIONS_DMATTSMATMULTEXPR_H_
37 
38 
39 //*************************************************************************************************
40 // Includes
41 //*************************************************************************************************
42 
43 #include <stdexcept>
51 #include <blaze/math/shims/Reset.h>
78 #include <blaze/util/Assert.h>
80 #include <blaze/util/DisableIf.h>
81 #include <blaze/util/EnableIf.h>
82 #include <blaze/util/InvalidType.h>
84 #include <blaze/util/SelectType.h>
85 #include <blaze/util/Types.h>
87 
88 
89 namespace blaze {
90 
91 //=================================================================================================
92 //
93 // CLASS DMATTSMATMULTEXPR
94 //
95 //=================================================================================================
96 
97 //*************************************************************************************************
104 template< typename MT1 // Type of the left-hand side dense matrix
105  , typename MT2 > // Type of the right-hand side sparse matrix
106 class DMatTSMatMultExpr : public DenseMatrix< DMatTSMatMultExpr<MT1,MT2>, false >
107  , private MatMatMultExpr
108  , private Computation
109 {
110  private:
111  //**Type definitions****************************************************************************
112  typedef typename MT1::ResultType RT1;
113  typedef typename MT2::ResultType RT2;
114  typedef typename RT1::ElementType ET1;
115  typedef typename RT2::ElementType ET2;
116  typedef typename MT1::CompositeType CT1;
117  typedef typename MT2::CompositeType CT2;
118  //**********************************************************************************************
119 
120  //**********************************************************************************************
123  //**********************************************************************************************
124 
125  //**********************************************************************************************
127  enum { evaluateRight = IsComputation<MT2>::value || RequiresEvaluation<MT2>::value };
128  //**********************************************************************************************
129 
130  //**********************************************************************************************
132 
135  template< typename T1, typename T2, typename T3 >
136  struct UseSMPAssignKernel {
137  enum { value = evaluateLeft || evaluateRight };
138  };
140  //**********************************************************************************************
141 
142  public:
143  //**Type definitions****************************************************************************
149  typedef const ElementType ReturnType;
150  typedef const ResultType CompositeType;
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 
160 
163  //**********************************************************************************************
164 
165  //**Compilation flags***************************************************************************
167  enum { vectorizable = 0 };
168 
170  enum { smpAssignable = !evaluateLeft && !evaluateRight };
171  //**********************************************************************************************
172 
173  //**Constructor*********************************************************************************
179  explicit inline DMatTSMatMultExpr( const MT1& lhs, const MT2& rhs )
180  : lhs_( lhs ) // Left-hand side dense matrix of the multiplication expression
181  , rhs_( rhs ) // Right-hand side sparse matrix of the multiplication expression
182  {
183  BLAZE_INTERNAL_ASSERT( lhs.columns() == rhs.rows(), "Invalid matrix sizes" );
184  }
185  //**********************************************************************************************
186 
187  //**Access operator*****************************************************************************
194  inline ReturnType operator()( size_t i, size_t j ) const {
195  BLAZE_INTERNAL_ASSERT( i < lhs_.rows() , "Invalid row access index" );
196  BLAZE_INTERNAL_ASSERT( j < rhs_.columns(), "Invalid column access index" );
197 
199 
200  ElementType tmp = ElementType();
201 
202  // Early exit
203  if( lhs_.columns() == 0UL )
204  return tmp;
205 
206  // Fast computation in case the right-hand side sparse matrix directly provides iterators
208  {
209  CT2 B( rhs_ ); // Evaluation of the right-hand side sparse matrix operand
210 
211  const ConstIterator end( B.end(j) );
212  ConstIterator element( B.begin(j) );
213 
214  // Early exit in case column j is empty
215  if( element == end )
216  return tmp;
217 
218  // Calculating element (i,j)
219  tmp = lhs_(i,element->index()) * element->value();
220  ++element;
221  for( ; element!=end; ++element )
222  tmp += lhs_(i,element->index()) * element->value();
223  }
224 
225  // Default computation in case the right-hand side sparse matrix doesn't provide iterators
226  else {
227  tmp = lhs_(i,0UL) * rhs_(0UL,j);
228  for( size_t k=1UL; k<lhs_.columns(); ++k ) {
229  tmp += lhs_(i,k) * rhs_(k,j);
230  }
231  }
232 
233  return tmp;
234  }
235  //**********************************************************************************************
236 
237  //**Rows function*******************************************************************************
242  inline size_t rows() const {
243  return lhs_.rows();
244  }
245  //**********************************************************************************************
246 
247  //**Columns function****************************************************************************
252  inline size_t columns() const {
253  return rhs_.columns();
254  }
255  //**********************************************************************************************
256 
257  //**Left operand access*************************************************************************
262  inline LeftOperand leftOperand() const {
263  return lhs_;
264  }
265  //**********************************************************************************************
266 
267  //**Right operand access************************************************************************
272  inline RightOperand rightOperand() const {
273  return rhs_;
274  }
275  //**********************************************************************************************
276 
277  //**********************************************************************************************
283  template< typename T >
284  inline bool canAlias( const T* alias ) const {
285  return ( lhs_.isAliased( alias ) || rhs_.isAliased( alias ) );
286  }
287  //**********************************************************************************************
288 
289  //**********************************************************************************************
295  template< typename T >
296  inline bool isAliased( const T* alias ) const {
297  return ( lhs_.isAliased( alias ) || rhs_.isAliased( alias ) );
298  }
299  //**********************************************************************************************
300 
301  //**********************************************************************************************
306  inline bool isAligned() const {
307  return lhs_.isAligned();
308  }
309  //**********************************************************************************************
310 
311  //**********************************************************************************************
316  inline bool canSMPAssign() const {
317  return ( rows() > SMP_DMATTSMATMULT_THRESHOLD );
318  }
319  //**********************************************************************************************
320 
321  private:
322  //**Member variables****************************************************************************
325  //**********************************************************************************************
326 
327  //**Assignment to dense matrices****************************************************************
340  template< typename MT // Type of the target dense matrix
341  , bool SO > // Storage order of the target dense matrix
342  friend inline void assign( DenseMatrix<MT,SO>& lhs, const DMatTSMatMultExpr& 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  LT A( rhs.lhs_ ); // Evaluation of the left-hand side dense matrix operand
350  RT B( rhs.rhs_ ); // Evaluation of the right-hand side sparse matrix operand
351 
352  BLAZE_INTERNAL_ASSERT( A.rows() == (~lhs).rows() , "Invalid number of rows" );
353  BLAZE_INTERNAL_ASSERT( A.columns() == B.rows() , "Invalid matrix sizes" );
354  BLAZE_INTERNAL_ASSERT( B.columns() == (~lhs).columns(), "Invalid number of columns" );
355 
356  DMatTSMatMultExpr::selectAssignKernel( ~lhs, A, B );
357  }
359  //**********************************************************************************************
360 
361  //**Default assignment to dense matrices********************************************************
375  template< typename MT3 // Type of the left-hand side target matrix
376  , typename MT4 // Type of the left-hand side matrix operand
377  , typename MT5 > // Type of the right-hand side matrix operand
378  static inline typename DisableIf< UseSMPAssignKernel<MT3,MT4,MT5> >::Type
379  selectAssignKernel( MT3& C, const MT4& A, const MT5& B )
380  {
381  typedef typename MT5::ConstIterator ConstIterator;
382 
383  for( size_t i=0UL; i<C.rows(); ++i ) {
384  for( size_t j=0UL; j<C.columns(); ++j )
385  {
386  ConstIterator element( B.begin(j) );
387  const ConstIterator end( B.end(j) );
388 
389  if( element == end ) {
390  reset( C(i,j) );
391  continue;
392  }
393 
394  C(i,j) = A(i,element->index()) * element->value();
395  ++element;
396  for( ; element!=end; ++element )
397  C(i,j) += A(i,element->index()) * element->value();
398  }
399  }
400  }
402  //**********************************************************************************************
403 
404  //**SMP assignment to dense matrices************************************************************
418  template< typename MT3 // Type of the left-hand side target matrix
419  , typename MT4 // Type of the left-hand side matrix operand
420  , typename MT5 > // Type of the right-hand side matrix operand
421  static inline typename EnableIf< UseSMPAssignKernel<MT3,MT4,MT5> >::Type
422  selectAssignKernel( MT3& C, const MT4& A, const MT5& B )
423  {
424  smpAssign( C, A * B );
425  }
427  //**********************************************************************************************
428 
429  //**Assignment to sparse matrices***************************************************************
442  template< typename MT // Type of the target sparse matrix
443  , bool SO > // Storage order of the target sparse matrix
444  friend inline void assign( SparseMatrix<MT,SO>& lhs, const DMatTSMatMultExpr& rhs )
445  {
447 
448  typedef typename SelectType< SO, 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  //**Addition assignment to dense matrices*******************************************************
479  template< typename MT // Type of the target dense matrix
480  , bool SO > // Storage order of the target dense matrix
481  friend inline void addAssign( DenseMatrix<MT,SO>& lhs, const DMatTSMatMultExpr& rhs )
482  {
484 
485  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
486  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
487 
488  LT A( rhs.lhs_ ); // Evaluation of the left-hand side dense matrix operand
489  RT B( rhs.rhs_ ); // Evaluation of the right-hand side sparse matrix operand
490 
491  BLAZE_INTERNAL_ASSERT( A.rows() == (~lhs).rows() , "Invalid number of rows" );
492  BLAZE_INTERNAL_ASSERT( A.columns() == B.rows() , "Invalid matrix sizes" );
493  BLAZE_INTERNAL_ASSERT( B.columns() == (~lhs).columns(), "Invalid number of columns" );
494 
495  DMatTSMatMultExpr::selectAddAssignKernel( ~lhs, A, B );
496  }
498  //**********************************************************************************************
499 
500  //**Default addition assignment to dense matrices***********************************************
514  template< typename MT3 // Type of the left-hand side target matrix
515  , typename MT4 // Type of the left-hand side matrix operand
516  , typename MT5 > // Type of the right-hand side matrix operand
517  static inline typename DisableIf< UseSMPAssignKernel<MT3,MT4,MT5> >::Type
518  selectAddAssignKernel( MT3& C, const MT4& A, const MT5& B )
519  {
520  typedef typename MT5::ConstIterator ConstIterator;
521 
522  for( size_t i=0UL; i<C.rows(); ++i ) {
523  for( size_t j=0UL; j<C.columns(); ++j )
524  {
525  ConstIterator element( B.begin(j) );
526  const ConstIterator end( B.end(j) );
527 
528  for( ; element!=end; ++element )
529  C(i,j) += A(i,element->index()) * element->value();
530  }
531  }
532  }
534  //**********************************************************************************************
535 
536  //**SMP addition assignment to dense matrices***************************************************
550  template< typename MT3 // Type of the left-hand side target matrix
551  , typename MT4 // Type of the left-hand side matrix operand
552  , typename MT5 > // Type of the right-hand side matrix operand
553  static inline typename EnableIf< UseSMPAssignKernel<MT3,MT4,MT5> >::Type
554  selectAddAssignKernel( MT3& C, const MT4& A, const MT5& B )
555  {
556  smpAddAssign( C, A * B );
557  }
559  //**********************************************************************************************
560 
561  //**Addition assignment to sparse matrices******************************************************
562  // No special implementation for the addition assignment to sparse matrices.
563  //**********************************************************************************************
564 
565  //**Subtraction assignment to dense matrices****************************************************
578  template< typename MT // Type of the target dense matrix
579  , bool SO > // Storage order of the target dense matrix
580  friend inline void subAssign( DenseMatrix<MT,SO>& lhs, const DMatTSMatMultExpr& rhs )
581  {
583 
584  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
585  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
586 
587  LT A( rhs.lhs_ ); // Evaluation of the left-hand side dense matrix operand
588  RT B( rhs.rhs_ ); // Evaluation of the right-hand side sparse matrix operand
589 
590  BLAZE_INTERNAL_ASSERT( A.rows() == (~lhs).rows() , "Invalid number of rows" );
591  BLAZE_INTERNAL_ASSERT( A.columns() == B.rows() , "Invalid matrix sizes" );
592  BLAZE_INTERNAL_ASSERT( B.columns() == (~lhs).columns(), "Invalid number of columns" );
593 
594  DMatTSMatMultExpr::selectSubAssignKernel( ~lhs, A, B );
595  }
597  //**********************************************************************************************
598 
599  //**Default subtraction assignment to dense matrices***********************************************
613  template< typename MT3 // Type of the left-hand side target matrix
614  , typename MT4 // Type of the left-hand side matrix operand
615  , typename MT5 > // Type of the right-hand side matrix operand
616  static inline typename DisableIf< UseSMPAssignKernel<MT3,MT4,MT5> >::Type
617  selectSubAssignKernel( MT3& C, const MT4& A, const MT5& B )
618  {
619  typedef typename MT5::ConstIterator ConstIterator;
620 
621  for( size_t i=0UL; i<C.rows(); ++i ) {
622  for( size_t j=0UL; j<C.columns(); ++j )
623  {
624  ConstIterator element( B.begin(j) );
625  const ConstIterator end( B.end(j) );
626 
627  for( ; element!=end; ++element )
628  C(i,j) -= A(i,element->index()) * element->value();
629  }
630  }
631  }
633  //**********************************************************************************************
634 
635  //**SMP subtraction assignment to dense matrices************************************************
649  template< typename MT3 // Type of the left-hand side target matrix
650  , typename MT4 // Type of the left-hand side matrix operand
651  , typename MT5 > // Type of the right-hand side matrix operand
652  static inline typename EnableIf< UseSMPAssignKernel<MT3,MT4,MT5> >::Type
653  selectSubAssignKernel( MT3& C, const MT4& A, const MT5& B )
654  {
655  smpSubAssign( C, A * B );
656  }
658  //**********************************************************************************************
659 
660  //**Subtraction assignment to sparse matrices***************************************************
661  // No special implementation for the subtraction assignment to sparse matrices.
662  //**********************************************************************************************
663 
664  //**Multiplication assignment to dense matrices*************************************************
665  // No special implementation for the multiplication assignment to dense matrices.
666  //**********************************************************************************************
667 
668  //**Multiplication assignment to sparse matrices************************************************
669  // No special implementation for the multiplication assignment to sparse matrices.
670  //**********************************************************************************************
671 
672  //**Compile time checks*************************************************************************
679  //**********************************************************************************************
680 };
681 //*************************************************************************************************
682 
683 
684 
685 
686 //=================================================================================================
687 //
688 // GLOBAL BINARY ARITHMETIC OPERATORS
689 //
690 //=================================================================================================
691 
692 //*************************************************************************************************
722 template< typename T1 // Type of the left-hand side dense matrix
723  , typename T2 > // Type of the right-hand side sparse matrix
724 inline const DMatTSMatMultExpr<T1,T2>
726 {
728 
729  if( (~lhs).columns() != (~rhs).rows() )
730  throw std::invalid_argument( "Matrix sizes do not match" );
731 
732  return DMatTSMatMultExpr<T1,T2>( ~lhs, ~rhs );
733 }
734 //*************************************************************************************************
735 
736 
737 
738 
739 //=================================================================================================
740 //
741 // EXPRESSION TRAIT SPECIALIZATIONS
742 //
743 //=================================================================================================
744 
745 //*************************************************************************************************
747 template< typename MT1, typename MT2, typename VT >
748 struct DMatDVecMultExprTrait< DMatTSMatMultExpr<MT1,MT2>, VT >
749 {
750  public:
751  //**********************************************************************************************
752  typedef typename SelectType< IsDenseMatrix<MT1>::value && IsRowMajorMatrix<MT1>::value &&
753  IsSparseMatrix<MT2>::value && IsColumnMajorMatrix<MT2>::value &&
754  IsDenseVector<VT>::value && IsColumnVector<VT>::value
755  , typename DMatDVecMultExprTrait< MT1, typename TSMatDVecMultExprTrait<MT2,VT>::Type >::Type
756  , INVALID_TYPE >::Type Type;
757  //**********************************************************************************************
758 };
760 //*************************************************************************************************
761 
762 
763 //*************************************************************************************************
765 template< typename MT1, typename MT2, typename VT >
766 struct DMatSVecMultExprTrait< DMatTSMatMultExpr<MT1,MT2>, VT >
767 {
768  public:
769  //**********************************************************************************************
770  typedef typename SelectType< IsDenseMatrix<MT1>::value && IsRowMajorMatrix<MT1>::value &&
771  IsSparseMatrix<MT2>::value && IsColumnMajorMatrix<MT2>::value &&
772  IsSparseVector<VT>::value && IsColumnVector<VT>::value
773  , typename DMatSVecMultExprTrait< MT1, typename TSMatSVecMultExprTrait<MT2,VT>::Type >::Type
774  , INVALID_TYPE >::Type Type;
775  //**********************************************************************************************
776 };
778 //*************************************************************************************************
779 
780 
781 //*************************************************************************************************
783 template< typename VT, typename MT1, typename MT2 >
784 struct TDVecDMatMultExprTrait< VT, DMatTSMatMultExpr<MT1,MT2> >
785 {
786  public:
787  //**********************************************************************************************
788  typedef typename SelectType< IsDenseVector<VT>::value && IsRowVector<VT>::value &&
789  IsDenseMatrix<MT1>::value && IsRowMajorMatrix<MT1>::value &&
790  IsSparseMatrix<MT2>::value && IsColumnMajorMatrix<MT2>::value
791  , typename TDVecTSMatMultExprTrait< typename TDVecDMatMultExprTrait<VT,MT1>::Type, MT2 >::Type
792  , INVALID_TYPE >::Type Type;
793  //**********************************************************************************************
794 };
796 //*************************************************************************************************
797 
798 
799 //*************************************************************************************************
801 template< typename VT, typename MT1, typename MT2 >
802 struct TSVecDMatMultExprTrait< VT, DMatTSMatMultExpr<MT1,MT2> >
803 {
804  public:
805  //**********************************************************************************************
806  typedef typename SelectType< IsSparseVector<VT>::value && IsRowVector<VT>::value &&
807  IsDenseMatrix<MT1>::value && IsRowMajorMatrix<MT1>::value &&
808  IsSparseMatrix<MT2>::value && IsColumnMajorMatrix<MT2>::value
809  , typename TDVecTSMatMultExprTrait< typename TSVecDMatMultExprTrait<VT,MT1>::Type, MT2 >::Type
810  , INVALID_TYPE >::Type Type;
811  //**********************************************************************************************
812 };
814 //*************************************************************************************************
815 
816 
817 //*************************************************************************************************
819 template< typename MT1, typename MT2, bool AF >
820 struct SubmatrixExprTrait< DMatTSMatMultExpr<MT1,MT2>, AF >
821 {
822  public:
823  //**********************************************************************************************
824  typedef typename MultExprTrait< typename SubmatrixExprTrait<const MT1,AF>::Type
825  , typename SubmatrixExprTrait<const MT2,AF>::Type >::Type Type;
826  //**********************************************************************************************
827 };
829 //*************************************************************************************************
830 
831 
832 //*************************************************************************************************
834 template< typename MT1, typename MT2 >
835 struct RowExprTrait< DMatTSMatMultExpr<MT1,MT2> >
836 {
837  public:
838  //**********************************************************************************************
839  typedef typename MultExprTrait< typename RowExprTrait<const MT1>::Type, MT2 >::Type Type;
840  //**********************************************************************************************
841 };
843 //*************************************************************************************************
844 
845 
846 //*************************************************************************************************
848 template< typename MT1, typename MT2 >
849 struct ColumnExprTrait< DMatTSMatMultExpr<MT1,MT2> >
850 {
851  public:
852  //**********************************************************************************************
853  typedef typename MultExprTrait< MT1, typename ColumnExprTrait<const MT2>::Type >::Type Type;
854  //**********************************************************************************************
855 };
857 //*************************************************************************************************
858 
859 } // namespace blaze
860 
861 #endif
ResultType::ElementType ElementType
Resulting element type.
Definition: DMatTSMatMultExpr.h:148
Compile time check whether the given type is a computational expression template.This type trait clas...
Definition: IsComputation.h:89
void reset(DynamicMatrix< Type, SO > &m)
Resetting the given dense matrix.
Definition: DynamicMatrix.h:4579
ReturnType operator()(size_t i, size_t j) const
2D-access to the matrix elements.
Definition: DMatTSMatMultExpr.h:194
const DMatDMatMultExpr< T1, T2 > operator*(const DenseMatrix< T1, false > &lhs, const DenseMatrix< T2, false > &rhs)
Multiplication operator for the multiplication of two row-major dense matrices ( ).
Definition: DMatDMatMultExpr.h:4075
SelectType< IsExpression< MT1 >::value, const MT1, const MT1 & >::Type LeftOperand
Composite type of the left-hand side dense matrix expression.
Definition: DMatTSMatMultExpr.h:153
MT2::CompositeType CT2
Composite type of the right-hand side sparse matrix expression.
Definition: DMatTSMatMultExpr.h:117
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
bool canAlias(const T *alias) const
Returns whether the expression can alias with the given address alias.
Definition: DMatTSMatMultExpr.h:284
Header file for the IsSparseMatrix type trait.
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
Header file for the ColumnExprTrait class template.
Header file for the IsColumnMajorMatrix type trait.
Header file for the sparse matrix SMP implementation.
ResultType::TransposeType TransposeType
Transpose type for expression template evaluations.
Definition: DMatTSMatMultExpr.h:147
const This & CompositeType
Data type for composite expression templates.
Definition: CompressedMatrix.h:2384
Header file for the IsRowVector type trait.
Type ElementType
Type of the sparse matrix elements.
Definition: CompressedMatrix.h:249
Header file for the Computation base class.
Header file for the MatMatMultExpr base class.
Header file for the RequiresEvaluation type trait.
LeftOperand leftOperand() const
Returns the left-hand side dense matrix operand.
Definition: DMatTSMatMultExpr.h:262
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 ResultType CompositeType
Data type for composite expression templates.
Definition: DMatTSMatMultExpr.h:150
Constraint on the data type.
Constraint on the data type.
Header file for the MultExprTrait class template.
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
bool isAligned() const
Returns whether the operands of the expression are properly aligned in memory.
Definition: DMatTSMatMultExpr.h:306
DMatTSMatMultExpr(const MT1 &lhs, const MT2 &rhs)
Constructor for the DMatTSMatMultExpr class.
Definition: DMatTSMatMultExpr.h:179
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 DisableIf class template.
Header file for the multiplication trait.
size_t rows() const
Returns the current number of rows of the matrix.
Definition: DMatTSMatMultExpr.h:242
#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
MT1::CompositeType CT1
Composite type of the left-hand side dense matrix expression.
Definition: DMatTSMatMultExpr.h:116
const size_t SMP_DMATTSMATMULT_THRESHOLD
SMP row-major dense matrix/column-major sparse matrix multiplication threshold.This threshold represe...
Definition: Thresholds.h:498
const Element * ConstIterator
Iterator over constant elements.
Definition: CompressedMatrix.h:2388
Header file for the TDVecTSMatMultExprTrait class template.
Header file for the dense matrix SMP implementation.
Header file for the DenseMatrix base class.
Header file for the TSMatDVecMultExprTrait class template.
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
RT2::ElementType ET2
Element type of the right-hand side sparse matrix expression.
Definition: DMatTSMatMultExpr.h:115
SelectType< evaluateLeft, const RT1, CT1 >::Type LT
Type for the assignment of the left-hand side dense matrix operand.
Definition: DMatTSMatMultExpr.h:159
Header file for the DMatDVecMultExprTrait class template.
MT1::ResultType RT1
Result type of the left-hand side dense matrix expression.
Definition: DMatTSMatMultExpr.h:112
ResultType::OppositeType OppositeType
Result type with opposite storage order for expression template evaluations.
Definition: DMatTSMatMultExpr.h:146
#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.
RT1::ElementType ET1
Element type of the left-hand side dense matrix expression.
Definition: DMatTSMatMultExpr.h:114
Type ElementType
Type of the sparse matrix elements.
Definition: CompressedMatrix.h:2382
RightOperand rhs_
Right-hand side sparse matrix of the multiplication expression.
Definition: DMatTSMatMultExpr.h:324
Header file for the SelectType class template.
Header file for the RowExprTrait class template.
Header file for all forward declarations for expression class templates.
Header file for the IsDenseMatrix type trait.
Header file for the EnableIf class template.
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
Base class for all matrix/matrix multiplication expression templates.The MatMatMultExpr class serves ...
Definition: MatMatMultExpr.h:65
Header file for the IsSparseVector type trait.
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
Removal of reference modifiers.The RemoveCV type trait removes any reference modifiers from the given...
Definition: RemoveReference.h:69
Header file for run time assertion macros.
Utility type for generic codes.
Base template for the MultTrait class.
Definition: MultTrait.h:141
const ElementType ReturnType
Return type for expression template evaluations.
Definition: DMatTSMatMultExpr.h:149
MultTrait< RT1, RT2 >::Type ResultType
Result type for expression template evaluations.
Definition: DMatTSMatMultExpr.h:145
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
RightOperand rightOperand() const
Returns the right-hand side transpose sparse matrix operand.
Definition: DMatTSMatMultExpr.h:272
Header file for the reset shim.
SelectType< evaluateRight, const RT2, CT2 >::Type RT
Type for the assignment of the right-hand side sparse matrix operand.
Definition: DMatTSMatMultExpr.h:162
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
Expression object for dense matrix-transpose sparse matrix multiplications.The DMatTSMatMultExpr clas...
Definition: DMatTSMatMultExpr.h:106
Header file for the RemoveReference type trait.
bool isAliased(const T *alias) const
Returns whether the expression is aliased with the given address alias.
Definition: DMatTSMatMultExpr.h:296
Substitution Failure Is Not An Error (SFINAE) class.The DisableIf class template is an auxiliary tool...
Definition: DisableIf.h:184
#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
Header file for the IsDenseVector type trait.
bool canSMPAssign() const
Returns whether the expression can be used in SMP assignments.
Definition: DMatTSMatMultExpr.h:316
LeftOperand lhs_
Left-hand side dense matrix of the multiplication expression.
Definition: DMatTSMatMultExpr.h:323
Header file for the IsRowMajorMatrix type trait.
Header file for the IsComputation type trait class.
Base class for all compute expression templates.The Computation class serves as a tag for all computa...
Definition: Computation.h:59
Header file for the TDVecDMatMultExprTrait class template.
#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.
Header file for the TSVecDMatMultExprTrait class template.
size_t columns() const
Returns the current number of columns of the matrix.
Definition: DMatTSMatMultExpr.h:252
MT2::ResultType RT2
Result type of the right-hand side sparse matrix expression.
Definition: DMatTSMatMultExpr.h:113
Header file for the DMatSVecMultExprTrait class template.
Header file for the IsColumnVector type trait.
Header file for the thresholds for matrix/vector and matrix/matrix multiplications.
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
DMatTSMatMultExpr< MT1, MT2 > This
Type of this DMatTSMatMultExpr instance.
Definition: DMatTSMatMultExpr.h:144
#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
SelectType< IsExpression< MT2 >::value, const MT2, const MT2 & >::Type RightOperand
Composite type of the right-hand side sparse matrix expression.
Definition: DMatTSMatMultExpr.h:156
Header file for the IsExpression type trait class.
Header file for the TSMatSVecMultExprTrait class template.
Header file for the FunctionTrace class.