src/PETE/PETE.h File Reference

#include "PETE/TypeComputations.h"
#include "Utility/PAssert.h"
#include <stdlib.h>
#include <memory.h>

Include dependency graph for PETE.h:

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

Go to the source code of this file.

Classes

class  PETE_Expr< WrappedExpr >
class  PETE_Scalar< T >
struct  EvalFunctor_0
struct  PETE_Increment
struct  PETE_CountElems
struct  PETE_TUTree< Value_t, Child_t >
struct  PETE_TBTree< Value_t, Left_t, Right_t >
class  PETE_TTTree< Value_t, Left_t, Middle_t, Right_t >
struct  PETE_Combiner< T, Op >
struct  AssertEquals
struct  PETE_NullCombiner
struct  struct_for_each< Op, T1, T2, Functor >
struct  ConditionalAssign< T >
struct  struct_for_each< OpWhere, T1, T2, Functor >
struct  SafeCombine< I1, I2 >
struct  SafeCombine< 0, 0 >
struct  SafeCombine< 1, 0 >
struct  SafeCombine< 0, 1 >
struct  SafeCombine< 1, 1 >
struct  SafeExpression< Expr >
struct  SafeExpression< PETE_TUTree< Op, Sub > >
struct  SafeExpression< PETE_TBTree< Op, Left, Right > >
struct  SafeExpression< PETE_TTTree< Op, Left, Middle, Right > >
struct  SafeExpression< PETE_TBTree< OpDivide, Left, Right > >
struct  TrinaryForEach< Safe, T1, T2, T3, Op, Functor >
struct  TrinaryForEach< 0, T1, T2, T3, OpWhere, Functor >
struct  Expressionize< PETE_Expr< T > >

Defines

#define PETE_USER_REDUCTION_CODE
#define PETE_DefineUnary(Fun, Expr, Op)
#define PETE_DefineBinary(Fun, Expr, Op)
#define PETE_DefineBinarySynonym(Fun, Op)
#define PETE_DefineBinaryWithScalars(Fun, Op, Sca)
#define PETE_DefineTrinary(Fun, Expr, Op)
#define PETE_DefineTrinaryWithScalars(Fun, Op, Sca)
#define PETE_DefineScalar(Sca)
#define PETE_DefineAssign(Expr, Cond, Op)
#define UNARY_FUNCTION(RET, FUNC, ARG)
#define BINARY_FUNCTION(RET, FUNC, ARG1, ARG2)

Typedefs

typedef PETE_Combiner< bool,
OpAnd > 		PETE_AndCombiner
typedef PETE_Combiner< bool,
OpOr > 		PETE_OrCombiner
typedef PETE_Combiner< int,
OpAdd > 		PETE_SumCombiner

Functions

