synaps/arithm/REF.h

/*********************************************************************
*      This file is part of the source code of SYNAPS kernel.        *
*   Author(s): B. Mourrain, GALAAD, INRIA                            *
**********************************************************************
**********************************************************************/
#ifndef SYNAPS_ARITHM_REF_H
#define SYNAPS_ARITHM_REF_H
//---------------------------------------------------------------------
#include <synaps/init.h>
#include <synaps/arithm/let.h>
#include <synaps/arithm/GENERIC.h>
//---------------------------------------------------------------------
__BEGIN_NAMESPACE_SYNAPS


template<class R>
struct VAL {
  R  _rep;

  const R & rep() const { return _rep;}
  
  VAL() {}
  VAL(const R & r): _rep(r){}
  VAL(const VAL<R> & r): _rep(r._rep){ }

};
//----------------------------------------------------------------------
template<class R> inline
R * operator&( const VAL<R*> & x) {return x.rep();}
//----------------------------------------------------------------------
template<class R> inline
VAL<R> Convert(const R & r) {return VAL<R>(r);}
//----------------------------------------------------------------------
template<class R> inline
VAL<R> Eval (const R & r)   {return VAL<R>(r);}
//----------------------------------------------------------------------
template<class R> inline
VAL<R> Eval (const VAL<R> & r)  {return r;}
//----------------------------------------------------------------------
namespace let {
  template<class R,class T> void assign(R & r, const VAL<T> & x)
  { assign(r,x.rep()); }
}
//----------------------------------------------------------------------
template<class R> inline
std::ostream & operator<<(std::ostream & os, const VAL<R*> & x)
{
  return (os<<*(x.rep()));
}
//----------------------------------------------------------------------
template <class R,class S> inline 
VAL< OP<'+',R,VAL<S> > >
  operator+(const R & a, const VAL<S>& b)
{
  return VAL<OP<'+',R,VAL<S> > >(OP<'+',R,VAL<S> >(a,b));
}
template <class R,class S> inline 
VAL<OP<'+',VAL<R>,S> >
  operator+(const VAL<R> & a, const S & b)
{
  return VAL<OP<'+',VAL<R>,S> >(OP<'+',VAL<R>,S>(a,b));
}
template <class R,class S> inline 
VAL< OP<'+',VAL<R>,VAL<S> > >
  operator+(const VAL<R> & a, const VAL<S>& b)
{
  return VAL<OP<'+',VAL<R>,VAL<S> > >(OP<'+',VAL<R>,VAL<S> >(a,b));
}
//----------------------------------------------------------------------
template <class R,class S> inline 
VAL<OP<'-',R,VAL<S> > >
  operator-(const R & a, const VAL<S>& b)
{
  return VAL<OP<'-',R,VAL<S> > >(OP<'-',R,VAL<S> >(a,b));
}
template <class R,class S> inline 
VAL<OP<'-',VAL<R>,S> >
  operator-(const VAL<R> & a, const S & b)
{
  return VAL<OP<'-',VAL<R>,S> >(OP<'-',VAL<R>,S>(a,b));
}
template <class R,class S> inline 
VAL<OP<'-',VAL<R>,VAL<S> > >
  operator-(const VAL<R> & a, const VAL<S>& b)
{
  return VAL<OP<'-',VAL<R>,VAL<S> > >(OP<'-',VAL<R>,VAL<S> >(a,b));
}
//----------------------------------------------------------------------
template <class R,class S> inline 
VAL<OP<'*',R,VAL<S> > >
  operator*(const R & a, const VAL<S>& b)
{
  return VAL<OP<'*',R,VAL<S> > >(OP<'*',R,VAL<S> >(a,b));
}
template <class R,class S> inline 
VAL<OP<'*',VAL<R>,S> >
  operator*(const VAL<R> & a, const S & b)
{
  return VAL<OP<'*',VAL<R>,S> >(OP<'*',VAL<R>,S>(a,b));
}
template <class R,class S> inline 
VAL<OP<'*',VAL<R>,VAL<S> > >
  operator*(const VAL<R> & a, const VAL<S>& b)
{
  return VAL<OP<'*',VAL<R>,VAL<S> > >(OP<'*',VAL<R>,VAL<S> >(a,b));
}
//----------------------------------------------------------------------
template <class R,class S> inline 
VAL<OP<'/',R,VAL<S> > >
  operator/(const R & a, const VAL<S>& b)
{
  return VAL<OP<'/',R,VAL<S> > >(OP<'/',R,VAL<S> >(a,b));
}
template <class R,class S> inline 
VAL<OP<'/',VAL<R>,S> >
  operator/(const VAL<R> & a, const S & b)
{
  return VAL<OP<'/',VAL<R>,S> >(OP<'/',VAL<R>,S>(a,b));
}
template <class R,class S> inline 
VAL<OP<'/',VAL<R>,VAL<S> > >
  operator/(const VAL<R> & a, const VAL<S>& b)
{
  return VAL<OP<'/',VAL<R>,VAL<S> > >(OP<'/',VAL<R>,VAL<S> >(a,b));
}
//----------------------------------------------------------------------
template <class R,class S> inline 
VAL<OP<'^',VAL<R>,S> >
  operator^(const VAL<R> & a, const S & b)
{
  return VAL<OP<'^',VAL<R>,S> >(OP<'^',VAL<R>,S>(a,b));
}
//---------------------------------------------------------------------
template<class R> inline
std::ostream & operator << (std::ostream & os,const VAL<R> & M)
{
  os <<M.rep(); return os;
}
//----------------------------------------------------------------------
namespace let {
  template<class R,class X> inline
  void assign(R & r,const OP<'+',X,int> & x) {add(r,x.op1.rep(),x.op2);}

