/Users/mourrain/Devel/mmx/realroot/include/realroot/texp_expression.hpp

Go to the documentation of this file.

#ifndef realroot_ARITHM_TEXP_TEMPLATE_EXPRESSION_H
#define realroot_ARITHM_TEXP_TEMPLATE_EXPRESSION_H
#include <iostream>
#include <realroot/assign.hpp>
#include <realroot/texp_sup.hpp>
#include <realroot/texp_structureof.hpp>

namespace mmx {

namespace texp {

  template<class F, class X, class Y>
  struct operator_iscommutative  
  {
    enum { V = 0 };
    typedef texp::false_t T;
  };
  // in place example
  //  G(r,s,t) (1) ==> r = s; G(r,z) (2)
  // (2) is better than (1) if G is "in place" otherwise G(r,z) ==> G(r,s=r,z) (3)
  // and (3) is worst than (1).
  // note: makes sense if s or t are unevaluated expression, (2) is better because the 
  // expression s will be evaluated in the same memory space as the following call to operator.
  // note: able to "unroll" (a . b.  c. d) as r = a, r.= b, r .=c, r .=d
  template<class F, class X, class Y>
  struct operator_isinplace
  {
    enum { V = 0 };
    typedef texp::false_t T;
  };
  
  template<class op, class X>
  struct unary_operator_prototype
  {
    typedef X F;
    typedef X U; 
  };
  
  
  template<class op, class X, class Y, class SX, class SY>
  struct binary_operator_structure_prototype
  {
    typedef typename sup< X, Y >::T F; 
    typedef X                       U;
    typedef Y                       V;
  };

  template<class op, class X, class Y>
  struct binary_operator_prototype
  {
    typedef binary_operator_structure_prototype< op, X, Y, 
                                                 typename structureof<X>::T, 
                                                 typename structureof<Y>::T > proto;
    typedef typename proto::F F;
    typedef typename proto::U U;
    typedef typename proto::V V;
  };
  
  template<typename O, typename A>             struct unary_operator  {};
  template<typename O, typename A, typename B> struct binary_operator {};
  template< class A >
  struct template_expression_operand { typedef const A & T; };
  template<>
  struct template_expression_operand<int> { typedef int  T; };
  
  template<class A>
  struct template_expression 
  {
    typedef true_t terminal_t;
    typedef A            E;
    typename template_expression_operand<A>::T  a;
    inline const   A & term() const { return a; };
    template<class X> operator X() { return X(term()); };
    template_expression( const A & a ) : a(a) {};
  };
  
  
  template< class O, class A > 
  struct template_expression< unary_operator<O,A> > 
  {
    typedef false_t terminal_t;
    typedef typename unary_operator_prototype<O,typename A::E>::F E;
    typedef typename unary_operator_prototype<O,typename A::E>::U L;

    A a;
    
    operator E() 
    { 
      E tmp; 
      eval(tmp); 
      return tmp; 
    };
  
    
    template<class E> inline template_expression( const E& e ): a(e.a) { };
    inline template_expression( const A& _a ): a(_a) {};

    
    template<class R>
    static inline void  evalterm ( E & r, R & l  ) { L tmp; let::assign(tmp,l); O()(r,l); };
    static inline void  evalterm ( E & r, L & l  ) { O()(r,l); };
    
    inline void  evaltree( E & r ) const 
    { 
      L tmp; 
      a.eval(tmp);
      O()(r,tmp);
    };
    
    inline void  eval    ( E & r, const false_t & ) const { evaltree( r );      };
    inline void  eval    ( E & r, const true_t& )   const { evalterm( r, a.a ); };
    inline void  eval    ( E & r ) const  { eval(r,typename A::terminal_t()); };
    template<class R> 
    inline void eval( R & r ) const 
    { 
      E tmp; 
      eval(tmp);
      let::assign(r,tmp);
    };
  }; 


  // evaluation on terminals.

  
  template< class O, class A, class B>
  struct template_expression< binary_operator< O, A, B > >
  {
    typedef texp::false_t false_t;
    typedef texp::true_t  true_t;
    typedef texp::false_t terminal_t;

    A a;
    B b;
    typedef O Operator;
    typedef binary_operator_prototype< O, typename A::E, typename B::E > S;
    typedef typename S::F E;
    typedef typename S::U L;
    typedef typename S::V R;
  
    inline operator E() { E tmp; eval(tmp); return tmp; };
    
    inline template_expression(){};
    template<class E>
    inline template_expression( const E& e ) { a = e.a; b = e.b; };
    inline template_expression( const A& _a, const B& _b ) : a(_a), b(_b) {};
  
