src/PETE/IpplExpressions.h File Reference

#include "Message/Message.h"
#include "PETE/IpplTypeComputations.h"
#include "PETE/PETE.h"

Include dependency graph for IpplExpressions.h:

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

Go to the source code of this file.

Classes

struct  AnyHolder< T, OP >
struct  BoundsHolder< T, D >
struct  OperatorTraits< Op >
struct  OperatorTraits< OpAssign >

Defines

#define PETE_USER_REDUCTION_CODE
#define PETE_DefineScalarMinMax(Sca)
#define PETE_DefineIPPLScalar(Sca)
#define PETE_DefineBinaryWithVSTScalars(Fun, Op, Sca)
#define PETE_DefineTrinaryWithVSTScalars(Fun, Op, Sca)
#define PETE_DefineVSTScalar(Sca)

Functions

 PETE_DefineUnary (Abs,(0< a?a:-a), FnAbs) inline double PETE_apply(FnAbs
T::PETE_Expr_t abs (const PETE_Expr< T > &l)
 PETE_DefineUnary (conj,(conj(a)), FnConj) PETE_DefineUnary(arg
 arg (a))
FnArg PETE_DefineUnary (norm,(norm(a)), FnNorm) PETE_DefineUnary(real
FnArg FnReal PETE_DefineUnary (imag,(imag(a)), FnImag) PETE_DefineUnary(sign
FnArg FnReal sign (a))
FnArg FnReal FnSign PETE_DefineUnary (trace,(trace(a)), FnTrace) PETE_DefineUnary(transpose
FnArg FnReal FnSign transpose (a))
FnArg FnReal FnSign FnTranspose PETE_DefineUnary (det,(det(a)), FnDet) PETE_DefineUnary(cofactors
FnArg FnReal FnSign FnTranspose cofactors (a))
 PETE_DefineScalarMinMax (short) PETE_DefineScalarMinMax(int) PETE_DefineScalarMinMax(long) PETE_DefineScalarMinMax(float) PETE_DefineScalarMinMax(double) PETE_DefineBinary(Min
 Min (a, b))
FnMin PETE_DefineBinary (Max,(Max(a, b)), FnMax) PETE_DefineBinary(dot
FnMin FnDot PETE_DefineBinary (dotdot,(dotdot(a, b)), FnDotDot) PETE_DefineBinary(outerProduct
FnMin FnDot outerProduct (a, b))
FnMin FnDot FnOuterProduct PETE_DefineBinary (cross,(cross(a, b)), FnCross) PETE_DefineBinarySynonym(lt
FnMin FnDot FnOuterProduct
OpLT 		PETE_DefineBinarySynonym (gt, OpGT) PETE_DefineBinarySynonym(le
FnMin FnDot FnOuterProduct
OpLT OpLE 		PETE_DefineBinarySynonym (ge, OpGE) PETE_DefineBinarySynonym(eq
FnMin FnDot FnOuterProduct
OpLT OpLE OpEQ 		PETE_DefineBinarySynonym (ne, OpNE) PETE_DefineIPPLScalar(short) PETE_DefineIPPLScalar(int) PETE_DefineIPPLScalar(long) PETE_DefineIPPLScalar(float) PETE_DefineIPPLScalar(double) PETE_DefineScalar(dcomplex) PETE_DefineBinaryWithScalars(eq
FnMin FnDot FnOuterProduct
OpLT OpLE OpEQ dcomplex 		PETE_DefineBinaryWithScalars (ne, OpNE, dcomplex) PETE_DefineVSTScalar(Vektor) PETE_DefineVSTScalar(SymTenzor) PETE_DefineVSTScalar(Tenzor) PETE_DefineAssign((a
template<class T1, class T2>
void minmax (const PETE_Expr< T1 > &expr, T2 &minval, T2 &maxval)
template<class T1, class T2>
bool any (const PETE_Expr< T1 > &expr, T2 val)
template<class T1, class T2, class Op>
bool any (const PETE_Expr< T1 > &expr, T2 val, Op op)
template<class T1, class T2, unsigned int D>
void bounds (const PETE_Expr< T1 > &expr, Vektor< T2, D > &minval, Vektor< T2, D > &maxval)
template<class T, class TP>
PETEUnaryReturn< T, OpParens<
TP > >::type 		PETE_apply (OpParens< TP > op, const T &a)

Variables

FnArg real (a))
FnMin dot (a, b))
FnMin FnDot FnOuterProduct
OpLT OpLE OpEQ 		OpEQ

Define Documentation

#define PETE_DefineBinaryWithVSTScalars (  Fun,
Op,
Sca   ) 
 

Value:

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

#define PETE_DefineIPPLScalar (  Sca   ) 
 

Value:

PETE_DefineBinaryWithScalars(Min, FnMin, Sca)                               \
PETE_DefineBinaryWithScalars(Max, FnMax, Sca)                               \
PETE_DefineBinaryWithScalars(dot, FnDot, Sca)                               \
PETE_DefineBinaryWithScalars(dotdot, FnDotDot, Sca)                         \
PETE_DefineBinaryWithScalars(outerProduct, FnOuterProduct, Sca)             \
PETE_DefineBinaryWithScalars(cross, FnDot, Sca)                             \
PETE_DefineBinaryWithScalars(lt, OpLT, Sca)                                 \
PETE_DefineBinaryWithScalars(le, OpLE, Sca)                                 \
PETE_DefineBinaryWithScalars(gt, OpGT, Sca)                                 \
PETE_DefineBinaryWithScalars(ge, OpGE, Sca)                                 \
PETE_DefineBinaryWithScalars(eq, OpEQ, Sca)                                 \
PETE_DefineBinaryWithScalars(ne, OpNE, Sca)

#define PETE_DefineScalarMinMax (  Sca   ) 
 

Value:

inline Sca                                                                \
Min(const Sca& a, const Sca& b)                                           \
{                                                                         \
  return (a<b ? a : b);                                                   \
}                                                                         \
inline Sca                                                                \
Max(const Sca& a, const Sca& b)                                           \
{                                                                         \
  return (b<a ? a : b);                                                   \
}

Definition at line 87 of file IpplExpressions.h.

#define PETE_DefineTrinaryWithVSTScalars (  Fun,
Op,
Sca   ) 
 

#define PETE_DefineVSTScalar (  Sca   ) 
 

#define PETE_USER_REDUCTION_CODE
 

Value:

R global_ret;                                                             \
  reduce_masked(ret, global_ret, acc_op, 0 < n );                           \
  ret = global_ret;

Definition at line 32 of file IpplExpressions.h.

Function Documentation

T::PETE_Expr_t abs (  const PETE_Expr< T > &  l  ) 
 

Definition at line 62 of file IpplExpressions.h.

References PETE_Expr< WrappedExpr >::PETE_unwrap().

Here is the call graph for this function:

template<class T1, class T2, class Op>
bool any (  const PETE_Expr< T1 > &  expr,
T2  val,
Op  op
) 
 

Definition at line 464 of file IpplExpressions.h.

References PETE_Expr< WrappedExpr >::PETE_unwrap(), Reduction(), and AnyHolder< T, OP >::Test.

Here is the call graph for this function:

template<class T1, class T2>
bool any (  const PETE_Expr< T1 > &  expr,
T2  val
) 
 

Definition at line 452 of file IpplExpressions.h.

References OpEQ, PETE_Expr< WrappedExpr >::PETE_unwrap(), Reduction(), and AnyHolder< T, OP >::Test.

Here is the call graph for this function:

arg (  a   ) 
 

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

template<class T1, class T2, unsigned int D>
void bounds (  const PETE_Expr< T1 > &  expr,
Vektor< T2, D > &  minval,
Vektor< T2, D > &  maxval
) 
 

Definition at line 543 of file IpplExpressions.h.

References BoundsHolder< T, D >::a, BoundsHolder< T, D >::b, PETE_Expr< WrappedExpr >::PETE_unwrap(), and Reduction().

Referenced by vizAxesTool::GetGlobalBoundingBox(), and vizAxesTool::GetMaxSideLenOfGlobalBoundingBox().

Here is the call graph for this function:

FnArg FnReal FnSign FnTranspose cofactors (  a   ) 
 

Min (  a  ,
b 
) 
 

template<class T1, class T2>
void minmax (  const PETE_Expr< T1 > &  expr,
T2 &  minval,
T2 &  maxval
) 
 

Definition at line 384 of file IpplExpressions.h.

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

Here is the call graph for this function:

FnMin FnDot outerProduct (  a  ,
b 
) 
 

template<class T, class TP>
PETEUnaryReturn<T,OpParens<TP> >::type PETE_apply (  OpParens< TP >  op,
const T &  a
)  [inline]
 

Definition at line 563 of file IpplExpressions.h.

References a, and OpParens< TP >::Arg.

FnMin FnDot FnOuterProduct PETE_DefineBinary (  cross  ,
(cross(a, b))  ,
FnCross 
) 
 

FnMin FnDot PETE_DefineBinary (  dotdot  ,
(dotdot(a, b))  ,
FnDotDot 
) 
 

FnMin PETE_DefineBinary (  Max  ,
(Max(a, b))  ,
FnMax 
) 
 

FnMin FnDot FnOuterProduct OpLT OpLE OpEQ PETE_DefineBinarySynonym (  ne  ,
OpNE 
) 
 

FnMin FnDot FnOuterProduct OpLT OpLE PETE_DefineBinarySynonym (  ge  ,
OpGE 
) 
 

FnMin FnDot FnOuterProduct OpLT PETE_DefineBinarySynonym (  gt  ,
OpGT 
) 
 

FnMin FnDot FnOuterProduct OpLT OpLE OpEQ dcomplex PETE_DefineBinaryWithScalars (  ne  ,
OpNE  ,
dcomplex 
) 
 

PETE_DefineScalarMinMax (  short   ) 
 

FnArg FnReal FnSign FnTranspose PETE_DefineUnary (  det  ,
(det(a))  ,
FnDet 
) 
 

FnArg FnReal FnSign PETE_DefineUnary (  trace  ,
(trace(a))  ,
FnTrace 
) 
 

FnArg FnReal PETE_DefineUnary (  imag  ,
(imag(a))  ,
FnImag 
) 
 

FnArg PETE_DefineUnary (  norm  ,
(norm(a))  ,
FnNorm 
) 
 

PETE_DefineUnary (  conj  ,
(conj(a))  ,
FnConj 
) 
 

PETE_DefineUnary (  Abs  ,
(0< a?a:-a)  ,
FnAbs 
) 
 

FnArg FnReal sign (  a   ) 
 

FnArg FnReal FnSign transpose (  a   ) 
 

Variable Documentation

FnMin dot(a, b))
 

Referenced by TSV_MetaDot< Tenzor< T1, D >, SymTenzor< T2, D > >::apply(), TSV_MetaDot< SymTenzor< T1, D >, Tenzor< T2, D > >::apply(), TSV_MetaDot< SymTenzor< T1, D >, SymTenzor< T2, D > >::apply(), TSV_MetaDot< Tenzor< T1, D >, Tenzor< T2, D > >::apply(), TSV_MetaDot< Vektor< T1, D >, Vektor< T2, D > >::apply(), and Div().

FnMin FnDot FnOuterProduct OpLT OpLE OpEQ OpEQ
 

Definition at line 142 of file IpplExpressions.h.

Referenced by any().

FnArg real(a))
 

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