  template<class R,class X,class Y> inline
  void assign(R & r,const OP<'+',X,Y> & x)
  {add(r.rep(),x.op1.rep(),x.op2.rep());}
  
  template<class R,class X> inline
  void assign(R & r,const OP<'-',X,int> & x) {sub(r,x.op1.rep(),x.op2);}
  template<class R,class X,class Y> inline
  void assign(R & r,const OP<'-',X,Y> & x)
  {sub(r.rep(),x.op1.rep(),x.op2.rep());}

  template<class R,class X> inline
  void assign(R & r,const OP<'*',X,int> & x) {mul(r,x.op1.rep(),x.op2);}
  template<class R,class X,class Y> inline
  void assign(R & r,const OP<'*',X,Y> & x)   {mul(r.rep(),x.op1.rep(),x.op2.rep());}

  template<class R,class X> inline
  void assign(R & r,const OP<'/',X,int> & x) {div(r,x.op1.rep(),x.op2);}
  template<class R,class X,class Y> inline
  void assign(R & r,const OP<'/',X,Y> & x)   {div(r.rep(),x.op1.rep(),x.op2.rep());}
  //----------------------------------------------------------------------
//   template<class V, class S>
//   void assign(V & r, const OP<'+',VAL<S>,V> &  M)
//   {
//     V a = M.op1; r= a+M.op2;
//   }
//   template<class V, class T>
//   void assign(V & r, const OP<'+',V,VAL<T> >  & M)
//   {
//     std::cout<<"B "<<M.op2<<" "<<r<<std::endl;
//     V b=M.op2; 
//     std::cout<<"B "<<b<<std::endl;
//     r=M.op1+b;
//   }
//   template<class V, class S, class T>
//   void assign(V & r, const OP<'+',VAL<S>,VAL<T> > & M)
//   {
//     V a=M.op1, b=M.op2; r=a+b;
//   }
  //----------------------------------------------------------------------
//   template<class V, class S>
//   void assign(V & r, const OP<'-',VAL<S>,V> &  M)
//   {
//     V a=M.op1; r=a-M.op2;
//   }
//   template<class V, class T>
//   void assign(V & r, const OP<'-',V,VAL<T> > &  M)
//   {
//     V b=M.op2; r=M.op1-b;
//   }
//   template<class V, class S, class T>
//   void assign(V & r, const OP<'-',VAL<S>,VAL<T> > & M)
//   {
//     V a=M.op1, b=M.op2; r=a-b;
//   }
  //----------------------------------------------------------------------
  template<class V, class S>
  void assign(V & r, const OP<'*',VAL<S>,V> M)
  {
    V a=M.op1; r=a*M.op2;
  }
  template<class V, class S>
  void assign(V & r, const OP<'*',V,VAL<S> > M)
  {
    V b=M.op2; r=M.op1*b;
  }
  template<class V, class S, class T>
  void assign(V & r, const OP<'*',VAL<S>,VAL<T> > M)
  {
    V a=M.op1, b=M.op2; r=a*b;
  }
  //----------------------------------------------------------------------
  template<class V, class S>
  void assign(V & r, const OP<'.',VAL<S>,V> & M)
  {
    V a=M.op1; r=a*M.op2;
  }
  template<class V, class S>
  void assign(V & r, const OP<'.',V,VAL<S> > & M)
  {
    V b=M.op2; r=M.op1*b;
  }
  template<class V, class S, class T>
  void assign(V & r, const OP<'.',VAL<S>,VAL<T> > & M)
  {
    V a=M.op1, b=M.op2; r=a*b;
  }
  //----------------------------------------------------------------------
  template<class V, class S>
  void assign(V & r, const OP<'/',VAL<S>,V> & M)
  {
    V a=M.op1; r=a/M.op2;
  }
  template<class V, class S>
  void assign(V & r, const OP<'/',V,VAL<S> > & M)
  {
    V b=M.op2; r=M.op1/b;
  }
  template<class V, class S, class T>
  void assign(V & r, const OP<'/',VAL<S>,VAL<T> > & M)
  {
    V a=M.op1, b=M.op2; r=a/b;
  }
}//let
//---------------------------------------------------------------------
template<class A>
struct Promote {typedef A TYPE;};

template<char c,class A,class B> 
struct Promote<OP<c,A,B> > {typedef typename Promote<A>::TYPE TYPE;};

template<class A>
struct Promote<VAL<A> >      {typedef typename Promote<A>::TYPE TYPE;};

//---------------------------------------------------------------------


__END_NAMESPACE_SYNAPS


#endif // SYNAPS_ARITHM_REF_H