    template<class S>
    bool operator!=( const S& s )
    {
      E tmp;
      eval(tmp);
      return tmp != s;
    };
    
  public:
    inline void eval( E & e, const L & l, const R & r ) const { O()(e,l,r); };
    
    template<class X> inline
    void eval( E & r, const  X & a, const R & b )  const
    { 
      using namespace let;
      L _a;
      let::assign(_a,a);
      O()(r,_a,b);
    };
    
    template<class Y> inline
    void eval( E & r, const L & a, const Y & b ) const
    {
      using namespace let;
      R _b;
      let::assign(_b,b);
      O()(r,a,_b);
    };
    
    template<class X, class Y> inline
    void eval( E & r, const X & a, const Y & b ) const
    {
      L _a;
      R _b;
      using namespace let;
      let::assign(_a,a);
      let::assign(_b,b);
      O()( r, _a, _b );
    };

    inline void _eval_( E& r, const false_t&, const false_t&  ) const
    {
      /*      if ( isinplace< O, L, R >::V )
        { 
          a._eval_(r);
          R b_;
          b.eval(b_);
          eval(r,b.a); 
        }
        else */
        { 
          L _a; a._eval_(_a);
          R _b; b._eval_(_b);
          eval(r,_a,_b);
        };
    };

    inline void eval( E& r, const false_t&, const false_t&  ) const
    {
      L _a; a._eval_(_a); 
      R _b; b._eval_(_b);
      eval(r,_a,_b);
    };
    
    inline void _eval_( E & r, const false_t&, const true_t& ) const 
    {
      /*      if ( isinplace< O, L, R >::V ) (check if E == A::E)
        { a._eval_( r ); eval(r,b.a); }
      else 
      */

        { L _a; a._eval_(_a); eval(r,_a,b.a); };
    };
    inline void  eval ( E & r, const false_t&, const true_t& ) const 
    { 
      L _a; 
      a._eval_(_a); 
      eval(r,_a,b.a); 
    };
    
    inline void _eval_( E & r, const true_t&, const false_t& ) const 
    {
      /*      if ( isinplace< O, L, R >::V && iscommutative< O, L, R >::V )
        {
          b._eval_(r);
          eval(r,a.a);
        }
        else */
      {
        R b_;
        b._eval_(b_);
        eval(r,a.a,b_);
      };
    };
  
    inline void  eval ( E & r, const true_t&, const false_t& ) const 
    { R _b; b._eval_(_b); eval(r,a.a,_b); };
    
  
    inline void  eval ( E & r, const true_t& , const true_t& ) const { eval(r,a.a,b.a); };
    inline void _eval_( E & r, const true_t& , const true_t& ) const { eval(r,a.a,b.a); };
  
    
    // evaluation on T which is not the result type F of the operator O(A::E,B::E)
    template<class T> inline
    void eval( T & r ) const
    { 
      using namespace let;
      E tmp; 
      _eval_(tmp, typename A::terminal_t(), typename B::terminal_t());
      let::assign(r,tmp);
    };
    // same thing on temporary object
    template<class U> inline
    void _eval_( U & r ) const 
    {
      using namespace let;
      E tmp;
      _eval_(tmp,typename A::terminal_t(), typename B::terminal_t());
      let::assign(r,tmp);
    };
    
    inline void eval( E& r ) const { eval( r, typename A::terminal_t(), typename B::terminal_t() ); };
    inline void _eval_( E& r ) const { _eval_( r, typename A::terminal_t(), typename B::terminal_t() ); };
    //template<class X> operator X() { X tmp; eval(tmp,*this); return tmp; };
    /*    operator E() { 
          E tmp; 
          _eval_(tmp); 
          return tmp; 
          };
    */
  };

  
  template< class A > inline
  std::ostream& operator<<( std::ostream& o, const template_expression<A>& e )
  { 
    o << (e.a);
    return o;
  };

  template< class O, class A > inline
  std::ostream& operator<<( std::ostream& o, const template_expression< unary_operator< O, A > > & a )
  {
    return (o << O::name() << "(" << a.a << ")");
  };

  template< class O, class A, class B > inline
  std::ostream& operator<<( std::ostream& o, const template_expression< binary_operator< O, A, B > >& a )
  {
    o << O::name() << "(";
    o << a.a << "," << a.b << ")";
    return o;
  };
}

  //using namespace arithm;

}// end namespace mmx

#include "texp_operators.hpp"
#include "texp_operators_prototypes.hpp"

#endif