All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
TSMatTDMatMultExpr.h
Go to the documentation of this file.
1 //=================================================================================================
33 //=================================================================================================
34 
35 #ifndef _BLAZE_MATH_EXPRESSIONS_TSMATTDMATMULTEXPR_H_
36 #define _BLAZE_MATH_EXPRESSIONS_TSMATTDMATMULTEXPR_H_
37 
38 
39 //*************************************************************************************************
40 // Includes
41 //*************************************************************************************************
42 
43 #include <stdexcept>
51 #include <blaze/math/shims/Reset.h>
74 #include <blaze/util/Assert.h>
75 #include <blaze/util/EnableIf.h>
76 #include <blaze/util/DisableIf.h>
77 #include <blaze/util/InvalidType.h>
79 #include <blaze/util/SelectType.h>
80 #include <blaze/util/Types.h>
82 
83 
84 namespace blaze {
85 
86 //=================================================================================================
87 //
88 // CLASS SMATDMATMULTEXPR
89 //
90 //=================================================================================================
91 
92 //*************************************************************************************************
99 template< typename MT1 // Type of the left-hand side dense matrix
100  , typename MT2 > // Type of the right-hand side sparse matrix
101 class TSMatTDMatMultExpr : public DenseMatrix< TSMatTDMatMultExpr<MT1,MT2>, true >
102  , private MatMatMultExpr
103  , private Computation
104 {
105  private:
106  //**Type definitions****************************************************************************
107  typedef typename MT1::ResultType RT1;
108  typedef typename MT2::ResultType RT2;
109  typedef typename MT1::ElementType ET1;
110  typedef typename MT2::ElementType ET2;
111  typedef typename MT1::CompositeType CT1;
112  typedef typename MT2::CompositeType CT2;
113  //**********************************************************************************************
114 
115  public:
116  //**Type definitions****************************************************************************
122  typedef const ElementType ReturnType;
123  typedef const ResultType CompositeType;
124 
126  typedef typename SelectType< IsExpression<MT1>::value, const MT1, const MT1& >::Type LeftOperand;
127 
129  typedef typename SelectType< IsExpression<MT2>::value, const MT2, const MT2& >::Type RightOperand;
130 
132  typedef typename SelectType< IsComputation<MT1>::value, const RT1, CT1 >::Type LT;
133 
135  typedef typename SelectType< IsComputation<MT2>::value, const RT2, CT2 >::Type RT;
136  //**********************************************************************************************
137 
138  //**Compilation flags***************************************************************************
140  enum { vectorizable = 0 };
141  //**********************************************************************************************
142 
143  //**Constructor*********************************************************************************
149  explicit inline TSMatTDMatMultExpr( const MT1& lhs, const MT2& rhs )
150  : lhs_( lhs ) // Left-hand side sparse matrix of the multiplication expression
151  , rhs_( rhs ) // Right-hand side dense matrix of the multiplication expression
152  {
153  BLAZE_INTERNAL_ASSERT( lhs.columns() == rhs.rows(), "Invalid matrix sizes" );
154  }
155  //**********************************************************************************************
156 
157  //**Access operator*****************************************************************************
164  inline ReturnType operator()( size_t i, size_t j ) const {
165  BLAZE_INTERNAL_ASSERT( i < lhs_.rows() , "Invalid row access index" );
166  BLAZE_INTERNAL_ASSERT( j < rhs_.columns(), "Invalid column access index" );
167 
168  ElementType tmp;
169 
170  if( lhs_.columns() != 0UL ) {
171  tmp = lhs_(i,0UL) * rhs_(0UL,j);
172  for( size_t k=1UL; k<lhs_.columns(); ++k ) {
173  tmp += lhs_(i,k) * rhs_(k,j);
174  }
175  }
176  else {
177  reset( tmp );
178  }
179 
180  return tmp;
181  }
182  //**********************************************************************************************
183 
184  //**Rows function*******************************************************************************
189  inline size_t rows() const {
190  return lhs_.rows();
191  }
192  //**********************************************************************************************
193 
194  //**Columns function****************************************************************************
199  inline size_t columns() const {
200  return rhs_.columns();
201  }
202  //**********************************************************************************************
203 
204  //**Left operand access*************************************************************************
209  inline LeftOperand leftOperand() const {
210  return lhs_;
211  }
212  //**********************************************************************************************
213 
214  //**Right operand access************************************************************************
219  inline RightOperand rightOperand() const {
220  return rhs_;
221  }
222  //**********************************************************************************************
223 
224  //**********************************************************************************************
230  template< typename T >
231  inline bool canAlias( const T* alias ) const {
232  return ( lhs_.isAliased( alias ) || rhs_.isAliased( alias ) );
233  }
234  //**********************************************************************************************
235 
236  //**********************************************************************************************
242  template< typename T >
243  inline bool isAliased( const T* alias ) const {
244  return ( lhs_.isAliased( alias ) || rhs_.isAliased( alias ) );
245  }
246  //**********************************************************************************************
247 
248  private:
249  //**Member variables****************************************************************************
252  //**********************************************************************************************
253 
254  //**Default assignment to dense matrices********************************************************
268  template< typename MT // Type of the target dense matrix
269  , bool SO > // Storage order of the target dense matrix
270  friend inline typename EnableIf< IsResizable<typename MT::ElementType> >::Type
271  assign( DenseMatrix<MT,SO>& lhs, const TSMatTDMatMultExpr& rhs )
272  {
274 
275  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
276  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
277 
279 
280  LT A( rhs.lhs_ ); // Evaluation of the right-hand side sparse matrix operand
281  RT B( rhs.rhs_ ); // Evaluation of the left-hand side dense matrix operand
282 
283  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.lhs_.rows() , "Invalid number of rows" );
284  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.lhs_.columns(), "Invalid number of columns" );
285  BLAZE_INTERNAL_ASSERT( B.rows() == rhs.rhs_.rows() , "Invalid number of rows" );
286  BLAZE_INTERNAL_ASSERT( B.columns() == rhs.rhs_.columns(), "Invalid number of columns" );
287  BLAZE_INTERNAL_ASSERT( A.rows() == (~lhs).rows() , "Invalid number of rows" );
288  BLAZE_INTERNAL_ASSERT( B.columns() == (~lhs).columns() , "Invalid number of columns" );
289 
290  reset( ~lhs );
291 
292  const size_t block( 64UL );
293 
294  for( size_t jj=0UL; jj<B.columns(); jj+=block ) {
295  const size_t jend( ( jj+block > B.columns() )?( B.columns() ):( jj+block ) );
296  for( size_t i=0UL; i<A.columns(); ++i ) {
297  const ConstIterator end( A.end(i) );
298  ConstIterator element( A.begin(i) );
299  for( ; element!=end; ++element ) {
300  for( size_t j=jj; j<jend; ++j ) {
301  if( isDefault( (~lhs)(element->index(),j) ) )
302  (~lhs)(element->index(),j) = element->value() * B(i,j);
303  else
304  (~lhs)(element->index(),j) += element->value() * B(i,j);
305  }
306  }
307  }
308  }
309  }
311  //**********************************************************************************************
312 
313  //**Optimized assignment to dense matrices******************************************************
327  template< typename MT // Type of the target dense matrix
328  , bool SO > // Storage order of the target dense matrix
329  friend inline typename DisableIf< IsResizable<typename MT::ElementType> >::Type
330  assign( DenseMatrix<MT,SO>& lhs, const TSMatTDMatMultExpr& rhs )
331  {
333 
334  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
335  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
336 
338 
339  LT A( rhs.lhs_ ); // Evaluation of the right-hand side sparse matrix operand
340  RT B( rhs.rhs_ ); // Evaluation of the left-hand side dense matrix operand
341 
342  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.lhs_.rows() , "Invalid number of rows" );
343  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.lhs_.columns(), "Invalid number of columns" );
344  BLAZE_INTERNAL_ASSERT( B.rows() == rhs.rhs_.rows() , "Invalid number of rows" );
345  BLAZE_INTERNAL_ASSERT( B.columns() == rhs.rhs_.columns(), "Invalid number of columns" );
346  BLAZE_INTERNAL_ASSERT( A.rows() == (~lhs).rows() , "Invalid number of rows" );
347  BLAZE_INTERNAL_ASSERT( B.columns() == (~lhs).columns() , "Invalid number of columns" );
348 
349  const size_t block( SO ? 64UL : 128UL );
350 
351  for( size_t jj=0UL; jj<B.columns(); jj+=block ) {
352  const size_t jend( ( jj+block > B.columns() )?( B.columns() ):( jj+block ) );
353  for( size_t i=0UL; i<A.rows(); ++i ) {
354  for( size_t j=jj; j<jend; ++j ) {
355  reset( (~lhs)(i,j) );
356  }
357  }
358  for( size_t i=0UL; i<A.columns(); ++i )
359  {
360  const ConstIterator end( A.end(i) );
361  ConstIterator element( A.begin(i) );
362 
363  const size_t nonzeros( A.nonZeros(i) );
364 
365  BLAZE_INTERNAL_ASSERT( ( nonzeros - ( nonzeros % 4UL ) ) == ( nonzeros & size_t(-4) ), "Invalid end calculation" );
366  const size_t kend( nonzeros & size_t(-4) );
367 
368  for( size_t k=0UL; k<kend; k+=4UL ) {
369  const size_t i1( element->index() );
370  const ET1 v1( element->value() );
371  ++element;
372  const size_t i2( element->index() );
373  const ET1 v2( element->value() );
374  ++element;
375  const size_t i3( element->index() );
376  const ET1 v3( element->value() );
377  ++element;
378  const size_t i4( element->index() );
379  const ET1 v4( element->value() );
380  ++element;
381 
382  for( size_t j=jj; j<jend; ++j ) {
383  (~lhs)(i1,j) += v1 * B(i,j);
384  (~lhs)(i2,j) += v2 * B(i,j);
385  (~lhs)(i3,j) += v3 * B(i,j);
386  (~lhs)(i4,j) += v4 * B(i,j);
387  }
388  }
389 
390  for( ; element!=end; ++element ) {
391  for( size_t j=jj; j<jend; ++j ) {
392  (~lhs)(element->index(),j) += element->value() * B(i,j);
393  }
394  }
395  }
396  }
397  }
399  //**********************************************************************************************
400 
401  //**Assignment to sparse matrices***************************************************************
414  template< typename MT // Type of the target sparse matrix
415  , bool SO > // Storage order of the target sparse matrix
416  friend inline void assign( SparseMatrix<MT,SO>& lhs, const TSMatTDMatMultExpr& rhs )
417  {
419 
420  typedef typename SelectType< SO, ResultType, OppositeType >::Type TmpType;
421 
428 
429  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
430  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
431 
432  const TmpType tmp( rhs );
433  assign( ~lhs, tmp );
434  }
436  //**********************************************************************************************
437 
438  //**Addition assignment to dense matrices*******************************************************
451  template< typename MT // Type of the target dense matrix
452  , bool SO > // Storage order of the target dense matrix
453  friend inline void addAssign( DenseMatrix<MT,SO>& lhs, const TSMatTDMatMultExpr& rhs )
454  {
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 
461 
462  LT A( rhs.lhs_ ); // Evaluation of the right-hand side sparse matrix operand
463  RT B( rhs.rhs_ ); // Evaluation of the left-hand side dense matrix operand
464 
465  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.lhs_.rows() , "Invalid number of rows" );
466  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.lhs_.columns(), "Invalid number of columns" );
467  BLAZE_INTERNAL_ASSERT( B.rows() == rhs.rhs_.rows() , "Invalid number of rows" );
468  BLAZE_INTERNAL_ASSERT( B.columns() == rhs.rhs_.columns(), "Invalid number of columns" );
469  BLAZE_INTERNAL_ASSERT( A.rows() == (~lhs).rows() , "Invalid number of rows" );
470  BLAZE_INTERNAL_ASSERT( B.columns() == (~lhs).columns() , "Invalid number of columns" );
471 
472  const size_t block( SO ? 64UL : 128UL );
473 
474  for( size_t jj=0UL; jj<B.columns(); jj+=block ) {
475  const size_t jend( ( jj+block > B.columns() )?( B.columns() ):( jj+block ) );
476  for( size_t i=0UL; i<A.columns(); ++i )
477  {
478  const ConstIterator end( A.end(i) );
479  ConstIterator element( A.begin(i) );
480 
481  const size_t nonzeros( A.nonZeros(i) );
482 
483  BLAZE_INTERNAL_ASSERT( ( nonzeros - ( nonzeros % 4UL ) ) == ( nonzeros & size_t(-4) ), "Invalid end calculation" );
484  const size_t kend( nonzeros & size_t(-4) );
485 
486  for( size_t k=0UL; k<kend; k+=4UL ) {
487  const size_t i1( element->index() );
488  const ET1 v1( element->value() );
489  ++element;
490  const size_t i2( element->index() );
491  const ET1 v2( element->value() );
492  ++element;
493  const size_t i3( element->index() );
494  const ET1 v3( element->value() );
495  ++element;
496  const size_t i4( element->index() );
497  const ET1 v4( element->value() );
498  ++element;
499 
500  for( size_t j=jj; j<jend; ++j ) {
501  (~lhs)(i1,j) += v1 * B(i,j);
502  (~lhs)(i2,j) += v2 * B(i,j);
503  (~lhs)(i3,j) += v3 * B(i,j);
504  (~lhs)(i4,j) += v4 * B(i,j);
505  }
506  }
507 
508  for( ; element!=end; ++element ) {
509  for( size_t j=jj; j<jend; ++j ) {
510  (~lhs)(element->index(),j) += element->value() * B(i,j);
511  }
512  }
513  }
514  }
515  }
517  //**********************************************************************************************
518 
519  //**Addition assignment to sparse matrices******************************************************
520  // No special implementation for the addition assignment to sparse matrices.
521  //**********************************************************************************************
522 
523  //**Subtraction assignment to dense matrices****************************************************
536  template< typename MT // Type of the target dense matrix
537  , bool SO > // Storage order of the target dense matrix
538  friend inline void subAssign( DenseMatrix<MT,SO>& lhs, const TSMatTDMatMultExpr& rhs )
539  {
541 
542  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
543  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
544 
546 
547  LT A( rhs.lhs_ ); // Evaluation of the right-hand side sparse matrix operand
548  RT B( rhs.rhs_ ); // Evaluation of the left-hand side dense matrix operand
549 
550  BLAZE_INTERNAL_ASSERT( A.rows() == rhs.lhs_.rows() , "Invalid number of rows" );
551  BLAZE_INTERNAL_ASSERT( A.columns() == rhs.lhs_.columns(), "Invalid number of columns" );
552  BLAZE_INTERNAL_ASSERT( B.rows() == rhs.rhs_.rows() , "Invalid number of rows" );
553  BLAZE_INTERNAL_ASSERT( B.columns() == rhs.rhs_.columns(), "Invalid number of columns" );
554  BLAZE_INTERNAL_ASSERT( A.rows() == (~lhs).rows() , "Invalid number of rows" );
555  BLAZE_INTERNAL_ASSERT( B.columns() == (~lhs).columns() , "Invalid number of columns" );
556 
557  const size_t block( SO ? 64UL : 128UL );
558 
559  for( size_t jj=0UL; jj<B.columns(); jj+=block ) {
560  const size_t jend( ( jj+block > B.columns() )?( B.columns() ):( jj+block ) );
561  for( size_t i=0UL; i<A.columns(); ++i )
562  {
563  const ConstIterator end( A.end(i) );
564  ConstIterator element( A.begin(i) );
565 
566  const size_t nonzeros( A.nonZeros(i) );
567 
568  BLAZE_INTERNAL_ASSERT( ( nonzeros - ( nonzeros % 4UL ) ) == ( nonzeros & size_t(-4) ), "Invalid end calculation" );
569  const size_t kend( nonzeros & size_t(-4) );
570 
571  for( size_t k=0UL; k<kend; k+=4UL ) {
572  const size_t i1( element->index() );
573  const ET1 v1( element->value() );
574  ++element;
575  const size_t i2( element->index() );
576  const ET1 v2( element->value() );
577  ++element;
578  const size_t i3( element->index() );
579  const ET1 v3( element->value() );
580  ++element;
581  const size_t i4( element->index() );
582  const ET1 v4( element->value() );
583  ++element;
584 
585  for( size_t j=jj; j<jend; ++j ) {
586  (~lhs)(i1,j) -= v1 * B(i,j);
587  (~lhs)(i2,j) -= v2 * B(i,j);
588  (~lhs)(i3,j) -= v3 * B(i,j);
589  (~lhs)(i4,j) -= v4 * B(i,j);
590  }
591  }
592 
593  for( ; element!=end; ++element ) {
594  for( size_t j=jj; j<jend; ++j ) {
595  (~lhs)(element->index(),j) -= element->value() * B(i,j);
596  }
597  }
598  }
599  }
600  }
602  //**********************************************************************************************
603 
604  //**Subtraction assignment to sparse matrices***************************************************
605  // No special implementation for the subtraction assignment to sparse matrices.
606  //**********************************************************************************************
607 
608  //**Multiplication assignment to dense matrices*************************************************
609  // No special implementation for the multiplication assignment to dense matrices.
610  //**********************************************************************************************
611 
612  //**Multiplication assignment to sparse matrices************************************************
613  // No special implementation for the multiplication assignment to sparse matrices.
614  //**********************************************************************************************
615 
616  //**Compile time checks*************************************************************************
623  //**********************************************************************************************
624 };
625 //*************************************************************************************************
626 
627 
628 
629 
630 //=================================================================================================
631 //
632 // GLOBAL BINARY ARITHMETIC OPERATORS
633 //
634 //=================================================================================================
635 
636 //*************************************************************************************************
665 template< typename T1 // Type of the left-hand side sparse matrix
666  , typename T2 > // Type of the right-hand side dense matrix
667 inline const TSMatTDMatMultExpr<T1,T2>
669 {
671 
672  if( (~lhs).columns() != (~rhs).rows() )
673  throw std::invalid_argument( "Matrix sizes do not match" );
674 
675  return TSMatTDMatMultExpr<T1,T2>( ~lhs, ~rhs );
676 }
677 //*************************************************************************************************
678 
679 
680 
681 
682 //=================================================================================================
683 //
684 // EXPRESSION TRAIT SPECIALIZATIONS
685 //
686 //=================================================================================================
687 
688 //*************************************************************************************************
690 template< typename MT1, typename MT2, typename VT >
691 struct TDMatDVecMultExprTrait< TSMatTDMatMultExpr<MT1,MT2>, VT >
692 {
693  public:
694  //**********************************************************************************************
695  typedef typename SelectType< IsSparseMatrix<MT1>::value && IsColumnMajorMatrix<MT1>::value &&
696  IsDenseMatrix<MT2>::value && IsColumnMajorMatrix<MT2>::value &&
697  IsDenseVector<VT>::value && IsColumnVector<VT>::value
698  , typename TSMatDVecMultExprTrait< MT1, typename TDMatDVecMultExprTrait<MT2,VT>::Type >::Type
699  , INVALID_TYPE >::Type Type;
700  //**********************************************************************************************
701 };
703 //*************************************************************************************************
704 
705 
706 //*************************************************************************************************
708 template< typename MT1, typename MT2, typename VT >
709 struct TDMatSVecMultExprTrait< TSMatTDMatMultExpr<MT1,MT2>, VT >
710 {
711  public:
712  //**********************************************************************************************
713  typedef typename SelectType< IsSparseMatrix<MT1>::value && IsColumnMajorMatrix<MT1>::value &&
714  IsDenseMatrix<MT2>::value && IsColumnMajorMatrix<MT2>::value &&
715  IsSparseVector<VT>::value && IsColumnVector<VT>::value
716  , typename TSMatDVecMultExprTrait< MT1, typename TDMatSVecMultExprTrait<MT2,VT>::Type >::Type
717  , INVALID_TYPE >::Type Type;
718  //**********************************************************************************************
719 };
721 //*************************************************************************************************
722 
723 
724 //*************************************************************************************************
726 template< typename VT, typename MT1, typename MT2 >
727 struct TDVecTDMatMultExprTrait< VT, TSMatTDMatMultExpr<MT1,MT2> >
728 {
729  public:
730  //**********************************************************************************************
731  typedef typename SelectType< IsDenseVector<VT>::value && IsRowVector<VT>::value &&
732  IsSparseMatrix<MT1>::value && IsColumnMajorMatrix<MT1>::value &&
733  IsDenseMatrix<MT2>::value && IsColumnMajorMatrix<MT2>::value
734  , typename TDVecTDMatMultExprTrait< typename TDVecTSMatMultExprTrait<VT,MT1>::Type, MT2 >::Type
735  , INVALID_TYPE >::Type Type;
736  //**********************************************************************************************
737 };
739 //*************************************************************************************************
740 
741 
742 //*************************************************************************************************
744 template< typename VT, typename MT1, typename MT2 >
745 struct TSVecTDMatMultExprTrait< VT, TSMatTDMatMultExpr<MT1,MT2> >
746 {
747  public:
748  //**********************************************************************************************
749  typedef typename SelectType< IsSparseVector<VT>::value && IsRowVector<VT>::value &&
750  IsSparseMatrix<MT1>::value && IsColumnMajorMatrix<MT1>::value &&
751  IsDenseMatrix<MT2>::value && IsColumnMajorMatrix<MT2>::value
752  , typename TSVecTDMatMultExprTrait< typename TSVecTSMatMultExprTrait<VT,MT1>::Type, MT2 >::Type
753  , INVALID_TYPE >::Type Type;
754  //**********************************************************************************************
755 };
757 //*************************************************************************************************
758 
759 
760 //*************************************************************************************************
762 template< typename MT1, typename MT2 >
763 struct SubmatrixExprTrait< TSMatTDMatMultExpr<MT1,MT2> >
764 {
765  public:
766  //**********************************************************************************************
767  typedef typename MultExprTrait< typename SubmatrixExprTrait<const MT1>::Type
768  , typename SubmatrixExprTrait<const MT2>::Type >::Type Type;
769  //**********************************************************************************************
770 };
772 //*************************************************************************************************
773 
774 
775 //*************************************************************************************************
777 template< typename MT1, typename MT2 >
778 struct RowExprTrait< TSMatTDMatMultExpr<MT1,MT2> >
779 {
780  public:
781  //**********************************************************************************************
782  typedef typename MultExprTrait< typename RowExprTrait<const MT1>::Type, MT2 >::Type Type;
783  //**********************************************************************************************
784 };
786 //*************************************************************************************************
787 
788 
789 //*************************************************************************************************
791 template< typename MT1, typename MT2 >
792 struct ColumnExprTrait< TSMatTDMatMultExpr<MT1,MT2> >
793 {
794  public:
795  //**********************************************************************************************
796  typedef typename MultExprTrait< MT1, typename ColumnExprTrait<const MT2>::Type >::Type Type;
797  //**********************************************************************************************
798 };
800 //*************************************************************************************************
801 
802 } // namespace blaze
803 
804 #endif
size_t columns() const
Returns the current number of columns of the matrix.
Definition: TSMatTDMatMultExpr.h:199
size_t rows() const
Returns the current number of rows of the matrix.
Definition: TSMatTDMatMultExpr.h:189
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
Expression object for transpose sparse matrix-transpose dense matrix multiplications.The TSMatTDMatMultExpr class represents the compile time expression for multiplications between a column-major sparse matrix and a column-major dense matrix.
Definition: Forward.h:139
TSMatTDMatMultExpr(const MT1 &lhs, const MT2 &rhs)
Constructor for the TSMatTDMatMultExpr class.
Definition: TSMatTDMatMultExpr.h:149
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.
LeftOperand leftOperand() const
Returns the left-hand side transpose sparse matrix operand.
Definition: TSMatTDMatMultExpr.h:209
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
MT2::ElementType ET2
Element type of the right-hand side sparse matrix expression.
Definition: TSMatTDMatMultExpr.h:110
TSMatTDMatMultExpr< MT1, MT2 > This
Type of this TSMatTDMatMultExpr instance.
Definition: TSMatTDMatMultExpr.h:117
Header file for the Computation base class.
Header file for the MatMatMultExpr base class.
MultTrait< RT1, RT2 >::Type ResultType
Result type for expression template evaluations.
Definition: TSMatTDMatMultExpr.h:118
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
ResultType::OppositeType OppositeType
Result type with opposite storage order for expression template evaluations.
Definition: TSMatTDMatMultExpr.h:119
const ElementType ReturnType
Return type for expression template evaluations.
Definition: TSMatTDMatMultExpr.h:122
MT1::ResultType RT1
Result type of the left-hand side sparse matrix expression.
Definition: TSMatTDMatMultExpr.h:107
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.
#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
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.
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
MT1::ElementType ET1
Element type of the left-hand side dense matrix expression.
Definition: TSMatTDMatMultExpr.h:109
bool canAlias(const T *alias) const
Returns whether the expression can alias with the given address alias.
Definition: TSMatTDMatMultExpr.h:231
#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
ResultType::ElementType ElementType
Resulting element type.
Definition: TSMatTDMatMultExpr.h:121
MT2::ResultType RT2
Result type of the right-hand side dense matrix expression.
Definition: TSMatTDMatMultExpr.h:108
RightOperand rhs_
Right-hand side dense matrix of the multiplication expression.
Definition: TSMatTDMatMultExpr.h:251
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.
Header file for the IsDenseMatrix type trait.
MT1::CompositeType CT1
Composite type of the left-hand side sparse matrix expression.
Definition: TSMatTDMatMultExpr.h:111
SelectType< IsExpression< MT1 >::value, const MT1, const MT1 & >::Type LeftOperand
Composite type of the left-hand side sparse matrix expression.
Definition: TSMatTDMatMultExpr.h:126
Header file for the EnableIf class template.
RightOperand rightOperand() const
Returns the right-hand side transpose dense matrix operand.
Definition: TSMatTDMatMultExpr.h:219
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
MT2::CompositeType CT2
Composite type of the right-hand side dense matrix expression.
Definition: TSMatTDMatMultExpr.h:112
ReturnType operator()(size_t i, size_t j) const
2D-access to the matrix elements.
Definition: TSMatTDMatMultExpr.h:164
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.
SelectType< IsComputation< MT2 >::value, const RT2, CT2 >::Type RT
Type for the assignment of the right-hand side dense matrix operand.
Definition: TSMatTDMatMultExpr.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:239
SelectType< IsComputation< MT1 >::value, const RT1, CT1 >::Type LT
Type for the assignment of the left-hand side sparse matrix operand.
Definition: TSMatTDMatMultExpr.h:132
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.
bool isAliased(const T *alias) const
Returns whether the expression is aliased with the given address alias.
Definition: TSMatTDMatMultExpr.h:243
const ResultType CompositeType
Data type for composite expression templates.
Definition: TSMatTDMatMultExpr.h:123
Header file for the IsComputation type trait class.
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
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.
ResultType::TransposeType TransposeType
Transpose type for expression template evaluations.
Definition: TSMatTDMatMultExpr.h:120
Header file for the IsColumnVector type trait.
SelectType< IsExpression< MT2 >::value, const MT2, const MT2 & >::Type RightOperand
Composite type of the right-hand side dense matrix expression.
Definition: TSMatTDMatMultExpr.h:129
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.
LeftOperand lhs_
Left-hand side sparse matrix of the multiplication expression.
Definition: TSMatTDMatMultExpr.h:250