dump.hpp

Go to the documentation of this file.

template<typename pol>
struct dumpstruct 
{
  typedef pol pol_t;
  int k;
  int size;
  pol * nf;
};
template<typename poldense,typename polsparse>
void sparsify(const poldense &p, polsparse & res)
{
  typedef typename poldense::monom_t mon;
  mon tmpmon;
  int comp=0;
  res.ind=p.ind;
  res.size=0;
  for(int i=0;i<p.size;i++)
    if(!Iszero(p.nf[i])) res.size++;
  res.nf=(mon*)MAC_REV_MALLOC<mon>(res.size*sizeof(mon));
  for(int i=0;i<p.size;i++)
     if(!Iszero(p.nf[i]))
       {
     int2mon(i,tmpmon);
     tmpmon.SetCoeff(p.nf[i]);
     res.nf[comp++]=tmpmon;
       }
}

template<typename poldense,typename polsparse>
void densify(const polsparse & p, poldense &res)
{
  typedef typename poldense::coeff_t coeff;
  res.ind=p.ind;
  res.size=0;
  for(int i=0;i<p.size;i++)
    if(mon2int(p.nf[i])>res.size) res.size=mon2int(p.nf[i]);
  res.size++;
  res.nf=(coeff*)MAC_REV_MALLOC<coeff>(res.size*sizeof(coeff));
  for(int i=0;i<res.size;i++)
    res.nf[i]=0;
  for(int i=0;i<p.size;i++)
    {
      res.nf[mon2int(p.nf[i])]=p.nf[i].GetCoeff();
    }
}

