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>
53 #include <blaze/math/shims/Reset.h>
63 #include <blaze/util/Assert.h>
65 #include <blaze/util/EnableIf.h>
66 #include <blaze/util/Exception.h>
68 #include <blaze/util/mpl/Max.h>
69 #include <blaze/util/SelectType.h>
70 #include <blaze/util/Types.h>
72 
73 
74 namespace blaze {
75 
76 //=================================================================================================
77 //
78 // CLASS DVECSVECMULTEXPR
79 //
80 //=================================================================================================
81 
82 //*************************************************************************************************
89 template< typename VT1 // Type of the left-hand side dense vector
90  , typename VT2 // Type of the right-hand side sparse vector
91  , bool TF > // Transpose flag
92 class DVecSVecMultExpr : public SparseVector< DVecSVecMultExpr<VT1,VT2,TF>, TF >
93  , private VecVecMultExpr
94  , private Computation
95 {
96  private:
97  //**Type definitions****************************************************************************
98  typedef typename VT1::ResultType RT1;
99  typedef typename VT2::ResultType RT2;
100  typedef typename VT1::ReturnType RN1;
101  typedef typename VT2::ReturnType RN2;
102  typedef typename VT1::CompositeType CT1;
103  typedef typename VT2::CompositeType CT2;
104  typedef typename VT1::TransposeType TT1;
105  typedef typename VT2::TransposeType TT2;
106  //**********************************************************************************************
107 
108  //**Return type evaluation**********************************************************************
110 
115  enum { returnExpr = !IsTemporary<RN1>::value && !IsTemporary<RN2>::value };
116 
119  //**********************************************************************************************
120 
121  //**Evaluation strategy*************************************************************************
123 
130 
132  template< typename VT >
134  struct UseAssign {
135  enum { value = useAssign };
136  };
138  //**********************************************************************************************
139 
140  public:
141  //**Type definitions****************************************************************************
146 
149 
152 
154  typedef typename SelectType< IsExpression<VT1>::value, const VT1, const VT1& >::Type LeftOperand;
155 
157  typedef typename SelectType< IsExpression<VT2>::value, const VT2, const VT2& >::Type RightOperand;
158  //**********************************************************************************************
159 
160  //**Compilation flags***************************************************************************
162  enum { smpAssignable = 0 };
163  //**********************************************************************************************
164 
165  //**ConstIterator class definition**************************************************************
169  {
170  public:
171  //**Type definitions*************************************************************************
174 
177 
178  typedef std::forward_iterator_tag IteratorCategory;
179  typedef Element ValueType;
180  typedef ValueType* PointerType;
181  typedef ValueType& ReferenceType;
183 
184  // STL iterator requirements
185  typedef IteratorCategory iterator_category;
186  typedef ValueType value_type;
187  typedef PointerType pointer;
188  typedef ReferenceType reference;
189  typedef DifferenceType difference_type;
190  //*******************************************************************************************
191 
192  //**Constructor******************************************************************************
195  inline ConstIterator( LeftOperand vec, IteratorType it )
196  : vec_( vec ) // Left-hand side dense vector expression
197  , it_ ( it ) // Iterator over the elements of the right-hand side sparse vector expression
198  {}
199  //*******************************************************************************************
200 
201  //**Prefix increment operator****************************************************************
207  ++it_;
208  return *this;
209  }
210  //*******************************************************************************************
211 
212  //**Element access operator******************************************************************
217  inline const Element operator*() const {
218  return Element( vec_[it_->index()] * it_->value(), it_->index() );
219  }
220  //*******************************************************************************************
221 
222  //**Element access operator******************************************************************
227  inline const ConstIterator* operator->() const {
228  return this;
229  }
230  //*******************************************************************************************
231 
232  //**Value function***************************************************************************
237  inline ReturnType value() const {
238  return vec_[it_->index()] * it_->value();
239  }
240  //*******************************************************************************************
241 
242  //**Index function***************************************************************************
247  inline size_t index() const {
248  return it_->index();
249  }
250  //*******************************************************************************************
251 
252  //**Equality operator************************************************************************
258  inline bool operator==( const ConstIterator& rhs ) const {
259  return it_ == rhs.it_;
260  }
261  //*******************************************************************************************
262 
263  //**Inequality operator**********************************************************************
269  inline bool operator!=( const ConstIterator& rhs ) const {
270  return it_ != rhs.it_;
271  }
272  //*******************************************************************************************
273 
274  //**Subtraction operator*********************************************************************
280  inline DifferenceType operator-( const ConstIterator& rhs ) const {
281  return it_ - rhs.it_;
282  }
283  //*******************************************************************************************
284 
285  private:
286  //**Member variables*************************************************************************
287  LeftOperand vec_;
288  IteratorType it_;
289  //*******************************************************************************************
290  };
291  //**********************************************************************************************
292 
293  //**Constructor*********************************************************************************
299  explicit inline DVecSVecMultExpr( const VT1& lhs, const VT2& rhs )
300  : lhs_( lhs ) // Left-hand side dense vector of the multiplication expression
301  , rhs_( rhs ) // Right-hand side sparse vector of the multiplication expression
302  {
303  BLAZE_INTERNAL_ASSERT( lhs.size() == rhs.size(), "Invalid vector sizes" );
304  }
305  //**********************************************************************************************
306 
307  //**Subscript operator**************************************************************************
313  inline ReturnType operator[]( size_t index ) const {
314  BLAZE_INTERNAL_ASSERT( index < lhs_.size(), "Invalid vector access index" );
315  return lhs_[index] * rhs_[index];
316  }
317  //**********************************************************************************************
318 
319  //**At function*********************************************************************************
326  inline ReturnType at( size_t index ) const {
327  if( index >= lhs_.size() ) {
328  BLAZE_THROW_OUT_OF_RANGE( "Invalid vector access index" );
329  }
330  return (*this)[index];
331  }
332  //**********************************************************************************************
333 
334  //**Begin function******************************************************************************
339  inline ConstIterator begin() const {
340  return ConstIterator( lhs_, rhs_.begin() );
341  }
342  //**********************************************************************************************
343 
344  //**End function********************************************************************************
349  inline ConstIterator end() const {
350  return ConstIterator( lhs_, rhs_.end() );
351  }
352  //**********************************************************************************************
353 
354  //**Size function*******************************************************************************
359  inline size_t size() const {
360  return lhs_.size();
361  }
362  //**********************************************************************************************
363 
364  //**NonZeros function***************************************************************************
369  inline size_t nonZeros() const {
370  return rhs_.nonZeros();
371  }
372  //**********************************************************************************************
373 
374  //**Find function*******************************************************************************
380  inline ConstIterator find( size_t index ) const {
382  return ConstIterator( lhs_, rhs_.find( index ) );
383  }
384  //**********************************************************************************************
385 
386  //**LowerBound function*************************************************************************
392  inline ConstIterator lowerBound( size_t index ) const {
394  return ConstIterator( lhs_, rhs_.lowerBound( index ) );
395  }
396  //**********************************************************************************************
397 
398  //**UpperBound function*************************************************************************
404  inline ConstIterator upperBound( size_t index ) const {
406  return ConstIterator( lhs_, rhs_.upperBound( index ) );
407  }
408  //**********************************************************************************************
409 
410  //**Left operand access*************************************************************************
415  inline LeftOperand leftOperand() const {
416  return lhs_;
417  }
418  //**********************************************************************************************
419 
420  //**Right operand access************************************************************************
425  inline RightOperand rightOperand() const {
426  return rhs_;
427  }
428  //**********************************************************************************************
429 
430  //**********************************************************************************************
436  template< typename T >
437  inline bool canAlias( const T* alias ) const {
438  return ( lhs_.canAlias( alias ) || rhs_.canAlias( alias ) );
439  }
440  //**********************************************************************************************
441 
442  //**********************************************************************************************
448  template< typename T >
449  inline bool isAliased( const T* alias ) const {
450  return ( lhs_.isAliased( alias ) || rhs_.isAliased( alias ) );
451  }
452  //**********************************************************************************************
453 
454  private:
455  //**Member variables****************************************************************************
456  LeftOperand lhs_;
457  RightOperand rhs_;
458  //**********************************************************************************************
459 
460  //**Assignment to dense vectors*****************************************************************
474  template< typename VT > // Type of the target dense vector
475  friend inline typename EnableIf< UseAssign<VT> >::Type
476  assign( DenseVector<VT,TF>& lhs, const DVecSVecMultExpr& rhs )
477  {
479 
480  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
481 
483 
484  CT1 x( serial( rhs.lhs_ ) ); // Evaluation of the left-hand side dense vector operand
485  CT2 y( serial( rhs.rhs_ ) ); // Evaluation of the right-hand side sparse vector operand
486 
487  BLAZE_INTERNAL_ASSERT( x.size() == rhs.lhs_.size(), "Invalid vector size" );
488  BLAZE_INTERNAL_ASSERT( y.size() == rhs.rhs_.size(), "Invalid vector size" );
489  BLAZE_INTERNAL_ASSERT( x.size() == (~lhs).size() , "Invalid vector size" );
490 
491  for( ConstIterator element=y.begin(); element!=y.end(); ++element )
492  (~lhs)[element->index()] = x[element->index()] * element->value();
493  }
495  //**********************************************************************************************
496 
497  //**Assignment to sparse vectors****************************************************************
511  template< typename VT > // Type of the target sparse vector
512  friend inline typename EnableIf< UseAssign<VT> >::Type
513  assign( SparseVector<VT,TF>& lhs, const DVecSVecMultExpr& rhs )
514  {
516 
517  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
518 
520 
521  CT1 x( serial( rhs.lhs_ ) ); // Evaluation of the left-hand side dense vector operand
522  CT2 y( serial( rhs.rhs_ ) ); // Evaluation of the right-hand side sparse vector operand
523 
524  BLAZE_INTERNAL_ASSERT( x.size() == rhs.lhs_.size(), "Invalid vector size" );
525  BLAZE_INTERNAL_ASSERT( y.size() == rhs.rhs_.size(), "Invalid vector size" );
526  BLAZE_INTERNAL_ASSERT( x.size() == (~lhs).size() , "Invalid vector size" );
527 
528  for( ConstIterator element=y.begin(); element!=y.end(); ++element )
529  (~lhs).append( element->index(), x[element->index()] * element->value() );
530  }
532  //**********************************************************************************************
533 
534  //**Addition assignment to dense vectors********************************************************
548  template< typename VT > // Type of the target dense vector
549  friend inline typename EnableIf< UseAssign<VT> >::Type
550  addAssign( DenseVector<VT,TF>& lhs, const DVecSVecMultExpr& rhs )
551  {
553 
554  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
555 
557 
558  CT1 x( serial( rhs.lhs_ ) ); // Evaluation of the left-hand side dense vector operand
559  CT2 y( serial( rhs.rhs_ ) ); // Evaluation of the right-hand side sparse vector operand
560 
561  BLAZE_INTERNAL_ASSERT( x.size() == rhs.lhs_.size(), "Invalid vector size" );
562  BLAZE_INTERNAL_ASSERT( y.size() == rhs.rhs_.size(), "Invalid vector size" );
563  BLAZE_INTERNAL_ASSERT( x.size() == (~lhs).size() , "Invalid vector size" );
564 
565  for( ConstIterator element=y.begin(); element!=y.end(); ++element )
566  (~lhs)[element->index()] += x[element->index()] * element->value();
567  }
569  //**********************************************************************************************
570 
571  //**Addition assignment to sparse vectors*******************************************************
572  // No special implementation for the addition assignment to sparse vectors.
573  //**********************************************************************************************
574 
575  //**Subtraction assignment to dense vectors*****************************************************
589  template< typename VT > // Type of the target dense vector
590  friend inline typename EnableIf< UseAssign<VT> >::Type
591  subAssign( DenseVector<VT,TF>& lhs, const DVecSVecMultExpr& rhs )
592  {
594 
595  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
596 
598 
599  CT1 x( serial( rhs.lhs_ ) ); // Evaluation of the left-hand side dense vector operand
600  CT2 y( serial( rhs.rhs_ ) ); // Evaluation of the right-hand side sparse vector operand
601 
602  BLAZE_INTERNAL_ASSERT( x.size() == rhs.lhs_.size(), "Invalid vector size" );
603  BLAZE_INTERNAL_ASSERT( y.size() == rhs.rhs_.size(), "Invalid vector size" );
604  BLAZE_INTERNAL_ASSERT( x.size() == (~lhs).size() , "Invalid vector size" );
605 
606  for( ConstIterator element=y.begin(); element!=y.end(); ++element )
607  (~lhs)[element->index()] -= x[element->index()] * element->value();
608  }
610  //**********************************************************************************************
611 
612  //**Subtraction assignment to sparse vectors****************************************************
613  // No special implementation for the subtraction assignment to sparse vectors.
614  //**********************************************************************************************
615 
616  //**Multiplication assignment to dense vectors**************************************************
630  template< typename VT > // Type of the target dense vector
631  friend inline typename EnableIf< UseAssign<VT> >::Type
632  multAssign( DenseVector<VT,TF>& lhs, const DVecSVecMultExpr& rhs )
633  {
635 
636  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
637 
639 
640  CT1 x( serial( rhs.lhs_ ) ); // Evaluation of the left-hand side dense vector operand
641  CT2 y( serial( rhs.rhs_ ) ); // Evaluation of the right-hand side sparse vector operand
642 
643  BLAZE_INTERNAL_ASSERT( x.size() == rhs.lhs_.size(), "Invalid vector size" );
644  BLAZE_INTERNAL_ASSERT( y.size() == rhs.rhs_.size(), "Invalid vector size" );
645  BLAZE_INTERNAL_ASSERT( x.size() == (~lhs).size() , "Invalid vector size" );
646 
647  const ConstIterator end( y.end() );
648  ConstIterator begin( y.begin() );
649  size_t i( 0UL );
650 
651  for( ; begin!=end; ++begin ) {
652  const size_t index( begin->index() );
653  for( ; i<index; ++i )
654  reset( (~lhs)[i] );
655  (~lhs)[index] *= x[index] * begin->value();
656  ++i;
657  }
658 
659  for( ; i<(~lhs).size(); ++i )
660  reset( (~lhs)[i] );
661  }
663  //**********************************************************************************************
664 
665  //**Multiplication assignment to sparse vectors*************************************************
666  // No special implementation for the multiplication assignment to sparse vectors.
667  //**********************************************************************************************
668 
669  //**Compile time checks*************************************************************************
677  //**********************************************************************************************
678 };
679 //*************************************************************************************************
680 
681 
682 
683 
684 //=================================================================================================
685 //
686 // GLOBAL BINARY ARITHMETIC OPERATORS
687 //
688 //=================================================================================================
689 
690 //*************************************************************************************************
717 template< typename T1 // Type of the left-hand side dense vector
718  , typename T2 // Type of the right-hand side sparse vector
719  , bool TF > // Transpose flag
720 inline const DVecSVecMultExpr<T1,T2,TF>
722 {
724 
725  if( (~lhs).size() != (~rhs).size() ) {
726  BLAZE_THROW_INVALID_ARGUMENT( "Vector sizes do not match" );
727  }
728 
729  return DVecSVecMultExpr<T1,T2,TF>( ~lhs, ~rhs );
730 }
731 //*************************************************************************************************
732 
733 
734 
735 
736 //=================================================================================================
737 //
738 // SIZE SPECIALIZATIONS
739 //
740 //=================================================================================================
741 
742 //*************************************************************************************************
744 template< typename VT1, typename VT2, bool TF >
745 struct Size< DVecSVecMultExpr<VT1,VT2,TF> >
746  : public Max< Size<VT1>, Size<VT2> >
747 {};
749 //*************************************************************************************************
750 
751 
752 
753 
754 //=================================================================================================
755 //
756 // EXPRESSION TRAIT SPECIALIZATIONS
757 //
758 //=================================================================================================
759 
760 //*************************************************************************************************
762 template< typename VT1, typename VT2, bool TF, bool AF >
763 struct SubvectorExprTrait< DVecSVecMultExpr<VT1,VT2,TF>, AF >
764 {
765  public:
766  //**********************************************************************************************
767  typedef typename MultExprTrait< typename SubvectorExprTrait<const VT1,AF>::Type
768  , typename SubvectorExprTrait<const VT2,AF>::Type >::Type Type;
769  //**********************************************************************************************
770 };
772 //*************************************************************************************************
773 
774 } // namespace blaze
775 
776 #endif
ptrdiff_t DifferenceType
Difference between two iterators.
Definition: DVecSVecMultExpr.h:182
#define BLAZE_THROW_INVALID_ARGUMENT(MESSAGE)
Macro for the emission of a std::invalid_argument exceptionThis macro encapsulates the default way of...
Definition: Exception.h:187
Pointer difference type of the Blaze library.
LeftOperand vec_
Left-hand side dense vector expression.
Definition: DVecSVecMultExpr.h:287
Header file for the Max class template.
VT2::TransposeType TT2
Transpose type of the right-hand side sparse vector expression.
Definition: DVecSVecMultExpr.h:105
ConstIterator(LeftOperand vec, IteratorType it)
Constructor for the ConstIterator class.
Definition: DVecSVecMultExpr.h:195
Compile time check whether the given type is a temporary vector or matrix type.This type trait class ...
Definition: IsTemporary.h:87
const Element operator*() const
Direct access to the sparse vector element at the current iterator position.
Definition: DVecSVecMultExpr.h:217
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:7820
Header file for basic type definitions.
size_t index() const
Access to the current index of the sparse element.
Definition: DVecSVecMultExpr.h:247
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:369
SelectType< IsExpression< VT1 >::value, const VT1, const VT1 & >::Type LeftOperand
Composite type of the left-hand side dense vector expression.
Definition: DVecSVecMultExpr.h:154
Efficient implementation of a compressed matrix.The CompressedMatrix class template is the represent...
Definition: CompressedMatrix.h:207
Element ValueType
Type of the underlying pointers.
Definition: DVecSVecMultExpr.h:179
RightOperand rightOperand() const
Returns the right-hand side sparse vector operand.
Definition: DVecSVecMultExpr.h:425
VT1::CompositeType CT1
Composite type of the left-hand side dense vector expression.
Definition: DVecSVecMultExpr.h:102
void reset(const DiagonalProxy< MT > &proxy)
Resetting the represented element to the default initial values.
Definition: DiagonalProxy.h:507
const This & CompositeType
Data type for composite expression templates.
Definition: CompressedMatrix.h:2588
Type ElementType
Type of the sparse matrix elements.
Definition: CompressedMatrix.h:259
const DMatSerialExpr< MT, SO > serial(const DenseMatrix< MT, SO > &dm)
Forces the serial evaluation of the given dense matrix expression dm.
Definition: DMatSerialExpr.h:721
Expression object for dense vector-sparse vector multiplications.The DVecSVecMultExpr class represent...
Definition: DVecSVecMultExpr.h:92
Header file for the Computation base class.
ValueType value_type
Type of the underlying pointers.
Definition: DVecSVecMultExpr.h:186
Header file for the RequiresEvaluation type trait.
VT1::TransposeType TT1
Transpose type of the left-hand side dense vector expression.
Definition: DVecSVecMultExpr.h:104
IteratorCategory iterator_category
The iterator category.
Definition: DVecSVecMultExpr.h:185
RightOperand rhs_
Right-hand side sparse vector of the multiplication expression.
Definition: DVecSVecMultExpr.h:457
ConstIterator find(size_t index) const
Searches for a specific vector element.
Definition: DVecSVecMultExpr.h:380
Constraint on the data type.
ConstIterator lowerBound(size_t index) const
Returns an iterator to the first index not less then the given index.
Definition: DVecSVecMultExpr.h:392
std::forward_iterator_tag IteratorCategory
The iterator category.
Definition: DVecSVecMultExpr.h:178
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:90
DifferenceType operator-(const ConstIterator &rhs) const
Calculating the number of elements between two expression iterators.
Definition: DVecSVecMultExpr.h:280
const SelectType< returnExpr, ExprReturnType, ElementType >::Type ReturnType
Return type for expression template evaluations.
Definition: DVecSVecMultExpr.h:148
Header file for the ValueIndexPair class.
ConstIterator & operator++()
Pre-increment operator.
Definition: DVecSVecMultExpr.h:206
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 IsTemporary type trait class.
Header file for the multiplication trait.
Namespace of the Blaze C++ math library.
Definition: Blaze.h:57
const Element * ConstIterator
Iterator over constant elements.
Definition: CompressedMatrix.h:2592
#define BLAZE_THROW_OUT_OF_RANGE(MESSAGE)
Macro for the emission of a std::out_of_range exceptionThis macro encapsulates the default way of Bla...
Definition: Exception.h:331
ResultType::ElementType ElementType
Resulting element type.
Definition: DVecSVecMultExpr.h:145
SelectType< useAssign, const ResultType, const DVecSVecMultExpr & >::Type CompositeType
Data type for composite expression templates.
Definition: DVecSVecMultExpr.h:151
Base class for N-dimensional dense vectors.The DenseVector class is a base class for all arbitrarily ...
Definition: DenseVector.h:70
RemoveReference< RightOperand >::Type::ConstIterator IteratorType
Iterator type of the sparse vector expression.
Definition: DVecSVecMultExpr.h:176
#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
ResultType::TransposeType TransposeType
Transpose type for expression template evaluations.
Definition: DVecSVecMultExpr.h:144
Constraint on the data type.
DifferenceType difference_type
Difference between two iterators.
Definition: DVecSVecMultExpr.h:189
SelectType< IsExpression< VT2 >::value, const VT2, const VT2 & >::Type RightOperand
Composite type of the right-hand side sparse vector expression.
Definition: DVecSVecMultExpr.h:157
VT1::ResultType RT1
Result type of the left-hand side dense vector expression.
Definition: DVecSVecMultExpr.h:98
CompressedMatrix< Type, false > TransposeType
Transpose type for expression template evaluations.
Definition: CompressedMatrix.h:2585
Constraint on the data type.
Header file for the VecVecMultExpr base class.
ReturnType at(size_t index) const
Checked access to the vector elements.
Definition: DVecSVecMultExpr.h:326
Constraint on the data type.
Header file for the SelectType class template.
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:237
ReturnType operator[](size_t index) const
Subscript operator for the direct access to the vector elements.
Definition: DVecSVecMultExpr.h:313
Header file for the EnableIf class template.
VT2::ResultType RT2
Result type of the right-hand side sparse vector expression.
Definition: DVecSVecMultExpr.h:99
Header file for the serial shim.
VT1::ReturnType RN1
Return type of the left-hand side dense vector expression.
Definition: DVecSVecMultExpr.h:100
VT2::CompositeType CT2
Composite type of the right-hand side sparse vector expression.
Definition: DVecSVecMultExpr.h:103
ConstIterator upperBound(size_t index) const
Returns an iterator to the first index greater then the given index.
Definition: DVecSVecMultExpr.h:404
bool operator!=(const ConstIterator &rhs) const
Inequality comparison between two ConstIterator objects.
Definition: DVecSVecMultExpr.h:269
const Type & ReturnType
Return type for expression template evaluations.
Definition: CompressedMatrix.h:2587
Removal of reference modifiers.The RemoveCV type trait removes any reference modifiers from the given...
Definition: RemoveReference.h:69
ReferenceType reference
Reference return type.
Definition: DVecSVecMultExpr.h:188
Iterator over the elements of the dense vector-sparse vector multiplication expression.
Definition: DVecSVecMultExpr.h:168
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:339
Base template for the MultTrait class.
Definition: MultTrait.h:138
Substitution Failure Is Not An Error (SFINAE) class.The EnableIf class template is an auxiliary tool ...
Definition: EnableIf.h:184
Header file for the reset shim.
ValueType & ReferenceType
Reference return type.
Definition: DVecSVecMultExpr.h:181
ConstIterator end() const
Returns an iterator just past the last non-zero element of the sparse vector.
Definition: DVecSVecMultExpr.h:349
#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:118
Header file for the RemoveReference type trait.
PointerType pointer
Pointer return type.
Definition: DVecSVecMultExpr.h:187
const ConstIterator * operator->() const
Direct access to the sparse vector element at the current iterator position.
Definition: DVecSVecMultExpr.h:227
VT2::ReturnType RN2
Return type of the right-hand side sparse vector expression.
Definition: DVecSVecMultExpr.h:101
ValueIndexPair< ElementType > Element
Element type of the sparse vector expression.
Definition: DVecSVecMultExpr.h:173
LeftOperand leftOperand() const
Returns the left-hand side dense vector operand.
Definition: DVecSVecMultExpr.h:415
#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:79
bool canAlias(const T *alias) const
Returns whether the expression can alias with the given address alias.
Definition: DVecSVecMultExpr.h:437
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:180
#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:165
LeftOperand lhs_
Left-hand side dense vector of the multiplication expression.
Definition: DVecSVecMultExpr.h:456
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:118
#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
bool isAliased(const T *alias) const
Returns whether the expression is aliased with the given address alias.
Definition: DVecSVecMultExpr.h:449
This ResultType
Result type for expression template evaluations.
Definition: CompressedMatrix.h:2583
Header file for the SubvectorExprTrait class template.
bool operator==(const ConstIterator &rhs) const
Equality comparison between two ConstIterator objects.
Definition: DVecSVecMultExpr.h:258
MultTrait< RT1, RT2 >::Type ResultType
Result type for expression template evaluations.
Definition: DVecSVecMultExpr.h:143
Header file for exception macros.
DVecSVecMultExpr< VT1, VT2, TF > This
Type of this DVecSVecMultExpr instance.
Definition: DVecSVecMultExpr.h:142
IteratorType it_
Iterator over the elements of the right-hand side sparse vector expression.
Definition: DVecSVecMultExpr.h:288
DVecSVecMultExpr(const VT1 &lhs, const VT2 &rhs)
Constructor for the DVecSVecMultExpr class.
Definition: DVecSVecMultExpr.h:299
MultExprTrait< RN1, RN2 >::Type ExprReturnType
Expression return type for the subscript operator.
Definition: DVecSVecMultExpr.h:118
Header file for the Size type trait.
Evaluation of the resulting expression type of a multiplication.Via this type trait it is possible to...
Definition: MultExprTrait.h:137
#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:81
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
Header file for the IsExpression type trait class.
Header file for the FunctionTrace class.
size_t size() const
Returns the current size/dimension of the vector.
Definition: DVecSVecMultExpr.h:359