VectorOperators.h File Reference

#include "PETE/PETE.h"
#include "PETE/TypeComputations.h"
#include "Tiny/BinaryVectorOp.h"
#include "Tiny/UnaryVectorOp.h"

Include dependency graph for VectorOperators.h:

This graph shows which files directly or indirectly include this file:


Classes

struct  VectorDotVector< V1, V2, B, L >
struct  VectorDotVector< V1, V2, B, 1 >
struct  BinaryReturn< Vector< D, T1, E1 >, Vector< D, T2, E2 >, FnDot >
struct  UnaryReturn< Vector< D, T, E >, FnNorm >
struct  VectorEqualsVector< V1, V2, B, L >
struct  VectorEqualsVector< V1, V2, B, 1 >
struct  BinaryReturn< Vector< D, T1, E1 >, Vector< D, T2, E2 >, OpEQ >
struct  BinaryReturn< Vector< D, T1, E1 >, Vector< D, T2, E2 >, OpNE >

Defines

#define POOMA_VECTOR_UNARY_OPERATOR(FUNC, TAG)
#define POOMA_VECTOR_BINARY_OPERATOR(FUNC, TAG)
#define POOMA_VECTOR_ACCUM_OPERATOR(FUNC, TAG)

Functions

template<int D, class T1 , class T2 , class E1 , class E2 >
BinaryReturn< Vector< D, T1,
E1 >, Vector< D, T2, E2 >
, FnDot >::Type_t 
dot (const Vector< D, T1, E1 > &v1, const Vector< D, T2, E2 > &v2)
template<int D, class T , class E >
norm (const Vector< D, T, E > &x)
template<int D, class T , class E >
norm2 (const Vector< D, T, E > &x)
template<int D, class T1 , class T2 , class E1 , class E2 >
BinaryReturn< Vector< D, T1,
E1 >, Vector< D, T2, E2 >
, OpEQ >::Type_t 
operator== (const Vector< D, T1, E1 > &v1, const Vector< D, T2, E2 > &v2)
template<int D, class T1 , class T2 , class E1 , class E2 >
BinaryReturn< Vector< D, T1,
E1 >, Vector< D, T2, E2 >
, OpNE >::Type_t 
operator!= (const Vector< D, T1, E1 > &v1, const Vector< D, T2, E2 > &v2)
template<int D, class T , class E >
BinaryReturn< Vector< D, T, E >
, Vector< D, T, E >, OpNE >
::Type_t 
operator!= (const Vector< D, T, E > &v1, const Vector< D, T, E > &v2)

Define Documentation

#define POOMA_VECTOR_UNARY_OPERATOR ( FUNC,
TAG   ) 

Value:

\
template <int D, class T, class E>                                            \
struct UnaryReturn< Vector<D,T,E>, TAG >                                      \
{                                                                             \
  typedef Vector< D, typename UnaryReturn<T,TAG>::Type_t, E > Type_t;         \
};                                                                            \
                                                                              \
template <int D, class T, class E>                                            \
inline typename UnaryReturn< Vector<D,T,E>, TAG >::Type_t                     \
FUNC( const Vector<D,T,E>& v1 )                                               \
{                                                                             \
  typedef Vector<D,T,E> V1;                                                   \
  typedef typename UnaryReturn<T,TAG>::Type_t T3;                             \
  typedef Vector< D, T3, UnaryVectorOp<V1,TAG> > Expr_t;                      \
  typedef typename UnaryReturn<V1,TAG>::Type_t Return_t;                      \
  return Return_t( Expr_t(v1) );                                              \
}

#define POOMA_VECTOR_BINARY_OPERATOR ( FUNC,
TAG   ) 

#define POOMA_VECTOR_ACCUM_OPERATOR ( FUNC,
TAG   ) 

Value:

\
template <int D, class T1, class T2, class E1, class E2>                      \
inline Vector<D,T1,E1>&                                                       \
FUNC( Vector<D,T1,E1>& v1, const Vector<D,T2,E2>& v2 )                        \
{                                                                             \
  VectorAssign<Vector<D,T1,E1>,Vector<D,T2,E2>,TAG,0,D>::apply(v1,v2,TAG());  \
  return v1;                                                                  \
}                                                                             \
                                                                              \
template <int D, class T1, class T2, class E1>                                \
inline Vector<D,T1,E1>&                                                       \
FUNC( Vector<D,T1,E1>& v1, const T2& v2 )                                     \
{                                                                             \
  VectorAssign<Vector<D,T1,E1>,T2,TAG,0,D>::apply(v1,v2,TAG());               \
  return v1;                                                                  \
}


Function Documentation

template<int D, class T1 , class T2 , class E1 , class E2 >
BinaryReturn< Vector<D,T1,E1>,Vector<D,T2,E2> , FnDot >::Type_t dot ( const Vector< D, T1, E1 > &  v1,
const Vector< D, T2, E2 > &  v2 
) [inline]

template<int D, class T , class E >
T norm ( const Vector< D, T, E > &  x  )  [inline]

References dot(), and sqrt().

template<int D, class T , class E >
T norm2 ( const Vector< D, T, E > &  x  )  [inline]

References dot().

template<int D, class T1 , class T2 , class E1 , class E2 >
BinaryReturn< Vector<D,T1,E1>,Vector<D,T2,E2> , OpEQ >::Type_t operator== ( const Vector< D, T1, E1 > &  v1,
const Vector< D, T2, E2 > &  v2 
) [inline]

template<int D, class T1 , class T2 , class E1 , class E2 >
BinaryReturn< Vector<D,T1,E1>,Vector<D,T2,E2> , OpNE >::Type_t operator!= ( const Vector< D, T1, E1 > &  v1,
const Vector< D, T2, E2 > &  v2 
) [inline]

template<int D, class T , class E >
BinaryReturn<Vector<D, T, E>, Vector<D, T, E> , OpNE>::Type_t operator!= ( const Vector< D, T, E > &  v1,
const Vector< D, T, E > &  v2 
) [inline]


Generated on Wed Mar 16 06:19:33 2011 for FreePOOMA by  doxygen 1.5.9