template<class T>
T for_each (const PETE_Scalar< T > &p, EvalFunctor_0)
template<class T, class C>
int for_each (PETE_Scalar< T > &, PETE_Increment, C)
template<class T, class C>
int for_each (const PETE_Scalar< T > &, PETE_CountElems, C)
template<class Op, class T1, class Functor, class Combiner>
Functor::PETE_Return_t for_each (PETE_TUTree< Op, T1 > &node, Functor f, Combiner c)
template<class Op, class T1, class T2, class Functor, class Combiner>
Functor::PETE_Return_t for_each (PETE_TBTree< Op, T1, T2 > &node, Functor f, Combiner c)
template<class Op, class T1, class T2, class T3, class Functor, class Combiner>
Functor::PETE_Return_t for_each (PETE_TTTree< Op, T1, T2, T3 > &node, Functor f, Combiner c)
template<class Op, class T1, class Functor>
PETEUnaryReturn< typename
T1::PETE_Return_t, Op >::type 		for_each (PETE_TUTree< Op, T1 > &node, Functor f)
template<class Op, class T1, class T2, class Functor>
struct_for_each< Op, T1, T2,
Functor >::Return_t 		for_each (PETE_TBTree< Op, T1, T2 > &node, Functor f)
template<class T1, class T2, class T3, class Functor, class Op>
PETETrinaryReturn< typename
T1::PETE_Return_t, typename
T2::PETE_Return_t, typename
T3::PETE_Return_t, Op >::type 		for_each (PETE_TTTree< Op, T1, T2, T3 > &node, Functor f)
template<class R, class T, class InitOp, class AccOp>
void Reduction (R &ret, const PETE_Expr< T > &const_expr, InitOp init_op, AccOp acc_op)
 PETE_DefineUnary (operator-,(-a), OpUnaryMinus) PETE_DefineUnary(operator+
OpUnaryPlus PETE_DefineUnary (operator~,(~a), OpBitwiseNot) PETE_DefineUnary(operator!
OpUnaryPlus OpNot PETE_DefineUnary (PETE_identity,(a), OpIdentity) PETE_DefineUnary(acos
OpUnaryPlus OpNot acos (a))
OpUnaryPlus OpNot FnArcCos PETE_DefineUnary (asin,(asin(a)), FnArcSin) PETE_DefineUnary(atan
OpUnaryPlus OpNot FnArcCos atan (a))
OpUnaryPlus OpNot FnArcCos
FnArcTan 		PETE_DefineUnary (ceil,(ceil(a)), FnCeil) PETE_DefineUnary(cos
OpUnaryPlus OpNot FnArcCos
FnArcTan 		cos (a))
OpUnaryPlus OpNot FnArcCos
FnArcTan FnCos 		PETE_DefineUnary (cosh,(cosh(a)), FnHypCos) PETE_DefineUnary(exp
OpUnaryPlus OpNot FnArcCos
FnArcTan FnCos 		exp (a))
OpUnaryPlus OpNot FnArcCos
FnArcTan FnCos FnExp 		PETE_DefineUnary (fabs,(fabs(a)), FnFabs) PETE_DefineUnary(floor
OpUnaryPlus OpNot FnArcCos
FnArcTan FnCos FnExp 		floor (a))
OpUnaryPlus OpNot FnArcCos
FnArcTan FnCos FnExp FnFloor 		PETE_DefineUnary (log,(log(a)), FnLog) PETE_DefineUnary(log10
OpUnaryPlus OpNot FnArcCos
FnArcTan FnCos FnExp FnFloor 		log10 (a))
OpUnaryPlus OpNot FnArcCos
FnArcTan FnCos FnExp FnFloor
FnLog10 		PETE_DefineUnary (sin,(sin(a)), FnSin) PETE_DefineUnary(sinh
OpUnaryPlus OpNot FnArcCos
FnArcTan FnCos FnExp FnFloor
FnLog10 		sinh (a))
OpUnaryPlus OpNot FnArcCos
FnArcTan FnCos FnExp FnFloor
FnLog10 FnHypSin 		PETE_DefineUnary (sqrt,(sqrt(a)), FnSqrt) PETE_DefineUnary(tan
OpUnaryPlus OpNot FnArcCos
FnArcTan FnCos FnExp FnFloor
FnLog10 FnHypSin 		tan (a))
OpUnaryPlus OpNot FnArcCos
FnArcTan FnCos FnExp FnFloor
FnLog10 FnHypSin FnTan 		PETE_DefineUnary (tanh,(tanh(a)), FnHypTan) template< class T1
OpUnaryPlus OpNot FnArcCos
FnArcTan FnCos FnExp FnFloor
FnLog10 FnHypSin FnTan class
T2 inline T1 		PETE_apply (OpCast< T1 >, const T2 &a)
template<class T1, class Expr>
PETE_TUTree< OpCast< T1 >,
typename Expr::PETE_Expr_t > 		pete_cast (const T1 &, const PETE_Expr< Expr > &l)
 PETE_DefineBinary (operator+,(a+b), OpAdd) PETE_DefineBinary(operator-
a OpSubtract PETE_DefineBinary (operator *,(a *b), OpMultipply) PETE_DefineBinary(operator/
a OpSubtract a OpDivide PETE_DefineBinary (operator%,(a%b), OpMod) PETE_DefineBinary(operator<
 PETE_DefineAssign ((a=b),(a=b.value), OpAssign) PETE_DefineAssign((a+
template<class T>
T::PETE_Expr_t::PETE_Return_t sum (const PETE_Expr< T > &expr)
template<class T>
T::PETE_Expr_t::PETE_Return_t prod (const PETE_Expr< T > &expr)

Variables

 a
OpUnaryPlus a
a b
a OpSubtract a b
a OpSubtract a OpDivide a< b), OpLT) PETE_DefineBinary(operator<=,(a<=b), OpLE) PETE_DefineBinary(operator>,(a > b), OpGT) PETE_DefineBinary(operator>
a OpSubtract a OpDivide a

Define Documentation

#define BINARY_FUNCTION (  RET,
FUNC,
ARG1,
ARG2   ) 
 

Value:

struct FnBinary_ ## FUNC {                                                  \
  enum { tag = PETE_BinaryPromoteTag };                                     \
};                                                                          \
PETE_DefineBinary(FUNC,(FUNC(a,b)),FnBinary_ ## FUNC)                       \
template<>                                                                  \
struct PETEBinaryReturn<ARG1,ARG2,FnBinary_ ## FUNC> {                      \
  typedef RET type;                                                         \
};

Definition at line 1303 of file PETE.h.

#define PETE_DefineAssign (  Expr,
Cond,
Op   ) 
 

Value:

template<class T1, class T2>                                    \
struct PETE_StructApply<Op,T1,T2>                               \
{                                                               \
  static void apply(T1& a,const T2& b) { Expr; }                \
};                                                              \
                                                                \
template<class T1, class T2>                                    \
struct PETE_StructApply<Op,T1,ConditionalAssign<T2> >           \
{                                                               \
  static void apply(T1& a, const ConditionalAssign<T2>& b)      \
    {                                                           \
      if ( b.cond )                                             \
        Cond;                                                   \
    }                                                           \
};                                                              \
                                                                \
template<class T1, class T2>                                    \
inline void                                                     \
PETE_apply(Op, T1 &a, const T2& b)                              \
{                                                               \
  PETE_StructApply<Op,T1,T2>::apply(a,b);                       \
}

Definition at line 1149 of file PETE.h.

#define PETE_DefineBinary (  Fun,
Expr,
Op   ) 
 

Value:

template<class T1, class T2>                                                \
inline typename PETEBinaryReturn<T1, T2, Op>::type                          \
PETE_apply(Op, const T1& a, const T2& b)                                    \
{                                                                           \
  return Expr;                                                              \
}                                                                           \
template<class T1, class T2>                                                \
inline PETE_TBTree<Op, typename T1::PETE_Expr_t, typename T2::PETE_Expr_t>  \
Fun(const PETE_Expr<T1>& l, const PETE_Expr<T2>& r)                         \
{                                                                           \
  typedef PETE_TBTree<Op,typename T1::PETE_Expr_t,                          \
    typename T2::PETE_Expr_t> ret;                                          \
  return ret(l.PETE_unwrap().MakeExpression(),                              \
    r.PETE_unwrap().MakeExpression());                                      \
}

Definition at line 890 of file PETE.h.

#define PETE_DefineBinarySynonym (  Fun,
Op   ) 
 

Value:

template<class T1, class T2>                                                \
inline PETE_TBTree<Op, typename T1::PETE_Expr_t, typename T2::PETE_Expr_t>  \
Fun(const PETE_Expr<T1>& l, const PETE_Expr<T2>& r)                         \
{                                                                           \
  typedef PETE_TBTree<Op,typename T1::PETE_Expr_t,typename T2::PETE_Expr_t> \
    ret;                                                                    \
  return ret(l.PETE_unwrap().MakeExpression(),                              \
    r.PETE_unwrap().MakeExpression());                                      \
}

Definition at line 907 of file PETE.h.

#define PETE_DefineBinaryWithScalars (  Fun,
Op,
Sca   ) 
 

