All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
SMatTSMatMultExpr.h
Go to the documentation of this file.
1 //=================================================================================================
33 //=================================================================================================
34 
35 #ifndef _BLAZE_MATH_EXPRESSIONS_SMATTSMATMULTEXPR_H_
36 #define _BLAZE_MATH_EXPRESSIONS_SMATTSMATMULTEXPR_H_
37 
38 
39 //*************************************************************************************************
40 // Includes
41 //*************************************************************************************************
42 
43 #include <stdexcept>
76 #include <blaze/util/Assert.h>
77 #include <blaze/util/InvalidType.h>
79 #include <blaze/util/SelectType.h>
80 #include <blaze/util/Types.h>
82 #include <blaze/util/Unused.h>
83 
84 
85 namespace blaze {
86 
87 //=================================================================================================
88 //
89 // CLASS SMATTSMATMULTEXPR
90 //
91 //=================================================================================================
92 
93 //*************************************************************************************************
100 template< typename MT1 // Type of the left-hand side sparse matrix
101  , typename MT2 > // Type of the right-hand side sparse matrix
102 class SMatTSMatMultExpr : public SparseMatrix< SMatTSMatMultExpr<MT1,MT2>, false >
103  , private MatMatMultExpr
104  , private Computation
105 {
106  private:
107  //**Type definitions****************************************************************************
108  typedef typename MT1::ResultType RT1;
109  typedef typename MT2::ResultType RT2;
110  typedef typename MT1::CompositeType CT1;
111  typedef typename MT2::CompositeType CT2;
112  //**********************************************************************************************
113 
114  public:
115  //**Type definitions****************************************************************************
121  typedef const ElementType ReturnType;
122  typedef const ResultType CompositeType;
123 
125  typedef typename SelectType< IsExpression<MT1>::value, const MT1, const MT1& >::Type LeftOperand;
126 
128  typedef typename SelectType< IsExpression<MT2>::value, const MT2, const MT2& >::Type RightOperand;
129  //**********************************************************************************************
130 
131  //**Compilation flags***************************************************************************
133  enum { smpAssignable = 0 };
134  //**********************************************************************************************
135 
136  //**Constructor*********************************************************************************
142  explicit inline SMatTSMatMultExpr( const MT1& lhs, const MT2& rhs )
143  : lhs_( lhs ) // Left-hand side sparse matrix of the multiplication expression
144  , rhs_( rhs ) // Right-hand side sparse matrix of the multiplication expression
145  {
146  BLAZE_INTERNAL_ASSERT( lhs.columns() == rhs.rows(), "Invalid matrix sizes" );
147  }
148  //**********************************************************************************************
149 
150  //**Access operator*****************************************************************************
157  inline ReturnType operator()( size_t i, size_t j ) const {
158  BLAZE_INTERNAL_ASSERT( i < lhs_.rows() , "Invalid row access index" );
159  BLAZE_INTERNAL_ASSERT( j < rhs_.columns(), "Invalid column access index" );
160 
161  typedef typename RemoveReference<CT1>::Type::ConstIterator LeftIterator;
162  typedef typename RemoveReference<CT2>::Type::ConstIterator RightIterator;
163 
164  ElementType tmp = ElementType();
165 
166  // Early exit
167  if( lhs_.columns() == 0UL )
168  return tmp;
169 
170  // Fast computation in case both the left-hand side and the right-hand side
171  // sparse matrices directly provide iterators
173  {
174  // Evaluation of the left-hand side sparse matrix operand
175  CT1 A( lhs_ );
176 
177  const LeftIterator lend( A.end(i) );
178  LeftIterator lelem( A.begin(i) );
179 
180  // Evaluation of the right-hand side sparse matrix operand
181  CT2 B( rhs_ );
182 
183  const RightIterator rend( B.end(j) );
184  RightIterator relem( B.begin(j) );
185 
186  // Early exit in case row i or column j are empty
187  if( lelem == lend || relem == rend )
188  return tmp;
189 
190  // Calculating element (i,j)
191  while( true ) {
192  if( lelem->index() < relem->index() ) {
193  ++lelem;
194  if( lelem == lend ) break;
195  }
196  else if( relem->index() < lelem->index() ) {
197  ++relem;
198  if( relem == rend ) break;
199  }
200  else {
201  tmp = lelem->value() * relem->value();
202  ++lelem;
203  ++relem;
204  break;
205  }
206  }
207 
208  if( lelem != lend && relem != rend )
209  {
210  while( true ) {
211  if( lelem->index() < relem->index() ) {
212  ++lelem;
213  if( lelem == lend ) break;
214  }
215  else if( relem->index() < lelem->index() ) {
216  ++relem;
217  if( relem == rend ) break;
218  }
219  else {
220  tmp += lelem->value() * relem->value();
221  ++lelem;
222  if( lelem == lend ) break;
223  ++relem;
224  if( relem == rend ) break;
225  }
226  }
227  }
228  }
229 
230  // Optimized computation in case the left-hand side sparse matrix directly provides iterators
232  {
233  // Evaluation of the left-hand side sparse matrix operand
234  CT1 A( lhs_ );
235 
236  const LeftIterator end( A.end(i) );
237  LeftIterator element( A.begin(i) );
238 
239  // Early exit in case row i is empty
240  if( element == end )
241  return tmp;
242 
243  // Calculating element (i,j)
244  tmp = element->value() * rhs_(element->index(),j);
245  ++element;
246  for( ; element!=end; ++element )
247  tmp += element->value() * rhs_(element->index(),j);
248  }
249 
250  // Optimized computation in case the right-hand side sparse matrix directly provides iterators
252  {
253  // Evaluation of the right-hand side sparse matrix operand
254  CT2 B( rhs_ );
255 
256  const RightIterator end( B.end(j) );
257  RightIterator element( B.begin(j) );
258 
259  // Early exit in case row i is empty
260  if( element == end )
261  return tmp;
262 
263  // Calculating element (i,j)
264  tmp = lhs_(i,element->index()) * element->value();
265  ++element;
266  for( ; element!=end; ++element )
267  tmp += lhs_(i,element->index()) * element->value();
268  }
269 
270  // Default computation in case both sparse matrices don't provide iterators
271  else {
272  tmp = lhs_(i,0UL) * rhs_(0UL,j);
273  for( size_t k=1UL; k<lhs_.columns(); ++k ) {
274  tmp += lhs_(i,k) * rhs_(k,j);
275  }
276  }
277 
278  return tmp;
279  }
280  //**********************************************************************************************
281 
282  //**Rows function*******************************************************************************
287  inline size_t rows() const {
288  return lhs_.rows();
289  }
290  //**********************************************************************************************
291 
292  //**Columns function****************************************************************************
297  inline size_t columns() const {
298  return rhs_.columns();
299  }
300  //**********************************************************************************************
301 
302  //**NonZeros function***************************************************************************
307  inline size_t nonZeros() const {
308  return 0UL;
309  }
310  //**********************************************************************************************
311 
312  //**NonZeros function***************************************************************************
318  inline size_t nonZeros( size_t i ) const {
319  UNUSED_PARAMETER( i );
320  return 0UL;
321  }
322  //**********************************************************************************************
323 
324  //**Left operand access*************************************************************************
329  inline LeftOperand leftOperand() const {
330  return lhs_;
331  }
332  //**********************************************************************************************
333 
334  //**Right operand access************************************************************************
339  inline RightOperand rightOperand() const {
340  return rhs_;
341  }
342  //**********************************************************************************************
343 
344  //**********************************************************************************************
350  template< typename T >
351  inline bool canAlias( const T* alias ) const {
352  return ( lhs_.isAliased( alias ) || rhs_.isAliased( alias ) );
353  }
354  //**********************************************************************************************
355 
356  //**********************************************************************************************
362  template< typename T >
363  inline bool isAliased( const T* alias ) const {
364  return ( lhs_.isAliased( alias ) || rhs_.isAliased( alias ) );
365  }
366  //**********************************************************************************************
367 
368  //**********************************************************************************************
373  inline bool canSMPAssign() const {
374  return ( rows() > SMP_SMATTSMATMULT_THRESHOLD );
375  }
376  //**********************************************************************************************
377 
378  private:
379  //**Member variables****************************************************************************
382  //**********************************************************************************************
383 
384  //**Assignment to row-major dense matrices******************************************************
397  template< typename MT > // Type of the target dense matrix
398  friend inline void assign( DenseMatrix<MT,false>& lhs, const SMatTSMatMultExpr& rhs )
399  {
401 
402  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
403  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
404 
406 
407  const typename MT2::OppositeType tmp( rhs.rhs_ );
408  smpAssign( ~lhs, rhs.lhs_ * tmp );
409  }
411  //**********************************************************************************************
412 
413  //**Assignment to column-major dense matrices***************************************************
426  template< typename MT > // Type of the target dense matrix
427  friend inline void assign( DenseMatrix<MT,true>& lhs, const SMatTSMatMultExpr& rhs )
428  {
430 
431  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
432  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
433 
435 
436  const typename MT1::OppositeType tmp( rhs.lhs_ );
437  smpAssign( ~lhs, tmp * rhs.rhs_ );
438  }
440  //**********************************************************************************************
441 
442  //**Assignment to row-major sparse matrices*****************************************************
455  template< typename MT > // Type of the target sparse matrix
456  friend inline void assign( SparseMatrix<MT,false>& lhs, const SMatTSMatMultExpr& rhs )
457  {
459 
460  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
461  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
462 
464 
465  const typename MT2::OppositeType tmp( rhs.rhs_ );
466  smpAssign( ~lhs, rhs.lhs_ * tmp );
467  }
469  //**********************************************************************************************
470 
471  //**Assignment to column-major sparse matrices**************************************************
484  template< typename MT > // Type of the target sparse matrix
485  friend inline void assign( SparseMatrix<MT,true>& lhs, const SMatTSMatMultExpr& rhs )
486  {
488 
489  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
490  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
491 
493 
494  const typename MT1::OppositeType tmp( rhs.lhs_ );
495  smpAssign( ~lhs, tmp * rhs.rhs_ );
496  }
498  //**********************************************************************************************
499 
500  //**Addition assignment to row-major dense matrices*********************************************
513  template< typename MT > // Type of the target dense matrix
514  friend inline void addAssign( DenseMatrix<MT,false>& lhs, const SMatTSMatMultExpr& rhs )
515  {
517 
518  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
519  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
520 
522 
523  const typename MT2::OppositeType tmp( rhs.rhs_ );
524  smpAddAssign( ~lhs, rhs.lhs_ * tmp );
525  }
527  //**********************************************************************************************
528 
529  //**Addition assignment to column-major dense matrices******************************************
542  template< typename MT > // Type of the target dense matrix
543  friend inline void addAssign( DenseMatrix<MT,true>& lhs, const SMatTSMatMultExpr& rhs )
544  {
546 
547  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
548  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
549 
551 
552  const typename MT1::OppositeType tmp( rhs.lhs_ );
553  smpAddAssign( ~lhs, tmp * rhs.rhs_ );
554  }
556  //**********************************************************************************************
557 
558  //**Addition assignment to sparse matrices******************************************************
559  // No special implementation for the addition assignment to sparse matrices.
560  //**********************************************************************************************
561 
562  //**Subtraction assignment to row-major dense matrices******************************************
575  template< typename MT > // Type of the target dense matrix
576  friend inline void subAssign( DenseMatrix<MT,false>& lhs, const SMatTSMatMultExpr& rhs )
577  {
579 
580  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
581  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
582 
584 
585  const typename MT2::OppositeType tmp( rhs.rhs_ );
586  smpSubAssign( ~lhs, rhs.lhs_ * tmp );
587  }
589  //**********************************************************************************************
590 
591  //**Subtraction assignment to column-major dense matrices***************************************
604  template< typename MT > // Type of the target dense matrix
605  friend inline void subAssign( DenseMatrix<MT,true>& lhs, const SMatTSMatMultExpr& rhs )
606  {
608 
609  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
610  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
611 
613 
614  const typename MT1::OppositeType tmp( rhs.lhs_ );
615  smpSubAssign( ~lhs, tmp * rhs.rhs_ );
616  }
618  //**********************************************************************************************
619 
620  //**Subtraction assignment to sparse matrices***************************************************
621  // No special implementation for the subtraction assignment to sparse matrices.
622  //**********************************************************************************************
623 
624  //**Multiplication assignment to dense matrices*************************************************
625  // No special implementation for the multiplication assignment to dense matrices.
626  //**********************************************************************************************
627 
628  //**Multiplication assignment to sparse matrices************************************************
629  // No special implementation for the multiplication assignment to sparse matrices.
630  //**********************************************************************************************
631 
632  //**Compile time checks*************************************************************************
639  //**********************************************************************************************
640 };
641 //*************************************************************************************************
642 
643 
644 
645 
646 //=================================================================================================
647 //
648 // GLOBAL BINARY ARITHMETIC OPERATORS
649 //
650 //=================================================================================================
651 
652 //*************************************************************************************************
682 template< typename T1 // Type of the left-hand side sparse matrix
683  , typename T2 > // Type of the right-hand side sparse matrix
684 inline const SMatTSMatMultExpr<T1,T2>
686 {
688 
689  if( (~lhs).columns() != (~rhs).rows() )
690  throw std::invalid_argument( "Matrix sizes do not match" );
691 
692  return SMatTSMatMultExpr<T1,T2>( ~lhs, ~rhs );
693 }
694 //*************************************************************************************************
695 
696 
697 
698 
699 //=================================================================================================
700 //
701 // EXPRESSION TRAIT SPECIALIZATIONS
702 //
703 //=================================================================================================
704 
705 //*************************************************************************************************
707 template< typename MT1, typename MT2, typename VT >
708 struct SMatDVecMultExprTrait< SMatTSMatMultExpr<MT1,MT2>, VT >
709 {
710  public:
711  //**********************************************************************************************
712  typedef typename SelectType< IsSparseMatrix<MT1>::value && IsRowMajorMatrix<MT1>::value &&
713  IsSparseMatrix<MT2>::value && IsColumnMajorMatrix<MT2>::value &&
714  IsDenseVector<VT>::value && IsColumnVector<VT>::value
715  , typename SMatDVecMultExprTrait< MT1, typename TSMatDVecMultExprTrait<MT2,VT>::Type >::Type
716  , INVALID_TYPE >::Type Type;
717  //**********************************************************************************************
718 };
720 //*************************************************************************************************
721 
722 
723 //*************************************************************************************************
725 template< typename MT1, typename MT2, typename VT >
726 struct SMatSVecMultExprTrait< SMatTSMatMultExpr<MT1,MT2>, VT >
727 {
728  public:
729  //**********************************************************************************************
730  typedef typename SelectType< IsSparseMatrix<MT1>::value && IsRowMajorMatrix<MT1>::value &&
731  IsSparseMatrix<MT2>::value && IsColumnMajorMatrix<MT2>::value &&
732  IsSparseVector<VT>::value && IsColumnVector<VT>::value
733  , typename SMatSVecMultExprTrait< MT1, typename TSMatSVecMultExprTrait<MT2,VT>::Type >::Type
734  , INVALID_TYPE >::Type Type;
735  //**********************************************************************************************
736 };
738 //*************************************************************************************************
739 
740 
741 //*************************************************************************************************
743 template< typename VT, typename MT1, typename MT2 >
744 struct TDVecSMatMultExprTrait< VT, SMatTSMatMultExpr<MT1,MT2> >
745 {
746  public:
747  //**********************************************************************************************
748  typedef typename SelectType< IsDenseVector<VT>::value && IsRowVector<VT>::value &&
749  IsSparseMatrix<MT1>::value && IsRowMajorMatrix<MT1>::value &&
750  IsSparseMatrix<MT2>::value && IsColumnMajorMatrix<MT2>::value
751  , typename TDVecTSMatMultExprTrait< typename TDVecSMatMultExprTrait<VT,MT1>::Type, MT2 >::Type
752  , INVALID_TYPE >::Type Type;
753  //**********************************************************************************************
754 };
756 //*************************************************************************************************
757 
758 
759 //*************************************************************************************************
761 template< typename VT, typename MT1, typename MT2 >
762 struct TSVecSMatMultExprTrait< VT, SMatTSMatMultExpr<MT1,MT2> >
763 {
764  public:
765  //**********************************************************************************************
766  typedef typename SelectType< IsSparseVector<VT>::value && IsRowVector<VT>::value &&
767  IsSparseMatrix<MT1>::value && IsRowMajorMatrix<MT1>::value &&
768  IsSparseMatrix<MT2>::value && IsColumnMajorMatrix<MT2>::value
769  , typename TDVecTSMatMultExprTrait< typename TDVecSMatMultExprTrait<VT,MT1>::Type, MT2 >::Type
770  , INVALID_TYPE >::Type Type;
771  //**********************************************************************************************
772 };
774 //*************************************************************************************************
775 
776 
777 //*************************************************************************************************
779 template< typename MT1, typename MT2, bool AF >
780 struct SubmatrixExprTrait< SMatTSMatMultExpr<MT1,MT2>, AF >
781 {
782  public:
783  //**********************************************************************************************
784  typedef typename MultExprTrait< typename SubmatrixExprTrait<const MT1,AF>::Type
785  , typename SubmatrixExprTrait<const MT2,AF>::Type >::Type Type;
786  //**********************************************************************************************
787 };
789 //*************************************************************************************************
790 
791 
792 //*************************************************************************************************
794 template< typename MT1, typename MT2 >
795 struct RowExprTrait< SMatTSMatMultExpr<MT1,MT2> >
796 {
797  public:
798  //**********************************************************************************************
799  typedef typename MultExprTrait< typename RowExprTrait<const MT1>::Type, MT2 >::Type Type;
800  //**********************************************************************************************
801 };
803 //*************************************************************************************************
804 
805 
806 //*************************************************************************************************
808 template< typename MT1, typename MT2 >
809 struct ColumnExprTrait< SMatTSMatMultExpr<MT1,MT2> >
810 {
811  public:
812  //**********************************************************************************************
813  typedef typename MultExprTrait< MT1, typename ColumnExprTrait<const MT2>::Type >::Type Type;
814  //**********************************************************************************************
815 };
817 //*************************************************************************************************
818 
819 } // namespace blaze
820 
821 #endif
Header file for the SMatDVecMultExprTrait class template.
Header file for the UNUSED_PARAMETER function template.
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
size_t nonZeros(size_t i) const
Returns the number of non-zero elements in the specified row.
Definition: SMatTSMatMultExpr.h:318
MT1::CompositeType CT1
Composite type of the left-hand side sparse matrix expression.
Definition: SMatTSMatMultExpr.h:110
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
Header file for the IsSparseMatrix type trait.
Efficient implementation of a compressed matrix.The CompressedMatrix class template is the represent...
Definition: CompressedMatrix.h:197
Header file for the ColumnExprTrait class template.
Header file for the IsColumnMajorMatrix type trait.
bool canAlias(const T *alias) const
Returns whether the expression can alias with the given address alias.
Definition: SMatTSMatMultExpr.h:351
Header file for the TSVecTSMatMultExprTrait class template.
Header file for the sparse matrix SMP implementation.
const This & CompositeType
Data type for composite expression templates.
Definition: CompressedMatrix.h:2384
Header file for the IsRowVector type trait.
SMatTSMatMultExpr< MT1, MT2 > This
Type of this SMatTSMatMultExpr instance.
Definition: SMatTSMatMultExpr.h:116
Type ElementType
Type of the sparse matrix elements.
Definition: CompressedMatrix.h:249
MT1::ResultType RT1
Result type of the left-hand side sparse matrix expression.
Definition: SMatTSMatMultExpr.h:108
SelectType< IsExpression< MT2 >::value, const MT2, const MT2 & >::Type RightOperand
Composite type of the right-hand side sparse matrix expression.
Definition: SMatTSMatMultExpr.h:128
void UNUSED_PARAMETER(const T1 &)
Suppression of unused parameter warnings.
Definition: Unused.h:84
MT2::CompositeType CT2
Composite type of the right-hand side sparse matrix expression.
Definition: SMatTSMatMultExpr.h:111
Header file for the TDVecSMatMultExprTrait class template.
Header file for the Computation base class.
Header file for the MatMatMultExpr base class.
bool canSMPAssign() const
Returns whether the expression can be used in SMP assignments.
Definition: SMatTSMatMultExpr.h:373
Header file for the RequiresEvaluation type trait.
Header file for the TSVecSMatMultExprTrait class template.
CompressedMatrix< Type, false > OppositeType
Result type with opposite storage order for expression template evaluations.
Definition: CompressedMatrix.h:2380
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
const ResultType CompositeType
Data type for composite expression templates.
Definition: SMatTSMatMultExpr.h:122
Header file for the SparseMatrix base class.
Constraint on the data type.
Expression object for sparse matrix-transpose sparse matrix multiplications.The SMatTSMatMultExpr cla...
Definition: Forward.h:102
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
ResultType::ElementType ElementType
Resulting element type.
Definition: SMatTSMatMultExpr.h:120
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 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 TDVecTSMatMultExprTrait class template.
Header file for the dense matrix SMP implementation.
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
bool isAliased(const T *alias) const
Returns whether the expression is aliased with the given address alias.
Definition: SMatTSMatMultExpr.h:363
Header file for the SMatSVecMultExprTrait class template.
size_t columns() const
Returns the current number of columns of the matrix.
Definition: SMatTSMatMultExpr.h:297
Constraints on the storage order of matrix types.
RightOperand rightOperand() const
Returns the right-hand side transpose sparse matrix operand.
Definition: SMatTSMatMultExpr.h:339
RightOperand rhs_
Right-hand side sparse matrix of the multiplication expression.
Definition: SMatTSMatMultExpr.h:381
Header file for the SelectType class template.
Header file for the RowExprTrait class template.
Header file for all forward declarations for expression class templates.
size_t nonZeros() const
Returns the number of non-zero elements in the sparse matrix.
Definition: SMatTSMatMultExpr.h:307
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
const size_t SMP_SMATTSMATMULT_THRESHOLD
SMP row-major sparse matrix/column-major sparse matrix multiplication threshold.This threshold repres...
Definition: Thresholds.h:602
ReturnType operator()(size_t i, size_t j) const
2D-access to the matrix elements.
Definition: SMatTSMatMultExpr.h:157
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
SelectType< IsExpression< MT1 >::value, const MT1, const MT1 & >::Type LeftOperand
Composite type of the left-hand side sparse matrix expression.
Definition: SMatTSMatMultExpr.h:125
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
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
MultTrait< RT1, RT2 >::Type ResultType
Result type for expression template evaluations.
Definition: SMatTSMatMultExpr.h:117
size_t rows() const
Returns the current number of rows of the matrix.
Definition: SMatTSMatMultExpr.h:287
Header file for the RemoveReference type trait.
Header file for the IsDenseVector type trait.
SMatTSMatMultExpr(const MT1 &lhs, const MT2 &rhs)
Constructor for the SMatTSMatMultExpr class.
Definition: SMatTSMatMultExpr.h:142
LeftOperand leftOperand() const
Returns the left-hand side sparse matrix operand.
Definition: SMatTSMatMultExpr.h:329
LeftOperand lhs_
Left-hand side sparse matrix of the multiplication expression.
Definition: SMatTSMatMultExpr.h:380
Header file for the IsRowMajorMatrix type trait.
Header file for the IsComputation type trait class.
#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.
ResultType::OppositeType OppositeType
Result type with opposite storage order for expression template evaluations.
Definition: SMatTSMatMultExpr.h:118
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
#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
MT2::ResultType RT2
Result type of the right-hand side sparse matrix expression.
Definition: SMatTSMatMultExpr.h:109
Header file for the IsExpression type trait class.
Header file for the TSMatSVecMultExprTrait class template.
Header file for the FunctionTrace class.
ResultType::TransposeType TransposeType
Transpose type for expression template evaluations.
Definition: SMatTSMatMultExpr.h:119
const ElementType ReturnType
Return type for expression template evaluations.
Definition: SMatTSMatMultExpr.h:121