synaps/upol/UPolDse.h

/*********************************************************************
*      This file is part of the source code of SYNAPS library.       *
*      Author(s): B. Mourrain, GALAAD, INRIA                         *
**********************************************************************
$Id: UPolDse.h,v 1.2 2005/08/29 14:30:17 mourrain Exp $
**********************************************************************/
#ifndef SYNAPS_UPOL_UPOLDSE_H
#define SYNAPS_UPOL_UPOLDSE_H
#include <synaps/init.h>
#include <synaps/base/parser.h>
#include <stdlib.h>
#include <string>
#include <synaps/arithm/let.h>
#include <synaps/arithm/REF.h>
#include <synaps/linalg/VECTOR.m>
#include <synaps/upol/UPOLDAR.m>
#include <synaps/upol/rep.h>
#include <synaps/upol/EUCLIDIAN.h>
#include <synaps/base/shared_object.h>
#include <synaps/base/type.h>

__BEGIN_NAMESPACE_SYNAPS


template<class C, class R=upol::rep<C> >
struct UPolDse {

#ifdef NOREFCOUNT
  R data;
  R &       rep()       {return data;}
  const R & rep() const {return data;}
#else
  shared_object<R> data;
  R &       rep()       {return *data;}
  const R & rep() const {return *data;}
#endif
  typedef C                            value_type;
  typedef C                            coeff_t;
  typedef typename R::size_type        size_type;
  typedef R                            rep_type;
  typedef typename R::iterator         iterator;
  typedef typename R::const_iterator   const_iterator;
  typedef typename R::reverse_iterator reverse_iterator;
  typedef typename R::const_reverse_iterator const_reverse_iterator;
  typedef UPolDse<C,R>                self_t;

  static char* var_;
  
  UPolDse() : data() {}
  UPolDse(const R & r) {data(r);}
  UPolDse(const int n);
  //  UPolDse( const coeff_t & c );
  UPolDse(size_type n, type::AsSize A)
    {rep().resize(n);VECTOR::init(rep(),(value_type)0);}
  UPolDse(value_type c, size_type n = 0 );
  UPolDse(size_type n, value_type * t);
  UPolDse(iterator b, iterator e);

  UPolDse(const char *);
  UPolDse(const self_t & P) {data=P.data;} //COUNT<self_t>('c');}

  template<class S>
  UPolDse(const VAL<S> & P) {let::assign(*this,P.rep());}

  iterator               begin()        {return rep().begin();}
  const_iterator         begin()  const {return rep().begin();}
  iterator               end()          {return rep().end();}
  const_iterator         end()    const {return rep().end();}
  reverse_iterator       rbegin()       {return rep().rbegin();}
  const_reverse_iterator rbegin() const {return rep().rbegin();}
  reverse_iterator       rend()         {return rep().rend();}
  const_reverse_iterator rend()   const {return rep().rend();}

  self_t & operator=(const self_t & P)
    {
      data=P.data;
      //  COUNT<self_t>('=');
      return *this;
    }

  template<class S>
  self_t & operator =(const VAL<S> & M)
  {let::assign(*this,M.rep());return *this;}

  bool operator==(int n) const;
  bool operator!=(int n) const {return !(*this==n);}

  bool operator==(const self_t & p) const;
  bool operator!=(const self_t & p) const {return !(*this==p);}

  self_t & operator+= (const self_t  & P);
  self_t & operator+= (const value_type & c);

  self_t & operator-= (const self_t  & P);
  self_t & operator-= (const value_type & c);

  self_t & operator*= (const self_t  & P);
  self_t & operator*= (const value_type & c);

  self_t & operator/= (const self_t  & Q);
  self_t & operator/= (const value_type & c);

  self_t & operator%= (const self_t  & Q);
  self_t & operator%= ( const value_type & x );
  int get_degree() const 
  { 
    using UPOLDAR::degree; return degree(rep());
  }
  size_type   size() const { return (rep().size()); }
  void resize(size_type i) { rep().resize(i); }

  inline  value_type &  operator[] (size_type i)
  {
    assert(i<size()); return (rep())[i];
  }
  inline  value_type    operator[] (size_type i) const
  {
    if(i< std::max((size_type)(this->get_degree()+1),(size_type)0))
      return (rep())[i]; else return 0;
  }