Value:

template<class T>                                                           \
inline PETE_TBTree<Op, PETE_Scalar<Sca>, typename T::PETE_Expr_t>           \
Fun(const Sca l, const PETE_Expr<T>& r)                                     \
{                                                                           \
  typedef PETE_TBTree<Op, PETE_Scalar<Sca>, typename T::PETE_Expr_t> ret;   \
  return ret(PETE_Scalar<Sca>(l), r.PETE_unwrap().MakeExpression());        \
}                                                                           \
template<class T>                                                           \
inline PETE_TBTree<Op, typename T::PETE_Expr_t, PETE_Scalar<Sca> >          \
Fun(const PETE_Expr<T>& l, const Sca r)                                     \
{                                                                           \
  typedef PETE_TBTree<Op, typename T::PETE_Expr_t, PETE_Scalar<Sca> > ret;  \
  return ret(l.PETE_unwrap().MakeExpression(), PETE_Scalar<Sca>(r));        \
}

#define PETE_DefineScalar (  Sca   ) 
 

Value:

PETE_DefineBinaryWithScalars(operator+, OpAdd, Sca)                         \
PETE_DefineBinaryWithScalars(operator-, OpSubtract, Sca)                    \
PETE_DefineBinaryWithScalars(operator*, OpMultipply, Sca)                    \
PETE_DefineBinaryWithScalars(operator/, OpDivide, Sca)                      \
PETE_DefineBinaryWithScalars(operator%, OpMod, Sca)                         \
PETE_DefineBinaryWithScalars(operator<, OpLT, Sca)                          \
PETE_DefineBinaryWithScalars(operator<=, OpLE, Sca)                         \
PETE_DefineBinaryWithScalars(operator>, OpGT, Sca)                          \
PETE_DefineBinaryWithScalars(operator>=, OpGE, Sca)                         \
PETE_DefineBinaryWithScalars(operator==, OpEQ, Sca)                         \
PETE_DefineBinaryWithScalars(operator!=, OpNE, Sca)                         \
PETE_DefineBinaryWithScalars(operator&&, OpAnd, Sca)                        \
PETE_DefineBinaryWithScalars(operator||, OpOr, Sca)                         \
PETE_DefineBinaryWithScalars(operator&, OpBitwiseAnd, Sca)                  \
PETE_DefineBinaryWithScalars(operator|, OpBitwiseOr, Sca)                   \
PETE_DefineBinaryWithScalars(operator^, OpBitwiseXor, Sca)                  \
PETE_DefineBinaryWithScalars(where, OpWhere, Sca)                           \
PETE_DefineBinaryWithScalars(copysign, FnCopysign, Sca)                     \
PETE_DefineBinaryWithScalars(ldexp, FnLdexp, Sca)                           \
PETE_DefineBinaryWithScalars(pow, FnPow, Sca)                               \
PETE_DefineBinaryWithScalars(fmod, FnFmod, Sca)                             \
PETE_DefineBinaryWithScalars(atan2, FnArcTan2, Sca)                         \
PETE_DefineTrinaryWithScalars(where, OpWhere, Sca)