template<typename typPk, typename typdump>
void Dump(const typPk & Pk ,typdump &dump)
{
  typedef typename typdump::value_type dumpstruct;
  int i=0;
  dumpstruct next;
  if(!Pk.empty())
    {
      next.k=Pk.front().ind.GetDegree();
      next.size=Pk.size();
      next.nf=(typename dumpstruct::pol_t *)MAC_REV_MALLOC
    <typename dumpstruct::pol_t>(Pk.size()*
                 sizeof(typename dumpstruct::pol_t));
      for(typename typPk::const_iterator iter=Pk.begin();iter!=Pk.end();iter++,i++)
    {
      next.nf[i]=*iter;
      //Tue Dec  4 16:12:10 MET 2001
      //sparsify(*iter,next.nf[i]);
      //Tue Dec  4 16:12:10 MET 2001
      next.nf[i].ind.SetCoeff(1);
      //      cout<<"dans le dump "<<iter->ind<<" "<<next.nf[i].ind<<endl;
      //cout<<"et le ptr "<<iter->nf<<" "<<next.nf[i].nf<<endl;
    }
      dump.push_back(next);
    }
  return;
}
template<typename Base,typename typdump,typename typrecall>
void forget(Base &b,typdump &dump,int k,typrecall & recall)

  //template<typename Base,typename typdump>
  //void forget(Base &b,typdump &dump,const int &k)
{
  typedef typename Base::mon mon;
  typedef typename mon::coeff_t coeff;
  typedef typename typdump::value_type::pol_t pol;
  typename typdump::iterator iterdump=dump.begin(),stockiter=dump.end();
  //Tue Dec  4 16:12:10 MET 2001
  //for(typename typrecall::iterator iter=recall.begin();iter!=recall.end();iter++)
  //MAC_REV_FREE<mon>(iter->nf,iter->size*sizeof(mon));
  //Tue Dec  4 16:12:10 MET 2001
  for(typename typrecall::iterator iter=recall.begin();iter!=recall.end();iter++)
    MAC_REV_FREE<coeff>(iter->nf,iter->size*sizeof(coeff));
  recall.erase(recall.begin(),recall.end());
  //cout<<"destruction dans B"<<endl;
  for(typename Base::iterator iter=b.begin();iter!=b.end();iter++)
    {
      mon *tmp=(mon*)MAC_REV_MALLOC<mon>(iter->taille1*sizeof(mon));
      int tmptaille=0;
      for(int i=0;i<iter->taille1;i++)
    if(iter->accept[i].GetDegree()<=k)
      //27/08/2001(iter->refuse[i].GetDegree()<=k)
      {
        tmp[tmptaille++]=iter->accept[i];
      }
      //on suppose que le monomes se detruisent tout seuls
      //rajouter un destroy mon sinon
      if(tmptaille==0) 
    {
      MAC_REV_FREE<mon>(tmp,iter->taille1*sizeof(mon));
      MAC_REV_FREE<mon>(iter->accept,iter->taille1*sizeof(mon));
      MAC_REV_FREE<mon>(iter->refuse,iter->taille2*sizeof(mon));
      b.erase(iter--);
      continue;
      //tmp[tmptaille++]=mon(1);
    }
      MAC_REV_FREE<mon>(iter->accept,iter->taille1*sizeof(mon));
      iter->accept=(mon*)MAC_REV_REALLOC<mon>((void*)tmp
                    ,iter->taille1*sizeof(mon)
                     ,tmptaille*sizeof(mon));
      iter->taille1=tmptaille;
      //pour les refuses
      tmp=(mon*)MAC_REV_MALLOC<mon>(iter->taille2*sizeof(mon));
      tmptaille=0;
      for(int i=0;i<iter->taille2;i++)
    if(iter->refuse[i].GetDegree()<=k)
      //27/08/2001(iter->refuse[i].GetDegree()<=k)
      {
        tmp[tmptaille++]=iter->refuse[i];
      }
      //on suppose que les monomes se detruisent tout seuls
      //rajouter un destroy mon sinon
      MAC_REV_FREE<mon>(iter->refuse,iter->taille2*sizeof(mon));
      //iter->taille2=tmptaille;
      //if(tmptaille==0) 
      //{
      /*free(iter->refuse);*/
      //  iter->refuse=NULL;
      //}
      //else
    {
      iter->refuse=(mon*)MAC_REV_REALLOC<mon>((void*)tmp
                          ,iter->taille2*sizeof(mon)
                         ,tmptaille*sizeof(mon));
    }
      iter->taille2=tmptaille;
    }
  //on vire des differentes composantes B les monomes de degre>k
  //ca ralentit l'algo mais c coherent sinon on cherche des nf 
  //que l'on ne connait pas
  //ya un opti a faire ici

  for(iterdump=dump.begin();iterdump!=stockiter/*dump.end()*/ && iterdump->k<k;iterdump++);
  // cout<<"je detruit tout a partir du degre "<<k<<endl;
  if(iterdump!=stockiter)
    stockiter=iterdump++;//on suppose qu'on a fait
  if(stockiter!=dump.end())
    free(stockiter->nf);
  //un recover avant du meme degre sinon il y a fuite de memoire
  
  if(k==0) {cout<<"pas de sol"<<endl;exit(0);}
  //cout<<"iter!=dump.end()"<<(iter!=dump.end())<<endl;
  if(0&&iterdump!=dump.end())
    {
      for(int i=0;i<iterdump->size;i++)
    recall.push_back(iterdump->nf[i]);
        iterdump++;
    }
  for(;iterdump!=dump.end();iterdump++)
    {
      //destruction de pol de cette couche
      //for(int i=0;i<iterdump->size;i++)
      //    recall.push_back(iterdump->nf[i]);
    //recall.push_back(invconv<typename typP::value_type>(iterdump->nf[i]));
    {
      
      // cout<<"le pointeur "<<(double*)iterdump->nf[i].nf<<endl;
      //Tue Dec 4
      //for(int ii=0;ii<(iterdump->size);ii++)
      //  MAC_REV_FREE<mon>(iterdump->nf[ii].nf
      //            ,iterdump->nf[ii].size*sizeof(mon));
      //Tue Dec 4
      for(int ii=0;ii<(iterdump->size);ii++)
            MAC_REV_FREE<coeff>(iterdump->nf[ii].nf
                ,iterdump->nf[ii].size*sizeof(coeff));
      MAC_REV_FREE<pol>(iterdump->nf,iterdump->size*sizeof(pol));
    }
    //free(iterdump->nf);
    }
  //cout<<"au tour de B "<<endl;
  dump.erase(stockiter,dump.end());

}

template<typename typPk, typename typMk, typename typdump>
void recover(typPk &Pk,typMk &Mk, const typdump & dump, int k)
{
  typedef typename typPk::value_type pol;
  typename typdump::const_iterator iter;
  typedef typename pol::coeff_t coeff;
  //if (k!=Pk.front().GetDegree())
    {
      //les mecs dans Pkont ete dumpe normalment donc il faut pas les detruire
      //sinon on est embette par forget qui va chercher a la faire aussi
      Pk.erase(Pk.begin(),Pk.end());
      Mk.erase(Mk.begin(),Mk.end());
      for(iter=dump.begin();(iter!=dump.end())&&(iter->k<k);iter++);
      //    if (iter!=dump.end()) cout<<"iter->k "<<iter->k<<endl;
      if ((iter!=dump.end())&&(iter->k==k))
    for(int i=0;i<iter->size;i++)
      {
        //Tue Dec  4 16:12:10 MET 2001
        //      pol tmppol;
        //densify(iter->nf[i],tmppol);
        //Pk.push_back(tmppol);
        //Tue Dec  4 16:12:10 MET 2001
        Pk.push_back(iter->nf[i]);
        Mk.push_back(Pk.rbegin()->ind);
      }
    }
  return;
}