  template<class T> T operator()(const T & c) const;
  
  bool operator<( const value_type & c ) { return false; };
};
template<class C, class R> inline bool adjust_denum( const UPolDse<C,R> &  ) { return false; };
//======================================================================
template<class C,class R> char* UPolDse<C,R>::var_="x";
template<class P> char*& Variable(void) {return P::var_;}
//======================================================================
template <class C, class R>  inline
int degree(const UPolDse<C,R>& p)
{
  using UPOLDAR::degree;  return degree(p.rep());
}
//----------------------------------------------------------------------
template <class C, class R>  inline
UPolDse<C,R> const diff(const UPolDse<C,R>& p)
{
  if(degree(p)>0)
    {
      UPolDse<C,R> r(degree(p),type::AsSize());
      using UPOLDAR::diff; diff(r.rep(),p.rep());
      return r;
    }
  else
    return 0;
}
//----------------------------------------------------------------------
template <class C, class R>  inline
UPolDse<C,R> const diff(const UPolDse<C,R>& p, unsigned int k)
{
  if(degree(p)>(int)k-1)
    {
      UPolDse<C,R> r(p);
      using UPOLDAR::diff;
      for(unsigned i=0; i<k;++i) diff(r.rep(),r.rep());
      return r;
    }
  else
    return 0;
}
//======================================================================
// THE ARITHMETIC OPERATORS
//======================================================================
#ifndef UPOL_WITH_TEMP_EXP
//----------------------------------------------------------------------
template <class C, class R> inline
UPolDse<C,R> operator+(const UPolDse<C,R> & a, const UPolDse<C,R> & b)
{
  UPolDse<C,R> result(std::max(degree(a),degree(b))+1, type::AsSize());
  using UPOLDAR::add; add(result.rep(),a.rep(),b.rep());
  using UPOLDAR::checkdegree; checkdegree(result.rep());
  return result;
}
//----------------------------------------------------------------------
template <class C, class R>
inline UPolDse<C,R>
  operator-(const UPolDse<C,R> & a, const UPolDse<C,R> & b)
{

  UPolDse<C,R> result(std::max(degree(a),degree(b))+1,type::AsSize());
  using UPOLDAR::sub; sub(result.rep(),a.rep(),b.rep());
  using UPOLDAR::checkdegree; checkdegree(result.rep());
  return result;
}
//----------------------------------------------------------------------}
template <class C, class R>
inline UPolDse<C,R> operator-(const UPolDse<C,R> & a)
{
  UPolDse<C,R> result(degree(a)+1,type::AsSize());
  using UPOLDAR::mul_ext; mul_ext(result.rep(),a.rep(),-1);
  return result;
}
//----------------------------------------------------------------------
template <class C, class R> inline
UPolDse<C,R> operator*(const UPolDse<C,R> & a, const UPolDse<C,R> & b)
{
  UPolDse<C,R> result(std::max(degree(a)+degree(b)+1,0),type::AsSize());
  using UPOLDAR::mul;         mul(result.rep(),a.rep(),b.rep());
  using UPOLDAR::checkdegree; checkdegree(result.rep());
  return result;
}
//----------------------------------------------------------------------
template <class C, class R> inline
UPolDse<C,R> operator+(const UPolDse<C,R> & a,
                       const typename UPolDse<C,R>::value_type & c)
{
  if(degree(a) >= 0)
    {
      UPolDse<C,R> r(a);
      using UPOLDAR::add_cst; add_cst(r.rep(),c);
      return r;
    }
  else
    return UPolDse<C,R>(c,1);
}
//----------------------------------------------------------------------
template <class C, class R> inline
UPolDse<C,R> operator+(const typename UPolDse<C,R>::value_type & c,
                       const UPolDse<C,R> & a)
{
  return a+c;  
}
//----------------------------------------------------------------------
template <class C, class R> inline
UPolDse<C,R> operator-(const UPolDse<C,R> & a,
                       const typename UPolDse<C,R>::value_type & c)
{
  if(degree(a) >= 0)
    {
      UPolDse<C,R> r(a);
      using UPOLDAR::add_cst; add_cst(r.rep(),-c);
      return r;
    }
  else
    return UPolDse<C,R>(-c,1);
}
//----------------------------------------------------------------------
template <class C, class R> inline
UPolDse<C,R> operator-(const typename UPolDse<C,R>::value_type & c,
                        const UPolDse<C,R> & a)
{
  return  (-a)+c;   
}
//----------------------------------------------------------------------
template <class C, class R> inline
UPolDse<C,R> operator*(const UPolDse<C,R> & a,
                       const typename UPolDse<C,R>::value_type & c)
{
  //  std::cout<<"Mult ext a*c: "<<a<<" "<<c<<std::endl;
  UPolDse<C,R> result(degree(a)+1,type::AsSize());
  using UPOLDAR::mul_ext;
  mul_ext(result.rep(),a.rep(),c);
  checkdegree(result.rep());
  return result;
}