#define PETE_DefineTrinary (  Fun,
Expr,
Op   ) 
 

Value:

template<class T1, class T2, class T3>                                      \
inline typename PETETrinaryReturn<T1,T2,T3,Op>::type                        \
PETE_apply(Op, const T1& a, const T2& b, const T3& c)                       \
{                                                                           \
  return Expr;                                                              \
}                                                                           \
template<class Cond_t, class True_t, class False_t>                         \
inline PETE_TTTree<Op, typename Cond_t::PETE_Expr_t,                        \
  typename True_t::PETE_Expr_t, typename False_t::PETE_Expr_t>              \
Fun(const PETE_Expr<Cond_t>& c, const PETE_Expr<True_t>& t,                 \
  const PETE_Expr<False_t>& f)                                              \
{                                                                           \
  typedef PETE_TTTree<Op, typename Cond_t::PETE_Expr_t,                     \
    typename True_t::PETE_Expr_t, typename False_t::PETE_Expr_t> ret;       \
  return ret(c.PETE_unwrap().MakeExpression(),                              \
    t.PETE_unwrap().MakeExpression(),                                       \
    f.PETE_unwrap().MakeExpression());                                      \
}

#define PETE_DefineTrinaryWithScalars (  Fun,
Op,
Sca   ) 
 

Value:

template<class Cond_t, class True_t>                                        \
inline PETE_TTTree<Op, typename Cond_t::PETE_Expr_t,                        \
  typename True_t::PETE_Expr_t, PETE_Scalar<Sca> >                          \
