src/PETE/IpplTypeComputations.h File Reference

#include "PETE/TypeComputations.h"
#include "AppTypes/dcomplex.h"

Include dependency graph for IpplTypeComputations.h:

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

Go to the source code of this file.

Classes

struct  PETE_Type2Index< dcomplex >
struct  PETE_Type2Index< Vektor< short, 1U > >
struct  PETE_Type2Index< Vektor< int, 1U > >
struct  PETE_Type2Index< Vektor< long, 1U > >
struct  PETE_Type2Index< Vektor< float, 1U > >
struct  PETE_Type2Index< Vektor< double, 1U > >
struct  PETE_Type2Index< Vektor< dcomplex, 1U > >
struct  PETE_Type2Index< Vektor< short, 2U > >
struct  PETE_Type2Index< Vektor< int, 2U > >
struct  PETE_Type2Index< Vektor< long, 2U > >
struct  PETE_Type2Index< Vektor< float, 2U > >
struct  PETE_Type2Index< Vektor< double, 2U > >
struct  PETE_Type2Index< Vektor< dcomplex, 2U > >
struct  PETE_Type2Index< Vektor< short, 3U > >
struct  PETE_Type2Index< Vektor< int, 3U > >
struct  PETE_Type2Index< Vektor< long, 3U > >
struct  PETE_Type2Index< Vektor< float, 3U > >
struct  PETE_Type2Index< Vektor< double, 3U > >
struct  PETE_Type2Index< Vektor< dcomplex, 3U > >
struct  PETE_Type2Index< SymTenzor< short, 1U > >
struct  PETE_Type2Index< SymTenzor< int, 1U > >
struct  PETE_Type2Index< SymTenzor< long, 1U > >
struct  PETE_Type2Index< SymTenzor< float, 1U > >
struct  PETE_Type2Index< SymTenzor< double, 1U > >
struct  PETE_Type2Index< SymTenzor< dcomplex, 1U > >
struct  PETE_Type2Index< SymTenzor< short, 2U > >
struct  PETE_Type2Index< SymTenzor< int, 2U > >
struct  PETE_Type2Index< SymTenzor< long, 2U > >
struct  PETE_Type2Index< SymTenzor< float, 2U > >
struct  PETE_Type2Index< SymTenzor< double, 2U > >
struct  PETE_Type2Index< SymTenzor< dcomplex, 2U > >
struct  PETE_Type2Index< SymTenzor< short, 3U > >
struct  PETE_Type2Index< SymTenzor< int, 3U > >
struct  PETE_Type2Index< SymTenzor< long, 3U > >
struct  PETE_Type2Index< SymTenzor< float, 3U > >
struct  PETE_Type2Index< SymTenzor< double, 3U > >
struct  PETE_Type2Index< SymTenzor< dcomplex, 3U > >
struct  PETE_Type2Index< Tenzor< short, 1U > >
struct  PETE_Type2Index< Tenzor< int, 1U > >
struct  PETE_Type2Index< Tenzor< long, 1U > >
struct  PETE_Type2Index< Tenzor< float, 1U > >
struct  PETE_Type2Index< Tenzor< double, 1U > >
struct  PETE_Type2Index< Tenzor< dcomplex, 1U > >
struct  PETE_Type2Index< Tenzor< short, 2U > >
struct  PETE_Type2Index< Tenzor< int, 2U > >
struct  PETE_Type2Index< Tenzor< long, 2U > >
struct  PETE_Type2Index< Tenzor< float, 2U > >
struct  PETE_Type2Index< Tenzor< double, 2U > >
struct  PETE_Type2Index< Tenzor< dcomplex, 2U > >
struct  PETE_Type2Index< Tenzor< short, 3U > >
struct  PETE_Type2Index< Tenzor< int, 3U > >
struct  PETE_Type2Index< Tenzor< long, 3U > >
struct  PETE_Type2Index< Tenzor< float, 3U > >
struct  PETE_Type2Index< Tenzor< double, 3U > >
struct  PETE_Type2Index< Tenzor< dcomplex, 3U > >
struct  PETE_Index2Type< 8 >
struct  PETE_Index2Type< 30 >
struct  PETE_Index2Type< 31 >
struct  PETE_Index2Type< 32 >
struct  PETE_Index2Type< 33 >
struct  PETE_Index2Type< 34 >
struct  PETE_Index2Type< 35 >
struct  PETE_Index2Type< 40 >
struct  PETE_Index2Type< 41 >
struct  PETE_Index2Type< 42 >
struct  PETE_Index2Type< 43 >
struct  PETE_Index2Type< 44 >
struct  PETE_Index2Type< 45 >
struct  PETE_Index2Type< 50 >
struct  PETE_Index2Type< 51 >
struct  PETE_Index2Type< 52 >
struct  PETE_Index2Type< 53 >
struct  PETE_Index2Type< 54 >
struct  PETE_Index2Type< 55 >
struct  PETE_Index2Type< 130 >
struct  PETE_Index2Type< 131 >
struct  PETE_Index2Type< 132 >
struct  PETE_Index2Type< 133 >
struct  PETE_Index2Type< 134 >
struct  PETE_Index2Type< 135 >
struct  PETE_Index2Type< 140 >
struct  PETE_Index2Type< 141 >
struct  PETE_Index2Type< 142 >
struct  PETE_Index2Type< 143 >
struct  PETE_Index2Type< 144 >
struct  PETE_Index2Type< 145 >
struct  PETE_Index2Type< 150 >
struct  PETE_Index2Type< 151 >
struct  PETE_Index2Type< 152 >
struct  PETE_Index2Type< 153 >
struct  PETE_Index2Type< 154 >
struct  PETE_Index2Type< 155 >
struct  PETE_Index2Type< 230 >
struct  PETE_Index2Type< 231 >
struct  PETE_Index2Type< 232 >
struct  PETE_Index2Type< 233 >
struct  PETE_Index2Type< 234 >
struct  PETE_Index2Type< 235 >
struct  PETE_Index2Type< 240 >
struct  PETE_Index2Type< 241 >
struct  PETE_Index2Type< 242 >
struct  PETE_Index2Type< 243 >
struct  PETE_Index2Type< 244 >
struct  PETE_Index2Type< 245 >
struct  PETE_Index2Type< 250 >
struct  PETE_Index2Type< 251 >
struct  PETE_Index2Type< 252 >
struct  PETE_Index2Type< 253 >
struct  PETE_Index2Type< 254 >
struct  PETE_Index2Type< 255 >
struct  FnAbs
struct  PETEUnaryReturn< dcomplex, FnAbs >
struct  FnConj
struct  FnNorm
struct  PETEUnaryReturn< dcomplex, FnNorm >
struct  FnArg
struct  PETEUnaryReturn< dcomplex, FnArg >
struct  FnReal
struct  PETEUnaryReturn< dcomplex, FnReal >
struct  FnImag
struct  PETEUnaryReturn< dcomplex, FnImag >
struct  FnSign
struct  OpParens< TP >
struct  FnTrace
struct  FnDet
struct  FnTranspose
struct  FnCofactors
struct  FnMin
struct  FnMax
struct  FnDot
struct  FnDotDot
struct  FnOuterProduct
struct  FnCross
struct  OpMinAssign
struct  OpMaxAssign
struct  OpAndAssign
struct  OpOrAssign

