pol3.hpp

Go to the documentation of this file.

#include"ugly.hpp"
#define SIZE_LIMB 100
//
//
//Les trois types de limb :
// 0 = vide
// 1 = dense
// 2 = creux
//
//

template<typename T> void *MAC_REV_MALLOC(int size);
template<typename T> void *MAC_REV_REALLOC(void*ptr,int,int);
template<typename T> void MAC_REV_FREE(void*ptr,int size);

template<typename mon,typename T>
struct polmix  
{
  typedef mon monom_t;
  typedef T coeff_t;
  mon ind;
  int nblimb;
  int *type_limb;
  int *size_limb;
  T ** nf;
  int **nfind;
  
  // 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);
};
//
//l'autre par un coeff constant
//
template<typename mon,typename T>
polmix<mon,T> 
polmix<mon,T>::operator*(const typename polmix<mon,T>::coeff_t & toto)
{
  int tmpsize=this->size;
  for(int i=0;i<nblib;i++)
    {
      if(this->type_limb[i]!=0)//vide?
    {
      if(this->type_limb[i]==1)//dense
        for(int j=0;j<SIZE_LIMB;j++)
          this->nf[i][j]*=toto;
      else 
        if(this->type_limb[i]==2) //creux
          {
        for(int j=0;j<this->size_limb[i];j++)
          this->nf[i][j]*=toto;
          }
    }
    }
  return *this;
}

template<typename mon,typename T>
polmix<mon,T>& polmix<mon,T>::operator-=(const polmix<mon,T> &Q)
{
  typedef typename mon::coeff_t mcoeff_t;
  int nblimb2treat;
  if (this->nblimb<Q.nblimb)
    nblimb2treat=this->nblimb;
  else 
    nblimb2treat=Q.nblimb;
  for(int i=0;i<nblimb2treat;i++)
    {
      add_limb[3*this->type_limb[i]+Q.type_limb[i]](*this,Q);
      //add_limb tableau de fonctions ajoutant suivant les cas
    }
  return *this;
}
//attention l'operateur -= n'agit que sur les nf

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

template<typename mon,typename T>
polmix<mon,T> & polmix<mon,T>::operator/= (const T&t)
{
 for(int i=0;i<this->size;i++)
    nf[i]/=t;
  return *this;
}

template<typename polmixyalp,typename polmixy> 
polmixyalp invconv(const polmixy & 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(p.nfind[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;
}

//converti un polmixyalp en polmix
template<typename polmix,typename polyalp,typename Base>
polmix 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;
  polmix res;
  int i;
  res.size=P.size()-1;//l'ind n'est pas comptabilise dans la nf
  res.nf=(coeff*)MAC_REV_MALLOC<coeff>(res.size*sizeof(coeff));
  res.nfind=(int*)MAC_REV_MALLOC<int>(res.size*sizeof(int));
  for( i=0;i<res.size;i++)
    res.nf[i]=0;
  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[i]=iter->GetCoeff();
    res.nfind[i++]=mon2int(*iter);
      }
  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 polmix 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();
    }
    }
  /*
  //TRi a bulle a remplcer
  for(int i=1;i<res.size;i++)
    for(int j=0;j<res.size-i;j++)
      {
    if(res.nfind[j]>res.nfind[j+1])
      {
        coeff tmpcoeff=res.nf[j];
        int tmpind=res.nfind[j];
        res.nf[j]=res.nf[j+1];
        res.nfind[j]=res.nfind[j+1];
        res.nf[j+1]=tmpcoeff;
        res.nfind[j+1]=tmpind;
      }
      }
  */
  sortpolmix(res);
  return res;
}

template<typename mon,typename T>
int Degree(const polmix<mon,T> &p)
{
  int mmax=-1;
  for(int i=0;i<p.size;i++)
    if(!Iszero(p.nf[i]))
      {
    mon tmpmon;
    int2mon(p.nfind[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>
int hasmonom(const polmix<mon,T>& p,const mon & m)
{
  int res=0,i,tmpind=mon2int(m);
  for(i=0;i<p.size&&p.nfind[i]<tmpind;i++);
  if(i<p.size&&p.nfind[i]==tmpind&&!Iszero(p.nf[i]))
    res=1;
  return res;
}

template<typename T> 
void simqsort(T * coeff, int * ind, int sizesort)
{
  int i,j=sizesort-1,stockind;
  T stock;
  //cout<<"en entree du tri"<<endl;
  //for(i=0;i<sizesort;i++)
  //  cout<<ind[i]<<" ";
  //cout<<endl;
  if (sizesort<=1) return;
  stockind=ind[0];
  stock=*coeff;
  for(i=1;i<=j;i++)
    {
      if(stockind<ind[i])
    {
      for(;j>=i&&ind[j]>stockind;j--);
      // cout<<"la place "<<j<<endl;
      if(i<=j)
        {
          coeff[i-1]=coeff[j];
          ind[i-1]=ind[j];
          ind[j]=ind[i];
          coeff[j]=coeff[i];
        }
      else break;
    }
      else
    {
       coeff[i-1]=coeff[i];
       ind[i-1]=ind[i];
        }
    }
  coeff[i-1]=stock;
  ind[i-1]=stockind;
  //cout<<"i ici "<<i<<endl;
  simqsort(coeff,ind,i-1);
  simqsort(coeff+i,ind+i,sizesort-i);
  //cout<<"le resulat du tri"<<endl;
  //for(i=0;i<sizesort;i++)
  // cout<<ind[i]<<" ";
  //cout<<endl;
}

template<typename mon, typename T>
void sortpol(polmix<mon, T> & p)
{
  simqsort(p.nf,p.nfind,p.size);
  
}