TensorOperators.h File Reference

#include "PETE/PETE.h"
#include "PETE/TypeComputations.h"
#include "Tiny/BinaryTensorOp.h"
#include "Tiny/UnaryTensorOp.h"

Include dependency graph for TensorOperators.h:

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


Classes

struct  TensorDotTensor< T1, T2, I, J, K, L >
struct  TensorDotTensor< T1, T2, I, J, K, 1 >
struct  TensorEngineElem< D, T, BinaryTensorOp< T1, T2, FnDot >, I, J, 1 >
struct  BinaryReturn< Tensor< D, T1, E1 >, Tensor< D, T2, E2 >, FnDot >
struct  UnaryReturn< Tensor< D, T, E >, FnTrace >
struct  UnaryReturn< Tensor< D, T, E >, FnDet >
struct  UnaryReturn< Tensor< D, T, E >, FnTranspose >
struct  BinaryReturn< Tensor< D, T1, E1 >, Tensor< D, T2, E2 >, OpEQ >
struct  BinaryReturn< Tensor< D, T1, E1 >, Tensor< D, T2, E2 >, OpNE >

Defines

#define POOMA_TENSOR_UNARY_OPERATOR(FUNC, TAG)
#define POOMA_TENSOR_BINARY_OPERATOR(FUNC, TAG)
#define POOMA_TENSOR_ACCUM_OPERATOR(FUNC, TAG)

Functions

template<int D, class T1 , class T2 , class E1 , class E2 >
BinaryReturn< Tensor< D, T1,
E1 >, Tensor< D, T2, E2 >
, FnDot >::Type_t 
dot (const Tensor< D, T1, E1 > &v1, const Tensor< D, T2, E2 > &v2)
template<int D, class T , class E >
trace (const Tensor< D, T, E > &t)
template<int D, class T >
trace (const Tensor< D, T, Diagonal > &t)
template<int D, class T >
trace (const Tensor< D, T, Antisymmetric > &t)
template<int D, class T , class E >
det (const Tensor< D, T, E > &t)
template<class T , class E >
det (const Tensor< 3, T, E > &t)
template<class T , class E >
det (const Tensor< 2, T, E > &t)
template<class T , class E >
det (const Tensor< 1, T, E > &t)
template<class T >
det (const Tensor< 3, T, Diagonal > &t)
template<class T >
det (const Tensor< 2, T, Diagonal > &t)
template<class T >
det (const Tensor< 1, T, Diagonal > &t)
template<class T >
det (const Tensor< 3, T, Antisymmetric > &t)
template<class T >
det (const Tensor< 2, T, Antisymmetric > &t)
template<class T >
det (const Tensor< 1, T, Antisymmetric > &t)
template<int D, class T , class E >
Tensor< D, T, E > transpose (const Tensor< D, T, E > &t)
template<int D, class T >
Tensor< D, T, Symmetrictranspose (const Tensor< D, T, Symmetric > &t)
template<int D, class T >
Tensor< D, T, Antisymmetrictranspose (const Tensor< D, T, Antisymmetric > &t)
template<int D, class T >
Tensor< D, T, Diagonaltranspose (const Tensor< D, T, Diagonal > &t)
template<int D, class T1 , class T2 , class E1 , class E2 >
BinaryReturn< Tensor< D, T1,
E1 >, Tensor< D, T2, E2 >
, OpEQ >::Type_t 
operator== (const Tensor< D, T1, E1 > &t1, const Tensor< D, T2, E2 > &t2)
template<int D, class T1 , class T2 , class E1 , class E2 >
BinaryReturn< Tensor< D, T1,
E1 >, Tensor< D, T2, E2 >
, OpNE >::Type_t 
operator!= (const Tensor< D, T1, E1 > &t1, const Tensor< D, T2, E2 > &t2)

Define Documentation

#define POOMA_TENSOR_UNARY_OPERATOR ( FUNC,
TAG   ) 

Value:

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

#define POOMA_TENSOR_BINARY_OPERATOR ( FUNC,
TAG   ) 

#define POOMA_TENSOR_ACCUM_OPERATOR ( FUNC,
TAG   ) 


Function Documentation

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

template<int D, class T , class E >
T trace ( const Tensor< D, T, E > &  t  )  [inline]

template<int D, class T >
T trace ( const Tensor< D, T, Diagonal > &  t  )  [inline]

template<int D, class T >
T trace ( const Tensor< D, T, Antisymmetric > &  t  )  [inline]

template<int D, class T , class E >
T det ( const Tensor< D, T, E > &  t  )  [inline]

References PInsist.

template<class T , class E >
T det ( const Tensor< 3, T, E > &  t  )  [inline]

template<class T , class E >
T det ( const Tensor< 2, T, E > &  t  )  [inline]

template<class T , class E >
T det ( const Tensor< 1, T, E > &  t  )  [inline]

template<class T >
T det ( const Tensor< 3, T, Diagonal > &  t  )  [inline]

template<class T >
T det ( const Tensor< 2, T, Diagonal > &  t  )  [inline]

template<class T >
T det ( const Tensor< 1, T, Diagonal > &  t  )  [inline]

template<class T >
T det ( const Tensor< 3, T, Antisymmetric > &  t  )  [inline]

template<class T >
T det ( const Tensor< 2, T, Antisymmetric > &  t  )  [inline]

template<class T >
T det ( const Tensor< 1, T, Antisymmetric > &  t  )  [inline]

template<int D, class T , class E >
Tensor<D,T,E> transpose ( const Tensor< D, T, E > &  t  )  [inline]

template<int D, class T >
Tensor<D,T,Symmetric> transpose ( const Tensor< D, T, Symmetric > &  t  )  [inline]

template<int D, class T >
Tensor<D,T,Antisymmetric> transpose ( const Tensor< D, T, Antisymmetric > &  t  )  [inline]

template<int D, class T >
Tensor<D,T,Diagonal> transpose ( const Tensor< D, T, Diagonal > &  t  )  [inline]

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

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


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