Defines

#define _SCALAR_RNG_OP_RETURNS_(GEN, SCA, OP)
#define _SCALAR_RNG_RETURNS_(GEN, SCA)
#define _PETE_RNG_RETURNS_(GEN)
#define _UNARY_TENSOR_RETURNS_(T, D)
#define _VEKTOR_RETURNS_(T1, T2, Dim)
#define _TENZOR_RETURNS_(T1, T2, Dim)
#define _SYMTENZOR_RETURNS_(T1, T2, Dim)
#define _ANTISYMTENZOR_RETURNS_(T1, T2, Dim)
#define _PETE_DEFINE_PARENS_RETURNS_(T, D)

Functions

template<class T>
int sign (T a)

Define Documentation

#define _ANTISYMTENZOR_RETURNS_ (  T1,
T2,
Dim   ) 
 

Definition at line 1563 of file IpplTypeComputations.h.

#define _PETE_DEFINE_PARENS_RETURNS_ (  T,
D   ) 
 

Value:

template<> struct PETEUnaryReturn<class Vektor<T,D>,OpParens<int> >         \
  { typedef T type; };                                                      \
template<> struct                                                           \
  PETEUnaryReturn<class Tenzor<T,D>,OpParens<pair<int,int> > >              \
  { typedef T type; };                                                      \