Fun(const PETE_Expr<Cond_t>& c, const PETE_Expr<True_t>& t,Sca f)           \
{                                                                           \
  typedef PETE_TTTree<Op, typename Cond_t::PETE_Expr_t,                     \
    typename True_t::PETE_Expr_t, PETE_Scalar<Sca> > ret;                   \
  return ret(c.PETE_unwrap().MakeExpression(),                              \
    t.PETE_unwrap().MakeExpression(), PETE_Scalar<Sca>(f));                 \
}                                                                           \
template<class Cond_t, class False_t>                                       \
inline PETE_TTTree<Op, typename Cond_t::PETE_Expr_t, PETE_Scalar<Sca>,      \
  typename False_t::PETE_Expr_t >                                           \
Fun(const PETE_Expr<Cond_t>& c, Sca t, const PETE_Expr<False_t>& f)         \
{                                                                           \
  typedef PETE_TTTree<Op, typename Cond_t::PETE_Expr_t, PETE_Scalar<Sca>,   \
    typename False_t::PETE_Expr_t > ret;                                    \
  return ret(c.PETE_unwrap().MakeExpression(),                              \
    PETE_Scalar<Sca>(t), f.PETE_unwrap().MakeExpression());                 \
}                                                                           \
template<class Cond_t>                                                      \
inline PETE_TTTree<Op, typename Cond_t::PETE_Expr_t, PETE_Scalar<Sca>,      \
  PETE_Scalar<Sca> >                                                        \
Fun(const PETE_Expr<Cond_t>& c, Sca t, Sca f)                               \
{                                                                           \
  typedef PETE_TTTree<Op, typename Cond_t::PETE_Expr_t, PETE_Scalar<Sca>,   \
    PETE_Scalar<Sca> > ret;                                                 \
  return ret(c.PETE_unwrap().MakeExpression(),                              \
    PETE_Scalar<Sca>(t), PETE_Scalar<Sca>(f));                              \
}

#define PETE_DefineUnary (  Fun,
Expr,
Op   ) 
 

Value:

template<class T>                                                           \
inline typename PETEUnaryReturn<T, Op>::type                                \
PETE_apply(Op, const T& a)                                                  \
{                                                                           \
  return Expr;                                                              \
}                                                                           \
template<class T>                                                           \
inline PETE_TUTree<Op, typename T::PETE_Expr_t>                             \
Fun(const PETE_Expr<T>& l)                                                  \
{                                                                           \
  return PETE_TUTree<Op, typename T::PETE_Expr_t>                           \
    (l.PETE_unwrap().MakeExpression());                                     \
}

Definition at line 825 of file PETE.h.

#define PETE_USER_REDUCTION_CODE
 

Definition at line 776 of file PETE.h.

#define UNARY_FUNCTION (  RET,
FUNC,
ARG   ) 
 

Value:

struct FnUnary_ ## FUNC {                                                   \
  enum { tag = PETE_UnaryPassThruTag };                                     \
};                                                                          \
PETE_DefineUnary(FUNC,FUNC(a),FnUnary_ ## FUNC)                             \
template <>                                                                 \
struct PETEUnaryReturn<ARG, FnUnary_ ## FUNC> {                             \
  typedef RET type;                                                         \
};

Definition at line 1293 of file PETE.h.

Typedef Documentation

typedef PETE_Combiner<bool,OpAnd> PETE_AndCombiner
 

Definition at line 568 of file PETE.h.

typedef PETE_Combiner<bool,OpOr> PETE_OrCombiner
 

Definition at line 569 of file PETE.h.

typedef PETE_Combiner<int,OpAdd> PETE_SumCombiner
 

Definition at line 570 of file PETE.h.

Function Documentation

OpUnaryPlus OpNot acos (  a   ) 
 

OpUnaryPlus OpNot FnArcCos atan (  a   ) 
 

Referenced by main(), and my_atan().

OpUnaryPlus OpNot FnArcCos FnArcTan cos (  a   ) 
 

Referenced by cffti1_(), fcffti1_(), fradbg_(), fradfg_(), frffti1_(), radbg_(), radfg_(), and rffti1_().

OpUnaryPlus OpNot FnArcCos FnArcTan FnCos exp (  a   ) 
 

OpUnaryPlus OpNot FnArcCos FnArcTan FnCos FnExp floor (  a   ) 
 

