synaps/arithm/Rg.h

/*********************************************************************
*      This file is part of the source code of SYNAPS kernel.        *
*   Author(s): B. Mourrain, GALAAD, INRIA                            *
**********************************************************************/
#ifndef NDEBUG
        #include <cassert>
#endif


#ifndef SYNAPS_ARITHM_RG_H
#define SYNAPS_ARITHM_RG_H

//----------------------------------------------------------------------
#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:
  shared_object<T> data;
  T &       rep()       {return *data;}
  const T & rep() const {return *data;}

  Rg () {init(rep());}
  Rg (const Rg<T>& b)   { init(rep()); data=b.data; }
  Rg (const T& t): data(t)  {}
  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);}

  ~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;}
  template<class X>  Rg<T>& operator += (const X & rhs) 
    {*this=*this+rhs; return *this;}
  template<class X>  Rg<T>& operator -= (const X & rhs) 
    {*this=*this-rhs; return *this;}
  template<class X>  Rg<T>& operator *= (const X & rhs) 
    {*this=*this*rhs;   return *this;}
  template<class X>  Rg<T>& operator /= (const X & rhs) 
    { assert(rhs!=0); *this=*this/rhs;   return *this;}
  template<class X>  Rg<T>& operator %= (const X & rhs) 
    { assert(rhs!=0); *this=*this%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
const Rg<R> operator+(const Rg<R> & a, const Rg<R> & b)
{
  Rg<R> r;  add(r.rep(),a.rep(),b.rep()); return r;
}
template<class R> inline
const Rg<R> operator+(const Rg<R> & a, const int & b)
{
  Rg<R> r;  add(r.rep(),a.rep(),b);  return r;
}
template<class R> inline
const Rg<R> operator+(const int & b, const Rg<R> & a)
{
   return a+b;
}
//----------------------------------------------------------------------
template <class R> inline
const Rg<R> operator-(const Rg<R> & a, const Rg<R> & b)
{
 Rg<R> r; sub(r.rep(),a.rep(),b.rep());  return r;
}
template<class R> inline
const Rg<R> operator-(const Rg<R> & a, const int & b)
{
  Rg<R> r; sub(r.rep(),a.rep(),b);  return r;
}
template<class R> inline
const Rg<R> &  operator-(const int & b, const Rg<R> & a)
{
   return a+(-b);
}
//----------------------------------------------------------------------
template<class R> inline
const Rg<R>  operator*(const Rg<R> & a, const Rg<R> & b)
{
  Rg<R> r; mul(r.rep(),a.rep(),b.rep()); return r;
}

template<class R> inline
const Rg<R>  operator*(const Rg<R> & a, int b)
{
  Rg<R> r; mul(r.rep(),a.rep(),b); return r;
}
template<class R> inline 
const Rg<R>  operator*(int b, const Rg<R> & a)
{
  return a*b;
}
//----------------------------------------------------------------------
template<class T> inline 
Rg<T>& operator - (const Rg<T>& b) 
{
  Rg<T> r(b); return (r.negate());
}
//----------------------------------------------------------------------
// Quotient
template <class R>  inline 
const Rg<R> operator/(const Rg<R> & a, const Rg<R> & b)
{
  assert(b!=0);
  Rg<R> r; div(r.rep(),a.rep(),b.rep()); return r;
}

template <class R>  inline 
const Rg<R> operator/(const Rg<R> & a, unsigned int b)
{
  assert(b!=0);
  Rg<R> r; div(r.rep(),a.rep(),b); return r;
}
//----------------------------------------------------------------------
// Remainder
template <class R>  inline 
const Rg<R> operator%(const Rg<R> & a, const Rg<R> & b)
{
  assert(b!=0);
  Rg<R> r; mod(r.rep(),a.rep(),b.rep()); return r;
}

template <class R>  inline 
const Rg<R> operator%(const Rg<R> & a, unsigned int b)
{
  assert(b!=0);
  Rg<R> r; mod(r.rep(),a.rep(),b); return r;
}
//----------------------------------------------------------------------

__END_NAMESPACE_SYNAPS

#endif // SYNAPS_ARITHM_RG_H