template<> struct                                                           \
  PETEUnaryReturn<class AntiSymTenzor<T,D>,OpParens<pair<int,int> > >       \
  { typedef T type; };                                                      \
template<> struct                                                           \
  PETEUnaryReturn<class SymTenzor<T,D>,OpParens<pair<int,int> > >           \
  { typedef T type; };

Definition at line 1798 of file IpplTypeComputations.h.

#define _PETE_RNG_RETURNS_ (  GEN   ) 
 

Value:

\
template <> struct PETE_Type2Index< GEN > {                             \
  enum { val = PETE_Type2Index<double>::val };                          \
};                                                                      \
                                                                        \
_SCALAR_RNG_RETURNS_(GEN,short)                                         \
_SCALAR_RNG_RETURNS_(GEN,int)                                           \
_SCALAR_RNG_RETURNS_(GEN,long)                                          \
_SCALAR_RNG_RETURNS_(GEN,float)                                         \
_SCALAR_RNG_RETURNS_(GEN,double)                                        \
_SCALAR_RNG_RETURNS_(GEN,dcomplex)

Definition at line 84 of file IpplTypeComputations.h.

#define _SCALAR_RNG_OP_RETURNS_ (  GEN,
SCA,
OP   ) 
 

Value:

template <>                                                             \
struct PETEBinaryReturn<GEN,SCA,OP> {                                   \
  typedef PETEBinaryReturn<double,SCA,OP>::type type;                   \
};                                                                      \
template <>                                                             \
struct PETEBinaryReturn<SCA,GEN,OP> {                                   \
  typedef PETEBinaryReturn<SCA,double,OP>::type type;                   \
};

Definition at line 68 of file IpplTypeComputations.h.

#define _SCALAR_RNG_RETURNS_ (  GEN,
SCA   ) 
 

Value:

_SCALAR_RNG_OP_RETURNS_(GEN,SCA,OpAdd)                                  \
_SCALAR_RNG_OP_RETURNS_(GEN,SCA,OpSubtract)                             \
_SCALAR_RNG_OP_RETURNS_(GEN,SCA,OpMultipply)                             \
_SCALAR_RNG_OP_RETURNS_(GEN,SCA,OpDivide)

Definition at line 78 of file IpplTypeComputations.h.

#define _SYMTENZOR_RETURNS_ (  T1,
T2,
Dim   ) 
 

Definition at line 1440 of file IpplTypeComputations.h.

#define _TENZOR_RETURNS_ (  T1,
T2,
Dim   ) 
 

Value:

template<> struct PETEBinaryReturn<Tenzor<T1,Dim>,Tenzor<T2,Dim>, FnDot>    \
  { typedef                                                                 \
    Tenzor<PETEBinaryReturn<T1,T2,OpMultipply>::type,Dim> type; };           \
template<> struct PETEBinaryReturn<Tenzor<T1,Dim>,Tenzor<T2,Dim>, FnDotDot> \
  { typedef PETEBinaryReturn<T1,T2,OpMultipply>::type type; };              \
template<> struct PETEBinaryReturn<Vektor<T1,Dim>,Tenzor<T2,Dim>, FnDot>    \
  { typedef                                                                 \
    Vektor<PETEBinaryReturn<T1,T2,OpMultipply>::type,Dim> type; };           \
template<> struct PETEBinaryReturn<Tenzor<T1,Dim>,Vektor<T2,Dim>, FnDot>    \
  { typedef                                                                 \
    Vektor<PETEBinaryReturn<T1,T2,OpMultipply>::type,Dim> type; };           \
template<> struct PETEBinaryReturn<T1,Tenzor<T2,Dim>,OpMultipply>           \
  { typedef                                                                 \
    Tenzor<PETEBinaryReturn<T1,T2,OpMultipply>::type,Dim> type; };           \