//----------------------------------------------------------------------
template <class C, class R> inline
UPolDse<C,R> operator*(const typename UPolDse<C,R>::value_type & c,
                       const UPolDse<C,R> & a)
{
  //  std::cout<<"Mult ext c*a:"<<c<<" "<<a<<std::endl;
  return a*c;
}


//----------------------------------------------------------------------
template <class C, class R>  inline
UPolDse<C,R> operator/(const UPolDse<C,R> & a, const UPolDse<C,R> & b)
{
  assert(b!=0);
  UPolDse<C,R> result(0), tmp(a);
  EUCLIDIAN::div_rem(result,tmp,b);
  return result;
}//----------------------------------------------------------------------
template <class C, class R>  inline
UPolDse<C,R> operator/(const UPolDse<C,R> & a,
                       const typename UPolDse<C,R>::value_type &  c)
{
  assert(c!=0);
  UPolDse<C,R> result(degree(a)+1,type::AsSize());
  using namespace UPOLDAR;
  div_ext(result.rep(),a.rep(),c);
  checkdegree(result.rep());
  return result;

}

//----------------------------------------------------------------------
template <class C, class R>  inline
UPolDse<C,R> operator%(const UPolDse<C,R> & a, const UPolDse<C,R> & b)
{
  assert(b!=0);
  UPolDse<C,R> result(a);
  result %= b;
  return result;
}

