Monom.hpp

Go to the documentation of this file.

/*********************************************************************
*      This file is part of the source code of borderbasix           *
*      (C) B. Mourrain, Ph. Trebuchet                                *
**********************************************************************/
#ifndef _Monom_H_
#define _Monom_H_

template <class C, class R> 
struct Monom {

  // Type definitions 
  typedef int                    index_t;
  typedef typename R::exponent_t exponent_t; //typename R::coeff_t exponent_t;
  typedef C                      coeff_t;
  typedef R                      rep_t;
  //fields
  C coeff;
  R rep;
  // Constructors
  Monom():coeff(0),rep(){}
  Monom(const C & c, const R & r):coeff(c),rep(r){}
  Monom(const C & c):coeff(c),rep(){} // monome constant
  Monom(int i):coeff(i){}  
  Monom(int i, int d):coeff(1){
    rep.reserve(i+1);
    for(int j=0;j<i;j++) rep.setExponent(j,0);
    rep.setExponent(i,d);
  } 
  // monome x_i^d
  Monom(const C & c, int i, int d=1 ):coeff(c), rep(i){ // monome c*x_i^d
    for(int j=0;j<i;j++)
      rep.setExponent(j,0);
    rep.setExponent(i,d);
  }
  Monom(const C & c, int s, int *t):coeff(c), rep(s){ 
    for(int i=0;i<s;i++) rep.setExponent(i,t[i]);
  }
  Monom(const Monom & m):coeff(m.coeff),rep(m.rep){}
  //cout <<"  C[m]"<<m<<endl;} // copy constructor
  
  // Destructor
  // not dynamic allocation at this level
  //    ~Monom<C,R> () {}
  // affectation operator
  Monom<C,R> & operator = ( const Monom<C,R> & m) {
    //cout <<"  =[m] "<<m<<endl;
    //cout<<"coeff "<<coeff<<endl;
    coeff = m.coeff;
    rep = m.rep;
    return *this;
  }
  
  // Accessors
  //  int size() const {return rep.size;}
  C GetCoeff () const { return coeff; }
  void SetCoeff (const C & c) { coeff = c; }
  int Lvar() const { return lvar(rep); }
  exponent_t GetDegree () const { return Degree(rep);}
  exponent_t operator[] (int i) const { return rep[i]; }      
  exponent_t GetDegree  (int i) const { return rep[i]; }
   void SetDegree (int i, int d) { SDegree(rep,i,d); }
  
  // boolean opeartors and functions
  friend bool IsComparable (const Monom<C,R> & m1, const Monom<C,R> & m2){
    return m1.rep == m2.rep;
  } 
  bool operator == (const Monom<C,R> & m2) const {
    return coeff == m2.coeff && rep == m2.rep;
  }
  bool operator != (const Monom<C,R> & m2) const {return !(m2==*this);}
  //  friend bool operator == (const Monom<C,R> & m1, const Monom<C,R> & m2) {
  // return m1.coeff == m2.coeff && m1.rep == m2.rep;
  // Comput operators
  Monom<C,R> operator - () const {
    Monom<C,R> res((C)(-1)*coeff,rep);
    return res;
  }
  Monom<C,R> & operator += (const Monom<C,R> &);
  Monom<C,R> & operator -= (const Monom<C,R> &);
  Monom<C,R> & operator *= (const Monom<C,R> &);
  Monom<C,R> & operator *= (const C &);
//   friend Monom<C,R> & operator + <>(const Monom<C,R> &, const Monom<C,R> &);
//   friend Monom<C,R> & operator - <>(const Monom<C,R> &, const Monom<C,R> &);
//   friend Monom<C,R> & operator * <>(const Monom<C,R> &, const Monom<C,R> &);
//   friend Monom<C,R> & operator * <>(const Monom<C,R> &, const coeff_t &);

  // Input/output operators
  //friend ostream & operator << <>(ostream &, const Monom<C,R> &);
  
  //private:
  
};

//----------------------------------------------------------------------
// arithmetic operators
//----------------------------------------------------------------------

template <class C, class R> inline
Monom<C,R> & Monom<C,R>::operator += (const Monom<C,R> & m) {
        coeff += m.coeff;
        if (coeff==(C)0) erase(rep);
        return *this;
}

template <class C, class R> inline
Monom<C,R> & Monom<C,R>::operator -= (const Monom<C,R> & m) {
        coeff -= m.coeff;
        if (coeff==(C)0) erase(rep);
        return *this;
}

template <class C, class R> inline
Monom<C,R>  operator +  (const Monom<C,R> & m1, const Monom<C,R> & m2) {
        Monom<C,R> res(m1);
        res.coeff += m2.coeff;
        return (*res);
}

template <class C, class R> inline
Monom<C,R> operator - (const Monom<C,R> & m1, const Monom<C,R> & m2) {
        Monom<C,R> res(m1);
        res.coeff -= m2.coeff;
        return (res);
}

template <class C, class R> inline
Monom<C,R> & Monom<C,R>::operator *= (const Monom<C,R> & m) {
        coeff *= m.coeff;
        if (coeff!=(C)0) rep+=m.rep;
        else
            erase(rep);
        return *this;
}

template <class C, class R> inline
Monom<C,R> operator * (const Monom<C,R> & m1, const Monom<C,R> & m2)
{
        Monom<C,R> res;
        res.coeff = (m1.coeff*m2.coeff);
        if (res.coeff !=(C)0)
            add(res.rep,m1.rep,m2.rep);
        else
            erase(res.rep);
        return res ;
}

template <class C, class R> inline
Monom<C,R> & Monom<C,R>::operator *= (const C & c)
{
        coeff *= c;
        if (coeff==(C)0) erase(rep);
        return *this;
}

template <class C, class R> inline
Monom<C,R> operator * (const Monom<C,R> & m1, const C & c2)
{
  Monom<C,R> res(m1);
  res.coeff *= c2;
  if (res.coeff ==(C)0) erase(res.rep);
  return (res);
}

//----------------------------------------------------------------------
// operateurs d'entrees/sorties
//----------------------------------------------------------------------
template <class C, class R> inline
std::ostream & operator << (std::ostream & os, const Monom <C,R> & m)
{
  if (m.coeff !=(C)0 )  os << m.coeff;
  if (m.Lvar()>=0) os <<m.rep;
  return os;
}
//----------------------------------------------------------------------

template <class C, class R, class T>
Monom<C,R> pow(Monom<C,R>& m, T n)
{
  Monom<C,R> result(m);
  result.SetCoeff(pow(m.GetCoeff(),n));
  for(int i=0; i<m.Lvar(); i++)
    result.SetDegree(i,m[i]*n);
  return result;
}

//----------------------------------------------------------------------//
template <class C, class R> 
typename R::degree_t Degree(const Monom<C,R> & m) 
{
  return Degree(m.rep);
}

//----------------------------------------------------------------------//
template<class M>
M MGcd(const M & m1, const M & m2) {
  int d = Gcd(m1.GetCoeff(),m2.GetCoeff());
  M res(d);
  int v = Min(m1.Lvar(),m2.Lvar());
  for (int i = 0; i <= v; ++i)
    res.SetDegree(i, Min(m1.GetDegree(i),m2.GetDegree(i)));
  return res;
}

template <class M>
M div(const M & m1, const M & m2) {
  M res(1); res*=(m1.GetCoeff()/m2.GetCoeff());
  for (int i = 0; i <= m1.Lvar(); ++i)
    res.SetDegree(i,m1.GetDegree(i) - m2.GetDegree(i));
  return res;
}

#endif //