template<> struct PETEBinaryReturn<Tenzor<T1,Dim>,T2,OpMultipply>           \
  { typedef                                                                 \
    Tenzor<PETEBinaryReturn<T1,T2,OpMultipply>::type,Dim> type; };           \
template<> struct PETEBinaryReturn<Tenzor<T1,Dim>,T2,OpDivide>              \
  { typedef                                                                 \
    Tenzor<PETEBinaryReturn<T1,T2,OpDivide>::type,Dim> type; };

Definition at line 1349 of file IpplTypeComputations.h.

#define _UNARY_TENSOR_RETURNS_ (  T,
D   ) 
 

Value:

template<> struct PETEUnaryReturn<Tenzor<T,D>, FnTrace>                     \
{ typedef T type; };                                                        \
template<> struct PETEUnaryReturn<SymTenzor<T,D>, FnTrace>                  \
{ typedef T type; };                                                        \
template<> struct PETEUnaryReturn<AntiSymTenzor<T,D>, FnTrace>              \
{ typedef T type; };                                                        \
template<> struct PETEUnaryReturn<Tenzor<T,D>, FnDet>                       \
{ typedef T type; };                                                        \
template<> struct PETEUnaryReturn<SymTenzor<T,D>, FnDet>                    \
{ typedef T type; };                                                        \
template<> struct PETEUnaryReturn<AntiSymTenzor<T,D>, FnDet>                \
{ typedef T type; };                                                        \
template<> struct PETEUnaryReturn<Tenzor<T,D>, FnTranspose>                 \
{ typedef Tenzor<T,D> type; };                                              \
template<> struct PETEUnaryReturn<SymTenzor<T,D>, FnTranspose>              \
{ typedef SymTenzor<T,D> type; }                                            \
template<> struct PETEUnaryReturn<AntiSymTenzor<T,D>, FnTranspose>          \
{ typedef AntiSymTenzor<T,D> type; }                                        \
template<> struct PETEUnaryReturn<Tenzor<T,D>, FnCofactors>                 \
{ typedef Tenzor<T,D> type; };                                              \
template<> struct PETEUnaryReturn<SymTenzor<T,D>, FnCofactors>              \
{ typedef Tenzor<T,D> type; }                                               \
template<> struct PETEUnaryReturn<AntiSymTenzor<T,D>, FnCofactors>          \
{ typedef SymTenzor<T,D> type; }

Definition at line 837 of file IpplTypeComputations.h.

#define _VEKTOR_RETURNS_ (  T1,
T2,
Dim   ) 
 

Value:

template<> struct                                                           \
  PETEBinaryReturn<Vektor<T1,Dim>,Vektor<T2,Dim>, FnOuterProduct>           \
  { typedef Tenzor<PETEBinaryReturn<T1,T2,OpMultipply>::type,Dim>            \
    type; };                                                                \
template<> struct PETEBinaryReturn<Vektor<T1,Dim>,Vektor<T2,Dim>,FnDot>     \
  { typedef PETEBinaryReturn<T1,T2,OpMultipply>::type type; };              \
template<> struct PETEBinaryReturn<Vektor<T1,Dim>,T2,OpMultipply>           \
  { typedef Vektor<PETEBinaryReturn<T1,T2,OpMultipply>::type,Dim>            \
    type; };                                                                \
template<> struct PETEBinaryReturn<T2,Vektor<T1,Dim>,OpMultipply>           \
  { typedef Vektor<PETEBinaryReturn<T1,T2,OpMultipply>::type,Dim>            \
    type; };                                                                \
template<> struct PETEBinaryReturn<Vektor<T1,Dim>,T2,OpDivide>              \
  { typedef Vektor<PETEBinaryReturn<T1,T2,OpDivide>::type,Dim>              \
    type; };                                                                \
template<> struct PETEBinaryReturn<Vektor<T1,Dim>,Vektor<T2,Dim>,FnCross>   \
  { typedef Vektor<PETEBinaryReturn<T1,T2,OpMultipply>::type,Dim> type; };

Definition at line 1262 of file IpplTypeComputations.h.

Function Documentation

template<class T>
int sign (  T  a  )  [inline]
 

Definition at line 51 of file IpplTypeComputations.h.

References sign().

Here is the call graph for this function:

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