template <class C, class R>  inline
UPolDse<C,R> operator%(const UPolDse<C,R> & a, const C & b)
{
  assert(b!=0);
  UPolDse<C,R> result(a);
  result %= b;
  return result;
}
//----------------------------------------------------------------------
template <class C, class R>  inline
UPolDse<C,R> prem(const UPolDse<C,R> & a, const UPolDse<C,R> & b)
{
  assert(b!=0);
  UPolDse<C,R> r(a), q;
  EUCLIDIAN::pseudo_div_rem(q,r,b);
  return r;
}
//----------------------------------------------------------------------
template <class C, class R>  inline
UPolDse<C,R> operator^(const UPolDse<C,R> & a, const unsigned int & n)
{
  UPolDse<C,R> result(1);
  //  ALGEBRA::power(result,a,n);
  for(unsigned int i=0; i< n; i++) result *= a;
  return result;
}
#else
//======================================================================
template <class C, class R>
inline VAL<OP<'+',UPolDse<C,R>,UPolDse<C,R> > >
  operator+(const UPolDse<C,R> & a, const UPolDse<C,R> & b)
{
  return VAL<OP<'+',UPolDse<C,R>,UPolDse<C,R> > >
    (OP<'+',UPolDse<C,R>,UPolDse<C,R> >(a,b));
}
//----------------------------------------------------------------------
template <class C, class R>
inline VAL<OP<'-',UPolDse<C,R>,UPolDse<C,R> > >
  operator-(const UPolDse<C,R> & a, const UPolDse<C,R> & b)
{
  return VAL<OP<'-',UPolDse<C,R>,UPolDse<C,R> > >
    (OP<'-',UPolDse<C,R>,UPolDse<C,R> >(a,b));
}
//----------------------------------------------------------------------}
template <class C, class R>
inline VAL<OP<'-',UPolDse<C,R>,UPolDse<C,R> > >
  operator-(const UPolDse<C,R> & a)
{
  return VAL<OP<'-',UPolDse<C,R>,UPolDse<C,R> > >
    (OP<'-',UPolDse<C,R>,UPolDse<C,R> >(UPolDse<C,R>(0),a));
}
//----------------------------------------------------------------------
template <class C, class R>  inline
VAL<OP<'*',UPolDse<C,R>,UPolDse<C,R> > >
  operator*(const UPolDse<C,R> & a, const UPolDse<C,R> & b)
{
  return VAL<OP<'*',UPolDse<C,R>,UPolDse<C,R> > >
   (OP<'*',UPolDse<C,R>,UPolDse<C,R> >(a,b));
}
//----------------------------------------------------------------------
template <class C, class R> inline
VAL<OP<'.',UPolDse<C,R>,typename UPolDse<C,R>::value_type> >
  operator*(const UPolDse<C,R> & a, const typename UPolDse<C,R>::value_type & c)
{
  typedef typename UPolDse<C,R>::value_type C;
  return VAL<OP<'.',UPolDse<C,R>,C> >(OP<'.',UPolDse<C,R>,C>(a,c));
}
//----------------------------------------------------------------------
template <class C, class R>  inline
VAL<OP<'/',UPolDse<C,R>,UPolDse<C,R> > >
  operator/(const UPolDse<C,R> & a, const UPolDse<C,R> & b)
{
  return VAL<OP<'/',UPolDse<C,R>,UPolDse<C,R> > >
   (OP<'/',UPolDse<C,R>,UPolDse<C,R> >(a,b));
}
//----------------------------------------------------------------------
template <class C, class R>  inline
VAL<OP<'%',UPolDse<C,R>,UPolDse<C,R> > >
  operator%(const UPolDse<C,R> & a, const UPolDse<C,R> & b)
{
  return VAL<OP<'%',UPolDse<C,R>,UPolDse<C,R> > >
   (OP<'%',UPolDse<C,R>,UPolDse<C,R> >(a,b));
}
//----------------------------------------------------------------------
template <class C, class R>  inline
VAL<OP<'^',UPolDse<C,R>,unsigned int> >
  operator^(const UPolDse<C,R> & a, const unsigned int & n)
{
  return VAL<OP<'^',UPolDse<C,R>,unsigned int> >
   (OP<'^',UPolDse<C,R>,unsigned int>(a,n));
}
//======================================================================
// ASSIGNEMENTS
//======================================================================
namespace let {
  template<class C, class R> inline
  void assign(UPolDse<C,R> & p,
              const OP<'+',UPolDse<C,R>, UPolDse<C,R> >& M)
  {
    assert(&(p.rep())!=&(M.op1.rep())); 
    assert(&(p.rep())!=&(M.op2.rep()));
    p.rep().resize(std::max(degree(M.op1),degree(M.op2))+1);
    using namespace UPOLDAR;
    init(p.rep(),0);
    add(p.rep(),M.op1.rep(),M.op2.rep());
    checkdegree(p.rep());
  }


  template<class C, class R,class X> inline
  void assign(UPolDse<C,R> & p,
              const OP<'+',UPolDse<C,R>, VAL<X> >& M)
  {
    assert(&(p.rep())!=&(M.op1.rep())); 
    // assert(&(p.rep())!=&(M.op2.rep()));
    UPolDse<C,R> tmp=M.op2;
    p.rep().resize(std::max(degree(M.op1),degree(tmp))+1);
    using namespace UPOLDAR;
    init(p.rep(),0);
    add(p.rep(),M.op1.rep(),tmp);
    checkdegree(p.rep());
  }