template<class T1, class T2, class T3, class Functor, class Op>
PETETrinaryReturn<typename T1::PETE_Return_t, typename T2::PETE_Return_t, typename T3::PETE_Return_t,Op>::type for_each (  PETE_TTTree< Op, T1, T2, T3 > &  node,
Functor  f
)  [inline]
 

Definition at line 761 of file PETE.h.

template<class Op, class T1, class T2, class Functor>
struct_for_each<Op,T1,T2,Functor>::Return_t for_each (  PETE_TBTree< Op, T1, T2 > &  node,
Functor  f
)  [inline]
 

Definition at line 650 of file PETE.h.

References struct_for_each< Op, T1, T2, Functor >::apply().

Here is the call graph for this function:

template<class Op, class T1, class Functor>
PETEUnaryReturn<typename T1::PETE_Return_t,Op>::type for_each (  PETE_TUTree< Op, T1 > &  node,
Functor  f
)  [inline]
 

Definition at line 582 of file PETE.h.

References PETE_TUTree< Value_t, Child_t >::Child, for_each(), PETE_apply(), and PETE_TUTree< Value_t, Child_t >::Value.

Here is the call graph for this function:

template<class Op, class T1, class T2, class T3, class Functor, class Combiner>
Functor::PETE_Return_t for_each (  PETE_TTTree< Op, T1, T2, T3 > &  node,
Functor  f,
Combiner  c
)  [inline]
 

Definition at line 481 of file PETE.h.

References for_each(), PETE_TTTree< Value_t, Left_t, Middle_t, Right_t >::Left, PETE_TTTree< Value_t, Left_t, Middle_t, Right_t >::Middle, and PETE_TTTree< Value_t, Left_t, Middle_t, Right_t >::Right.

Here is the call graph for this function:

template<class Op, class T1, class T2, class Functor, class Combiner>
Functor::PETE_Return_t for_each (  PETE_TBTree< Op, T1, T2 > &  node,
Functor  f,
Combiner  c
)  [inline]
 

Definition at line 470 of file PETE.h.

References for_each(), PETE_TBTree< Value_t, Left_t, Right_t >::Left, and PETE_TBTree< Value_t, Left_t, Right_t >::Right.

Here is the call graph for this function:

template<class Op, class T1, class Functor, class Combiner>
Functor::PETE_Return_t for_each (  PETE_TUTree< Op, T1 > &  node,
Functor  f,
Combiner  c
)  [inline]
 

Definition at line 459 of file PETE.h.

References PETE_TUTree< Value_t, Child_t >::Child, and for_each().

Here is the call graph for this function:

template<class T, class C>
int for_each (  const PETE_Scalar< T > &  ,
PETE_CountElems  ,
C 
)  [inline]
 

Definition at line 262 of file PETE.h.

template<class T, class C>
int for_each (  PETE_Scalar< T > &  ,
PETE_Increment  ,
C 
)  [inline]
 

Definition at line 253 of file PETE.h.

template<class T>
T for_each (  const PETE_Scalar< T > &  p,
EvalFunctor_0 
)  [inline]
 

Definition at line 241 of file PETE.h.

OpUnaryPlus OpNot FnArcCos FnArcTan FnCos FnExp FnFloor log10 (  a   ) 
 

OpUnaryPlus OpNot FnArcCos FnArcTan FnCos FnExp FnFloor FnLog10 FnHypSin FnTan class T2 inline T1 PETE_apply (  OpCast< T1 >  ,
const T2 &  a
) 
 

Definition at line 870 of file PETE.h.

template<class T1, class Expr>
PETE_TUTree<OpCast<T1>, typename Expr::PETE_Expr_t> pete_cast (  const T1 &  ,
const PETE_Expr< Expr > &  l
)  [inline]
 

Definition at line 877 of file PETE.h.

References PETE_Expr< WrappedExpr >::PETE_unwrap().

Here is the call graph for this function:

PETE_DefineAssign (  (a=b)  ,
(a=b.value)  ,
OpAssign 
) 
 

a OpSubtract a OpDivide PETE_DefineBinary (  operator%  ,
(a%b)  ,
OpMod 
) 
 

a OpSubtract PETE_DefineBinary (  operator *  ,
(a *b)  ,
OpMultipply 
) 
 

