numexp.hpp

Go to the documentation of this file.

/***********************************************************************
History: Exponents for monomials are represented by element of E.
    Writen by Ph. Trebuchet (10/12/99).
$Id: numexp.hpp,v 1.1.1.1 2006/10/06 08:01:40 trebuche Exp $
**********************************************************************/
/*
 *pour etre type T valide on doit fournir:
 * T >> int
 * T<< int
 *T + T
 *T&T
 *T > (int)
 * T+= (inT)
 *T &= T
 * T += T
 *T-=T
 *T==T
 *ostream << T
 *added by moi :-) 
*/
// A verifier le D (decallage).
#ifndef numexp_H
#define numexp_H
static int mask=0;
template<char X, int D=2, class T=int> 
struct numexp {
  typedef T         exponent_t;
  typedef int         degree_t;
  typedef numexp<X,D,T> self_t;
  // static T mask;
  //Constructors
  numexp():ind(0) {};
  numexp(int t){};
  numexp(const self_t &A): ind(A.ind) {};
  numexp(int s, int *t)
    {
      for(int i=s-1;i>=0;i--)
    {
      ind+=t[i];
      ind=(ind<<D);
    }

    }

  //destructors // rien a faire ...
  int operator != (const numexp<X,D,T>&m)
  {
    return ind!=m.ind;
  }
  int operator != (const numexp<X,D,T>&m) const 
  {
    return ind!=m.ind;
  }
  exponent_t operator[](int i) const 
  {
#if 0
    if (mask==0)
      {
    for(int j=0;j<D;j++)
      mask=(mask<<1)+1;
      }
#endif
    return ((mask)&(ind>>(D*i)));
  }

  void reserve(int d) {};

  void setExponent(int i,int d) 
    {
      T tmp1=(ind>>(D*i+D))<<(D*i+D);
      T tmp2=0;
       if(mask==0)
     {
       for(int j=0;j<D;j++)
         mask=(mask<<1)+1;
     }
      for(int j=0;j<i;j++) tmp2=(tmp2<<D)+mask;
      tmp2&=ind;
      ind=tmp1+tmp2+(((T)d)<<(D*i));
    }
  
  
  //operators
  self_t & operator =(const numexp<X,D,T> &A)
  {
      ind=A.ind; return *this;
  }

  self_t & operator += (const self_t & A)
  {
    ind+=A.ind; return *this;
  }
  self_t & operator *=(const self_t & A)
    {
      ind+=A.ind; return *this;
    }
  self_t & operator /=(const numexp<X,D,T> &A)
    {
      ind-=A.ind; return *this;
    }

  bool operator == (const numexp<X,D,T> &A) const
    {
      return (ind==A.ind);
    }

  bool operator <(const numexp<X,D,T> &A) const
  {
    return this->ind<A.ind;
  }

  bool operator <(const numexp<X,D,T> &A) 
  {
    return this->ind<A.ind;
  }

  //data
  T ind;
};

template<char X,int D, class T> 
inline int Degree(const numexp<X,D,T> & m)
{
  int d=0;
  T stock;
   if(mask==0)
    {
      for(int j=0;j<D;j++)
    mask=(mask<<1)+1;
    }
   for(stock=m.ind;stock>0;stock=stock>>D)  d+=(stock&mask);
  return d;
}

template<char X,int D,class T> 
inline int GDegree(const numexp<X,D,T> &A,int i)
{
  //  static T mask=0;
  if(mask==0)
    {
      for(int j=0;j<D;j++)
    mask=(mask<<1)+1;
    }
  return ((A.ind>>(D*i))&mask);
}

template<char X,int D,class T> 
inline int SDegree(numexp<X,D,T> &A,int i,int d)
{
  T tmp1=(A.ind>>(D*i+D))<<(D*i+D);
  T tmp2=0;
  for(int j=0;j<i*D;j++) tmp2=(tmp2<<1)+1;
  tmp2&=A.ind;
  A.ind=tmp1+tmp2+(((T)d)<<(D*i));
  return A.ind;
}

template<char X,int D,class T>
inline  
int lvar(const numexp<X,D,T> &A)
{
  int i=0;
  T stock=A.ind;
  for(;stock>0;i++,stock=stock>>D);
  return i-1;
}

template<char X,int D,class T> 
inline void erase(numexp<X,D,T> &A) {}

template<char X,int D,class T> 
void add(numexp<X,D,T> &r,const numexp<X,D,T> &A,const numexp<X,D,T> &B)
{
  r.ind=A.ind+B.ind;
}

template<char X,int D,class T> 
std::ostream & operator<<(std::ostream &os, const numexp<X,D,T> & rep)
{
  //  T mask=0;//3 tjrs pareil
  T tmp;
  if (mask==0){
    for(int j=0;j<D;j++) mask=(mask<<1)+1;
  }
  for(int i=0;i<lvar(rep)+1;i++)
     {
       if((rep.ind>>(D*i))&mask)
    {
      os<<"*"<<X<<i;
      if ((tmp=(rep.ind>>(D*i))&mask)>1)
        os<<'^'<<tmp;
    }
     }
  return os;
}
#endif // //numexp_H