include/borderbasix/pol.cc

Go to the documentation of this file.

#include"ugly.cc"
template<typename T> void *MAC_REV_MALLOC(int size);
template<typename T> void *MAC_REV_REALLOC(void*ptr,int,int);

template<typename mon,typename T>
struct pol  
{
  typedef mon monom_t;
  typedef T coeff_t;
  int size;
  mon ind;
  T * nf;
  // pol operator*(const mon&t);//multi par un monome
  pol operator*(const T &t);
  pol &operator-=(const pol& Q);
  pol &operator=(const pol&Q);
  pol &operator/=(const T &t);
  ~pol() {};
};

//
//
//
// Attention deux operateurs de multiplication

//
//un par un monom constant alp
//Buggy function no change of indices... :-((((
//comented the
//Tue Dec  4 16:39:25 MET 2001
//    template<typename mon,typename T>
//  pol<mon,T> pol<mon,T>::operator*(const pol<mon,T>::monom_t & toto)
//  {
//    //  cout<<"size "<<size<<endl;
//    //cout<<"ind "<<ind<<endl;
//    //cout<<"nf "<<nf<<endl;
//    //cout<<"monom "<<toto<<endl;
//    T tmp=toto.GetCoeff();
//    int tmpsize=this->size;
//    for(int i=0;i<tmpsize;i++)
//      nf[i]*=tmp;
//    return *this;
//  }
//
//l'autre par un coeff constant
//

template<typename mon,typename T>
pol<mon,T> pol<mon,T>::operator*(const typename pol<mon,T>::coeff_t & toto)
{
  int tmpsize=this->size;
  for(int i=0;i<tmpsize;i++)
    nf[i]*=toto;
  return *this;
}
template<typename mon,typename T>
pol<mon,T>& pol<mon,T>::operator-=(const pol<mon,T> &Q)
{
  typedef typename mon::coeff_t mcoeff_t;
  int tmpsize=Q.size;
  //cout<<"op-="<<size<<endl;
  if (size<Q.size) 
    {
      nf=(mcoeff_t*)
        MAC_REV_REALLOC<mcoeff_t>(nf,sizeof(T)*size
                                              ,sizeof(T)*Q.size);
      for(int i=size;i<Q.size;i++)
        nf[i]=0;
      size=Q.size;
    }
  //if(min>Q.size) min=Q.size;
  for(int i=0;i<tmpsize;i++)
    nf[i]-=Q.nf[i];
  return *this;
}
//attention l'operateur -= n'agit que sur les nf

//
//operateur d'affectation sans recopie de nf!!!!
//
template<typename mon,typename T>
pol<mon,T> & pol<mon,T>::operator= (const pol<mon,T>&Q)
{
  nf=Q.nf;
  size=Q.size;
  ind=Q.ind;
  return *this;
}

template<typename mon,typename T>
pol<mon,T> & pol<mon,T>::operator/= (const T&t)
{
 for(int i=0;i<this->size;i++)
    nf[i]/=t;
  return *this;
}
template<typename polyalp,typename poly> 
polyalp invconv(const poly & p)
{
  typedef typename polyalp::monom_t mon;
  typedef typename polyalp::order_t ord;
  polyalp res(0);
  // cout<<"p.size "<<p.size<<endl;
  for(int i=0;i<p.size;i++)
    {
      if (!Iszero(p.nf[i]))
      {
        mon tmp;
        int2mon(i,tmp);
        //cout<<"i vaut"<<i<<endl;
        //cout<<"j'aoute le monome "<<tmp<<endl;
        //cout<<"LE COEFF EST "<<p.nf[i]<<endl;  
        //cout<<"res dans invconv"<<endl<<res<<endl;
        res+=tmp*p.nf[i];
      }
    }
  if (!Iszero(p.ind.GetCoeff()))
    res+=p.ind;
  //cout<<"res dans invconv"<<endl<<res<<endl;
  return res;
}


// renvoit mon/x_i .... mais suppose qu'on ne fait pas n'importe quoi
//necessaire pour convert

template <typename Mon,typename Base>
Mon divmon(const Mon &mon,int i,const Base &b)
{
  Mon res(1);
  for(int j=0;j<b.nvar();j++)
    if(i==j)
      {
        res*=Mon(j,mon.GetDegree(j)-1);
      }
  else 
    {
      res*=Mon(j,mon.GetDegree(j));
    }
  return res;
}

//convertie un polyalp en pol
template<typename pol,typename polyalp,typename Base>
pol convert(const polyalp &P,const Base &b)
{
  typedef typename polyalp::order_t ord;
  typedef typename polyalp::monom_t mon;
  typedef typename mon::coeff_t coeff;
  pol res;
  int max=0;
  //  cout<<"entree de convert"<<endl;
  //cout<<"le pol que g ici c "<<P<<endl;
  for(typename polyalp::const_iterator iter=P.begin();iter!=P.end();iter++)
    {
      if(IsinB(*iter,b))
        {
          //int toto=mon2int(*iter),tutu=mon2int(*iter);
          max=(max<mon2int(*iter))?mon2int(*iter):max;
          //  cout<<"mon2int(*iter)"<<toto<<" "<<tutu<<endl;
        }
      else {/*cout<<*iter<<" n'est pas dans B "<<endl;*/};
    }
  res.size=max+1;
  res.nf=(coeff*)MAC_REV_MALLOC<coeff>(res.size*sizeof(coeff));
  for(int i=0;i<res.size;i++)
    res.nf[i]=0;
  //memset((void*)res.nf,0,res.size*sizeof(coeff));
  for(typename polyalp::const_iterator iter=P.begin();iter!=P.end();iter++)
    if(IsinB(*iter,b))
      {
        //cout<<"mon2int("<<*iter<<") "<<mon2int(*iter)<<" et size "<<res.size<<endl;
        res.nf[mon2int(*iter)]=iter->GetCoeff();
      }
  else 
    {
      //  cout<<"le monome "<<*iter<<" et le coeff "<<iter->GetCoeff()<<endl;
      //printf("le vrai nom est %.32f\n",iter->GetCoeff());
      if(!Iszero(coeff(iter->GetCoeff())))
        //le pol devrait NE PAS CONTENIR DE MONOME
        //EN DEHORS DU QUOTIENT AUTRE QUE x_i^{d_i}
        {
          // int i;
          //  cout<<"trouve monome correspondant a la description "<<*iter<<endl;
          res.ind=*iter;
          //res.size--;
          //res/=iter->GetCoeff();
        }
    }
  return res;
}

template<typename mon,typename T>
int Degree(const pol<mon,T> &p)
{
  int mmax=-1;
  for(int i=0;i<p.size;i++)
    if(!Iszero(p.nf[i]))
      {
        mon tmpmon;
        int2mon(i,tmpmon);
        mmax=(mmax<tmpmon.GetDegree())?tmpmon.GetDegree():mmax;
      }
  if(!Iszero(p.ind.GetCoeff()))
     mmax=(mmax<p.ind.GetDegree())?p.ind.GetDegree():mmax;
  return mmax;//p.ind.GetDegree();
}

template<typename mon ,typename T>
mon monofindex(int j, pol<mon,T> &p)
{
  mon tmp;
  int2mon(j,tmp);
  return tmp;
}

---