synaps/arithm/Rg_with_te.h

/*********************************************************************
*      This file is part of the source code of SYNAPS kernel.        *
*   Author(s): B. Mourrain, GALAAD, INRIA                            *
**********************************************************************/

#ifndef SYNAPS_ARITHM_RG_WITH_TE_H
#define SYNAPS_ARITHM_RG_WITH_TE_H

#ifndef NDEBUG
        #include <cassert>
#endif

//----------------------------------------------------------------------
#include <synaps/init.h>
#include <synaps/arithm/REF.h>
#include <synaps/base/shared_object.h>
#include <synaps/base/COUNT.h>
//----------------------------------------------------------------------


__BEGIN_NAMESPACE_SYNAPS


template<class T> struct Rg
{
public:
  //data 
  shared_object<T>  data; 
  T &       rep()       {return (*data);}
  const T & rep() const {return (*data);}

  //T data;
  //  inline T &       rep()       {return (data);}
  //  inline const T & rep() const {return (data);}

  Rg () {init(rep());}
  Rg (const Rg<T>& b): data(b.data)       {}
  Rg (double d)         {init_set(rep(),d);}
  Rg (signed long sl)   {init_set(rep(),sl);}
  Rg (unsigned long ul) {init_set(rep(),ul);}
  Rg (int si)           {init_set(rep(),si);}
  Rg (const char* str, unsigned int b=10)  {init_set(rep(),str,b);}
  template<class X>  Rg(const X & P) {init();assign(this,P.rep());}

  ~Rg () { clear(rep()); }

  //-----------------------------------------------------------------
  template<class X> Rg<T> operator == (const VAL<X>& rhs) const 
    {assign(this->rep(),rhs.rep());}
  //-----------------------------------------------------------------
  template<class X> bool operator == (const X& rhs) const 
    { return cmp(rep(),rhs) ==0 ; }
  template<class X> bool operator != (const X& rhs) const
    { return cmp(rep(),rhs)!=0; }
  template<class X> bool operator >  (const X& rhs) const
    { return cmp(rep(),rhs)>0; }
  template<class X> bool operator >= (const X& rhs) const
    { return cmp(rep(),rhs)>=0; }
  template<class X> bool operator <  (const X& rhs) const
    { return cmp(rep(),rhs) <0; }
  template<class X> bool operator <= (const X& rhs) const
    { return cmp(rep(),rhs)<=0; }
  //-----------------------------------------------------------------
  Rg<T>& operator  = (const Rg<T>& rhs)  {data=rhs.data; return *this;}
  Rg<T>& operator += (const Rg<T>& rhs)  {add(rep(),rhs.rep()); return *this;}
  Rg<T>& operator -= (const Rg<T>& rhs)  {sub(rep(),rhs.rep()); return *this;}
  Rg<T>& operator *= (const Rg<T>& rhs)  {mul(rep(),rhs.rep()); return *this;}
  Rg<T>& operator /= (const Rg<T>& rhs) 
    { assert(rhs!=0); div(rep(),rhs.rep()); return *this; }
  Rg<T>& operator %= (const Rg<T>& rhs) 
    { assert(rhs!=0); mod(rep(),rhs.rep()); return *this; }
  //-----------------------------------------------------------------
  Rg<T>& operator  = (const int& rhs) {rep()=rhs; return *this; }
  Rg<T>& operator += (const int& rhs) {add(rep(),rhs); return *this; }
  Rg<T>& operator -= (const int& rhs) {sub(rep(),rhs); return *this; }
  Rg<T>& operator *= (const int& rhs) {mul(rep(),rhs); return *this; }
  Rg<T>& operator /= (const int& rhs) 
    { assert(rhs !=0); div(rep(),rhs); return *this; }
  Rg<T>& operator %= (const int& rhs)
    { assert(rhs!=0); mod(rep(),rhs); return *this; }
  //-----------------------------------------------------------------
  void                  operator ++ ( );
  void                  operator -- ( );
  //-----------------------------------------------------------------
};
//======================================================================
template <class R> inline
ostream & operator<<(ostream & os, const  Rg<R> & p)
{
  return Print(os,p.rep());
}
//======================================================================
// THE ARITHMETIC OPERATORS
//======================================================================
template <class R> inline
VAL<OP<'+',Rg<R>,Rg<R> > > operator+(const Rg<R> & a, const Rg<R> & b)
{
  return VAL<OP<'+',Rg<R>,Rg<R> > >(OP<'+',Rg<R>,Rg<R> >(a,b));
}
template<class R>
VAL<OP<'+',Rg<R>,int> > operator+(const Rg<R> & a, const int & b)
{
   return VAL<OP<'+',Rg<R>,int> >(OP<'+',Rg<R>,int>(a,b));
}
template<class R>
VAL<OP<'+',Rg<R>,int> > operator+(const int & b, const Rg<R> & a)
{
   return VAL<OP<'+',Rg<R>,int> >(OP<'+',Rg<R>,int>(a,b));
}
//----------------------------------------------------------------------
template <class R> inline
VAL<OP<'-',Rg<R>,Rg<R> > > operator-(const Rg<R> & a, const Rg<R> & b)
{
  return VAL<OP<'-',Rg<R>,Rg<R> > >(OP<'-',Rg<R>,Rg<R> >(a,b));
}
template<class R>
VAL<OP<'-',Rg<R>,int> > operator-(const Rg<R> & a, const int & b)
{
   return VAL<OP<'-',Rg<R>,int> >(OP<'-',Rg<R>,int>(a,b));
}
template<class R>
VAL<OP<'-',Rg<R>,int> > operator-(const int & b, const Rg<R> & a)
{
   return VAL<OP<'-',Rg<R>,int> >(OP<'-',Rg<R>,int>(a,b));
}
//----------------------------------------------------------------------
template<class R, class Y>
VAL<OP<'*',Rg<R>,Y> > operator*(const Rg<R> & a, const Y & b)
{
   return VAL<OP<'*',Rg<R>,Y> >(OP<'*',Rg<R>,Y>(a,b));
}
//----------------------------------------------------------------------
template<class T> inline 
Rg<T>& operator - (const Rg<T>& b) 
{
  Rg<T> r(b); return (r.negate());
}
//----------------------------------------------------------------------
// Product of polynomials 
template <class R>  inline 
VAL<OP<'*',Rg<R>,Rg<R> > > operator*(const Rg<R> & a, const Rg<R> & b)
{
  return VAL<OP<'*',Rg<R>,Rg<R> > >(OP<'*',Rg<R>,Rg<R> >(a,b));
}
//----------------------------------------------------------------------
// Division of polynomials 
template <class R>  inline 
VAL<OP<'/',Rg<R>,Rg<R> > > operator/(const Rg<R> & a, const Rg<R> & b)
{
  assert(b!=0);
  return VAL<OP<'/',Rg<R>,Rg<R> > >(OP<'/',Rg<R>,Rg<R> >(a,b));
}
//----------------------------------------------------------------------
// Division of polynomials 
template <class R>  inline 
VAL<OP<'%',Rg<R>,Rg<R> > > operator%(const Rg<R> & a, const Rg<R> & b)
{
  assert(b!=0);
  return VAL<OP<'%',Rg<R>,Rg<R> > >(OP<'%',Rg<R>,Rg<R> >(a,b));
}
//----------------------------------------------------------------------
// template<class T,class X> Rg<T>& operator + (const Rg<T>& b, const X& x)
// template<class T,class X> Rg<T>& operator - (const Rg<T>& b, const X& x);
// template<class T,class X> Rg<T>& operator * (const Rg<T>& b, const X& x);
// template<class T,class X> Rg<T>& operator % (const Rg<T>& b, const X& x);
//----------------------------------------------------------------------

__END_NAMESPACE_SYNAPS

#endif // SYNAPS_ARITHM_RG_WITH_TE_H