PETE_DefineBinary (  operator+  ,
(a+b)  ,
OpAdd 
) 
 

OpUnaryPlus OpNot FnArcCos FnArcTan FnCos FnExp FnFloor FnLog10 FnHypSin FnTan PETE_DefineUnary (  tanh  ,
(tanh(a))  ,
FnHypTan 
) 
 

OpUnaryPlus OpNot FnArcCos FnArcTan FnCos FnExp FnFloor FnLog10 FnHypSin PETE_DefineUnary (  sqrt  ,
(sqrt(a))  ,
FnSqrt 
) 
 

OpUnaryPlus OpNot FnArcCos FnArcTan FnCos FnExp FnFloor FnLog10 PETE_DefineUnary (  sin  ,
(sin(a))  ,
FnSin 
) 
 

OpUnaryPlus OpNot FnArcCos FnArcTan FnCos FnExp FnFloor PETE_DefineUnary (  log  ,
(log(a))  ,
FnLog 
) 
 

OpUnaryPlus OpNot FnArcCos FnArcTan FnCos FnExp PETE_DefineUnary (  fabs  ,
(fabs(a))  ,
FnFabs 
) 
 

OpUnaryPlus OpNot FnArcCos FnArcTan FnCos PETE_DefineUnary (  cosh  ,
(cosh(a))  ,
FnHypCos 
) 
 

OpUnaryPlus OpNot FnArcCos FnArcTan PETE_DefineUnary (  ceil  ,
(ceil(a))  ,
FnCeil 
) 
 

OpUnaryPlus OpNot FnArcCos PETE_DefineUnary (  asin  ,
(asin(a))  ,
FnArcSin 
) 
 

OpUnaryPlus OpNot PETE_DefineUnary (  PETE_identity  ,
(a)  ,
OpIdentity 
) 
 

OpUnaryPlus PETE_DefineUnary (  operator~  ,
(~a)  ,
OpBitwiseNot 
) 
 

PETE_DefineUnary (  operator-  ,
(-a)  ,
OpUnaryMinus 
) 
 

template<class T>
T::PETE_Expr_t::PETE_Return_t prod (  const PETE_Expr< T > &  expr  )  [inline]
 

Definition at line 1278 of file PETE.h.

References PETE_Expr< WrappedExpr >::PETE_unwrap(), and Reduction().

Here is the call graph for this function:

template<class R, class T, class InitOp, class AccOp>
void Reduction (  R &  ret,
const PETE_Expr< T > &  const_expr,
InitOp  init_op,
AccOp  acc_op
) 
 

Definition at line 781 of file PETE.h.

References for_each(), PETE_apply(), and PETE_Expr< WrappedExpr >::PETE_unwrap().

Here is the call graph for this function:

OpUnaryPlus OpNot FnArcCos FnArcTan FnCos FnExp FnFloor FnLog10 sinh (  a   ) 
 

template<class T>
T::PETE_Expr_t::PETE_Return_t sum (  const PETE_Expr< T > &  expr  )  [inline]
 

Definition at line 1248 of file PETE.h.

References PETE_Expr< WrappedExpr >::PETE_unwrap(), and Reduction().

Here is the call graph for this function:

OpUnaryPlus OpNot FnArcCos FnArcTan FnCos FnExp FnFloor FnLog10 FnHypSin tan (  a   ) 
 

Referenced by main(), and my_tan().

Variable Documentation

a OpSubtract a OpDivide a
 

Definition at line 926 of file PETE.h.

OpUnaryPlus a
 

Definition at line 843 of file PETE.h.

a
 

Definition at line 841 of file PETE.h.

