All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
DVecEvalExpr.h
Go to the documentation of this file.
1 //=================================================================================================
33 //=================================================================================================
34 
35 #ifndef _BLAZE_MATH_EXPRESSIONS_DVECEVALEXPR_H_
36 #define _BLAZE_MATH_EXPRESSIONS_DVECEVALEXPR_H_
37 
38 
39 //*************************************************************************************************
40 // Includes
41 //*************************************************************************************************
42 
43 #include <cmath>
58 #include <blaze/util/Assert.h>
60 #include <blaze/util/EnableIf.h>
61 #include <blaze/util/InvalidType.h>
63 #include <blaze/util/SelectType.h>
64 #include <blaze/util/Types.h>
65 
66 
67 namespace blaze {
68 
69 //=================================================================================================
70 //
71 // CLASS DVECEVALEXPR
72 //
73 //=================================================================================================
74 
75 //*************************************************************************************************
82 template< typename VT // Type of the dense vector
83  , bool TF > // Transpose flag
84 class DVecEvalExpr : public DenseVector< DVecEvalExpr<VT,TF>, TF >
85  , private VecEvalExpr
86  , private Computation
87 {
88  public:
89  //**Type definitions****************************************************************************
91  typedef typename VT::ResultType ResultType;
92  typedef typename VT::TransposeType TransposeType;
93  typedef typename VT::ElementType ElementType;
94  typedef typename VT::ReturnType ReturnType;
95 
97  typedef const ResultType CompositeType;
98 
100  typedef typename SelectType< IsExpression<VT>::value, const VT, const VT& >::Type Operand;
101  //**********************************************************************************************
102 
103  //**Compilation flags***************************************************************************
105  enum { vectorizable = 0 };
106 
108  enum { smpAssignable = VT::smpAssignable };
109  //**********************************************************************************************
110 
111  //**Constructor*********************************************************************************
116  explicit inline DVecEvalExpr( const VT& dv )
117  : dv_( dv ) // Dense vector of the evaluation expression
118  {}
119  //**********************************************************************************************
120 
121  //**Subscript operator**************************************************************************
127  inline ReturnType operator[]( size_t index ) const {
128  BLAZE_INTERNAL_ASSERT( index < dv_.size(), "Invalid vector access index" );
129  return dv_[index];
130  }
131  //**********************************************************************************************
132 
133  //**Size function*******************************************************************************
138  inline size_t size() const {
139  return dv_.size();
140  }
141  //**********************************************************************************************
142 
143  //**Operand access******************************************************************************
148  inline Operand operand() const {
149  return dv_;
150  }
151  //**********************************************************************************************
152 
153  //**********************************************************************************************
159  template< typename T >
160  inline bool canAlias( const T* alias ) const {
161  return dv_.canAlias( alias );
162  }
163  //**********************************************************************************************
164 
165  //**********************************************************************************************
171  template< typename T >
172  inline bool isAliased( const T* alias ) const {
173  return dv_.isAliased( alias );
174  }
175  //**********************************************************************************************
176 
177  private:
178  //**Member variables****************************************************************************
180  //**********************************************************************************************
181 
182  //**Assignment to dense vectors*****************************************************************
194  template< typename VT2 > // Type of the target dense vector
195  friend inline void assign( DenseVector<VT2,TF>& lhs, const DVecEvalExpr& rhs )
196  {
198 
199  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
200 
201  assign( ~lhs, rhs.dv_ );
202  }
204  //**********************************************************************************************
205 
206  //**Assignment to sparse vectors****************************************************************
218  template< typename VT2 > // Type of the target sparse vector
219  friend inline void assign( SparseVector<VT2,TF>& lhs, const DVecEvalExpr& rhs )
220  {
222 
223  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
224 
225  assign( ~lhs, rhs.dv_ );
226  }
228  //**********************************************************************************************
229 
230  //**Addition assignment to dense vectors********************************************************
242  template< typename VT2 > // Type of the target dense vector
243  friend inline void addAssign( DenseVector<VT2,TF>& lhs, const DVecEvalExpr& rhs )
244  {
246 
247  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
248 
249  addAssign( ~lhs, rhs.dv_ );
250  }
252  //**********************************************************************************************
253 
254  //**Addition assignment to sparse vectors*******************************************************
266  template< typename VT2 > // Type of the target sparse vector
267  friend inline void addAssign( SparseVector<VT2,TF>& lhs, const DVecEvalExpr& rhs )
268  {
270 
271  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
272 
273  addAssign( ~lhs, rhs.dv_ );
274  }
276  //**********************************************************************************************
277 
278  //**Subtraction assignment to dense vectors*****************************************************
290  template< typename VT2 > // Type of the target dense vector
291  friend inline void subAssign( DenseVector<VT2,TF>& lhs, const DVecEvalExpr& rhs )
292  {
294 
295  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
296 
297  subAssign( ~lhs, rhs.dv_ );
298  }
300  //**********************************************************************************************
301 
302  //**Subtraction assignment to sparse vectors****************************************************
314  template< typename VT2 > // Type of the target sparse vector
315  friend inline void subAssign( SparseVector<VT2,TF>& lhs, const DVecEvalExpr& rhs )
316  {
318 
319  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
320 
321  subAssign( ~lhs, rhs.dv_ );
322  }
324  //**********************************************************************************************
325 
326  //**Multiplication assignment to dense vectors**************************************************
338  template< typename VT2 > // Type of the target dense vector
339  friend inline void multAssign( DenseVector<VT2,TF>& lhs, const DVecEvalExpr& rhs )
340  {
342 
343  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
344 
345  multAssign( ~lhs, rhs.dv_ );
346  }
348  //**********************************************************************************************
349 
350  //**Multiplication assignment to sparse vectors*************************************************
362  template< typename VT2 > // Type of the target sparse vector
363  friend inline void multAssign( SparseVector<VT2,TF>& lhs, const DVecEvalExpr& rhs )
364  {
366 
367  BLAZE_INTERNAL_ASSERT( (~lhs).size() == rhs.size(), "Invalid vector sizes" );
368 
369  multAssign( ~lhs, rhs.dv_ );
370  }
372  //**********************************************************************************************
373 
374  //**Compile time checks*************************************************************************
379  //**********************************************************************************************
380 };
381 //*************************************************************************************************
382 
383 
384 
385 
386 //=================================================================================================
387 //
388 // GLOBAL FUNCTIONS
389 //
390 //=================================================================================================
391 
392 //*************************************************************************************************
409 template< typename VT // Type of the dense vector
410  , bool TF > // Transpose flag
411 inline const DVecEvalExpr<VT,TF> eval( const DenseVector<VT,TF>& dv )
412 {
414 
415  return DVecEvalExpr<VT,TF>( ~dv );
416 }
417 //*************************************************************************************************
418 
419 
420 
421 
422 //=================================================================================================
423 //
424 // GLOBAL RESTRUCTURING FUNCTIONS
425 //
426 //=================================================================================================
427 
428 //*************************************************************************************************
439 template< typename VT // Type of the dense vector
440  , bool TF > // Transpose flag
441 inline const DVecEvalExpr<VT,TF> eval( const DVecEvalExpr<VT,TF>& dv )
442 {
443  return dv;
444 }
446 //*************************************************************************************************
447 
448 
449 
450 
451 //=================================================================================================
452 //
453 // EXPRESSION TRAIT SPECIALIZATIONS
454 //
455 //=================================================================================================
456 
457 //*************************************************************************************************
459 template< typename VT >
460 struct DVecEvalExprTrait< DVecEvalExpr<VT,false> >
461 {
462  public:
463  //**********************************************************************************************
464  typedef typename SelectType< IsDenseVector<VT>::value && IsColumnVector<VT>::value
465  , DVecEvalExpr<VT,false>
466  , INVALID_TYPE >::Type Type;
467  //**********************************************************************************************
468 };
470 //*************************************************************************************************
471 
472 
473 //*************************************************************************************************
475 template< typename VT >
476 struct TDVecEvalExprTrait< DVecEvalExpr<VT,true> >
477 {
478  public:
479  //**********************************************************************************************
480  typedef typename SelectType< IsDenseVector<VT>::value && IsRowVector<VT>::value
481  , DVecEvalExpr<VT,true>
482  , INVALID_TYPE >::Type Type;
483  //**********************************************************************************************
484 };
486 //*************************************************************************************************
487 
488 
489 //*************************************************************************************************
491 template< typename VT, bool TF >
492 struct SubvectorExprTrait< DVecEvalExpr<VT,TF> >
493 {
494  public:
495  //**********************************************************************************************
496  typedef typename EvalExprTrait< typename SubvectorExprTrait<const VT>::Type >::Type Type;
497  //**********************************************************************************************
498 };
500 //*************************************************************************************************
501 
502 } // namespace blaze
503 
504 #endif
const ResultType CompositeType
Data type for composite expression templates.
Definition: DVecEvalExpr.h:97
Operand operand() const
Returns the dense vector operand.
Definition: DVecEvalExpr.h:148
VT::ElementType ElementType
Resulting element type.
Definition: DVecEvalExpr.h:93
Base class for all vector evaluation expression templates.The VecEvalExpr class serves as a tag for a...
Definition: VecEvalExpr.h:65
SelectType< IsExpression< VT >::value, const VT, const VT & >::Type Operand
Composite data type of the dense vector expression.
Definition: DVecEvalExpr.h:100
Header file for the IsRowVector type trait.
Header file for the DenseVector base class.
Header file for the Computation base class.
Header file for the VecEvalExpr base class.
Constraint on the data type.
Operand dv_
Dense vector of the evaluation expression.
Definition: DVecEvalExpr.h:179
Expression object for the forced evaluation of dense vectors.The DVecEvalExpr class represents the co...
Definition: DVecEvalExpr.h:84
Compile time type selection.The SelectType class template selects one of the two given types T1 and T...
Definition: SelectType.h:59
ReturnType operator[](size_t index) const
Subscript operator for the direct access to the vector elements.
Definition: DVecEvalExpr.h:127
size_t size() const
Returns the current size/dimension of the vector.
Definition: DVecEvalExpr.h:138
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
Header file for the TDVecEvalExprTrait class template.
Base class for N-dimensional dense vectors.The DenseVector class is a base class for all arbitrarily ...
Definition: DenseVector.h:70
Constraint on the data type.
CompressedMatrix< Type, false > TransposeType
Transpose type for expression template evaluations.
Definition: CompressedMatrix.h:2372
Constraint on the data type.
Type ElementType
Type of the sparse matrix elements.
Definition: CompressedMatrix.h:2373
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 SelectType class template.
Header file for all forward declarations for expression class templates.
Header file for the EnableIf class template.
bool isAliased(const T *alias) const
Returns whether the expression is aliased with the given address alias.
Definition: DVecEvalExpr.h:172
const Type & ReturnType
Return type for expression template evaluations.
Definition: CompressedMatrix.h:2374
Header file for run time assertion macros.
Utility type for generic codes.
Header file for the DVecEvalExprTrait class template.
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
Header file for the EvalExprTrait class template.
VT::ReturnType ReturnType
Return type for expression template evaluations.
Definition: DVecEvalExpr.h:94
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
DVecEvalExpr(const VT &dv)
Constructor for the DVecEvalExpr class.
Definition: DVecEvalExpr.h:116
const DMatEvalExpr< MT, SO > eval(const DenseMatrix< MT, SO > &dm)
Forces the evaluation of the given dense matrix expression dm.
Definition: DMatEvalExpr.h:395
Header file for the IsDenseVector type trait.
#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: DVecEvalExpr.h:160
DVecEvalExpr< VT, TF > This
Type of this DVecEvalExpr instance.
Definition: DVecEvalExpr.h:90
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:105
#define BLAZE_FUNCTION_TRACE
Function trace macro.This macro can be used to reliably trace function calls. In case function tracin...
Definition: FunctionTrace.h:157
This ResultType
Result type for expression template evaluations.
Definition: CompressedMatrix.h:2370
Header file for basic type definitions.
Header file for the SubvectorExprTrait class template.
Header file for the IsColumnVector type trait.
VT::ResultType ResultType
Result type for expression template evaluations.
Definition: DVecEvalExpr.h:91
VT::TransposeType TransposeType
Transpose type for expression template evaluations.
Definition: DVecEvalExpr.h:92
#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.