  template<class C, class R,class X> inline
  void assign(UPolDse<C,R> & p,
              const OP<'+',VAL<X>,UPolDse<C,R> >& M)
  {
    assert(&(p.rep())!=&(M.op2.rep())); 
    UPolDse<C,R> tmp=M.op2;
    p.rep().resize(std::max(degree(M.op2),degree(tmp))+1);
    using UPOLDAR::init;  init(p.rep(),0);
    using UPOLDAR::add;   add(p.rep(),tmp,M.op2.rep());
    using UPOLDAR::checkdegree; checkdegree(p.rep());
  }
  //----------------------------------------------------------------------
  template<class C, class R> inline
  void assign(UPolDse<C,R> & p,
              const OP<'-',UPolDse<C,R>, UPolDse<C,R> >& M)
  {
    assert(&(p.rep())!=&(M.op1.rep())); assert(&(p.rep())!=&(M.op2.rep()));
    p.rep().resize(std::max(degree(M.op1),degree(M.op2))+1);
    using namespace UPOLDAR;
    init(p.rep(),0);
    sub(p.rep(),M.op1.rep(),M.op2.rep());
    checkdegree(p.rep());
  }
  //----------------------------------------------------------------------
  template<class C, class R> inline
  void assign(UPolDse<C,R> & p,
              const OP<'*',UPolDse<C,R>, UPolDse<C,R> >& M)
  {
    using namespace UPOLDAR;
    if( &(p.rep())==&(M.op1.rep()) || &(p.rep())==&(M.op2.rep()) )
      {
        UPolDse<C,R> tmp;
        tmp.rep().resize(std::max(degree(M.op1)+degree(M.op2)+1,0));
        init(tmp.rep(),0);
        mul(tmp.rep(),M.op1.rep(),M.op2.rep());
        p=tmp;
      }
    else
      {
        p.rep().resize(std::max(degree(M.op1)+degree(M.op2)+1,0));
        init(p.rep(),0);
        mul(p.rep(),M.op1.rep(),M.op2.rep());
      }
  }
  //----------------------------------------------------------------------
  template<class C, class R> inline
  void assign(UPolDse<C,R> & p,
              const OP<'.',UPolDse<C,R>,typename R::value_type>& M)
  {
    p.rep().resize(degree(M.op1)+1);
    using namespace UPOLDAR;
    mul_scalar(p.rep(),M.op1.rep(),M.op2);
  }
  //----------------------------------------------------------------------
  template<class C, class R> inline
  void assign(UPolDse<C,R> & p,
              const OP<'/',UPolDse<C,R>,UPolDse<C,R> >& M)
  {
    assert(M.op2!=0);
    UPolDse<C,R> top1(M.op1);
    using namespace EUCLIDIAN; div_rem(p,top1,M.op2);
  }
  //----------------------------------------------------------------------
  template<class C, class R> inline
  void assign(UPolDse<C,R> & r,
              const OP<'%',UPolDse<C,R>,UPolDse<C,R> >& M)
  {
    assert(M.op2!=0);
    r= M.op1;
    UPolDse<C,R> tmp;
    using namespace EUCLIDIAN; div_rem(tmp,r,M.op2);
  }
  //--------------------------------------------------------------------
  template<class C, class R> inline
  void assign(UPolDse<C,R> & r,
              const OP<'^',UPolDse<C,R>,unsigned int> M)
  {
    r=M.op1;
    for(unsigned int i=1;i<M.op2;i++) r*=M.op1;
  }
  
} // namespace let
//======================================================================
#endif //UPOL_WITH_TEMP_EXP
//======================================================================
namespace let 
{
  //--------------------------------------------------------------------
  template<class C, class R, class D, class S>  inline
  void assign(UPolDse<C,R> & u, const UPolDse<D,S> & P)
  {
    //    using let::assign_x;
    u.resize(degree(P)+1);
    for(int k=0; k< u.size();++k) let::assign(u[k],P[k]);
  }
  //--------------------------------------------------------------------
  template<class POL, class C, class S>
    POL convert(const UPolDse<C,S> & P, type::As<POL>)
  {
    using let::assign;
    POL u(degree(P)+1, type::AsSize());
    assign(u,P);
    return u;
  }
}
//======================================================================
// INPUT OUTPUT
//======================================================================
template <class C, class R> inline
std::ostream & operator<<(std::ostream & os, const UPolDse<C,R> & p)
{
  using UPOLDAR::print;
  return print(os,p.rep(),UPolDse<C,R>::var_);
}
//----------------------------------------------------------------------
template <class C, class R>
std::istream & operator>>(std::istream & is, UPolDse<C,R> & P);
//====================================================================
template <class C, class R, class X>
int SignAt(const UPolDse<C,R>& p, const X& x)
{
  return sign(p(x));
}
//====================================================================
template<class C, class R>
UPolDse<C,R>::UPolDse(int n)
{
  if(n==0)
    resize(0);
  else
    {
      rep().resize(1);
      rep()[0]=n;
      checkdegree(rep());
    }
}
//----------------------------------------------------------------------
template<class C, class R>
UPolDse<C,R>::UPolDse(value_type c, size_type n)
{
  using UPOLDAR::set_monomial;  set_monomial(rep(),c,n);
}
//----------------------------------------------------------------------
template<class C, class R>
UPolDse<C,R>::UPolDse(size_type n, value_type * v)
{
  rep().resize(n);
  iterator it=rep().begin(), iv=v;
  for(unsigned int i=0;i<n;i++) *it++=*iv++;
  using UPOLDAR::checkdegree;  checkdegree(rep());
}
//----------------------------------------------------------------------
template<class C, class R>
UPolDse<C,R>::UPolDse(iterator b, iterator e)
{
  rep().resize(std::distance(b,e));
  iterator it=rep().begin(), iv=b;
  while(iv != e) *it++=*iv++;
  using UPOLDAR::checkdegree;  checkdegree(rep());
}
//----------------------------------------------------------------------
template <class C, class R>
UPolDse<C,R>::UPolDse(const char * s) {
  rep().resize(0);
  VECTOR::init(rep(),0);
  int n = strlen(s);
  if(s[n-1]==';')
    {
      synaps_input = new char[n+1];
      memcpy(synaps_input,s,n); synaps_input[n]='\0';
      synaps_inputlim = synaps_input + n;
    }
  else
    {
      synaps_input = new char[n+2];
      memcpy(synaps_input,s,n); synaps_input[n]=';'; synaps_input[n+1]='\0';
      synaps_inputlim = synaps_input + n+1;
    }
  synaps_inputptr = synaps_input;

  self_t m(1);
  bool sign  = true;
  bool first = true;
  int Ask=0;
  for (;;) {
    Ask = yylex();
    if (Ask == COEF) { /* Monome constant */
      value_type c;//(yylval);
      let::assign(c,yylval);
      m *= c;
    }
    else if (Ask == XID) { /* Variable */
      char * p = strchr(yylval,'^');
      if (p == NULL){
        m *= self_t(value_type(1),1);
      } else {
        p++;
        m *= self_t(value_type(1),atoi(p));
      }
    }
    else if (Ask == MULT); /* Multiplication */
    else if (Ask == SUM) { /* Addition */
      if (sign) {
        *this += m;
        m = self_t(1);
      }
      else {
        *this -= m;
        sign = true;
        m = self_t(1);
      }
    }
    else if (Ask == MINUS) { /* Soustraction */
      if (first)
        sign = false;
      else if (sign) {
        *this += m;
        sign = false;
        m = self_t(1);
      }
      else {
        *this -= m;
        m = self_t(1);
      }
    }
    else if (Ask == TERMINATOR) { /* ; */
      if (sign)
        *this += m;
      else
        *this -= m;
      break;
    }
    first = false;
  }
  delete[] synaps_input;
}
//----------------------------------------------------------------------
template<class C, class R> inline
bool UPolDse<C,R>::operator==(int n) const
{
  if(n==0 && degree(*this)<0)
    return(true);
  else{
    return( (degree(*this)==0) && ((*this)[0]==n) );
  }
}
//----------------------------------------------------------------------
template<class C, class R> inline
bool UPolDse<C,R>::operator==(const UPolDse<C,R> & p) const
{
  return &(rep())== &p.rep();
}
//----------------------------------------------------------------------
template<class C, class R> inline
UPolDse<C,R> & UPolDse<C,R>::operator+= (const UPolDse<C,R> & P)
{
  using UPOLDAR::add; add(rep(),P.rep());
  using UPOLDAR::checkdegree; checkdegree(rep());
  return *this;
}
//--------------------------------------------------------------------
template<class C, class R> inline
UPolDse<C,R>& UPolDse<C,R>::operator+=(const C& c)
{
  if(degree(*this) >= 0)
    {
      using UPOLDAR::add_cst; add_cst(rep(),c);
    }
  else
    *this=UPolDse<C,R>(c,1);
  return *this;
}
//----------------------------------------------------------------------
template<class C, class R> inline
UPolDse<C,R> & UPolDse<C,R>::operator-= (const UPolDse<C,R> & P)
{
  rep().resize(std::max(degree(*this),degree(P))+1);
  using UPOLDAR::sub; sub(rep(),P.rep());
  using UPOLDAR::checkdegree; checkdegree(rep());
  return *this;
}
//--------------------------------------------------------------------
template<class C, class R> inline
UPolDse<C,R>& UPolDse<C,R>::operator-=(const C& c)
{
  if(degree(*this) >= 0)
    {
      using UPOLDAR::add_cst; add_cst(rep(),-c);
    }
  else
    *this=UPolDse<C,R>(c,1);
  return *this;
}
//----------------------------------------------------------------------
template<class C, class R> inline
UPolDse<C,R> & UPolDse<C,R>::operator*= (const UPolDse<C,R> & P)
{
  //  using namespace UPOLDAR;  mul(rep(),P.rep());
  (*this)= (*this) * P;
  return (*this);
}
//----------------------------------------------------------------------
template<class C, class R> inline
UPolDse<C,R> & UPolDse<C,R>::operator*= (const typename UPolDse<C,R>::value_type & c)
{
  if (c != 0)
    {
      using UPOLDAR::mul_ext; mul_ext(rep(),rep(),c);
    }
  else 
    {
      rep().resize(0);// rep()[0]=0;
    }
  return *this;
}
//----------------------------------------------------------------------
template<class C, class R> inline
UPolDse<C,R> & UPolDse<C,R>::operator/= (const typename UPolDse<C,R>::value_type & c)
{
  using namespace VECTOR; div_ext(rep(),rep(),c);
  return *this;
}
//----------------------------------------------------------------------
template <class C, class R> inline
UPolDse<C,R> & UPolDse<C,R>::operator/= (const UPolDse<C,R> & Q) {
  using namespace UPOLDAR;
  assert(Q!=0);
  if (*this ==0) return *this;
  if (&rep()==&Q.rep()) {*this=1;return *this;}
  UPolDse<C,R> quo(0);
  div_rem(quo,*this,Q);
  *this=quo;
  return *this;
}
//-----------------------------------------------------------------------------
template <class C, class R> inline
UPolDse<C,R> & UPolDse<C,R>::operator%= (const UPolDse<C,R> & Q)
{
  assert(Q!=0);
  if (*this ==0) return *this;
  if (&rep()==&Q.rep()) {*this=0;return *this;}
  UPolDse<C,R> quo;
  EUCLIDIAN::div_rem(quo,*this,Q);
  return *this;
}

