All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
SVecDVecSubExpr.h
Go to the documentation of this file.
1 //=================================================================================================
33 //=================================================================================================
34 
35 #ifndef _BLAZE_MATH_EXPRESSIONS_SVECDVECSUBEXPR_H_
36 #define _BLAZE_MATH_EXPRESSIONS_SVECDVECSUBEXPR_H_
37 
38 
39 //*************************************************************************************************
40 // Includes
41 //*************************************************************************************************
42 
43 #include <stdexcept>
64 #include <blaze/util/Assert.h>
67 #include <blaze/util/SelectType.h>
68 #include <blaze/util/Types.h>
69 
70 
71 namespace blaze {
72 
73 //=================================================================================================
74 //
75 // CLASS SVECDVECSUBEXPR
76 //
77 //=================================================================================================
78 
79 //*************************************************************************************************
86 template< typename VT1 // Type of the left-hand side sparse vector
87  , typename VT2 // Type of the right-hand side dense vector
88  , bool TF > // Transpose flag
89 class SVecDVecSubExpr : public DenseVector< SVecDVecSubExpr<VT1,VT2,TF>, TF >
90  , private VecVecSubExpr
91  , private Computation
92 {
93  private:
94  //**Type definitions****************************************************************************
95  typedef typename VT1::ResultType RT1;
96  typedef typename VT2::ResultType RT2;
97  typedef typename VT1::ReturnType RN1;
98  typedef typename VT2::ReturnType RN2;
99  typedef typename VT1::CompositeType CT1;
100  typedef typename VT2::CompositeType CT2;
101  typedef typename VT1::TransposeType TT1;
102  typedef typename VT2::TransposeType TT2;
103  //**********************************************************************************************
104 
105  //**Return type evaluation**********************************************************************
107 
112  enum { returnExpr = !IsTemporary<RN1>::value && !IsTemporary<RN2>::value };
113 
116  //**********************************************************************************************
117 
118  public:
119  //**Type definitions****************************************************************************
124 
127 
129  typedef const ResultType CompositeType;
130 
132  typedef typename SelectType< IsExpression<VT1>::value, const VT1, const VT1& >::Type LeftOperand;
133 
135  typedef typename SelectType< IsExpression<VT2>::value, const VT2, const VT2& >::Type RightOperand;
136  //**********************************************************************************************
137 
138  //**Compilation flags***************************************************************************
140  enum { vectorizable = 0 };
141 
143  enum { smpAssignable = 0 };
144  //**********************************************************************************************
145 
146  //**Constructor*********************************************************************************
152  explicit inline SVecDVecSubExpr( const VT1& lhs, const VT2& rhs )
153  : lhs_( lhs ) // Left-hand side sparse vector of the subtraction expression
154  , rhs_( rhs ) // Right-hand side dense vector of the subtraction expression
155  {
156  BLAZE_INTERNAL_ASSERT( lhs.size() == rhs.size(), "Invalid vector sizes" );
157  }
158  //**********************************************************************************************
159 
160  //**Subscript operator**************************************************************************
166  inline ReturnType operator[]( size_t index ) const {
167  BLAZE_INTERNAL_ASSERT( index < lhs_.size(), "Invalid vector access index" );
168  return lhs_[index] - rhs_[index];
169  }
170  //**********************************************************************************************
171 
172  //**Size function*******************************************************************************
177  inline size_t size() const {
178  return lhs_.size();
179  }
180  //**********************************************************************************************
181 
182  //**Left operand access*************************************************************************
187  inline LeftOperand leftOperand() const {
188  return lhs_;
189  }
190  //**********************************************************************************************
191 
192  //**Right operand access************************************************************************
197  inline RightOperand rightOperand() const {
198  return rhs_;
199  }
200  //**********************************************************************************************
201 
202  //**********************************************************************************************
208  template< typename T >
209  inline bool canAlias( const T* alias ) const {
210  return ( lhs_.canAlias( alias ) || rhs_.canAlias( alias ) );
211  }
212  //**********************************************************************************************
213 
214  //**********************************************************************************************
220  template< typename T >
221  inline bool isAliased( const T* alias ) const {
222  return ( lhs_.isAliased( alias ) || rhs_.isAliased( alias ) );
223  }
224  //**********************************************************************************************
225 
226  private:
227  //**Member variables****************************************************************************
230  //**********************************************************************************************
231 
232  //**Assignment to dense vectors*****************************************************************
244  template< typename VT > // Type of the target dense vector
245  friend inline void assign( DenseVector<VT,TF>& lhs, const SVecDVecSubExpr& rhs )
246  {
248 
249  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
250 
251  smpAssign ( ~lhs, -rhs.rhs_ );
252  smpAddAssign( ~lhs, rhs.lhs_ );
253  }
255  //**********************************************************************************************
256 
257  //**Assignment to sparse vectors****************************************************************
269  template< typename VT > // Type of the target sparse vector
270  friend inline void assign( SparseVector<VT,TF>& lhs, const SVecDVecSubExpr& rhs )
271  {
273 
277 
278  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
279 
280  const ResultType tmp( rhs );
281  smpAssign( ~lhs, tmp );
282  }
284  //**********************************************************************************************
285 
286  //**Addition assignment to dense vectors********************************************************
298  template< typename VT > // Type of the target dense vector
299  friend inline void addAssign( DenseVector<VT,TF>& lhs, const SVecDVecSubExpr& rhs )
300  {
302 
303  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
304 
305  smpSubAssign( ~lhs, rhs.rhs_ );
306  smpAddAssign( ~lhs, rhs.lhs_ );
307  }
309  //**********************************************************************************************
310 
311  //**Addition assignment to sparse vectors*******************************************************
312  // No special implementation for the addition assignment to sparse vectors.
313  //**********************************************************************************************
314 
315  //**Subtraction assignment to dense vectors*****************************************************
327  template< typename VT > // Type of the target dense vector
328  friend inline void subAssign( DenseVector<VT,TF>& lhs, const SVecDVecSubExpr& rhs )
329  {
331 
332  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
333 
334  smpAddAssign( ~lhs, rhs.rhs_ );
335  smpSubAssign( ~lhs, rhs.lhs_ );
336  }
338  //**********************************************************************************************
339 
340  //**Subtraction assignment to sparse vectors****************************************************
341  // No special implementation for the subtraction assignment to sparse vectors.
342  //**********************************************************************************************
343 
344  //**Multiplication assignment to dense vectors**************************************************
356  template< typename VT > // Type of the target dense vector
357  friend inline void multAssign( DenseVector<VT,TF>& lhs, const SVecDVecSubExpr& rhs )
358  {
360 
364 
365  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
366 
367  const ResultType tmp( rhs );
368  smpMultAssign( ~lhs, tmp );
369  }
371  //**********************************************************************************************
372 
373  //**Multiplication assignment to sparse vectors*************************************************
374  // No special implementation for the multiplication assignment to sparse vectors.
375  //**********************************************************************************************
376 
377  //**Compile time checks*************************************************************************
384  //**********************************************************************************************
385 };
386 //*************************************************************************************************
387 
388 
389 
390 
391 //=================================================================================================
392 //
393 // GLOBAL BINARY ARITHMETIC OPERATORS
394 //
395 //=================================================================================================
396 
397 //*************************************************************************************************
423 template< typename T1 // Type of the left-hand side sparse vector
424  , typename T2 // Type of the right-hand side dense vector
425  , bool TF > // Transpose flag
426 inline const SVecDVecSubExpr<T1,T2,TF>
428 {
430 
431  if( (~lhs).size() != (~rhs).size() )
432  throw std::invalid_argument( "Vector sizes do not match" );
433 
434  return SVecDVecSubExpr<T1,T2,TF>( ~lhs, ~rhs );
435 }
436 //*************************************************************************************************
437 
438 
439 
440 
441 //=================================================================================================
442 //
443 // GLOBAL RESTRUCTURING BINARY ARITHMETIC OPERATORS
444 //
445 //=================================================================================================
446 
447 //*************************************************************************************************
460 template< typename T1 // Type of the sparse vector of the left-hand side expression
461  , typename T2 // Type of the dense vector of the left-hand side expression
462  , bool TF // Transpose flag of the left-hand side expression
463  , typename T3 > // Type of right-hand side dense vector
464 inline const typename AddExprTrait< SVecDVecSubExpr<T1,T2,TF>, T3 >::Type
465  operator+( const SVecDVecSubExpr<T1,T2,TF>& lhs, const DenseVector<T3,TF>& rhs )
466 {
468 
469  return ( (~rhs) - lhs.rightOperand() ) + lhs.leftOperand();
470 }
472 //*************************************************************************************************
473 
474 
475 //*************************************************************************************************
488 template< typename T1 // Type of the sparse vector of the left-hand side expression
489  , typename T2 // Type of the dense vector of the left-hand side expression
490  , bool TF // Transpose flag of the left-hand side expression
491  , typename T3 > // Type of right-hand side dense vector
492 inline const typename SubExprTrait< SVecDVecSubExpr<T1,T2,TF>, T3 >::Type
493  operator-( const SVecDVecSubExpr<T1,T2,TF>& lhs, const DenseVector<T3,TF>& rhs )
494 {
496 
497  return lhs.leftOperand() - ( lhs.rightOperand() + (~rhs) );
498 }
500 //*************************************************************************************************
501 
502 
503 
504 
505 //=================================================================================================
506 //
507 // EXPRESSION TRAIT SPECIALIZATIONS
508 //
509 //=================================================================================================
510 
511 //*************************************************************************************************
513 template< typename VT1, typename VT2, typename VT3 >
514 struct DVecDVecAddExprTrait< SVecDVecSubExpr<VT1,VT2,false>, VT3 >
515 {
516  public:
517  //**********************************************************************************************
519  typedef typename SelectType< IsSparseVector<VT1>::value && IsColumnVector<VT1>::value &&
520  IsDenseVector<VT2>::value && IsColumnVector<VT2>::value &&
521  IsDenseVector<VT3>::value && IsColumnVector<VT3>::value
522  , typename DVecSVecAddExprTrait< typename DVecDVecSubExprTrait<VT3,VT2>::Type, VT1 >::Type
523  , INVALID_TYPE >::Type Type;
525  //**********************************************************************************************
526 };
528 //*************************************************************************************************
529 
530 
531 //*************************************************************************************************
533 template< typename VT1, typename VT2, typename VT3 >
534 struct TDVecTDVecAddExprTrait< SVecDVecSubExpr<VT1,VT2,true>, VT3 >
535 {
536  public:
537  //**********************************************************************************************
539  typedef typename SelectType< IsSparseVector<VT1>::value && IsRowVector<VT1>::value &&
540  IsDenseVector<VT2>::value && IsRowVector<VT2>::value &&
541  IsDenseVector<VT3>::value && IsRowVector<VT3>::value
542  , typename TDVecTSVecAddExprTrait< typename TDVecTDVecSubExprTrait<VT3,VT2>::Type, VT1 >::Type
543  , INVALID_TYPE >::Type Type;
545  //**********************************************************************************************
546 };
548 //*************************************************************************************************
549 
550 
551 //*************************************************************************************************
553 template< typename VT1, typename VT2, typename VT3 >
554 struct DVecDVecSubExprTrait< SVecDVecSubExpr<VT1,VT2,false>, VT3 >
555 {
556  public:
557  //**********************************************************************************************
559  typedef typename SelectType< IsSparseVector<VT1>::value && IsColumnVector<VT1>::value &&
560  IsDenseVector<VT2>::value && IsColumnVector<VT2>::value &&
561  IsDenseVector<VT3>::value && IsColumnVector<VT3>::value
562  , typename SVecDVecSubExprTrait< VT1, typename DVecDVecAddExprTrait<VT2,VT3>::Type >::Type
563  , INVALID_TYPE >::Type Type;
565  //**********************************************************************************************
566 };
568 //*************************************************************************************************
569 
570 
571 //*************************************************************************************************
573 template< typename VT1, typename VT2, typename VT3 >
574 struct TDVecTDVecSubExprTrait< SVecDVecSubExpr<VT1,VT2,true>, VT3 >
575 {
576  public:
577  //**********************************************************************************************
579  typedef typename SelectType< IsSparseVector<VT1>::value && IsRowVector<VT1>::value &&
580  IsDenseVector<VT2>::value && IsRowVector<VT2>::value &&
581  IsDenseVector<VT3>::value && IsRowVector<VT3>::value
582  , typename TSVecTDVecSubExprTrait< VT1, typename TDVecTDVecAddExprTrait<VT2,VT3>::Type >::Type
583  , INVALID_TYPE >::Type Type;
585  //**********************************************************************************************
586 };
588 //*************************************************************************************************
589 
590 
591 //*************************************************************************************************
593 template< typename VT1, typename VT2, bool TF, bool AF >
594 struct SubvectorExprTrait< SVecDVecSubExpr<VT1,VT2,TF>, AF >
595 {
596  public:
597  //**********************************************************************************************
598  typedef typename SubExprTrait< typename SubvectorExprTrait<const VT1,AF>::Type
599  , typename SubvectorExprTrait<const VT2,AF>::Type >::Type Type;
600  //**********************************************************************************************
601 };
603 //*************************************************************************************************
604 
605 } // namespace blaze
606 
607 #endif
SVecDVecSubExpr(const VT1 &lhs, const VT2 &rhs)
Constructor for the SVecDVecSubExpr class.
Definition: SVecDVecSubExpr.h:152
Expression object for sparse vector-dense vector subtractions.The SVecDVecSubExpr class represents th...
Definition: Forward.h:109
Compile time check whether the given type is a temporary vector or matrix type.This type trait class ...
Definition: IsTemporary.h:87
Header file for the subtraction trait.
bool isAliased(const T *alias) const
Returns whether the expression is aliased with the given address alias.
Definition: SVecDVecSubExpr.h:221
void smpSubAssign(DenseMatrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the SMP subtraction assignment of a matrix to dense matrix.
Definition: DenseMatrix.h:151
const ResultType CompositeType
Data type for composite expression templates.
Definition: SVecDVecSubExpr.h:129
Efficient implementation of a compressed matrix.The CompressedMatrix class template is the represent...
Definition: CompressedMatrix.h:197
void smpMultAssign(DenseVector< 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:178
VT2::ResultType RT2
Result type of the right-hand side dense vector expression.
Definition: SVecDVecSubExpr.h:96
SubExprTrait< RN1, RN2 >::Type ExprReturnType
Expression return type for the subscript operator.
Definition: SVecDVecSubExpr.h:115
const This & CompositeType
Data type for composite expression templates.
Definition: CompressedMatrix.h:2384
Header file for the IsRowVector type trait.
Type ElementType
Type of the sparse matrix elements.
Definition: CompressedMatrix.h:249
Header file for the DenseVector base class.
Header file for the AddExprTrait class template.
Header file for the Computation base class.
SelectType< IsExpression< VT1 >::value, const VT1, const VT1 & >::Type LeftOperand
Composite type of the left-hand side sparse vector expression.
Definition: SVecDVecSubExpr.h:132
ResultType::TransposeType TransposeType
Transpose type for expression template evaluations.
Definition: SVecDVecSubExpr.h:122
Constraint on the data type.
VT1::ResultType RT1
Result type of the left-hand side sparse vector expression.
Definition: SVecDVecSubExpr.h:95
void smpAddAssign(DenseMatrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the SMP addition assignment of a matrix to a dense matrix.
Definition: DenseMatrix.h:121
const This & CompositeType
Data type for composite expression templates.
Definition: CompressedMatrix.h:251
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 dense vector SMP implementation.
void assign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the assignment of a matrix to a matrix.
Definition: Matrix.h:179
SubTrait< RT1, RT2 >::Type ResultType
Result type for expression template evaluations.
Definition: SVecDVecSubExpr.h:121
const DenseIterator< Type > operator+(const DenseIterator< Type > &it, ptrdiff_t inc)
Addition between a DenseIterator and an integral value.
Definition: DenseIterator.h:556
Base class for N-dimensional dense vectors.The DenseVector class is a base class for all arbitrarily ...
Definition: DenseVector.h:70
size_t size() const
Returns the current size/dimension of the vector.
Definition: SVecDVecSubExpr.h:177
RightOperand rightOperand() const
Returns the right-hand side dense vector operand.
Definition: SVecDVecSubExpr.h:197
LeftOperand leftOperand() const
Returns the left-hand side sparse vector operand.
Definition: SVecDVecSubExpr.h:187
const SelectType< returnExpr, ExprReturnType, ElementType >::Type ReturnType
Return type for expression template evaluations.
Definition: SVecDVecSubExpr.h:126
#define BLAZE_CONSTRAINT_MUST_BE_SPARSE_VECTOR_TYPE(T)
Constraint on the data type.In case the given data type T is not a sparse, N-dimensional vector type...
Definition: SparseVector.h:79
Constraint on the data type.
VT2::CompositeType CT2
Composite type of the right-hand side dense vector expression.
Definition: SVecDVecSubExpr.h:100
#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
CompressedMatrix< Type, false > TransposeType
Transpose type for expression template evaluations.
Definition: CompressedMatrix.h:2381
Constraint on the data type.
Evaluation of the return type of a subtraction expression.Via this type trait it is possible to evalu...
Definition: SubExprTrait.h:103
VT1::CompositeType CT1
Composite type of the left-hand side sparse vector expression.
Definition: SVecDVecSubExpr.h:99
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:269
Header file for the VecVecSubExpr base class.
Header file for the SelectType class template.
Header file for all forward declarations for expression class templates.
Constraint on the data type.
LeftOperand lhs_
Left-hand side sparse vector of the subtraction expression.
Definition: SVecDVecSubExpr.h:228
ReturnType operator[](size_t index) const
Subscript operator for the direct access to the vector elements.
Definition: SVecDVecSubExpr.h:166
VT1::ReturnType RN1
Return type of the left-hand side sparse vector expression.
Definition: SVecDVecSubExpr.h:97
VT2::ReturnType RN2
Return type of the right-hand side dense vector expression.
Definition: SVecDVecSubExpr.h:98
void smpAssign(DenseMatrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the SMP assignment of a matrix to a dense matrix.
Definition: DenseMatrix.h:91
Header file for the IsSparseVector type trait.
const Type & ReturnType
Return type for expression template evaluations.
Definition: CompressedMatrix.h:2383
Header file for run time assertion macros.
bool canAlias(const T *alias) const
Returns whether the expression can alias with the given address alias.
Definition: SVecDVecSubExpr.h:209
void addAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the addition assignment of a matrix to a matrix.
Definition: Matrix.h:209
const DenseIterator< Type > operator-(const DenseIterator< Type > &it, ptrdiff_t inc)
Subtraction between a DenseIterator and an integral value.
Definition: DenseIterator.h:585
SVecDVecSubExpr< VT1, VT2, TF > This
Type of this SVecDVecSubExpr instance.
Definition: SVecDVecSubExpr.h:120
void subAssign(Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
Default implementation of the subtraction assignment of a matrix to matrix.
Definition: Matrix.h:239
ResultType::ElementType ElementType
Resulting element type.
Definition: SVecDVecSubExpr.h:123
VT1::TransposeType TT1
Transpose type of the left-hand side sparse vector expression.
Definition: SVecDVecSubExpr.h:101
Header file for the IsDenseVector type trait.
VT2::TransposeType TT2
Transpose type of the right-hand side dense vector expression.
Definition: SVecDVecSubExpr.h:102
#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
Header file for the IsComputation type trait class.
Header file for the sparse vector SMP implementation.
Base class for sparse vectors.The SparseVector class is a base class for all arbitrarily sized (N-dim...
Definition: Forward.h:105
#define BLAZE_FUNCTION_TRACE
Function trace macro.This macro can be used to reliably trace function calls. In case function tracin...
Definition: FunctionTrace.h:157
SelectType< IsExpression< VT2 >::value, const VT2, const VT2 & >::Type RightOperand
Composite type of the right-hand side dense vector expression.
Definition: SVecDVecSubExpr.h:135
This ResultType
Result type for expression template evaluations.
Definition: CompressedMatrix.h:2379
RightOperand rhs_
Right-hand side dense vector of the subtraction expression.
Definition: SVecDVecSubExpr.h:229
Header file for basic type definitions.
Header file for the SubvectorExprTrait class template.
Base template for the SubTrait class.
Definition: SubTrait.h:141
Header file for the IsColumnVector type trait.
Header file for the SubExprTrait class template.
#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
#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.