/Users/mourrain/Devel/mmx/realroot/include/realroot/texp_operators.hpp File Reference

#include <realroot/texp_double.hpp>
#include <realroot/texp_expression.hpp>

Go to the source code of this file.

Namespaces

• namespace mmx

Defines

• #define define_binary_operator_structure(opname, function, call)
• #define define_binary_operator(opname, function, call)
• #define define_unary_operator(opname, function, call)
• #define declare_binary_operator(tp_arg_list, parm0, parm1, opname, function)
• #define declare_unary_operator(tp_arg_list, parm, opname, function)

---

Define Documentation

#define declare_binary_operator	(		tp_arg_list,
			parm0,
			parm1,
			opname,
			function
	)

Value:

tp_arg_list inline \
texp::template_expression< texp::binary_operator< opname,\
texp::template_expression< parm0 >, \
texp::template_expression< parm1 > > > \
function( const parm0 & x, const parm1 & y )\
{ return \
    texp::template_expression< \
    texp::binary_operator< \
    opname, texp::template_expression< parm0 >, texp::template_expression< parm1 > > >\
    (texp::template_expression< parm0 >(x),texp::template_expression< parm1 >(y));\
};\
tp_arg_list inline \
texp::template_expression< texp::binary_operator< opname , \
texp::template_expression< parm0 >,\
texp::template_expression< parm1 > > >\
function( const texp::template_expression<parm0> & x, const parm1 & y )\
{ return texp::template_expression< texp::binary_operator< opname, texp::template_expression< parm0 >, texp::template_expression< parm1 > > >\
 (x,texp::template_expression<parm1>(y)); };\
tp_arg_list inline \
texp::template_expression< texp::binary_operator< opname , \
texp::template_expression< parm0 >, \
texp::template_expression< parm1 > > >\
function( const parm0 & x, const texp::template_expression<parm1> & y )\
{ return texp::template_expression< texp::binary_operator< opname, texp::template_expression< parm0 >, texp::template_expression< parm1 > > >\
(texp::template_expression< parm0 >(x),y); }

Definition at line 121 of file texp_operators.hpp.

#define declare_unary_operator	(		tp_arg_list,
			parm,
			opname,
			function
	)

Value:

tp_arg_list inline \
texp::template_expression< texp::unary_operator< opname, \
                                                     texp::template_expression<parm> > >\
function( const parm& x ) \
{ \
  return texp::template_expression<\
    texp::unary_operator< opname, \
    texp::template_expression<parm> > >( texp::template_expression<parm>(x) ); \
};\

Definition at line 148 of file texp_operators.hpp.

#define define_binary_operator	(		opname,
			function,
			call
	)

Value:

define_binary_operator_structure(opname,function,call)\
template<class X, class Y>  inline                                                 \
texp::template_expression<                                                       \
texp::binary_operator<opname,                                                    \
        texp::template_expression<X>,                                            \
        texp::template_expression<Y> > >                                         \
function( const texp::template_expression<X>& x,                                 \
          const texp::template_expression<Y>& y )                                \
{                                                                                  \
  return texp::template_expression< texp::binary_operator< opname,               \
                                    texp::template_expression<X>,                \
                                    texp::template_expression<Y> > > ( x, y );   \
};                                                                               \
\
template<class X, class Y> inline                                                \
texp::template_expression<                                                       \
texp::binary_operator<opname,                                                    \
        texp::template_expression<X>,                                            \
        texp::template_expression<Y> > >                                         \
function( const texp::template_expression<X>& x, const Y& y )                    \
{                                                                                  \
  return texp::template_expression< texp::binary_operator< opname,             \
                                      texp::template_expression<X>,              \
                                      texp::template_expression<Y> > >           \
                                   ( x, texp::template_expression<Y>(y));        \
};                                                                                 \
\
template<class X, class Y> inline                                                  \
texp::template_expression<                                                       \
texp::binary_operator<opname,                                                    \
                        texp::template_expression<X>,                            \
                        texp::template_expression<Y> > >                         \
function( const X& x, const texp::template_expression<Y>& y )                    \
{                                                                                  \
  return                                                                           \
    texp::template_expression< texp::binary_operator<opname                    \
    ,                            texp::template_expression<X>                    \
    ,                            texp::template_expression<Y> > >                \
    (texp::template_expression<X>(x),y);                                         \
};                                                                                 \
\
template<class X,class Y>                                                          \
X & call( X & r, const texp::template_expression<Y> & exp )                      \
{                                                                                  \
  typename template_expression<Y>::E tmp;                                          \
  exp.eval(tmp);                                                                   \
  call(r,tmp);                                                                     \
  return r;                                                                        \
}                                                                                  \

Definition at line 26 of file texp_operators.hpp.

#define define_binary_operator_structure	(		opname,
			function,
			call
	)

Value:

\
struct opname                                             \
{                                                         \
  inline static const char * name() { return #call; };    \
  template < class A, class B, class C > inline           \
  void operator()( A & a, const B & b, const C & c) const \
  {                                                       \
    call (a, b, c);                                       \
  };                                                      \
  template < class A, class B > inline                    \
  void operator()( A & a, const B & b )             const \
  {                                                       \
    call (a, b);                                          \
  };                                                      \
};                                                        \

Definition at line 9 of file texp_operators.hpp.

#define define_unary_operator	(		opname,
			function,
			call
	)

Value:

\
struct opname                                      \
{                                                  \
  inline static const char * name()                \
  {                                                \
    return #call;                                  \
  };                                               \
                                                   \
  template < class A, class B > inline             \
  void operator()(A & a, const B & b) const        \
  {                                                \
    call (a, b);                                   \
  };                                               \
  template < class A> inline                       \
  void operator()(A & a) const                     \
  {                                                \
    call (a);                                      \
  };                                               \
};                                                 \
\
template<class X> inline                                            \
texp::template_expression<                                        \
  unary_operator< opname,                                           \
                  texp::template_expression<X> > >                \
function( const texp::template_expression<X>& x )                 \
{                                                                   \
  return                                                            \
    texp::template_expression<                                    \
    unary_operator<opname, texp::template_expression<X> > >( x ); \
};                                                                  \
\
template<class X> inline                                            \
texp::template_expression<                                        \
  unary_operator< opname,                                           \
                  texp::template_expression<X> > >                \
function( const X& x )                                              \
{                                                                   \
  return                                                            \
    texp::template_expression<                                    \
    unary_operator<opname, texp::template_expression<X> > >       \
    ( texp::template_expression<X>(x) );                          \
};                                                                  \

Definition at line 77 of file texp_operators.hpp.