All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
SVecTSVecMultExpr.h
Go to the documentation of this file.
1 //=================================================================================================
33 //=================================================================================================
34 
35 #ifndef _BLAZE_MATH_EXPRESSIONS_SVECTSVECMULTEXPR_H_
36 #define _BLAZE_MATH_EXPRESSIONS_SVECTSVECMULTEXPR_H_
37 
38 
39 //*************************************************************************************************
40 // Includes
41 //*************************************************************************************************
42 
60 #include <blaze/util/Assert.h>
63 #include <blaze/util/SelectType.h>
64 #include <blaze/util/Types.h>
66 
67 
68 namespace blaze {
69 
70 //=================================================================================================
71 //
72 // CLASS SVECTSVECMULTEXPR
73 //
74 //=================================================================================================
75 
76 //*************************************************************************************************
83 template< typename VT1 // Type of the left-hand side sparse vector
84  , typename VT2 > // Type of the right-hand side sparse vector
85 class SVecTSVecMultExpr : public SparseMatrix< SVecTSVecMultExpr<VT1,VT2>, false >
86  , private VecTVecMultExpr
87  , private Computation
88 {
89  private:
90  //**Type definitions****************************************************************************
91  typedef typename VT1::ResultType RT1;
92  typedef typename VT2::ResultType RT2;
93  typedef typename VT1::ReturnType RN1;
94  typedef typename VT2::ReturnType RN2;
95  typedef typename VT1::CompositeType CT1;
96  typedef typename VT2::CompositeType CT2;
97  //**********************************************************************************************
98 
99  //**Return type evaluation**********************************************************************
101 
106  enum { returnExpr = !IsTemporary<RN1>::value && !IsTemporary<RN2>::value };
107 
110  //**********************************************************************************************
111 
112  public:
113  //**Type definitions****************************************************************************
119 
122 
124  typedef const ResultType CompositeType;
125 
127  typedef typename SelectType< IsExpression<VT1>::value, const VT1, const VT1& >::Type LeftOperand;
128 
130  typedef typename SelectType< IsExpression<VT2>::value, const VT2, const VT2& >::Type RightOperand;
131 
133  typedef typename SelectType< IsComputation<VT1>::value, const RT1, CT1 >::Type LT;
134 
136  typedef typename SelectType< IsComputation<VT2>::value, const RT2, CT2 >::Type RT;
137  //**********************************************************************************************
138 
139  //**Compilation flags***************************************************************************
141  enum { smpAssignable = 0 };
142  //**********************************************************************************************
143 
144  //**Constructor*********************************************************************************
150  explicit inline SVecTSVecMultExpr( const VT1& lhs, const VT2& rhs )
151  : lhs_( lhs ) // Left-hand side sparse vector of the multiplication expression
152  , rhs_( rhs ) // Right-hand side sparse vector of the multiplication expression
153  {}
154  //**********************************************************************************************
155 
156  //**Access operator*****************************************************************************
163  inline ReturnType operator()( size_t i, size_t j ) const {
164  BLAZE_INTERNAL_ASSERT( i < lhs_.size(), "Invalid row access index" );
165  BLAZE_INTERNAL_ASSERT( j < rhs_.size(), "Invalid column access index" );
166 
167  return lhs_[i] * rhs_[j];
168  }
169  //**********************************************************************************************
170 
171  //**Rows function*******************************************************************************
176  inline size_t rows() const {
177  return lhs_.size();
178  }
179  //**********************************************************************************************
180 
181  //**Columns function****************************************************************************
186  inline size_t columns() const {
187  return rhs_.size();
188  }
189  //**********************************************************************************************
190 
191  //**NonZeros function***************************************************************************
196  inline size_t nonZeros() const {
197  return lhs_.nonZeros() * rhs_.nonZeros();
198  }
199  //**********************************************************************************************
200 
201  //**NonZeros function***************************************************************************
207  inline size_t nonZeros( size_t i ) const {
208  return ( isDefault( lhs_[i] ) )?( size_t(0) ):( rhs_.nonZeros(i) );
209  }
210  //**********************************************************************************************
211 
212  //**Left operand access*************************************************************************
217  inline LeftOperand leftOperand() const {
218  return lhs_;
219  }
220  //**********************************************************************************************
221 
222  //**Right operand access************************************************************************
227  inline RightOperand rightOperand() const {
228  return rhs_;
229  }
230  //**********************************************************************************************
231 
232  //**********************************************************************************************
238  template< typename T >
239  inline bool canAlias( const T* alias ) const {
240  return ( lhs_.canAlias( alias ) || rhs_.canAlias( alias ) );
241  }
242  //**********************************************************************************************
243 
244  //**********************************************************************************************
250  template< typename T >
251  inline bool isAliased( const T* alias ) const {
252  return ( lhs_.isAliased( alias ) || rhs_.isAliased( alias ) );
253  }
254  //**********************************************************************************************
255 
256  private:
257  //**Member variables****************************************************************************
260  //**********************************************************************************************
261 
262  //**Assignment to row-major dense matrices******************************************************
274  template< typename MT > // Type of the target dense matrix
275  friend inline void assign( DenseMatrix<MT,false>& lhs, const SVecTSVecMultExpr& rhs )
276  {
278 
279  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
280  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
281 
282  typedef typename RemoveReference<LT>::Type::ConstIterator LeftIterator;
283  typedef typename RemoveReference<RT>::Type::ConstIterator RightIterator;
284 
285  LT x( rhs.lhs_ ); // Evaluation of the left-hand side sparse vector operand
286  RT y( rhs.rhs_ ); // Evaluation of the right-hand side sparse vector operand
287 
288  BLAZE_INTERNAL_ASSERT( x.size() == rhs.lhs_.size() , "Invalid vector size" );
289  BLAZE_INTERNAL_ASSERT( y.size() == rhs.rhs_.size() , "Invalid vector size" );
290  BLAZE_INTERNAL_ASSERT( x.size() == (~lhs).rows() , "Invalid vector size" );
291  BLAZE_INTERNAL_ASSERT( y.size() == (~lhs).columns(), "Invalid vector size" );
292 
293  const LeftIterator lend( x.end() );
294  const RightIterator rend( y.end() );
295 
296  for( LeftIterator lelem=x.begin(); lelem!=lend; ++lelem ) {
297  if( !isDefault( lelem->value() ) ) {
298  for( RightIterator relem=y.begin(); relem!=rend; ++relem ) {
299  (~lhs)(lelem->index(),relem->index()) = lelem->value() * relem->value();
300  }
301  }
302  }
303  }
305  //**********************************************************************************************
306 
307  //**Assignment to column-major dense matrices***************************************************
320  template< typename MT > // Type of the target dense matrix
321  friend inline void assign( DenseMatrix<MT,true>& lhs, const SVecTSVecMultExpr& rhs )
322  {
324 
325  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
326  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
327 
328  typedef typename RemoveReference<LT>::Type::ConstIterator LeftIterator;
329  typedef typename RemoveReference<RT>::Type::ConstIterator RightIterator;
330 
331  LT x( rhs.lhs_ ); // Evaluation of the left-hand side sparse vector operand
332  RT y( rhs.rhs_ ); // Evaluation of the right-hand side sparse vector operand
333 
334  BLAZE_INTERNAL_ASSERT( x.size() == rhs.lhs_.size() , "Invalid vector size" );
335  BLAZE_INTERNAL_ASSERT( y.size() == rhs.rhs_.size() , "Invalid vector size" );
336  BLAZE_INTERNAL_ASSERT( x.size() == (~lhs).rows() , "Invalid vector size" );
337  BLAZE_INTERNAL_ASSERT( y.size() == (~lhs).columns(), "Invalid vector size" );
338 
339  const LeftIterator lend( x.end() );
340  const RightIterator rend( y.end() );
341 
342  for( RightIterator relem=y.begin(); relem!=rend; ++relem ) {
343  if( !isDefault( relem->value() ) ) {
344  for( LeftIterator lelem=x.begin(); lelem!=lend; ++lelem ) {
345  (~lhs)(lelem->index(),relem->index()) = lelem->value() * relem->value();
346  }
347  }
348  }
349  }
351  //**********************************************************************************************
352 
353  //**Assignment to row-major sparse matrices*****************************************************
365  template< typename MT > // Type of the target sparse matrix
366  friend inline void assign( SparseMatrix<MT,false>& lhs, const SVecTSVecMultExpr& rhs )
367  {
369 
370  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
371  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
372 
373  typedef typename RemoveReference<LT>::Type::ConstIterator LeftIterator;
374  typedef typename RemoveReference<RT>::Type::ConstIterator RightIterator;
375 
376  LT x( rhs.lhs_ ); // Evaluation of the left-hand side sparse vector operand
377  RT y( rhs.rhs_ ); // Evaluation of the right-hand side sparse vector operand
378 
379  BLAZE_INTERNAL_ASSERT( x.size() == rhs.lhs_.size() , "Invalid vector size" );
380  BLAZE_INTERNAL_ASSERT( y.size() == rhs.rhs_.size() , "Invalid vector size" );
381  BLAZE_INTERNAL_ASSERT( x.size() == (~lhs).rows() , "Invalid vector size" );
382  BLAZE_INTERNAL_ASSERT( y.size() == (~lhs).columns(), "Invalid vector size" );
383 
384  const LeftIterator lend( x.end() );
385  const RightIterator rend( y.end() );
386 
387  for( LeftIterator lelem=x.begin(); lelem!=lend; ++lelem ) {
388  if( !isDefault( lelem->value() ) ) {
389  (~lhs).reserve( lelem->index(), y.nonZeros() );
390  for( RightIterator relem=y.begin(); relem!=rend; ++relem ) {
391  (~lhs).append( lelem->index(), relem->index(), lelem->value() * relem->value() );
392  }
393  }
394  }
395  }
397  //**********************************************************************************************
398 
399  //**Assignment to column-major sparse matrices**************************************************
412  template< typename MT > // Type of the target sparse matrix
413  friend inline void assign( SparseMatrix<MT,true>& lhs, const SVecTSVecMultExpr& rhs )
414  {
416 
417  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
418  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
419 
420  typedef typename RemoveReference<LT>::Type::ConstIterator LeftIterator;
421  typedef typename RemoveReference<RT>::Type::ConstIterator RightIterator;
422 
423  LT x( rhs.lhs_ ); // Evaluation of the left-hand side sparse vector operand
424  RT y( rhs.rhs_ ); // Evaluation of the right-hand side sparse vector operand
425 
426  BLAZE_INTERNAL_ASSERT( x.size() == rhs.lhs_.size() , "Invalid vector size" );
427  BLAZE_INTERNAL_ASSERT( y.size() == rhs.rhs_.size() , "Invalid vector size" );
428  BLAZE_INTERNAL_ASSERT( x.size() == (~lhs).rows() , "Invalid vector size" );
429  BLAZE_INTERNAL_ASSERT( y.size() == (~lhs).columns(), "Invalid vector size" );
430 
431  const LeftIterator lend( x.end() );
432  const RightIterator rend( y.end() );
433 
434  for( RightIterator relem=y.begin(); relem!=rend; ++relem ) {
435  if( !isDefault( relem->value() ) ) {
436  (~lhs).reserve( relem->index(), x.nonZeros() );
437  for( LeftIterator lelem=x.begin(); lelem!=lend; ++lelem ) {
438  (~lhs).append( lelem->index(), relem->index(), lelem->value() * relem->value() );
439  }
440  }
441  }
442  }
444  //**********************************************************************************************
445 
446  //**Addition assignment to row-major dense matrices*********************************************
459  template< typename MT > // Type of the target dense matrix
460  friend inline void addAssign( DenseMatrix<MT,false>& lhs, const SVecTSVecMultExpr& rhs )
461  {
463 
464  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
465  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
466 
467  typedef typename RemoveReference<LT>::Type::ConstIterator LeftIterator;
468  typedef typename RemoveReference<RT>::Type::ConstIterator RightIterator;
469 
470  LT x( rhs.lhs_ ); // Evaluation of the left-hand side sparse vector operand
471  RT y( rhs.rhs_ ); // Evaluation of the right-hand side sparse vector operand
472 
473  BLAZE_INTERNAL_ASSERT( x.size() == rhs.lhs_.size() , "Invalid vector size" );
474  BLAZE_INTERNAL_ASSERT( y.size() == rhs.rhs_.size() , "Invalid vector size" );
475  BLAZE_INTERNAL_ASSERT( x.size() == (~lhs).rows() , "Invalid vector size" );
476  BLAZE_INTERNAL_ASSERT( y.size() == (~lhs).columns(), "Invalid vector size" );
477 
478  const LeftIterator lend( x.end() );
479  const RightIterator rend( y.end() );
480 
481  for( LeftIterator lelem=x.begin(); lelem!=lend; ++lelem ) {
482  if( !isDefault( lelem->value() ) ) {
483  for( RightIterator relem=y.begin(); relem!=rend; ++relem ) {
484  (~lhs)(lelem->index(),relem->index()) += lelem->value() * relem->value();
485  }
486  }
487  }
488  }
490  //**********************************************************************************************
491 
492  //**Addition assignment to column-major dense matrices******************************************
505  template< typename MT > // Type of the target dense matrix
506  friend inline void addAssign( DenseMatrix<MT,true>& lhs, const SVecTSVecMultExpr& rhs )
507  {
509 
510  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
511  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
512 
513  typedef typename RemoveReference<LT>::Type::ConstIterator LeftIterator;
514  typedef typename RemoveReference<RT>::Type::ConstIterator RightIterator;
515 
516  LT x( rhs.lhs_ ); // Evaluation of the left-hand side sparse vector operand
517  RT y( rhs.rhs_ ); // Evaluation of the right-hand side sparse vector operand
518 
519  BLAZE_INTERNAL_ASSERT( x.size() == rhs.lhs_.size() , "Invalid vector size" );
520  BLAZE_INTERNAL_ASSERT( y.size() == rhs.rhs_.size() , "Invalid vector size" );
521  BLAZE_INTERNAL_ASSERT( x.size() == (~lhs).rows() , "Invalid vector size" );
522  BLAZE_INTERNAL_ASSERT( y.size() == (~lhs).columns(), "Invalid vector size" );
523 
524  const LeftIterator lend( x.end() );
525  const RightIterator rend( y.end() );
526 
527  for( RightIterator relem=y.begin(); relem!=rend; ++relem ) {
528  if( !isDefault( relem->value() ) ) {
529  for( LeftIterator lelem=x.begin(); lelem!=lend; ++lelem ) {
530  (~lhs)(lelem->index(),relem->index()) += lelem->value() * relem->value();
531  }
532  }
533  }
534  }
536  //**********************************************************************************************
537 
538  //**Addition assignment to sparse matrices******************************************************
539  // No special implementation for the addition assignment to sparse matrices.
540  //**********************************************************************************************
541 
542  //**Subtraction assignment to row-major dense matrices******************************************
555  template< typename MT > // Type of the target dense matrix
556  friend inline void subAssign( DenseMatrix<MT,false>& lhs, const SVecTSVecMultExpr& rhs )
557  {
559 
560  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
561  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
562 
563  typedef typename RemoveReference<LT>::Type::ConstIterator LeftIterator;
564  typedef typename RemoveReference<RT>::Type::ConstIterator RightIterator;
565 
566  LT x( rhs.lhs_ ); // Evaluation of the left-hand side sparse vector operand
567  RT y( rhs.rhs_ ); // Evaluation of the right-hand side sparse vector operand
568 
569  BLAZE_INTERNAL_ASSERT( x.size() == rhs.lhs_.size() , "Invalid vector size" );
570  BLAZE_INTERNAL_ASSERT( y.size() == rhs.rhs_.size() , "Invalid vector size" );
571  BLAZE_INTERNAL_ASSERT( x.size() == (~lhs).rows() , "Invalid vector size" );
572  BLAZE_INTERNAL_ASSERT( y.size() == (~lhs).columns(), "Invalid vector size" );
573 
574  const LeftIterator lend( x.end() );
575  const RightIterator rend( y.end() );
576 
577  for( LeftIterator lelem=x.begin(); lelem!=lend; ++lelem ) {
578  if( !isDefault( lelem->value() ) ) {
579  for( RightIterator relem=y.begin(); relem!=rend; ++relem ) {
580  (~lhs)(lelem->index(),relem->index()) -= lelem->value() * relem->value();
581  }
582  }
583  }
584  }
586  //**********************************************************************************************
587 
588  //**Subtraction assignment to column-major dense matrices***************************************
601  template< typename MT > // Type of the target dense matrix
602  friend inline void subAssign( DenseMatrix<MT,true>& lhs, const SVecTSVecMultExpr& rhs )
603  {
605 
606  BLAZE_INTERNAL_ASSERT( (~lhs).rows() == rhs.rows() , "Invalid number of rows" );
607  BLAZE_INTERNAL_ASSERT( (~lhs).columns() == rhs.columns(), "Invalid number of columns" );
608 
609  typedef typename RemoveReference<LT>::Type::ConstIterator LeftIterator;
610  typedef typename RemoveReference<RT>::Type::ConstIterator RightIterator;
611 
612  LT x( rhs.lhs_ ); // Evaluation of the left-hand side sparse vector operand
613  RT y( rhs.rhs_ ); // Evaluation of the right-hand side sparse vector operand
614 
615  BLAZE_INTERNAL_ASSERT( x.size() == rhs.lhs_.size() , "Invalid vector size" );
616  BLAZE_INTERNAL_ASSERT( y.size() == rhs.rhs_.size() , "Invalid vector size" );
617  BLAZE_INTERNAL_ASSERT( x.size() == (~lhs).rows() , "Invalid vector size" );
618  BLAZE_INTERNAL_ASSERT( y.size() == (~lhs).columns(), "Invalid vector size" );
619 
620  const LeftIterator lend( x.end() );
621  const RightIterator rend( y.end() );
622 
623  for( RightIterator relem=y.begin(); relem!=rend; ++relem ) {
624  if( !isDefault( relem->value() ) ) {
625  for( LeftIterator lelem=x.begin(); lelem!=lend; ++lelem ) {
626  (~lhs)(lelem->index(),relem->index()) -= lelem->value() * relem->value();
627  }
628  }
629  }
630  }
632  //**********************************************************************************************
633 
634  //**Subtraction assignment to sparse matrices***************************************************
635  // No special implementation for the subtraction assignment to sparse matrices.
636  //**********************************************************************************************
637 
638  //**Multiplication assignment to dense matrices*************************************************
639  // No special implementation for the multiplication assignment to dense matrices.
640  //**********************************************************************************************
641 
642  //**Multiplication assignment to sparse matrices************************************************
643  // No special implementation for the multiplication assignment to sparse matrices.
644  //**********************************************************************************************
645 
646  //**Compile time checks*************************************************************************
653  //**********************************************************************************************
654 };
655 //*************************************************************************************************
656 
657 
658 
659 
660 //=================================================================================================
661 //
662 // GLOBAL BINARY ARITHMETIC OPERATORS
663 //
664 //=================================================================================================
665 
666 //*************************************************************************************************
693 template< typename T1 // Type of the left-hand side sparse vector
694  , typename T2 > // Type of the right-hand side sparse vector
695 inline const SVecTSVecMultExpr<T1,T2>
697 {
699 
700  return SVecTSVecMultExpr<T1,T2>( ~lhs, ~rhs );
701 }
702 //*************************************************************************************************
703 
704 
705 
706 
707 //=================================================================================================
708 //
709 // EXPRESSION TRAIT SPECIALIZATIONS
710 //
711 //=================================================================================================
712 
713 //*************************************************************************************************
715 template< typename VT1, typename VT2, bool AF >
716 struct SubmatrixExprTrait< SVecTSVecMultExpr<VT1,VT2>, AF >
717 {
718  public:
719  //**********************************************************************************************
720  typedef typename MultExprTrait< typename SubvectorExprTrait<const VT1,AF>::Type
721  , typename SubvectorExprTrait<const VT2,AF>::Type >::Type Type;
722  //**********************************************************************************************
723 };
725 //*************************************************************************************************
726 
727 
728 //*************************************************************************************************
730 template< typename VT1, typename VT2 >
731 struct RowExprTrait< SVecTSVecMultExpr<VT1,VT2> >
732 {
733  public:
734  //**********************************************************************************************
735  typedef typename MultExprTrait< typename VT1::ReturnType, VT2 >::Type Type;
736  //**********************************************************************************************
737 };
739 //*************************************************************************************************
740 
741 
742 //*************************************************************************************************
744 template< typename VT1, typename VT2 >
745 struct ColumnExprTrait< SVecTSVecMultExpr<VT1,VT2> >
746 {
747  public:
748  //**********************************************************************************************
749  typedef typename MultExprTrait< VT1, typename VT2::ReturnType >::Type Type;
750  //**********************************************************************************************
751 };
753 //*************************************************************************************************
754 
755 } // namespace blaze
756 
757 #endif
Compile time check whether the given type is a temporary vector or matrix type.This type trait class ...
Definition: IsTemporary.h:87
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
#define BLAZE_CONSTRAINT_MUST_BE_COLUMN_VECTOR_TYPE(T)
Constraint on the data type.In case the given data type T is not a column dense or sparse vector type...
Definition: TransposeFlag.h:159
bool isDefault(const DynamicMatrix< Type, SO > &m)
Returns whether the given dense matrix is in default state.
Definition: DynamicMatrix.h:4622
Efficient implementation of a compressed matrix.The CompressedMatrix class template is the represent...
Definition: CompressedMatrix.h:197
Header file for the ColumnExprTrait class template.
ReturnType operator()(size_t i, size_t j) const
2D-access to the matrix elements.
Definition: SVecTSVecMultExpr.h:163
SelectType< IsComputation< VT1 >::value, const RT1, CT1 >::Type LT
Type for the assignment of the left-hand side dense vector operand.
Definition: SVecTSVecMultExpr.h:133
const This & CompositeType
Data type for composite expression templates.
Definition: CompressedMatrix.h:2384
SVecTSVecMultExpr(const VT1 &lhs, const VT2 &rhs)
Constructor for the SVecTSVecMultExpr class.
Definition: SVecTSVecMultExpr.h:150
Type ElementType
Type of the sparse matrix elements.
Definition: CompressedMatrix.h:249
VT1::ResultType RT1
Result type of the left-hand side sparse vector expression.
Definition: SVecTSVecMultExpr.h:91
bool isAliased(const T *alias) const
Returns whether the expression is aliased with the given address alias.
Definition: SVecTSVecMultExpr.h:251
Header file for the Computation base class.
size_t columns() const
Returns the current number of columns of the matrix.
Definition: SVecTSVecMultExpr.h:186
size_t nonZeros() const
Returns the number of non-zero elements in the sparse matrix.
Definition: SVecTSVecMultExpr.h:196
ResultType::TransposeType TransposeType
Transpose type for expression template evaluations.
Definition: SVecTSVecMultExpr.h:117
bool canAlias(const T *alias) const
Returns whether the expression can alias with the given address alias.
Definition: SVecTSVecMultExpr.h:239
ResultType::ElementType ElementType
Resulting element type.
Definition: SVecTSVecMultExpr.h:118
Base class for dense matrices.The DenseMatrix class is a base class for all dense matrix classes...
Definition: DenseMatrix.h:70
Constraint on the data type.
Header file for the SparseMatrix base class.
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
VT2::CompositeType CT2
Composite type of the right-hand side sparse vector expression.
Definition: SVecTSVecMultExpr.h:96
Header file for the IsTemporary type trait class.
Header file for the multiplication trait.
size_t rows() const
Returns the current number of rows of the matrix.
Definition: SVecTSVecMultExpr.h:176
SelectType< IsExpression< VT2 >::value, const VT2, const VT2 & >::Type RightOperand
Composite type of the right-hand side sparse vector expression.
Definition: SVecTSVecMultExpr.h:130
LeftOperand lhs_
Left-hand side sparse vector of the multiplication expression.
Definition: SVecTSVecMultExpr.h:258
size_t nonZeros(size_t i) const
Returns the number of non-zero elements in the specified row.
Definition: SVecTSVecMultExpr.h:207
const Element * ConstIterator
Iterator over constant elements.
Definition: CompressedMatrix.h:2388
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
#define BLAZE_CONSTRAINT_MUST_BE_SPARSE_VECTOR_TYPE(T)
Constraint on the data type.In case the given data type T is not a sparse, N-dimensional vector type...
Definition: SparseVector.h:79
Constraint on the data type.
Expression object for sparse vector-sparse vector outer products.The SVecTSVecMultExpr class represen...
Definition: Forward.h:120
MultExprTrait< RN1, RN2 >::Type ExprReturnType
Expression return type for the subscript operator.
Definition: SVecTSVecMultExpr.h:109
Header file for the SelectType class template.
Header file for the RowExprTrait class template.
Header file for all forward declarations for expression class templates.
Constraint on the data type.
Header file for the VecTVecMultExpr base class.
ResultType::OppositeType OppositeType
Result type with opposite storage order for expression template evaluations.
Definition: SVecTSVecMultExpr.h:116
Header file for the SubmatrixExprTrait class template.
const Type & ReturnType
Return type for expression template evaluations.
Definition: CompressedMatrix.h:2383
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.
Base template for the MultTrait class.
Definition: MultTrait.h:141
RightOperand rhs_
Right-hand side sparse vector of the multiplication expression.
Definition: SVecTSVecMultExpr.h:259
VT1::CompositeType CT1
Composite type of the left-hand side sparse vector expression.
Definition: SVecTSVecMultExpr.h:95
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
VT2::ReturnType RN2
Return type of the right-hand side sparse vector expression.
Definition: SVecTSVecMultExpr.h:94
RightOperand rightOperand() const
Returns the right-hand side sparse vector operand.
Definition: SVecTSVecMultExpr.h:227
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< IsExpression< VT1 >::value, const VT1, const VT1 & >::Type LeftOperand
Composite type of the left-hand side sparse vector expression.
Definition: SVecTSVecMultExpr.h:127
Header file for the isDefault shim.
const ResultType CompositeType
Data type for composite expression templates.
Definition: SVecTSVecMultExpr.h:124
MultTrait< RT1, RT2 >::Type ResultType
Result type for expression template evaluations.
Definition: SVecTSVecMultExpr.h:115
Header file for the RemoveReference type trait.
VT1::ReturnType RN1
Return type of the left-hand side sparse vector expression.
Definition: SVecTSVecMultExpr.h:93
SVecTSVecMultExpr< VT1, VT2 > This
Type of this SVecTSVecMultExpr instance.
Definition: SVecTSVecMultExpr.h:114
Header file for the IsComputation type trait class.
Base class for sparse vectors.The SparseVector class is a base class for all arbitrarily sized (N-dim...
Definition: Forward.h:105
#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
Header file for basic type definitions.
#define BLAZE_CONSTRAINT_MUST_BE_ROW_VECTOR_TYPE(T)
Constraint on the data type.In case the given data type T is not a row dense or sparse vector type (i...
Definition: TransposeFlag.h:81
Header file for the SubvectorExprTrait class template.
VT2::ResultType RT2
Result type of the right-hand side sparse vector expression.
Definition: SVecTSVecMultExpr.h:92
const SelectType< returnExpr, ExprReturnType, ElementType >::Type ReturnType
Return type for expression template evaluations.
Definition: SVecTSVecMultExpr.h:121
Evaluation of the resulting expression type of a multiplication.Via this type trait it is possible to...
Definition: MultExprTrait.h:137
Size type of the Blaze library.
#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
LeftOperand leftOperand() const
Returns the left-hand side sparse vector operand.
Definition: SVecTSVecMultExpr.h:217
SelectType< IsComputation< VT2 >::value, const RT2, CT2 >::Type RT
Type for the assignment of the right-hand side dense vector operand.
Definition: SVecTSVecMultExpr.h:136
Header file for the IsExpression type trait class.
Header file for the FunctionTrace class.