Referenced by BConds< T, D, M, C >::apply(), TSV_MetaCross< Vektor< T1, 3 >, Vektor< T2, 3 > >::apply(), assertion::assertion(), assign(), BareField< T, Dim >::BareField(), SIndex< Dim >::clear(), NDIndex< Dim >::contains(), Index::contains(), NDIndex< Dim >::containsAllPoints(), Diag_DX_FE_var(), Diag_DX_FE_var_t(), Diag_DxDx_FE_var(), Diag_DxDy_FE_var(), Diag_DxDz_FE_var(), Diag_DY_FE_var(), Diag_DY_FE_var_t(), Diag_DyDx_FE_var(), Diag_DyDy_FE_var(), Diag_DyDz_FE_var(), Diag_DZ_FE_var(), Diag_DZ_FE_var_t(), Diag_DzDx_FE_var(), Diag_DzDy_FE_var(), Diag_DzDz_FE_var(), Diag_Helm_FE_var(), Diag_Int_boundary_var(), Diag_Laplace_FE_var(), DataSource::disconnect(), DomainMap< Key, T, Touches, Contains, Split >::DomainMap(), DX_FE_var(), DX_FE_var_t(), DxDx_FE_var(), DxDy_FE_var(), DxDz_FE_var(), DY_FE_var(), DY_FE_var_t(), DyDx_FE_var(), DyDy_FE_var(), DyDz_FE_var(), DZ_FE_var(), DZ_FE_var_t(), DzDx_FE_var(), DzDy_FE_var(), DzDz_FE_var(), Extrapolate_near_boundary(), ExtrapolateAndZeroFaceBCApply2(), ExtrapolateFaceBCApply2(), LSIndex< Dim >::find(), DataSource::findDataSourceObject(), Cartesian< Dim, MFLOAT >::getDeltaCell(), Cartesian< Dim, MFLOAT >::getDeltaVertex(), RNGXDiv::GetRandom(), DVar_Prol_Op::Give_Bo2p(), SIndex< Dim >::hasIndex(), LSIndex< Dim >::hasIndex(), Helm_FE_var(), DataSource::interact(), DataConnect::interact(), DResDiff< A >::Iterate_Calc_stencil(), DResDiff_Bo< A >::Iterate_Calc_stencil(), Laplace_FE_var(), operator &(), operator &&(), SIndex< Dim >::operator &=(), operator *(), ParticleAttribElemIterator< T, Dim >::operator!=(), ParticleAttribIterator< T >::operator!=(), SOffset< Dim >::operator!=(), BrickIterator< T, Dim >::operator!=(), Function::operator()(), Procedure::operator()(), SchleifeSum::operator()(), Schleife::operator()(), operator+(), operator-(), operator/(), SOffset< Dim >::operator<(), assertion::operator=(), DomainMap< Key, T, Touches, Contains, Split >::operator=(), AntiSymTenzor< T, 1 >::AssignProxy::operator=(), AntiSymTenzor< T, D >::AssignProxy::operator=(), RefBlockP< T, BoundsCheck >::operator==(), ParticleAttribElemIterator< T, Dim >::operator==(), ParticleAttribIterator< T >::operator==(), SOffset< Dim >::operator==(), BrickIterator< T, Dim >::operator==(), operator==(), SOffset< Dim >::operator>(), SOffset< Dim >::operator>=(), ParticleAttrib< T >::operator[](), operator|(), SIndex< Dim >::operator|=(), operator||(), PETE_apply(), Index::plugBase(), Print_Dx(), Print_Dx_moved(), Print_Dx_parallel(), Print_Gnuplot_moved(), Print_UCD(), Print_UCD_moved(), Print_UCD_moved_parallel(), Print_UCD_parallel(), Print_UCD_surface_parallel(), product(), Prolongation_FE(), SIndex< Dim >::reserve(), Restriction_FE(), SIndex< Dim >::size(), LField< T, Dim >::swapData(), SplitRegion< T, Dim >::test(), ContainsRegion< T, Dim >::test(), TouchesRegion< T, Dim >::test(), Split< Dim >::test(), Contains< Dim >::test(), Touches< Dim >::test(), NDIndex< Dim >::touches(), Index::touches(), DataSource::updateConnection(), DataConnect::updateConnections(), DiscParticle::write(), DiscMeta::~DiscMeta(), and UserList::~UserList().

a OpSubtract a OpDivide a< b), OpLT) PETE_DefineBinary(operator<=,(a<=b), OpLE) PETE_DefineBinary(operator>,(a > b), OpGT) PETE_DefineBinary(operator>
 

Definition at line 926 of file PETE.h.

a OpSubtract a b
 

Definition at line 921 of file PETE.h.

a b
 

Definition at line 919 of file PETE.h.

Generated on Mon Jan 16 14:16:43 2006 for IPPL by  doxygen 1.4.6