DVecDVecSubExpr.h
Go to the documentation of this file.
1 //=================================================================================================
33 //=================================================================================================
34 
35 #ifndef _BLAZE_MATH_EXPRESSIONS_DVECDVECSUBEXPR_H_
36 #define _BLAZE_MATH_EXPRESSIONS_DVECDVECSUBEXPR_H_
37 
38 
39 //*************************************************************************************************
40 // Includes
41 //*************************************************************************************************
42 
43 #include <stdexcept>
51 #include <blaze/math/Intrinsics.h>
61 #include <blaze/system/Inline.h>
63 #include <blaze/util/Assert.h>
65 #include <blaze/util/EnableIf.h>
67 #include <blaze/util/mpl/Max.h>
68 #include <blaze/util/SelectType.h>
69 #include <blaze/util/Types.h>
71 
72 
73 namespace blaze {
74 
75 //=================================================================================================
76 //
77 // CLASS DVECDVECSUBEXPR
78 //
79 //=================================================================================================
80 
81 //*************************************************************************************************
88 template< typename VT1 // Type of the left-hand side dense vector
89  , typename VT2 // Type of the right-hand side dense vector
90  , bool TF > // Transpose flag
91 class DVecDVecSubExpr : public DenseVector< DVecDVecSubExpr<VT1,VT2,TF>, TF >
92  , private VecVecSubExpr
93  , private Computation
94 {
95  private:
96  //**Type definitions****************************************************************************
97  typedef typename VT1::ResultType RT1;
98  typedef typename VT2::ResultType RT2;
99  typedef typename VT1::ReturnType RN1;
100  typedef typename VT2::ReturnType RN2;
101  typedef typename VT1::CompositeType CT1;
102  typedef typename VT2::CompositeType CT2;
103  typedef typename VT1::ElementType ET1;
104  typedef typename VT2::ElementType ET2;
105  //**********************************************************************************************
106 
107  //**Return type evaluation**********************************************************************
109 
114  enum { returnExpr = !IsTemporary<RN1>::value && !IsTemporary<RN2>::value };
115 
118  //**********************************************************************************************
119 
120  //**Serial evaluation strategy******************************************************************
122 
128  enum { useAssign = ( RequiresEvaluation<VT1>::value || RequiresEvaluation<VT2>::value || !returnExpr ) };
129 
131  template< typename VT >
133  struct UseAssign {
134  enum { value = useAssign };
135  };
137  //**********************************************************************************************
138 
139  //**Parallel evaluation strategy****************************************************************
141 
147  template< typename VT >
148  struct UseSMPAssign {
149  enum { value = ( !VT1::smpAssignable || !VT2::smpAssignable ) && useAssign };
150  };
152  //**********************************************************************************************
153 
154  public:
155  //**Type definitions****************************************************************************
161 
164 
167 
169  typedef typename SelectType< IsExpression<VT1>::value, const VT1, const VT1& >::Type LeftOperand;
170 
172  typedef typename SelectType< IsExpression<VT2>::value, const VT2, const VT2& >::Type RightOperand;
173  //**********************************************************************************************
174 
175  //**ConstIterator class definition**************************************************************
179  {
180  public:
181  //**Type definitions*************************************************************************
182  typedef std::random_access_iterator_tag IteratorCategory;
183  typedef ElementType ValueType;
184  typedef ElementType* PointerType;
185  typedef ElementType& ReferenceType;
187 
188  // STL iterator requirements
189  typedef IteratorCategory iterator_category;
190  typedef ValueType value_type;
191  typedef PointerType pointer;
192  typedef ReferenceType reference;
193  typedef DifferenceType difference_type;
194 
197 
200  //*******************************************************************************************
201 
202  //**Constructor******************************************************************************
208  explicit inline ConstIterator( LeftIteratorType left, RightIteratorType right )
209  : left_ ( left ) // Iterator to the current left-hand side element
210  , right_( right ) // Iterator to the current right-hand side element
211  {}
212  //*******************************************************************************************
213 
214  //**Addition assignment operator*************************************************************
220  inline ConstIterator& operator+=( size_t inc ) {
221  left_ += inc;
222  right_ += inc;
223  return *this;
224  }
225  //*******************************************************************************************
226 
227  //**Subtraction assignment operator**********************************************************
233  inline ConstIterator& operator-=( size_t dec ) {
234  left_ -= dec;
235  right_ -= dec;
236  return *this;
237  }
238  //*******************************************************************************************
239 
240  //**Prefix increment operator****************************************************************
246  ++left_;
247  ++right_;
248  return *this;
249  }
250  //*******************************************************************************************
251 
252  //**Postfix increment operator***************************************************************
257  inline const ConstIterator operator++( int ) {
258  return ConstIterator( left_++, right_++ );
259  }
260  //*******************************************************************************************
261 
262  //**Prefix decrement operator****************************************************************
268  --left_;
269  --right_;
270  return *this;
271  }
272  //*******************************************************************************************
273 
274  //**Postfix decrement operator***************************************************************
279  inline const ConstIterator operator--( int ) {
280  return ConstIterator( left_--, right_-- );
281  }
282  //*******************************************************************************************
283 
284  //**Element access operator******************************************************************
289  inline ReturnType operator*() const {
290  return (*left_) - (*right_);
291  }
292  //*******************************************************************************************
293 
294  //**Load function****************************************************************************
299  inline IntrinsicType load() const {
300  return left_.load() - right_.load();
301  }
302  //*******************************************************************************************
303 
304  //**Equality operator************************************************************************
310  inline bool operator==( const ConstIterator& rhs ) const {
311  return left_ == rhs.left_;
312  }
313  //*******************************************************************************************
314 
315  //**Inequality operator**********************************************************************
321  inline bool operator!=( const ConstIterator& rhs ) const {
322  return left_ != rhs.left_;
323  }
324  //*******************************************************************************************
325 
326  //**Less-than operator***********************************************************************
332  inline bool operator<( const ConstIterator& rhs ) const {
333  return left_ < rhs.left_;
334  }
335  //*******************************************************************************************
336 
337  //**Greater-than operator********************************************************************
343  inline bool operator>( const ConstIterator& rhs ) const {
344  return left_ > rhs.left_;
345  }
346  //*******************************************************************************************
347 
348  //**Less-or-equal-than operator**************************************************************
354  inline bool operator<=( const ConstIterator& rhs ) const {
355  return left_ <= rhs.left_;
356  }
357  //*******************************************************************************************
358 
359  //**Greater-or-equal-than operator***********************************************************
365  inline bool operator>=( const ConstIterator& rhs ) const {
366  return left_ >= rhs.left_;
367  }
368  //*******************************************************************************************
369 
370  //**Subtraction operator*********************************************************************
376  inline DifferenceType operator-( const ConstIterator& rhs ) const {
377  return left_ - rhs.left_;
378  }
379  //*******************************************************************************************
380 
381  //**Addition operator************************************************************************
388  friend inline const ConstIterator operator+( const ConstIterator& it, size_t inc ) {
389  return ConstIterator( it.left_ + inc, it.right_ + inc );
390  }
391  //*******************************************************************************************
392 
393  //**Addition operator************************************************************************
400  friend inline const ConstIterator operator+( size_t inc, const ConstIterator& it ) {
401  return ConstIterator( it.left_ + inc, it.right_ + inc );
402  }
403  //*******************************************************************************************
404 
405  //**Subtraction operator*********************************************************************
412  friend inline const ConstIterator operator-( const ConstIterator& it, size_t dec ) {
413  return ConstIterator( it.left_ - dec, it.right_ - dec );
414  }
415  //*******************************************************************************************
416 
417  private:
418  //**Member variables*************************************************************************
419  LeftIteratorType left_;
420  RightIteratorType right_;
421  //*******************************************************************************************
422  };
423  //**********************************************************************************************
424 
425  //**Compilation flags***************************************************************************
427  enum { vectorizable = VT1::vectorizable && VT2::vectorizable &&
430 
432  enum { smpAssignable = VT1::smpAssignable && VT2::smpAssignable };
433  //**********************************************************************************************
434 
435  //**Constructor*********************************************************************************
441  explicit inline DVecDVecSubExpr( const VT1& lhs, const VT2& rhs )
442  : lhs_( lhs ) // Left-hand side dense vector of the subtraction expression
443  , rhs_( rhs ) // Right-hand side dense vector of the subtraction expression
444  {
445  BLAZE_INTERNAL_ASSERT( lhs.size() == rhs.size(), "Invalid vector sizes" );
446  }
447  //**********************************************************************************************
448 
449  //**Subscript operator**************************************************************************
455  inline ReturnType operator[]( size_t index ) const {
456  BLAZE_INTERNAL_ASSERT( index < lhs_.size(), "Invalid vector access index" );
457  return lhs_[index] - rhs_[index];
458  }
459  //**********************************************************************************************
460 
461  //**Load function*******************************************************************************
467  BLAZE_ALWAYS_INLINE IntrinsicType load( size_t index ) const {
468  typedef IntrinsicTrait<ElementType> IT;
469  BLAZE_INTERNAL_ASSERT( index < lhs_.size() , "Invalid vector access index" );
470  BLAZE_INTERNAL_ASSERT( index % IT::size == 0UL, "Invalid vector access index" );
471  const IntrinsicType xmm1( lhs_.load( index ) );
472  const IntrinsicType xmm2( rhs_.load( index ) );
473  return xmm1 - xmm2;
474  }
475  //**********************************************************************************************
476 
477  //**Begin function******************************************************************************
482  inline ConstIterator begin() const {
483  return ConstIterator( lhs_.begin(), rhs_.begin() );
484  }
485  //**********************************************************************************************
486 
487  //**End function********************************************************************************
492  inline ConstIterator end() const {
493  return ConstIterator( lhs_.end(), rhs_.end() );
494  }
495  //**********************************************************************************************
496 
497  //**Size function*******************************************************************************
502  inline size_t size() const {
503  return lhs_.size();
504  }
505  //**********************************************************************************************
506 
507  //**Left operand access*************************************************************************
512  inline LeftOperand leftOperand() const {
513  return lhs_;
514  }
515  //**********************************************************************************************
516 
517  //**Right operand access************************************************************************
522  inline RightOperand rightOperand() const {
523  return rhs_;
524  }
525  //**********************************************************************************************
526 
527  //**********************************************************************************************
533  template< typename T >
534  inline bool canAlias( const T* alias ) const {
535  return ( IsExpression<VT1>::value && ( RequiresEvaluation<VT1>::value ? lhs_.isAliased( alias ) : lhs_.canAlias( alias ) ) ) ||
536  ( IsExpression<VT2>::value && ( RequiresEvaluation<VT2>::value ? rhs_.isAliased( alias ) : rhs_.canAlias( alias ) ) );
537  }
538  //**********************************************************************************************
539 
540  //**********************************************************************************************
546  template< typename T >
547  inline bool isAliased( const T* alias ) const {
548  return ( lhs_.isAliased( alias ) || rhs_.isAliased( alias ) );
549  }
550  //**********************************************************************************************
551 
552  //**********************************************************************************************
557  inline bool isAligned() const {
558  return lhs_.isAligned() && rhs_.isAligned();
559  }
560  //**********************************************************************************************
561 
562  //**********************************************************************************************
567  inline bool canSMPAssign() const {
568  return lhs_.canSMPAssign() || rhs_.canSMPAssign() ||
570  }
571  //**********************************************************************************************
572 
573  private:
574  //**Member variables****************************************************************************
575  LeftOperand lhs_;
576  RightOperand rhs_;
577  //**********************************************************************************************
578 
579  //**Assignment to dense vectors*****************************************************************
593  template< typename VT > // Type of the target dense vector
594  friend inline typename EnableIf< UseAssign<VT> >::Type
595  assign( DenseVector<VT,TF>& lhs, const DVecDVecSubExpr& rhs )
596  {
598 
599  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
600 
601  if( !IsComputation<VT1>::value && isSame( ~lhs, rhs.lhs_ ) ) {
602  subAssign( ~lhs, rhs.rhs_ );
603  }
604  else {
605  assign ( ~lhs, rhs.lhs_ );
606  subAssign( ~lhs, rhs.rhs_ );
607  }
608  }
610  //**********************************************************************************************
611 
612  //**Assignment to sparse vectors****************************************************************
626  template< typename VT > // Type of the target sparse vector
627  friend inline typename EnableIf< UseAssign<VT> >::Type
628  assign( SparseVector<VT,TF>& lhs, const DVecDVecSubExpr& rhs )
629  {
631 
635 
636  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
637 
638  const ResultType tmp( serial( rhs ) );
639  assign( ~lhs, tmp );
640  }
642  //**********************************************************************************************
643 
644  //**Addition assignment to dense vectors********************************************************
658  template< typename VT > // Type of the target dense vector
659  friend inline typename EnableIf< UseAssign<VT> >::Type
660  addAssign( DenseVector<VT,TF>& lhs, const DVecDVecSubExpr& rhs )
661  {
663 
664  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
665 
666  addAssign( ~lhs, rhs.lhs_ );
667  subAssign( ~lhs, rhs.rhs_ );
668  }
670  //**********************************************************************************************
671 
672  //**Addition assignment to sparse vectors*******************************************************
673  // No special implementation for the addition assignment to sparse vectors.
674  //**********************************************************************************************
675 
676  //**Subtraction assignment to dense vectors*****************************************************
690  template< typename VT > // Type of the target dense vector
691  friend inline typename EnableIf< UseAssign<VT> >::Type
692  subAssign( DenseVector<VT,TF>& lhs, const DVecDVecSubExpr& rhs )
693  {
695 
696  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
697 
698  subAssign( ~lhs, rhs.lhs_ );
699  addAssign( ~lhs, rhs.rhs_ );
700  }
702  //**********************************************************************************************
703 
704  //**Subtraction assignment to sparse vectors****************************************************
705  // No special implementation for the subtraction assignment to sparse vectors.
706  //**********************************************************************************************
707 
708  //**Multiplication assignment to dense vectors**************************************************
722  template< typename VT > // Type of the target dense vector
723  friend inline typename EnableIf< UseAssign<VT> >::Type
724  multAssign( DenseVector<VT,TF>& lhs, const DVecDVecSubExpr& rhs )
725  {
727 
731 
732  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
733 
734  const ResultType tmp( serial( rhs ) );
735  multAssign( ~lhs, tmp );
736  }
738  //**********************************************************************************************
739 
740  //**Multiplication assignment to sparse vectors*************************************************
741  // No special implementation for the multiplication assignment to sparse vectors.
742  //**********************************************************************************************
743 
744  //**SMP assignment to dense vectors*************************************************************
758  template< typename VT > // Type of the target dense vector
759  friend inline typename EnableIf< UseSMPAssign<VT> >::Type
760  smpAssign( DenseVector<VT,TF>& lhs, const DVecDVecSubExpr& rhs )
761  {
763 
764  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
765 
766  if( !IsComputation<VT1>::value && isSame( ~lhs, rhs.lhs_ ) ) {
767  smpSubAssign( ~lhs, rhs.rhs_ );
768  }
769  else {
770  smpAssign ( ~lhs, rhs.lhs_ );
771  smpSubAssign( ~lhs, rhs.rhs_ );
772  }
773  }
775  //**********************************************************************************************
776 
777  //**SMP assignment to sparse vectors************************************************************
791  template< typename VT > // Type of the target sparse vector
792  friend inline typename EnableIf< UseSMPAssign<VT> >::Type
793  smpAssign( SparseVector<VT,TF>& lhs, const DVecDVecSubExpr& rhs )
794  {
796 
800 
801  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
802 
803  const ResultType tmp( rhs );
804  smpAssign( ~lhs, tmp );
805  }
807  //**********************************************************************************************
808 
809  //**SMP addition assignment to dense vectors****************************************************
823  template< typename VT > // Type of the target dense vector
824  friend inline typename EnableIf< UseSMPAssign<VT> >::Type
825  smpAddAssign( DenseVector<VT,TF>& lhs, const DVecDVecSubExpr& rhs )
826  {
828 
829  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
830 
831  smpAddAssign( ~lhs, rhs.lhs_ );
832  smpSubAssign( ~lhs, rhs.rhs_ );
833  }
835  //**********************************************************************************************
836 
837  //**SMP addition assignment to sparse vectors***************************************************
838  // No special implementation for the SMP addition assignment to sparse vectors.
839  //**********************************************************************************************
840 
841  //**SMP subtraction assignment to dense vectors*************************************************
855  template< typename VT > // Type of the target dense vector
856  friend inline typename EnableIf< UseSMPAssign<VT> >::Type
857  smpSubAssign( DenseVector<VT,TF>& lhs, const DVecDVecSubExpr& rhs )
858  {
860 
861  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
862 
863  smpSubAssign( ~lhs, rhs.lhs_ );
864  smpAddAssign( ~lhs, rhs.rhs_ );
865  }
867  //**********************************************************************************************
868 
869  //**SMP subtraction assignment to sparse vectors************************************************
870  // No special implementation for the SMP subtraction assignment to sparse vectors.
871  //**********************************************************************************************
872 
873  //**SMP multiplication assignment to dense vectors**********************************************
887  template< typename VT > // Type of the target dense vector
888  friend inline typename EnableIf< UseSMPAssign<VT> >::Type
889  smpMultAssign( DenseVector<VT,TF>& lhs, const DVecDVecSubExpr& rhs )
890  {
892 
896 
897  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
898 
899  const ResultType tmp( rhs );
900  smpMultAssign( ~lhs, tmp );
901  }
903  //**********************************************************************************************
904 
905  //**SMP multiplication assignment to sparse vectors*********************************************
906  // No special implementation for the SMP multiplication assignment to sparse vectors.
907  //**********************************************************************************************
908 
909  //**Compile time checks*************************************************************************
917  //**********************************************************************************************
918 };
919 //*************************************************************************************************
920 
921 
922 
923 
924 //=================================================================================================
925 //
926 // GLOBAL BINARY ARITHMETIC OPERATORS
927 //
928 //=================================================================================================
929 
930 //*************************************************************************************************
954 template< typename T1 // Type of the left-hand side dense vector
955  , typename T2 // Type of the right-hand side dense vector
956  , bool TF > // Transpose flag
957 inline const DVecDVecSubExpr<T1,T2,TF>
959 {
961 
962  if( (~lhs).size() != (~rhs).size() )
963  throw std::invalid_argument( "Vector sizes do not match" );
964 
965  return DVecDVecSubExpr<T1,T2,TF>( ~lhs, ~rhs );
966 }
967 //*************************************************************************************************
968 
969 
970 
971 
972 //=================================================================================================
973 //
974 // SIZE SPECIALIZATIONS
975 //
976 //=================================================================================================
977 
978 //*************************************************************************************************
980 template< typename VT1, typename VT2, bool TF >
981 struct Size< DVecDVecSubExpr<VT1,VT2,TF> >
982  : public Max< Size<VT1>, Size<VT2> >::Type
983 {};
985 //*************************************************************************************************
986 
987 
988 
989 
990 //=================================================================================================
991 //
992 // EXPRESSION TRAIT SPECIALIZATIONS
993 //
994 //=================================================================================================
995 
996 //*************************************************************************************************
998 template< typename VT1, typename VT2, bool TF, bool AF >
999 struct SubvectorExprTrait< DVecDVecSubExpr<VT1,VT2,TF>, AF >
1000 {
1001  public:
1002  //**********************************************************************************************
1003  typedef typename SubExprTrait< typename SubvectorExprTrait<const VT1,AF>::Type
1004  , typename SubvectorExprTrait<const VT2,AF>::Type >::Type Type;
1005  //**********************************************************************************************
1006 };
1008 //*************************************************************************************************
1009 
1010 } // namespace blaze
1011 
1012 #endif
ptrdiff_t DifferenceType
Difference between two iterators.
Definition: DVecDVecSubExpr.h:186
RightIteratorType right_
Iterator to the current right-hand side element.
Definition: DVecDVecSubExpr.h:420
PointerType pointer
Pointer return type.
Definition: DVecDVecSubExpr.h:191
Pointer difference type of the Blaze library.
Header file for the Max class template.
Compile time check whether the given type is a computational expression template.This type trait clas...
Definition: IsComputation.h:89
BLAZE_ALWAYS_INLINE void multAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the multiplication assignment of a matrix to a matrix.
Definition: Matrix.h:879
Compile time check whether the given type is a temporary vector or matrix type.This type trait class ...
Definition: IsTemporary.h:87
ValueType value_type
Type of the underlying elements.
Definition: DVecDVecSubExpr.h:190
Header file for the subtraction trait.
Header file for basic type definitions.
BLAZE_ALWAYS_INLINE IntrinsicType load(size_t index) const
Access to the intrinsic elements of the vector.
Definition: DVecDVecSubExpr.h:467
ReferenceType reference
Reference return type.
Definition: DVecDVecSubExpr.h:192
BLAZE_ALWAYS_INLINE size_t size(const Vector< VT, TF > &vector)
Returns the current size/dimension of the vector.
Definition: Vector.h:264
SelectType< IsExpression< VT2 >::value, const VT2, const VT2 & >::Type RightOperand
Composite type of the right-hand side dense vector expression.
Definition: DVecDVecSubExpr.h:172
const ConstIterator operator++(int)
Post-increment operator.
Definition: DVecDVecSubExpr.h:257
ReturnType operator[](size_t index) const
Subscript operator for the direct access to the vector elements.
Definition: DVecDVecSubExpr.h:455
Efficient implementation of a compressed matrix.The CompressedMatrix class template is the represent...
Definition: CompressedMatrix.h:209
SelectType< IsExpression< VT1 >::value, const VT1, const VT1 & >::Type LeftOperand
Composite type of the left-hand side dense vector expression.
Definition: DVecDVecSubExpr.h:169
BLAZE_ALWAYS_INLINE bool isSame(const Matrix< MT1, SO1 > &a, const Matrix< MT2, SO2 > &b)
Returns whether the two given matrices represent the same observable state.
Definition: Matrix.h:946
Header file for the IsSame and IsStrictlySame type traits.
DVecDVecSubExpr(const VT1 &lhs, const VT2 &rhs)
Constructor for the DVecDVecSubExpr class.
Definition: DVecDVecSubExpr.h:441
VT1::ReturnType RN1
Return type of the left-hand side dense vector expression.
Definition: DVecDVecSubExpr.h:99
friend const ConstIterator operator+(const ConstIterator &it, size_t inc)
Addition between a ConstIterator and an integral value.
Definition: DVecDVecSubExpr.h:388
const This & CompositeType
Data type for composite expression templates.
Definition: CompressedMatrix.h:2507
Type ElementType
Type of the sparse matrix elements.
Definition: CompressedMatrix.h:261
VT2::ReturnType RN2
Return type of the right-hand side dense vector expression.
Definition: DVecDVecSubExpr.h:100
Header file for the DenseVector base class.
VT1::ElementType ET1
Element type of the left-hand side dense vector expression.
Definition: DVecDVecSubExpr.h:103
const DMatSerialExpr< MT, SO > serial(const DenseMatrix< MT, SO > &dm)
Forces the serial evaluation of the given dense matrix expression dm.
Definition: DMatSerialExpr.h:699
Header file for the Computation base class.
Type relationship analysis.This class tests if the two data types A and B are equal. For this type comparison, the cv-qualifiers of both data types are ignored. If A and B are the same data type (ignoring the cv-qualifiers), then the value member enumeration is set to 1, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to 0, Type is FalseType, and the class derives from FalseType.
Definition: IsSame.h:158
bool isAligned() const
Returns whether the operands of the expression are properly aligned in memory.
Definition: DVecDVecSubExpr.h:557
Header file for the RequiresEvaluation type trait.
ConstIterator & operator-=(size_t dec)
Subtraction assignment operator.
Definition: DVecDVecSubExpr.h:233
DVecDVecSubExpr< VT1, VT2, TF > This
Type of this DVecDVecSubExpr instance.
Definition: DVecDVecSubExpr.h:156
ElementType * PointerType
Pointer return type.
Definition: DVecDVecSubExpr.h:184
Constraint on the data type.
friend const ConstIterator operator-(const ConstIterator &it, size_t dec)
Subtraction between a ConstIterator and an integral value.
Definition: DVecDVecSubExpr.h:412
Compile time check to query the requirement to evaluate an expression.Via this type trait it is possi...
Definition: RequiresEvaluation.h:90
ConstIterator & operator+=(size_t inc)
Addition assignment operator.
Definition: DVecDVecSubExpr.h:220
const This & CompositeType
Data type for composite expression templates.
Definition: CompressedMatrix.h:263
IntrinsicTrait< ElementType >::Type IntrinsicType
Resulting intrinsic element type.
Definition: DVecDVecSubExpr.h:160
ReturnType operator*() const
Direct access to the element at the current iterator position.
Definition: DVecDVecSubExpr.h:289
bool operator<=(const ConstIterator &rhs) const
Less-than comparison between two ConstIterator objects.
Definition: DVecDVecSubExpr.h:354
Compile time type selection.The SelectType class template selects one of the two given types T1 and T...
Definition: SelectType.h:59
bool operator>=(const ConstIterator &rhs) const
Greater-than comparison between two ConstIterator objects.
Definition: DVecDVecSubExpr.h:365
Header file for the IsTemporary type trait class.
IteratorCategory iterator_category
The iterator category.
Definition: DVecDVecSubExpr.h:189
DifferenceType operator-(const ConstIterator &rhs) const
Calculating the number of elements between two iterators.
Definition: DVecDVecSubExpr.h:376
Namespace of the Blaze C++ math library.
Definition: Blaze.h:57
#define BLAZE_ALWAYS_INLINE
Platform dependent setup of an enforced inline keyword.
Definition: Inline.h:85
VT1::CompositeType CT1
Composite type of the left-hand side dense vector expression.
Definition: DVecDVecSubExpr.h:101
ConstIterator & operator--()
Pre-decrement operator.
Definition: DVecDVecSubExpr.h:267
const Element * ConstIterator
Iterator over constant elements.
Definition: CompressedMatrix.h:2511
std::random_access_iterator_tag IteratorCategory
The iterator category.
Definition: DVecDVecSubExpr.h:182
Iterator over the elements of the dense vector.
Definition: DVecDVecSubExpr.h:178
ResultType::ElementType ElementType
Resulting element type.
Definition: DVecDVecSubExpr.h:159
BLAZE_ALWAYS_INLINE 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:635
bool operator!=(const ConstIterator &rhs) const
Inequality comparison between two ConstIterator objects.
Definition: DVecDVecSubExpr.h:321
DifferenceType difference_type
Difference between two iterators.
Definition: DVecDVecSubExpr.h:193
Base class for N-dimensional dense vectors.The DenseVector class is a base class for all arbitrarily ...
Definition: DenseVector.h:70
const size_t SMP_DVECDVECSUB_THRESHOLD
SMP dense vector/dense vector subtraction threshold.This threshold specifies when a dense vector/dens...
Definition: Thresholds.h:253
SelectType< useAssign, const ResultType, const DVecDVecSubExpr & >::Type CompositeType
Data type for composite expression templates.
Definition: DVecDVecSubExpr.h:166
Constraint on the data type.
ResultType::TransposeType TransposeType
Transpose type for expression template evaluations.
Definition: DVecDVecSubExpr.h:158
#define BLAZE_CONSTRAINT_MUST_BE_REFERENCE_TYPE(T)
Constraint on the data type.In case the given data type T is not a reference type, a compilation error is created.
Definition: Reference.h:78
Constraint on the data type.
VT2::ElementType ET2
Element type of the right-hand side dense vector expression.
Definition: DVecDVecSubExpr.h:104
Evaluation of the return type of a subtraction expression.Via this type trait it is possible to evalu...
Definition: SubExprTrait.h:104
LeftIteratorType left_
Iterator to the current left-hand side element.
Definition: DVecDVecSubExpr.h:419
Type ElementType
Type of the sparse matrix elements.
Definition: CompressedMatrix.h:2505
friend const ConstIterator operator+(size_t inc, const ConstIterator &it)
Addition between an integral value and a ConstIterator.
Definition: DVecDVecSubExpr.h:400
Header file for the VecVecSubExpr base class.
Header file for the SelectType class template.
ConstIterator end() const
Returns an iterator just past the last non-zero element of the dense vector.
Definition: DVecDVecSubExpr.h:492
Header file for all forward declarations for expression class templates.
ConstIterator begin() const
Returns an iterator to the first non-zero element of the dense vector.
Definition: DVecDVecSubExpr.h:482
ElementType ValueType
Type of the underlying elements.
Definition: DVecDVecSubExpr.h:183
Header file for the EnableIf class template.
Header file for the serial shim.
bool canSMPAssign() const
Returns whether the expression can be used in SMP assignments.
Definition: DVecDVecSubExpr.h:567
ConstIterator(LeftIteratorType left, RightIteratorType right)
Constructor for the ConstIterator class.
Definition: DVecDVecSubExpr.h:208
bool operator<(const ConstIterator &rhs) const
Less-than comparison between two ConstIterator objects.
Definition: DVecDVecSubExpr.h:332
VT1::ConstIterator LeftIteratorType
ConstIterator type of the left-hand side dense vector expression.
Definition: DVecDVecSubExpr.h:196
EnableIf< IsDenseMatrix< MT1 > >::Type smpSubAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the SMP subtraction assignment of a matrix to dense matrix.
Definition: DenseMatrix.h:160
const Type & ReturnType
Return type for expression template evaluations.
Definition: CompressedMatrix.h:2506
Intrinsic characteristics of data types.The IntrinsicTrait class template provides the intrinsic char...
Definition: IntrinsicTrait.h:749
Header file for run time assertion macros.
EnableIf< IsDenseMatrix< MT1 > >::Type smpAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the SMP assignment of a matrix to a dense matrix.
Definition: DenseMatrix.h:98
BLAZE_ALWAYS_INLINE 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:742
const SelectType< returnExpr, ExprReturnType, ElementType >::Type ReturnType
Return type for expression template evaluations.
Definition: DVecDVecSubExpr.h:163
const DenseIterator< Type > operator-(const DenseIterator< Type > &it, ptrdiff_t inc)
Subtraction between a DenseIterator and an integral value.
Definition: DenseIterator.h:585
Substitution Failure Is Not An Error (SFINAE) class.The EnableIf class template is an auxiliary tool ...
Definition: EnableIf.h:184
ElementType & ReferenceType
Reference return type.
Definition: DVecDVecSubExpr.h:185
bool isAliased(const T *alias) const
Returns whether the expression is aliased with the given address alias.
Definition: DVecDVecSubExpr.h:547
ConstIterator & operator++()
Pre-increment operator.
Definition: DVecDVecSubExpr.h:245
SubTrait< RT1, RT2 >::Type ResultType
Result type for expression template evaluations.
Definition: DVecDVecSubExpr.h:157
VT2::ConstIterator RightIteratorType
ConstIterator type of the right-hand side dense vector expression.
Definition: DVecDVecSubExpr.h:199
bool operator==(const ConstIterator &rhs) const
Equality comparison between two ConstIterator objects.
Definition: DVecDVecSubExpr.h:310
IntrinsicType load() const
Access to the intrinsic elements of the vector.
Definition: DVecDVecSubExpr.h:299
RightOperand rhs_
Right-hand side dense vector of the subtraction expression.
Definition: DVecDVecSubExpr.h:576
SubExprTrait< RN1, RN2 >::Type ExprReturnType
Expression return type for the subscript operator.
Definition: DVecDVecSubExpr.h:117
Header file for all intrinsic functionality.
Constraint on the data type.
#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
VT2::CompositeType CT2
Composite type of the right-hand side dense vector expression.
Definition: DVecDVecSubExpr.h:102
bool canAlias(const T *alias) const
Returns whether the expression can alias with the given address alias.
Definition: DVecDVecSubExpr.h:534
#define BLAZE_CONSTRAINT_MUST_FORM_VALID_VECVECSUBEXPR(T1, T2)
Constraint on the data type.In case the given data types T1 and T2 do not form a valid vector/vector ...
Definition: VecVecSubExpr.h:165
Header file for the IsComputation type trait class.
Base class for all compute expression templates.The Computation class serves as a tag for all computa...
Definition: Computation.h:59
EnableIf< IsDenseMatrix< MT1 > >::Type smpAddAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the SMP addition assignment of a matrix to a dense matrix.
Definition: DenseMatrix.h:129
LeftOperand leftOperand() const
Returns the left-hand side dense vector operand.
Definition: DVecDVecSubExpr.h:512
Base class for sparse vectors.The SparseVector class is a base class for all arbitrarily sized (N-dim...
Definition: Forward.h:108
#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:2502
VT2::ResultType RT2
Result type of the right-hand side dense vector expression.
Definition: DVecDVecSubExpr.h:98
Header file for the SubvectorExprTrait class template.
Base template for the SubTrait class.
Definition: SubTrait.h:150
VT1::ResultType RT1
Result type of the left-hand side dense vector expression.
Definition: DVecDVecSubExpr.h:97
RightOperand rightOperand() const
Returns the right-hand side dense vector operand.
Definition: DVecDVecSubExpr.h:522
Base class for all vector/vector subtraction expression templates.The VecVecSubExpr class serves as a...
Definition: VecVecSubExpr.h:65
LeftOperand lhs_
Left-hand side dense vector of the subtraction expression.
Definition: DVecDVecSubExpr.h:575
const ConstIterator operator--(int)
Post-decrement operator.
Definition: DVecDVecSubExpr.h:279
Header file for the SubExprTrait class template.
size_t size() const
Returns the current size/dimension of the vector.
Definition: DVecDVecSubExpr.h:502
Expression object for dense vector-dense vector subtractions.The DVecDVecSubExpr class represents the...
Definition: DVecDVecSubExpr.h:91
System settings for the inline keywords.
EnableIf< IsDenseVector< VT1 > >::Type smpMultAssign(Vector< VT1, TF1 > &lhs, const Vector< VT2, TF2 > &rhs)
Default implementation of the SMP multiplication assignment of a vector to a dense vector...
Definition: DenseVector.h:189
Header file for the Size type trait.
#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:238
Header file for the thresholds for matrix/vector and matrix/matrix multiplications.
bool operator>(const ConstIterator &rhs) const
Greater-than comparison between two ConstIterator objects.
Definition: DVecDVecSubExpr.h:343
#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
Compile time check whether the given type is an expression template.This type trait class tests wheth...
Definition: IsExpression.h:87
Header file for the IsExpression type trait class.
Header file for the FunctionTrace class.
BLAZE_ALWAYS_INLINE 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:849