template<class C, class R> inline 
UPolDse<C,R> & UPolDse<C,R>::operator%=( const C & c )
{
  using namespace UPOLDAR;
  coeff_modulo(rep(),c);
  checkdegree(rep());
  return *this;
};

//-----------------------------------------------------------------------------
template <class C, class R> template<class T> inline
T UPolDse<C,R>::operator()(const T & c) const
{
  using UPOLDAR::eval;
  return eval(rep(),c);
}
//----------------------------------------------------------------------
// Input operator. The variable is @x@ or @x0@. Ended by a @;@.
template <class C, class R> inline
std::istream & operator>>(std::istream & is, UPolDse<C,R> & P)
{
  std::string s, ss = "";
  int p;
  for (;;) {
    is >> s;
    p = s.find(';');
    if (p == -1)
      ss += s;
    else {
      ss += s.substr(0,p+1);
      break;
    }
  }
  P = UPolDse<C,R>(ss.c_str());
  return is;
}

  template <class C, class R>
  std::ostream & print_as_coeff(std::ostream & os, const UPolDse<C,R> & p)
  {
    return os<<"+("<<p<<")";
  }

template<class C, class R>
void checkdegree( UPolDse<C,R> & p )
{
  using namespace UPOLDAR;
  checkdegree(p);
};

//template<class C, class R> 
//UPolDse<C,R> abs( const UPolDse<C,R> & p ) { if ( p[degree(p)] < 0 ) return -p; };

__END_NAMESPACE_SYNAPS

#include "traits.h"

//====================================================================
#endif // SYNAPS_UPOL_UPOLDSE_H