All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
TSMatDMatMultExpr.h
Go to the documentation of this file.
1 //=================================================================================================
33 //=================================================================================================
34 
35 #ifndef _BLAZE_MATH_EXPRESSIONS_TSMATDMATMULTEXPR_H_
36 #define _BLAZE_MATH_EXPRESSIONS_TSMATDMATMULTEXPR_H_
37 
38 
39 //*************************************************************************************************
40 // Includes
41 //*************************************************************************************************
42 
43 #include <stdexcept>
51 #include <blaze/math/shims/Reset.h>
79 #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 SMATDMATMULTEXPR
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 TSMatDMatMultExpr : public DenseMatrix< TSMatDMatMultExpr<MT1,MT2>, true >
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 MT1::ElementType ET1;
115  typedef typename MT2::ElementType ET2;
116  typedef typename MT1::CompositeType CT1;
117  typedef typename MT2::CompositeType CT2;
118  //**********************************************************************************************
119 
120  public:
121  //**Type definitions****************************************************************************
127  typedef const ElementType ReturnType;
128  typedef const ResultType CompositeType;
129 
131  typedef typename SelectType< IsExpression<MT1>::value, const MT1, const MT1& >::Type LeftOperand;
132 
134  typedef typename SelectType< IsExpression<MT2>::value, const MT2, const MT2& >::Type RightOperand;
135 
137  typedef typename SelectType< IsComputation<MT1>::value, const RT1, CT1 >::Type LT;
138 
140  typedef typename SelectType< IsComputation<MT2>::value, const RT2, CT2 >::Type RT;
141  //**********************************************************************************************
142 
143  //**Compilation flags***************************************************************************
145  enum { vectorizable = 0 };
146  //**********************************************************************************************
147 
148  //**Constructor*********************************************************************************
154  explicit inline TSMatDMatMultExpr( const MT1& lhs, const MT2& rhs )
155  : lhs_( lhs ) // Left-hand side sparse matrix of the multiplication expression
156  , rhs_( rhs ) // Right-hand side dense matrix of the multiplication expression
157  {
158  BLAZE_INTERNAL_ASSERT( lhs.columns() == rhs.rows(), "Invalid matrix sizes" );
159  }
160  //**********************************************************************************************
161 
162  //**Access operator*****************************************************************************
169  inline ReturnType operator()( size_t i, size_t j ) const {
170  BLAZE_INTERNAL_ASSERT( i < lhs_.rows() , "Invalid row access index" );
171  BLAZE_INTERNAL_ASSERT( j < rhs_.columns(), "Invalid column access index" );
172 
173  ElementType tmp;
174 
175  if( lhs_.columns() != 0UL ) {
176  tmp = lhs_(i,0UL) * rhs_(0UL,j);
177  for( size_t k=1UL; k<lhs_.columns(); ++k ) {
178  tmp += lhs_(i,k) * rhs_(k,j);
179  }
180  }
181  else {
182  reset( tmp );
183  }
184 
185  return tmp;
186  }
187  //**********************************************************************************************
188 
189  //**Rows function*******************************************************************************
194  inline size_t rows() const {
195  return lhs_.rows();
196  }
197  //**********************************************************************************************
198 
199  //**Columns function****************************************************************************
204  inline size_t columns() const {
205  return rhs_.columns();
206  }
207  //**********************************************************************************************
208 
209  //**Left operand access*************************************************************************
214  inline LeftOperand leftOperand() const {
215  return lhs_;
216  }
217  //**********************************************************************************************
218 
219  //**Right operand access************************************************************************
224  inline RightOperand rightOperand() const {
225  return rhs_;
226  }
227  //**********************************************************************************************
228 
229  //**********************************************************************************************
235  template< typename T >
236  inline bool canAlias( const T* alias ) const {
237  return ( lhs_.isAliased( alias ) || rhs_.isAliased( alias ) );
238  }
239  //**********************************************************************************************
240 
241  //**********************************************************************************************
247  template< typename T >
248  inline bool isAliased( const T* alias ) const {
249  return ( lhs_.isAliased( alias ) || rhs_.isAliased( alias ) );
250  }
251  //**********************************************************************************************
252 
253  private:
254  //**Member variables****************************************************************************
257  //**********************************************************************************************
258 
259  //**Default assignment to dense matrices********************************************************
273  template< typename MT // Type of the target dense matrix
274  , bool SO > // Storage order of the target dense matrix
275  friend inline typename EnableIf< IsResizable<typename MT::ElementType> >::Type
276  assign( DenseMatrix<MT,SO>& lhs, const TSMatDMatMultExpr& rhs )
277  {
279 
280  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
281  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
282 
284 
285  LT A( rhs.lhs_ ); // Evaluation of the right-hand side sparse matrix operand
286  RT B( rhs.rhs_ ); // Evaluation of the left-hand side dense matrix operand
287 
288  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.lhs_.rows() , "Invalid number of rows" );
289  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.lhs_.columns(), "Invalid number of columns" );
290  BLAZE_INTERNAL_ASSERT( B.rows() == rhs.rhs_.rows() , "Invalid number of rows" );
291  BLAZE_INTERNAL_ASSERT( B.columns() == rhs.rhs_.columns(), "Invalid number of columns" );
292  BLAZE_INTERNAL_ASSERT( A.rows() == (~lhs).rows() , "Invalid number of rows" );
293  BLAZE_INTERNAL_ASSERT( B.columns() == (~lhs).columns() , "Invalid number of columns" );
294 
295  reset( ~lhs );
296 
297  const size_t block( SO ? 8UL : 256UL );
298 
299  for( size_t jj=0UL; jj<B.columns(); jj+=block ) {
300  const size_t jend( ( jj+block > B.columns() )?( B.columns() ):( jj+block ) );
301  for( size_t i=0UL; i<A.columns(); ++i ) {
302  const ConstIterator end( A.end(i) );
303  ConstIterator element( A.begin(i) );
304  for( ; element!=end; ++element ) {
305  for( size_t j=jj; j<jend; ++j ) {
306  if( isDefault( (~lhs)(element->index(),j) ) )
307  (~lhs)(element->index(),j) = element->value() * B(i,j);
308  else
309  (~lhs)(element->index(),j) += element->value() * B(i,j);
310  }
311  }
312  }
313  }
314  }
316  //**********************************************************************************************
317 
318  //**Optimized assignment to dense matrices******************************************************
332  template< typename MT // Type of the target dense matrix
333  , bool SO > // Storage order of the target dense matrix
334  friend inline typename DisableIf< IsResizable<typename MT::ElementType> >::Type
335  assign( DenseMatrix<MT,SO>& lhs, const TSMatDMatMultExpr& 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 
343 
344  LT A( rhs.lhs_ ); // Evaluation of the right-hand side sparse matrix operand
345  RT B( rhs.rhs_ ); // Evaluation of the left-hand side dense matrix operand
346 
347  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.lhs_.rows() , "Invalid number of rows" );
348  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.lhs_.columns(), "Invalid number of columns" );
349  BLAZE_INTERNAL_ASSERT( B.rows() == rhs.rhs_.rows() , "Invalid number of rows" );
350  BLAZE_INTERNAL_ASSERT( B.columns() == rhs.rhs_.columns(), "Invalid number of columns" );
351  BLAZE_INTERNAL_ASSERT( A.rows() == (~lhs).rows() , "Invalid number of rows" );
352  BLAZE_INTERNAL_ASSERT( B.columns() == (~lhs).columns() , "Invalid number of columns" );
353 
354  const size_t block( SO ? 8UL : 256UL );
355 
356  for( size_t jj=0UL; jj<B.columns(); jj+=block ) {
357  const size_t jend( ( jj+block > B.columns() )?( B.columns() ):( jj+block ) );
358  for( size_t i=0UL; i<A.rows(); ++i ) {
359  for( size_t j=jj; j<jend; ++j ) {
360  reset( (~lhs)(i,j) );
361  }
362  }
363  for( size_t i=0UL; i<A.columns(); ++i )
364  {
365  const ConstIterator end( A.end(i) );
366  ConstIterator element( A.begin(i) );
367 
368  const size_t nonzeros( A.nonZeros(i) );
369 
370  BLAZE_INTERNAL_ASSERT( ( nonzeros - ( nonzeros % 4UL ) ) == ( nonzeros & size_t(-4) ), "Invalid end calculation" );
371  const size_t kend( nonzeros & size_t(-4) );
372 
373  for( size_t k=0UL; k<kend; k+=4UL ) {
374  const size_t i1( element->index() );
375  const ET1 v1( element->value() );
376  ++element;
377  const size_t i2( element->index() );
378  const ET1 v2( element->value() );
379  ++element;
380  const size_t i3( element->index() );
381  const ET1 v3( element->value() );
382  ++element;
383  const size_t i4( element->index() );
384  const ET1 v4( element->value() );
385  ++element;
386 
387  for( size_t j=jj; j<jend; ++j ) {
388  (~lhs)(i1,j) += v1 * B(i,j);
389  (~lhs)(i2,j) += v2 * B(i,j);
390  (~lhs)(i3,j) += v3 * B(i,j);
391  (~lhs)(i4,j) += v4 * B(i,j);
392  }
393  }
394 
395  for( ; element!=end; ++element ) {
396  for( size_t j=jj; j<jend; ++j ) {
397  (~lhs)(element->index(),j) += element->value() * B(i,j);
398  }
399  }
400  }
401  }
402  }
404  //**********************************************************************************************
405 
406  //**Assignment to sparse matrices***************************************************************
418  template< typename MT // Type of the target sparse matrix
419  , bool SO > // Storage order of the target sparse matrix
420  friend inline void assign( SparseMatrix<MT,SO>& lhs, const TSMatDMatMultExpr& rhs )
421  {
423 
424  typedef typename SelectType< SO, ResultType, OppositeType >::Type TmpType;
425 
432 
433  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
434  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
435 
436  const TmpType tmp( rhs );
437  assign( ~lhs, tmp );
438  }
440  //**********************************************************************************************
441 
442  //**Addition assignment to dense matrices*******************************************************
455  template< typename MT // Type of the target dense matrix
456  , bool SO > // Storage order of the target dense matrix
457  friend inline void addAssign( DenseMatrix<MT,SO>& lhs, const TSMatDMatMultExpr& rhs )
458  {
460 
461  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
462  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
463 
465 
466  LT A( rhs.lhs_ ); // Evaluation of the right-hand side sparse matrix operand
467  RT B( rhs.rhs_ ); // Evaluation of the left-hand side dense matrix operand
468 
469  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.lhs_.rows() , "Invalid number of rows" );
470  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.lhs_.columns(), "Invalid number of columns" );
471  BLAZE_INTERNAL_ASSERT( B.rows() == rhs.rhs_.rows() , "Invalid number of rows" );
472  BLAZE_INTERNAL_ASSERT( B.columns() == rhs.rhs_.columns(), "Invalid number of columns" );
473  BLAZE_INTERNAL_ASSERT( A.rows() == (~lhs).rows() , "Invalid number of rows" );
474  BLAZE_INTERNAL_ASSERT( B.columns() == (~lhs).columns() , "Invalid number of columns" );
475 
476  const size_t block( SO ? 8UL : 256UL );
477 
478  for( size_t jj=0UL; jj<B.columns(); jj+=block ) {
479  const size_t jend( ( jj+block > B.columns() )?( B.columns() ):( jj+block ) );
480  for( size_t i=0UL; i<A.columns(); ++i )
481  {
482  const ConstIterator end( A.end(i) );
483  ConstIterator element( A.begin(i) );
484 
485  const size_t nonzeros( A.nonZeros(i) );
486 
487  BLAZE_INTERNAL_ASSERT( ( nonzeros - ( nonzeros % 4UL ) ) == ( nonzeros & size_t(-4) ), "Invalid end calculation" );
488  const size_t kend( nonzeros & size_t(-4) );
489 
490  for( size_t k=0UL; k<kend; k+=4UL ) {
491  const size_t i1( element->index() );
492  const ET1 v1( element->value() );
493  ++element;
494  const size_t i2( element->index() );
495  const ET1 v2( element->value() );
496  ++element;
497  const size_t i3( element->index() );
498  const ET1 v3( element->value() );
499  ++element;
500  const size_t i4( element->index() );
501  const ET1 v4( element->value() );
502  ++element;
503 
504  for( size_t j=jj; j<jend; ++j ) {
505  (~lhs)(i1,j) += v1 * B(i,j);
506  (~lhs)(i2,j) += v2 * B(i,j);
507  (~lhs)(i3,j) += v3 * B(i,j);
508  (~lhs)(i4,j) += v4 * B(i,j);
509  }
510  }
511 
512  for( ; element!=end; ++element ) {
513  for( size_t j=jj; j<jend; ++j ) {
514  (~lhs)(element->index(),j) += element->value() * B(i,j);
515  }
516  }
517  }
518  }
519  }
521  //**********************************************************************************************
522 
523  //**Addition assignment to sparse matrices******************************************************
524  // No special implementation for the addition assignment to sparse matrices.
525  //**********************************************************************************************
526 
527  //**Subtraction assignment to dense matrices****************************************************
540  template< typename MT // Type of the target dense matrix
541  , bool SO > // Storage order of the target dense matrix
542  friend inline void subAssign( DenseMatrix<MT,SO>& lhs, const TSMatDMatMultExpr& rhs )
543  {
545 
546  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
547  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
548 
550 
551  LT A( rhs.lhs_ ); // Evaluation of the right-hand side sparse matrix operand
552  RT B( rhs.rhs_ ); // Evaluation of the left-hand side dense matrix operand
553 
554  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.lhs_.rows() , "Invalid number of rows" );
555  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.lhs_.columns(), "Invalid number of columns" );
556  BLAZE_INTERNAL_ASSERT( B.rows() == rhs.rhs_.rows() , "Invalid number of rows" );
557  BLAZE_INTERNAL_ASSERT( B.columns() == rhs.rhs_.columns(), "Invalid number of columns" );
558  BLAZE_INTERNAL_ASSERT( A.rows() == (~lhs).rows() , "Invalid number of rows" );
559  BLAZE_INTERNAL_ASSERT( B.columns() == (~lhs).columns() , "Invalid number of columns" );
560 
561  const size_t block( SO ? 8UL : 256UL );
562 
563  for( size_t jj=0UL; jj<B.columns(); jj+=block ) {
564  const size_t jend( ( jj+block > B.columns() )?( B.columns() ):( jj+block ) );
565  for( size_t i=0UL; i<A.columns(); ++i )
566  {
567  const ConstIterator end( A.end(i) );
568  ConstIterator element( A.begin(i) );
569 
570  const size_t nonzeros( A.nonZeros(i) );
571 
572  BLAZE_INTERNAL_ASSERT( ( nonzeros - ( nonzeros % 4UL ) ) == ( nonzeros & size_t(-4) ), "Invalid end calculation" );
573  const size_t kend( nonzeros & size_t(-4) );
574 
575  for( size_t k=0UL; k<kend; k+=4UL ) {
576  const size_t i1( element->index() );
577  const ET1 v1( element->value() );
578  ++element;
579  const size_t i2( element->index() );
580  const ET1 v2( element->value() );
581  ++element;
582  const size_t i3( element->index() );
583  const ET1 v3( element->value() );
584  ++element;
585  const size_t i4( element->index() );
586  const ET1 v4( element->value() );
587  ++element;
588 
589  for( size_t j=jj; j<jend; ++j ) {
590  (~lhs)(i1,j) -= v1 * B(i,j);
591  (~lhs)(i2,j) -= v2 * B(i,j);
592  (~lhs)(i3,j) -= v3 * B(i,j);
593  (~lhs)(i4,j) -= v4 * B(i,j);
594  }
595  }
596 
597  for( ; element!=end; ++element ) {
598  for( size_t j=jj; j<jend; ++j ) {
599  (~lhs)(element->index(),j) -= element->value() * B(i,j);
600  }
601  }
602  }
603  }
604  }
606  //**********************************************************************************************
607 
608  //**Subtraction assignment to sparse matrices***************************************************
609  // No special implementation for the subtraction assignment to sparse matrices.
610  //**********************************************************************************************
611 
612  //**Multiplication assignment to dense matrices*************************************************
613  // No special implementation for the multiplication assignment to dense matrices.
614  //**********************************************************************************************
615 
616  //**Multiplication assignment to sparse matrices************************************************
617  // No special implementation for the multiplication assignment to sparse matrices.
618  //**********************************************************************************************
619 
620  //**Compile time checks*************************************************************************
627  //**********************************************************************************************
628 };
629 //*************************************************************************************************
630 
631 
632 
633 
634 //=================================================================================================
635 //
636 // GLOBAL BINARY ARITHMETIC OPERATORS
637 //
638 //=================================================================================================
639 
640 //*************************************************************************************************
671 template< typename T1 // Type of the left-hand side sparse matrix
672  , typename T2 > // Type of the right-hand side dense matrix
673 inline const TSMatDMatMultExpr<T1,T2>
675 {
677 
678  if( (~lhs).columns() != (~rhs).rows() )
679  throw std::invalid_argument( "Matrix sizes do not match" );
680 
681  return TSMatDMatMultExpr<T1,T2>( ~lhs, ~rhs );
682 }
683 //*************************************************************************************************
684 
685 
686 
687 
688 //=================================================================================================
689 //
690 // EXPRESSION TRAIT SPECIALIZATIONS
691 //
692 //=================================================================================================
693 
694 //*************************************************************************************************
696 template< typename MT1, typename MT2, typename VT >
697 struct TDMatDVecMultExprTrait< TSMatDMatMultExpr<MT1,MT2>, VT >
698 {
699  public:
700  //**********************************************************************************************
701  typedef typename SelectType< IsSparseMatrix<MT1>::value && IsColumnMajorMatrix<MT1>::value &&
702  IsDenseMatrix<MT2>::value && IsRowMajorMatrix<MT2>::value &&
703  IsDenseVector<VT>::value && IsColumnVector<VT>::value
704  , typename TSMatDVecMultExprTrait< MT1, typename DMatDVecMultExprTrait<MT2,VT>::Type >::Type
705  , INVALID_TYPE >::Type Type;
706  //**********************************************************************************************
707 };
709 //*************************************************************************************************
710 
711 
712 //*************************************************************************************************
714 template< typename MT1, typename MT2, typename VT >
715 struct TDMatSVecMultExprTrait< TSMatDMatMultExpr<MT1,MT2>, VT >
716 {
717  public:
718  //**********************************************************************************************
719  typedef typename SelectType< IsSparseMatrix<MT1>::value && IsColumnMajorMatrix<MT1>::value &&
720  IsDenseMatrix<MT2>::value && IsRowMajorMatrix<MT2>::value &&
721  IsSparseVector<VT>::value && IsColumnVector<VT>::value
722  , typename TSMatDVecMultExprTrait< MT1, typename DMatSVecMultExprTrait<MT2,VT>::Type >::Type
723  , INVALID_TYPE >::Type Type;
724  //**********************************************************************************************
725 };
727 //*************************************************************************************************
728 
729 
730 //*************************************************************************************************
732 template< typename VT, typename MT1, typename MT2 >
733 struct TDVecTDMatMultExprTrait< VT, TSMatDMatMultExpr<MT1,MT2> >
734 {
735  public:
736  //**********************************************************************************************
737  typedef typename SelectType< IsDenseVector<VT>::value && IsRowVector<VT>::value &&
738  IsSparseMatrix<MT1>::value && IsColumnMajorMatrix<MT1>::value &&
739  IsDenseMatrix<MT2>::value && IsRowMajorMatrix<MT2>::value
740  , typename TDVecDMatMultExprTrait< typename TDVecTSMatMultExprTrait<VT,MT1>::Type, MT2 >::Type
741  , INVALID_TYPE >::Type Type;
742  //**********************************************************************************************
743 };
745 //*************************************************************************************************
746 
747 
748 //*************************************************************************************************
750 template< typename VT, typename MT1, typename MT2 >
751 struct TSVecTDMatMultExprTrait< VT, TSMatDMatMultExpr<MT1,MT2> >
752 {
753  public:
754  //**********************************************************************************************
755  typedef typename SelectType< IsSparseVector<VT>::value && IsRowVector<VT>::value &&
756  IsSparseMatrix<MT1>::value && IsColumnMajorMatrix<MT1>::value &&
757  IsDenseMatrix<MT2>::value && IsRowMajorMatrix<MT2>::value
758  , typename TDVecDMatMultExprTrait< typename TDVecTSMatMultExprTrait<VT,MT1>::Type, MT2 >::Type
759  , INVALID_TYPE >::Type Type;
760  //**********************************************************************************************
761 };
763 //*************************************************************************************************
764 
765 
766 //*************************************************************************************************
768 template< typename MT1, typename MT2 >
769 struct SubmatrixExprTrait< TSMatDMatMultExpr<MT1,MT2> >
770 {
771  public:
772  //**********************************************************************************************
773  typedef typename MultExprTrait< typename SubmatrixExprTrait<const MT1>::Type
774  , typename SubmatrixExprTrait<const MT2>::Type >::Type Type;
775  //**********************************************************************************************
776 };
778 //*************************************************************************************************
779 
780 
781 //*************************************************************************************************
783 template< typename MT1, typename MT2 >
784 struct RowExprTrait< TSMatDMatMultExpr<MT1,MT2> >
785 {
786  public:
787  //**********************************************************************************************
788  typedef typename MultExprTrait< typename RowExprTrait<const MT1>::Type, MT2 >::Type Type;
789  //**********************************************************************************************
790 };
792 //*************************************************************************************************
793 
794 
795 //*************************************************************************************************
797 template< typename MT1, typename MT2 >
798 struct ColumnExprTrait< TSMatDMatMultExpr<MT1,MT2> >
799 {
800  public:
801  //**********************************************************************************************
802  typedef typename MultExprTrait< MT1, typename ColumnExprTrait<const MT2>::Type >::Type Type;
803  //**********************************************************************************************
804 };
806 //*************************************************************************************************
807 
808 } // namespace blaze
809 
810 #endif
ResultType::OppositeType OppositeType
Result type with opposite storage order for expression template evaluations.
Definition: TSMatDMatMultExpr.h:124
void reset(DynamicMatrix< Type, SO > &m)
Resetting the given dense matrix.
Definition: DynamicMatrix.h:4512
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:3703
MultTrait< RT1, RT2 >::Type ResultType
Result type for expression template evaluations.
Definition: TSMatDMatMultExpr.h:123
Header file for the IsSparseMatrix type trait.
bool isDefault(const DynamicMatrix< Type, SO > &m)
Returns whether the given dense matrix is in default state.
Definition: DynamicMatrix.h:4555
Efficient implementation of a compressed matrix.The CompressedMatrix class template is the represent...
Definition: CompressedMatrix.h:196
#define BLAZE_CONSTRAINT_MUST_BE_DENSE_MATRIX_TYPE(T)
Constraint on the data type.In case the given data type T is not a dense, N-dimensional matrix type...
Definition: DenseMatrix.h:79
Header file for the ColumnExprTrait class template.
size_t columns() const
Returns the current number of columns of the matrix.
Definition: TSMatDMatMultExpr.h:204
bool canAlias(const T *alias) const
Returns whether the expression can alias with the given address alias.
Definition: TSMatDMatMultExpr.h:236
TSMatDMatMultExpr< MT1, MT2 > This
Type of this TSMatDMatMultExpr instance.
Definition: TSMatDMatMultExpr.h:122
Header file for the IsColumnMajorMatrix type trait.
Header file for the TSVecTSMatMultExprTrait class template.
const This & CompositeType
Data type for composite expression templates.
Definition: CompressedMatrix.h:2375
Header file for the IsRowVector type trait.
Type ElementType
Type of the sparse matrix elements.
Definition: CompressedMatrix.h:248
LeftOperand leftOperand() const
Returns the left-hand side transpose sparse matrix operand.
Definition: TSMatDMatMultExpr.h:214
ResultType::TransposeType TransposeType
Transpose type for expression template evaluations.
Definition: TSMatDMatMultExpr.h:125
Header file for the Computation base class.
Header file for the MatMatMultExpr base class.
SelectType< IsComputation< MT2 >::value, const RT2, CT2 >::Type RT
Type for the assignment of the right-hand side dense matrix operand.
Definition: TSMatDMatMultExpr.h:140
SelectType< IsComputation< MT1 >::value, const RT1, CT1 >::Type LT
Type for the assignment of the left-hand side sparse matrix operand.
Definition: TSMatDMatMultExpr.h:137
MT1::CompositeType CT1
Composite type of the left-hand side sparse matrix expression.
Definition: TSMatDMatMultExpr.h:116
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
LeftOperand lhs_
Left-hand side sparse matrix of the multiplication expression.
Definition: TSMatDMatMultExpr.h:255
bool isAliased(const T *alias) const
Returns whether the expression is aliased with the given address alias.
Definition: TSMatDMatMultExpr.h:248
MT1::ElementType ET1
Element type of the left-hand side dense matrix expression.
Definition: TSMatDMatMultExpr.h:114
Constraint on the data type.
Constraint on the data type.
Header file for the MultExprTrait class template.
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.
RightOperand rhs_
Right-hand side dense matrix of the multiplication expression.
Definition: TSMatDMatMultExpr.h:256
MT2::CompositeType CT2
Composite type of the right-hand side dense matrix expression.
Definition: TSMatDMatMultExpr.h:117
#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
RightOperand rightOperand() const
Returns the right-hand side dense matrix operand.
Definition: TSMatDMatMultExpr.h:224
Header file for the TSVecTDMatMultExprTrait class template.
const Element * ConstIterator
Iterator over constant elements.
Definition: CompressedMatrix.h:2379
Header file for the TDMatSVecMultExprTrait class template.
Header file for the TDVecTSMatMultExprTrait class template.
MT1::ResultType RT1
Result type of the left-hand side sparse matrix expression.
Definition: TSMatDMatMultExpr.h:112
Header file for the DenseMatrix base class.
Header file for the TSMatDVecMultExprTrait class template.
TSMatDMatMultExpr(const MT1 &lhs, const MT2 &rhs)
Constructor for the TSMatDMatMultExpr class.
Definition: TSMatDMatMultExpr.h:154
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
ReturnType operator()(size_t i, size_t j) const
2D-access to the matrix elements.
Definition: TSMatDMatMultExpr.h:169
Header file for the DMatDVecMultExprTrait class template.
#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
MT2::ResultType RT2
Result type of the right-hand side dense matrix expression.
Definition: TSMatDMatMultExpr.h:113
SelectType< IsExpression< MT2 >::value, const MT2, const MT2 & >::Type RightOperand
Composite type of the right-hand side dense matrix expression.
Definition: TSMatDMatMultExpr.h:134
Constraints on the storage order of matrix types.
Type ElementType
Type of the sparse matrix elements.
Definition: CompressedMatrix.h:2373
Header file for the SelectType class template.
Header file for the RowExprTrait class template.
Header file for all forward declarations for expression class templates.
SelectType< IsExpression< MT1 >::value, const MT1, const MT1 & >::Type LeftOperand
Composite type of the left-hand side sparse matrix expression.
Definition: TSMatDMatMultExpr.h:131
Header file for the IsDenseMatrix type trait.
Header file for the EnableIf class template.
const ResultType CompositeType
Data type for composite expression templates.
Definition: TSMatDMatMultExpr.h:128
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
const ElementType ReturnType
Return type for expression template evaluations.
Definition: TSMatDMatMultExpr.h:127
Header file for run time assertion macros.
Utility type for generic codes.
Base template for the MultTrait class.
Definition: MultTrait.h:141
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
Header file for the reset shim.
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
Header file for the RemoveReference type trait.
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.
size_t rows() const
Returns the current number of rows of the matrix.
Definition: TSMatDMatMultExpr.h:194
MT2::ElementType ET2
Element type of the right-hand side sparse matrix expression.
Definition: TSMatDMatMultExpr.h:115
Header file for the IsRowMajorMatrix type trait.
Header file for the IsComputation type trait class.
Expression object for transpose sparse matrix-dense matrix multiplications.The TSMatDMatMultExpr clas...
Definition: Forward.h:133
Header file for the TDVecDMatMultExprTrait class template.
Header file for the TDMatDVecMultExprTrait 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:2370
ResultType::ElementType ElementType
Resulting element type.
Definition: TSMatDMatMultExpr.h:126
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.
Header file for the DMatSVecMultExprTrait class template.
Header file for the IsColumnVector type trait.
Header file for the IsResizable type trait.
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
Header file for the TDVecTDMatMultExprTrait class template.
#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
Header file for the IsExpression type trait class.
Header file for the FunctionTrace class.