DVecSVecMultExpr.h
Go to the documentation of this file.
1 //=================================================================================================
33 //=================================================================================================
34 
35 #ifndef _BLAZE_MATH_EXPRESSIONS_DVECSVECMULTEXPR_H_
36 #define _BLAZE_MATH_EXPRESSIONS_DVECSVECMULTEXPR_H_
37 
38 
39 //*************************************************************************************************
40 // Includes
41 //*************************************************************************************************
42 
43 #include <iterator>
44 #include <blaze/math/Aliases.h>
50 #include <blaze/math/Exception.h>
55 #include <blaze/math/shims/Reset.h>
65 #include <blaze/util/Assert.h>
67 #include <blaze/util/EnableIf.h>
69 #include <blaze/util/mpl/If.h>
70 #include <blaze/util/mpl/Max.h>
71 #include <blaze/util/Types.h>
73 
74 
75 namespace blaze {
76 
77 //=================================================================================================
78 //
79 // CLASS DVECSVECMULTEXPR
80 //
81 //=================================================================================================
82 
83 //*************************************************************************************************
90 template< typename VT1 // Type of the left-hand side dense vector
91  , typename VT2 // Type of the right-hand side sparse vector
92  , bool TF > // Transpose flag
93 class DVecSVecMultExpr : public SparseVector< DVecSVecMultExpr<VT1,VT2,TF>, TF >
94  , private VecVecMultExpr
95  , private Computation
96 {
97  private:
98  //**Type definitions****************************************************************************
107  //**********************************************************************************************
108 
109  //**Return type evaluation**********************************************************************
111 
116  enum : bool { returnExpr = !IsTemporary<RN1>::value && !IsTemporary<RN2>::value };
117 
120  //**********************************************************************************************
121 
122  //**Evaluation strategy*************************************************************************
124 
130  enum : bool { useAssign = ( RequiresEvaluation<VT1>::value || RequiresEvaluation<VT2>::value ) };
131 
133  template< typename VT >
135  struct UseAssign {
136  enum : bool { value = useAssign };
137  };
139  //**********************************************************************************************
140 
141  public:
142  //**Type definitions****************************************************************************
147 
150 
153 
155  typedef If_< IsExpression<VT1>, const VT1, const VT1& > LeftOperand;
156 
158  typedef If_< IsExpression<VT2>, const VT2, const VT2& > RightOperand;
159  //**********************************************************************************************
160 
161  //**Compilation flags***************************************************************************
163  enum : bool { smpAssignable = false };
164  //**********************************************************************************************
165 
166  //**ConstIterator class definition**************************************************************
170  {
171  public:
172  //**Type definitions*************************************************************************
175 
178 
179  typedef std::forward_iterator_tag IteratorCategory;
180  typedef Element ValueType;
181  typedef ValueType* PointerType;
182  typedef ValueType& ReferenceType;
184 
185  // STL iterator requirements
186  typedef IteratorCategory iterator_category;
187  typedef ValueType value_type;
188  typedef PointerType pointer;
189  typedef ReferenceType reference;
190  typedef DifferenceType difference_type;
191  //*******************************************************************************************
192 
193  //**Constructor******************************************************************************
196  inline ConstIterator( LeftOperand vec, IteratorType it )
197  : vec_( vec ) // Left-hand side dense vector expression
198  , it_ ( it ) // Iterator over the elements of the right-hand side sparse vector expression
199  {}
200  //*******************************************************************************************
201 
202  //**Prefix increment operator****************************************************************
208  ++it_;
209  return *this;
210  }
211  //*******************************************************************************************
212 
213  //**Element access operator******************************************************************
218  inline const Element operator*() const {
219  return Element( vec_[it_->index()] * it_->value(), it_->index() );
220  }
221  //*******************************************************************************************
222 
223  //**Element access operator******************************************************************
228  inline const ConstIterator* operator->() const {
229  return this;
230  }
231  //*******************************************************************************************
232 
233  //**Value function***************************************************************************
238  inline ReturnType value() const {
239  return vec_[it_->index()] * it_->value();
240  }
241  //*******************************************************************************************
242 
243  //**Index function***************************************************************************
248  inline size_t index() const {
249  return it_->index();
250  }
251  //*******************************************************************************************
252 
253  //**Equality operator************************************************************************
259  inline bool operator==( const ConstIterator& rhs ) const {
260  return it_ == rhs.it_;
261  }
262  //*******************************************************************************************
263 
264  //**Inequality operator**********************************************************************
270  inline bool operator!=( const ConstIterator& rhs ) const {
271  return it_ != rhs.it_;
272  }
273  //*******************************************************************************************
274 
275  //**Subtraction operator*********************************************************************
281  inline DifferenceType operator-( const ConstIterator& rhs ) const {
282  return it_ - rhs.it_;
283  }
284  //*******************************************************************************************
285 
286  private:
287  //**Member variables*************************************************************************
288  LeftOperand vec_;
289  IteratorType it_;
290  //*******************************************************************************************
291  };
292  //**********************************************************************************************
293 
294  //**Constructor*********************************************************************************
300  explicit inline DVecSVecMultExpr( const VT1& lhs, const VT2& rhs ) noexcept
301  : lhs_( lhs ) // Left-hand side dense vector of the multiplication expression
302  , rhs_( rhs ) // Right-hand side sparse vector of the multiplication expression
303  {
304  BLAZE_INTERNAL_ASSERT( lhs.size() == rhs.size(), "Invalid vector sizes" );
305  }
306  //**********************************************************************************************
307 
308  //**Subscript operator**************************************************************************
314  inline ReturnType operator[]( size_t index ) const {
315  BLAZE_INTERNAL_ASSERT( index < lhs_.size(), "Invalid vector access index" );
316  return lhs_[index] * rhs_[index];
317  }
318  //**********************************************************************************************
319 
320  //**At function*********************************************************************************
327  inline ReturnType at( size_t index ) const {
328  if( index >= lhs_.size() ) {
329  BLAZE_THROW_OUT_OF_RANGE( "Invalid vector access index" );
330  }
331  return (*this)[index];
332  }
333  //**********************************************************************************************
334 
335  //**Begin function******************************************************************************
340  inline ConstIterator begin() const {
341  return ConstIterator( lhs_, rhs_.begin() );
342  }
343  //**********************************************************************************************
344 
345  //**End function********************************************************************************
350  inline ConstIterator end() const {
351  return ConstIterator( lhs_, rhs_.end() );
352  }
353  //**********************************************************************************************
354 
355  //**Size function*******************************************************************************
360  inline size_t size() const noexcept {
361  return lhs_.size();
362  }
363  //**********************************************************************************************
364 
365  //**NonZeros function***************************************************************************
370  inline size_t nonZeros() const {
371  return rhs_.nonZeros();
372  }
373  //**********************************************************************************************
374 
375  //**Find function*******************************************************************************
381  inline ConstIterator find( size_t index ) const {
383  return ConstIterator( lhs_, rhs_.find( index ) );
384  }
385  //**********************************************************************************************
386 
387  //**LowerBound function*************************************************************************
393  inline ConstIterator lowerBound( size_t index ) const {
395  return ConstIterator( lhs_, rhs_.lowerBound( index ) );
396  }
397  //**********************************************************************************************
398 
399  //**UpperBound function*************************************************************************
405  inline ConstIterator upperBound( size_t index ) const {
407  return ConstIterator( lhs_, rhs_.upperBound( index ) );
408  }
409  //**********************************************************************************************
410 
411  //**Left operand access*************************************************************************
416  inline LeftOperand leftOperand() const noexcept {
417  return lhs_;
418  }
419  //**********************************************************************************************
420 
421  //**Right operand access************************************************************************
426  inline RightOperand rightOperand() const noexcept {
427  return rhs_;
428  }
429  //**********************************************************************************************
430 
431  //**********************************************************************************************
437  template< typename T >
438  inline bool canAlias( const T* alias ) const noexcept {
439  return ( lhs_.canAlias( alias ) || rhs_.canAlias( alias ) );
440  }
441  //**********************************************************************************************
442 
443  //**********************************************************************************************
449  template< typename T >
450  inline bool isAliased( const T* alias ) const noexcept {
451  return ( lhs_.isAliased( alias ) || rhs_.isAliased( alias ) );
452  }
453  //**********************************************************************************************
454 
455  private:
456  //**Member variables****************************************************************************
457  LeftOperand lhs_;
458  RightOperand rhs_;
459  //**********************************************************************************************
460 
461  //**Assignment to dense vectors*****************************************************************
475  template< typename VT > // Type of the target dense vector
476  friend inline EnableIf_< UseAssign<VT> >
477  assign( DenseVector<VT,TF>& lhs, const DVecSVecMultExpr& rhs )
478  {
480 
481  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
482 
484 
485  CT1 x( serial( rhs.lhs_ ) ); // Evaluation of the left-hand side dense vector operand
486  CT2 y( serial( rhs.rhs_ ) ); // Evaluation of the right-hand side sparse vector operand
487 
488  BLAZE_INTERNAL_ASSERT( x.size() == rhs.lhs_.size(), "Invalid vector size" );
489  BLAZE_INTERNAL_ASSERT( y.size() == rhs.rhs_.size(), "Invalid vector size" );
490  BLAZE_INTERNAL_ASSERT( x.size() == (~lhs).size() , "Invalid vector size" );
491 
492  for( ConstIterator element=y.begin(); element!=y.end(); ++element )
493  (~lhs)[element->index()] = x[element->index()] * element->value();
494  }
496  //**********************************************************************************************
497 
498  //**Assignment to sparse vectors****************************************************************
512  template< typename VT > // Type of the target sparse vector
513  friend inline EnableIf_< UseAssign<VT> >
514  assign( SparseVector<VT,TF>& lhs, const DVecSVecMultExpr& rhs )
515  {
517 
518  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
519 
521 
522  CT1 x( serial( rhs.lhs_ ) ); // Evaluation of the left-hand side dense vector operand
523  CT2 y( serial( rhs.rhs_ ) ); // Evaluation of the right-hand side sparse vector operand
524 
525  BLAZE_INTERNAL_ASSERT( x.size() == rhs.lhs_.size(), "Invalid vector size" );
526  BLAZE_INTERNAL_ASSERT( y.size() == rhs.rhs_.size(), "Invalid vector size" );
527  BLAZE_INTERNAL_ASSERT( x.size() == (~lhs).size() , "Invalid vector size" );
528 
529  for( ConstIterator element=y.begin(); element!=y.end(); ++element )
530  (~lhs).append( element->index(), x[element->index()] * element->value() );
531  }
533  //**********************************************************************************************
534 
535  //**Addition assignment to dense vectors********************************************************
549  template< typename VT > // Type of the target dense vector
550  friend inline EnableIf_< UseAssign<VT> >
551  addAssign( DenseVector<VT,TF>& lhs, const DVecSVecMultExpr& rhs )
552  {
554 
555  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
556 
557  typedef ConstIterator_< RemoveReference_<CT2> > ConstIterator;
558 
559  CT1 x( serial( rhs.lhs_ ) ); // Evaluation of the left-hand side dense vector operand
560  CT2 y( serial( rhs.rhs_ ) ); // Evaluation of the right-hand side sparse vector operand
561 
562  BLAZE_INTERNAL_ASSERT( x.size() == rhs.lhs_.size(), "Invalid vector size" );
563  BLAZE_INTERNAL_ASSERT( y.size() == rhs.rhs_.size(), "Invalid vector size" );
564  BLAZE_INTERNAL_ASSERT( x.size() == (~lhs).size() , "Invalid vector size" );
565 
566  for( ConstIterator element=y.begin(); element!=y.end(); ++element )
567  (~lhs)[element->index()] += x[element->index()] * element->value();
568  }
570  //**********************************************************************************************
571 
572  //**Addition assignment to sparse vectors*******************************************************
573  // No special implementation for the addition assignment to sparse vectors.
574  //**********************************************************************************************
575 
576  //**Subtraction assignment to dense vectors*****************************************************
590  template< typename VT > // Type of the target dense vector
591  friend inline EnableIf_< UseAssign<VT> >
592  subAssign( DenseVector<VT,TF>& lhs, const DVecSVecMultExpr& rhs )
593  {
595 
596  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
597 
598  typedef ConstIterator_< RemoveReference_<CT2> > ConstIterator;
599 
600  CT1 x( serial( rhs.lhs_ ) ); // Evaluation of the left-hand side dense vector operand
601  CT2 y( serial( rhs.rhs_ ) ); // Evaluation of the right-hand side sparse vector operand
602 
603  BLAZE_INTERNAL_ASSERT( x.size() == rhs.lhs_.size(), "Invalid vector size" );
604  BLAZE_INTERNAL_ASSERT( y.size() == rhs.rhs_.size(), "Invalid vector size" );
605  BLAZE_INTERNAL_ASSERT( x.size() == (~lhs).size() , "Invalid vector size" );
606 
607  for( ConstIterator element=y.begin(); element!=y.end(); ++element )
608  (~lhs)[element->index()] -= x[element->index()] * element->value();
609  }
611  //**********************************************************************************************
612 
613  //**Subtraction assignment to sparse vectors****************************************************
614  // No special implementation for the subtraction assignment to sparse vectors.
615  //**********************************************************************************************
616 
617  //**Multiplication assignment to dense vectors**************************************************
631  template< typename VT > // Type of the target dense vector
632  friend inline EnableIf_< UseAssign<VT> >
633  multAssign( DenseVector<VT,TF>& lhs, const DVecSVecMultExpr& rhs )
634  {
636 
637  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
638 
639  typedef ConstIterator_< RemoveReference_<CT2> > ConstIterator;
640 
641  CT1 x( serial( rhs.lhs_ ) ); // Evaluation of the left-hand side dense vector operand
642  CT2 y( serial( rhs.rhs_ ) ); // Evaluation of the right-hand side sparse vector operand
643 
644  BLAZE_INTERNAL_ASSERT( x.size() == rhs.lhs_.size(), "Invalid vector size" );
645  BLAZE_INTERNAL_ASSERT( y.size() == rhs.rhs_.size(), "Invalid vector size" );
646  BLAZE_INTERNAL_ASSERT( x.size() == (~lhs).size() , "Invalid vector size" );
647 
648  const ConstIterator end( y.end() );
649  ConstIterator begin( y.begin() );
650  size_t i( 0UL );
651 
652  for( ; begin!=end; ++begin ) {
653  const size_t index( begin->index() );
654  for( ; i<index; ++i )
655  reset( (~lhs)[i] );
656  (~lhs)[index] *= x[index] * begin->value();
657  ++i;
658  }
659 
660  for( ; i<(~lhs).size(); ++i )
661  reset( (~lhs)[i] );
662  }
664  //**********************************************************************************************
665 
666  //**Multiplication assignment to sparse vectors*************************************************
667  // No special implementation for the multiplication assignment to sparse vectors.
668  //**********************************************************************************************
669 
670  //**Compile time checks*************************************************************************
678  //**********************************************************************************************
679 };
680 //*************************************************************************************************
681 
682 
683 
684 
685 //=================================================================================================
686 //
687 // GLOBAL BINARY ARITHMETIC OPERATORS
688 //
689 //=================================================================================================
690 
691 //*************************************************************************************************
718 template< typename T1 // Type of the left-hand side dense vector
719  , typename T2 // Type of the right-hand side sparse vector
720  , bool TF > // Transpose flag
721 inline const DVecSVecMultExpr<T1,T2,TF>
723 {
725 
726  if( (~lhs).size() != (~rhs).size() ) {
727  BLAZE_THROW_INVALID_ARGUMENT( "Vector sizes do not match" );
728  }
729 
730  return DVecSVecMultExpr<T1,T2,TF>( ~lhs, ~rhs );
731 }
732 //*************************************************************************************************
733 
734 
735 
736 
737 //=================================================================================================
738 //
739 // SIZE SPECIALIZATIONS
740 //
741 //=================================================================================================
742 
743 //*************************************************************************************************
745 template< typename VT1, typename VT2, bool TF >
746 struct Size< DVecSVecMultExpr<VT1,VT2,TF> >
747  : public Max< Size<VT1>, Size<VT2> >
748 {};
750 //*************************************************************************************************
751 
752 
753 
754 
755 //=================================================================================================
756 //
757 // EXPRESSION TRAIT SPECIALIZATIONS
758 //
759 //=================================================================================================
760 
761 //*************************************************************************************************
763 template< typename VT1, typename VT2, bool TF, bool AF >
764 struct SubvectorExprTrait< DVecSVecMultExpr<VT1,VT2,TF>, AF >
765 {
766  public:
767  //**********************************************************************************************
768  using Type = MultExprTrait_< SubvectorExprTrait_<const VT1,AF>
769  , SubvectorExprTrait_<const VT2,AF> >;
770  //**********************************************************************************************
771 };
773 //*************************************************************************************************
774 
775 } // namespace blaze
776 
777 #endif
ptrdiff_t DifferenceType
Difference between two iterators.
Definition: DVecSVecMultExpr.h:183
ConstIterator_< RemoveReference_< RightOperand > > IteratorType
Iterator type of the sparse vector expression.
Definition: DVecSVecMultExpr.h:177
#define BLAZE_THROW_INVALID_ARGUMENT(MESSAGE)
Macro for the emission of a std::invalid_argument exception.This macro encapsulates the default way o...
Definition: Exception.h:235
Pointer difference type of the Blaze library.
LeftOperand vec_
Left-hand side dense vector expression.
Definition: DVecSVecMultExpr.h:288
Header file for auxiliary alias declarations.
Header file for the Max class template.
ConstIterator(LeftOperand vec, IteratorType it)
Constructor for the ConstIterator class.
Definition: DVecSVecMultExpr.h:196
Compile time check whether the given type is a temporary vector or matrix type.This type trait class ...
Definition: IsTemporary.h:70
const Element operator*() const
Direct access to the sparse vector element at the current iterator position.
Definition: DVecSVecMultExpr.h:218
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:7800
Header file for basic type definitions.
size_t index() const
Access to the current index of the sparse element.
Definition: DVecSVecMultExpr.h:248
Header file for the SparseVector base class.
size_t nonZeros() const
Returns the number of non-zero elements in the sparse vector.
Definition: DVecSVecMultExpr.h:370
IfTrue_< useAssign, const ResultType, const DVecSVecMultExpr & > CompositeType
Data type for composite expression templates.
Definition: DVecSVecMultExpr.h:152
ReturnType_< VT1 > RN1
Return type of the left-hand side dense vector expression.
Definition: DVecSVecMultExpr.h:101
Header file for the serial shim.
Element ValueType
Type of the underlying pointers.
Definition: DVecSVecMultExpr.h:180
void reset(const DiagonalProxy< MT > &proxy)
Resetting the represented element to the default initial values.
Definition: DiagonalProxy.h:533
const DMatSerialExpr< MT, SO > serial(const DenseMatrix< MT, SO > &dm)
Forces the serial evaluation of the given dense matrix expression dm.
Definition: DMatSerialExpr.h:723
typename MultTrait< T1, T2 >::Type MultTrait_
Auxiliary alias declaration for the MultTrait class template.The MultTrait_ alias declaration provide...
Definition: MultTrait.h:245
bool canAlias(const T *alias) const noexcept
Returns whether the expression can alias with the given address alias.
Definition: DVecSVecMultExpr.h:438
Expression object for dense vector-sparse vector multiplications.The DVecSVecMultExpr class represent...
Definition: DVecSVecMultExpr.h:93
Header file for the Computation base class.
ValueType value_type
Type of the underlying pointers.
Definition: DVecSVecMultExpr.h:187
Header file for the RequiresEvaluation type trait.
IteratorCategory iterator_category
The iterator category.
Definition: DVecSVecMultExpr.h:186
typename T::ResultType ResultType_
Alias declaration for nested ResultType type definitions.The ResultType_ alias declaration provides a...
Definition: Aliases.h:323
ReturnType_< VT2 > RN2
Return type of the right-hand side sparse vector expression.
Definition: DVecSVecMultExpr.h:102
RightOperand rightOperand() const noexcept
Returns the right-hand side sparse vector operand.
Definition: DVecSVecMultExpr.h:426
RightOperand rhs_
Right-hand side sparse vector of the multiplication expression.
Definition: DVecSVecMultExpr.h:458
ConstIterator find(size_t index) const
Searches for a specific vector element.
Definition: DVecSVecMultExpr.h:381
Constraint on the data type.
typename IfTrue< Condition, T1, T2 >::Type IfTrue_
Auxiliary alias declaration for the IfTrue class template.The IfTrue_ alias declaration provides a co...
Definition: If.h:109
typename T::ReturnType ReturnType_
Alias declaration for nested ReturnType type definitions.The ReturnType_ alias declaration provides a...
Definition: Aliases.h:343
ConstIterator lowerBound(size_t index) const
Returns an iterator to the first index not less then the given index.
Definition: DVecSVecMultExpr.h:393
std::forward_iterator_tag IteratorCategory
The iterator category.
Definition: DVecSVecMultExpr.h:179
ResultType_< VT1 > RT1
Result type of the left-hand side dense vector expression.
Definition: DVecSVecMultExpr.h:99
typename MultExprTrait< T1, T2 >::Type MultExprTrait_
Auxiliary alias declaration for the MultExprTrait class template.The MultExprTrait_ alias declaration...
Definition: MultExprTrait.h:344
Header file for the MultExprTrait class template.
Compile time check to query the requirement to evaluate an expression.Via this type trait it is possi...
Definition: RequiresEvaluation.h:72
DifferenceType operator-(const ConstIterator &rhs) const
Calculating the number of elements between two expression iterators.
Definition: DVecSVecMultExpr.h:281
typename T::CompositeType CompositeType_
Alias declaration for nested CompositeType type definitions.The CompositeType_ alias declaration prov...
Definition: Aliases.h:83
MultExprTrait_< RN1, RN2 > ExprReturnType
Expression return type for the subscript operator.
Definition: DVecSVecMultExpr.h:119
CompositeType_< VT2 > CT2
Composite type of the right-hand side sparse vector expression.
Definition: DVecSVecMultExpr.h:104
Header file for the ValueIndexPair class.
ConstIterator & operator++()
Pre-increment operator.
Definition: DVecSVecMultExpr.h:207
Header file for the IsTemporary type trait class.
Header file for the multiplication trait.
size_t size() const noexcept
Returns the current size/dimension of the vector.
Definition: DVecSVecMultExpr.h:360
Namespace of the Blaze C++ math library.
Definition: Blaze.h:57
Header file for the If class template.
const Element * ConstIterator
Iterator over constant elements.
Definition: CompressedMatrix.h:2647
#define BLAZE_THROW_OUT_OF_RANGE(MESSAGE)
Macro for the emission of a std::out_of_range exception.This macro encapsulates the default way of Bl...
Definition: Exception.h:331
typename T::ElementType ElementType_
Alias declaration for nested ElementType type definitions.The ElementType_ alias declaration provides...
Definition: Aliases.h:163
Base class for N-dimensional dense vectors.The DenseVector class is a base class for all arbitrarily ...
Definition: DenseVector.h:70
#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:61
Constraint on the data type.
DifferenceType difference_type
Difference between two iterators.
Definition: DVecSVecMultExpr.h:190
Constraint on the data type.
Header file for the exception macros of the math module.
LeftOperand leftOperand() const noexcept
Returns the left-hand side dense vector operand.
Definition: DVecSVecMultExpr.h:416
Header file for the VecVecMultExpr base class.
ReturnType at(size_t index) const
Checked access to the vector elements.
Definition: DVecSVecMultExpr.h:327
ResultType_< VT2 > RT2
Result type of the right-hand side sparse vector expression.
Definition: DVecSVecMultExpr.h:100
Constraint on the data type.
Header file for all forward declarations for expression class templates.
Constraint on the data type.
ReturnType value() const
Access to the current value of the sparse element.
Definition: DVecSVecMultExpr.h:238
ReturnType operator[](size_t index) const
Subscript operator for the direct access to the vector elements.
Definition: DVecSVecMultExpr.h:314
Header file for the EnableIf class template.
DVecSVecMultExpr(const VT1 &lhs, const VT2 &rhs) noexcept
Constructor for the DVecSVecMultExpr class.
Definition: DVecSVecMultExpr.h:300
TransposeType_< VT2 > TT2
Transpose type of the right-hand side sparse vector expression.
Definition: DVecSVecMultExpr.h:106
ConstIterator upperBound(size_t index) const
Returns an iterator to the first index greater then the given index.
Definition: DVecSVecMultExpr.h:405
bool operator!=(const ConstIterator &rhs) const
Inequality comparison between two ConstIterator objects.
Definition: DVecSVecMultExpr.h:270
ReferenceType reference
Reference return type.
Definition: DVecSVecMultExpr.h:189
Iterator over the elements of the dense vector-sparse vector multiplication expression.
Definition: DVecSVecMultExpr.h:169
Header file for run time assertion macros.
ConstIterator begin() const
Returns an iterator to the first non-zero element of the sparse vector.
Definition: DVecSVecMultExpr.h:340
typename If< T1, T2, T3 >::Type If_
Auxiliary alias declaration for the If class template.The If_ alias declaration provides a convenient...
Definition: If.h:160
Header file for the reset shim.
ValueType & ReferenceType
Reference return type.
Definition: DVecSVecMultExpr.h:182
If_< IsExpression< VT2 >, const VT2, const VT2 & > RightOperand
Composite type of the right-hand side sparse vector expression.
Definition: DVecSVecMultExpr.h:158
TransposeType_< ResultType > TransposeType
Transpose type for expression template evaluations.
Definition: DVecSVecMultExpr.h:145
ConstIterator end() const
Returns an iterator just past the last non-zero element of the sparse vector.
Definition: DVecSVecMultExpr.h:350
#define BLAZE_CONSTRAINT_MUST_NOT_REQUIRE_EVALUATION(T)
Constraint on the data type.In case the given data type T requires an intermediate evaluation within ...
Definition: RequiresEvaluation.h:81
Header file for the RemoveReference type trait.
TransposeType_< VT1 > TT1
Transpose type of the left-hand side dense vector expression.
Definition: DVecSVecMultExpr.h:105
CompositeType_< VT1 > CT1
Composite type of the left-hand side dense vector expression.
Definition: DVecSVecMultExpr.h:103
PointerType pointer
Pointer return type.
Definition: DVecSVecMultExpr.h:188
typename EnableIf< Condition, T >::Type EnableIf_
Auxiliary alias declaration for the EnableIf class template.The EnableIf_ alias declaration provides ...
Definition: EnableIf.h:223
const ConstIterator * operator->() const
Direct access to the sparse vector element at the current iterator position.
Definition: DVecSVecMultExpr.h:228
ValueIndexPair< ElementType > Element
Element type of the sparse vector expression.
Definition: DVecSVecMultExpr.h:174
MultTrait_< RT1, RT2 > ResultType
Result type for expression template evaluations.
Definition: DVecSVecMultExpr.h:144
typename T::ConstIterator ConstIterator_
Alias declaration for nested ConstIterator type definitions.The ConstIterator_ alias declaration prov...
Definition: Aliases.h:103
#define BLAZE_CONSTRAINT_MUST_BE_DENSE_VECTOR_TYPE(T)
Constraint on the data type.In case the given data type T is not a dense, N-dimensional vector type...
Definition: DenseVector.h:61
Index-value-pair for sparse vectors and matrices.The ValueIndexPair class represents a single index-v...
Definition: ValueIndexPair.h:70
Constraint on the data type.
ValueType * PointerType
Pointer return type.
Definition: DVecSVecMultExpr.h:181
#define BLAZE_CONSTRAINT_MUST_FORM_VALID_VECVECMULTEXPR(T1, T2)
Constraint on the data type.In case the given data types T1 and T2 do not form a valid vector/vector ...
Definition: VecVecMultExpr.h:109
LeftOperand lhs_
Left-hand side dense vector of the multiplication expression.
Definition: DVecSVecMultExpr.h:457
Base class for all compute expression templates.The Computation class serves as a tag for all computa...
Definition: Computation.h:59
Base class for sparse vectors.The SparseVector class is a base class for all arbitrarily sized (N-dim...
Definition: Forward.h:110
#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
Header file for the SubvectorExprTrait class template.
bool operator==(const ConstIterator &rhs) const
Equality comparison between two ConstIterator objects.
Definition: DVecSVecMultExpr.h:259
const IfTrue_< returnExpr, ExprReturnType, ElementType > ReturnType
Return type for expression template evaluations.
Definition: DVecSVecMultExpr.h:149
typename T::TransposeType TransposeType_
Alias declaration for nested TransposeType type definitions.The TransposeType_ alias declaration prov...
Definition: Aliases.h:403
DVecSVecMultExpr< VT1, VT2, TF > This
Type of this DVecSVecMultExpr instance.
Definition: DVecSVecMultExpr.h:143
bool isAliased(const T *alias) const noexcept
Returns whether the expression is aliased with the given address alias.
Definition: DVecSVecMultExpr.h:450
IteratorType it_
Iterator over the elements of the right-hand side sparse vector expression.
Definition: DVecSVecMultExpr.h:289
Header file for the Size type trait.
If_< IsExpression< VT1 >, const VT1, const VT1 & > LeftOperand
Composite type of the left-hand side dense vector expression.
Definition: DVecSVecMultExpr.h:155
#define BLAZE_CONSTRAINT_MUST_BE_VECTOR_WITH_TRANSPOSE_FLAG(T, TF)
Constraint on the data type.In case the given data type T is not a dense or sparse vector type and in...
Definition: TransposeFlag.h:63
Base class for all vector/vector multiplication expression templates.The VecVecMultExpr class serves ...
Definition: VecVecMultExpr.h:65
#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
ElementType_< ResultType > ElementType
Resulting element type.
Definition: DVecSVecMultExpr.h:146
Header file for the IsExpression type trait class.
Header file for the FunctionTrace class.