include/borderbasix/dump.cc File Reference

Go to the source code of this file.

Classes

Functions

Function Documentation

void densify ( const polsparse &  p,
poldense &  res 
) [inline]

Definition at line 30 of file dump.cc.

References mon2int().

00031 {
00032   typedef typename poldense::coeff_t coeff;
00033   res.ind=p.ind;
00034   res.size=0;
00035   for(int i=0;i<p.size;i++)
00036     if(mon2int(p.nf[i])>res.size) res.size=mon2int(p.nf[i]);
00037   res.size++;
00038   res.nf=(coeff*)MAC_REV_MALLOC<coeff>(res.size*sizeof(coeff));
00039   for(int i=0;i<res.size;i++)
00040     res.nf[i]=0;
00041   for(int i=0;i<p.size;i++)
00042     {
00043       res.nf[mon2int(p.nf[i])]=p.nf[i].GetCoeff();
00044     }
00045 }

void Dump ( const typPk &  Pk,
typdump &  dump 
) [inline]

Definition at line 48 of file dump.cc.

References pol< mon, T >::ind, dumpstruct< pol >::k, MAC_REV_MALLOC(), dumpstruct< pol >::nf, and dumpstruct< pol >::size.

Referenced by algo(), init_algo(), and NewCrochetchoix().

00049 {
00050   typedef typename typdump::value_type dumpstruct;
00051   int i=0;
00052   dumpstruct next;
00053   if(!Pk.empty())
00054     {
00055       next.k=Pk.front().ind.GetDegree();
00056       next.size=Pk.size();
00057       next.nf=(typename dumpstruct::pol_t *)MAC_REV_MALLOC
00058     <typename dumpstruct::pol_t>(Pk.size()*
00059                                  sizeof(typename dumpstruct::pol_t));
00060       for(typename typPk::const_iterator iter=Pk.begin();iter!=Pk.end();iter++,i++)
00061     {
00062       next.nf[i]=*iter;
00063       //Tue Dec  4 16:12:10 MET 2001
00064       //sparsify(*iter,next.nf[i]);
00065       //Tue Dec  4 16:12:10 MET 2001
00066       next.nf[i].ind.SetCoeff(1);
00067       //      cout<<"dans le dump "<<iter->ind<<" "<<next.nf[i].ind<<endl;
00068       //cout<<"et le ptr "<<iter->nf<<" "<<next.nf[i].nf<<endl;
00069     }
00070       dump.push_back(next);
00071     }
00072   return;
00073 }

void forget ( Base &  b,
typdump &  dump,
int  k,
typrecall &  recall 
) [inline]

Definition at line 75 of file dump.cc.

References Base< predicat >::begin(), Base< predicat >::end(), and Base< predicat >::erase().

Referenced by algo(), NewCrochetchoix(), and newPkMkMatrixof().

00079 {
00080   typedef typename Base::mon mon;
00081   typedef typename mon::coeff_t coeff;
00082   typedef typename typdump::value_type::pol_t pol;
00083   typename typdump::iterator iterdump=dump.begin(),stockiter=dump.end();
00084   //Tue Dec  4 16:12:10 MET 2001
00085   //for(typename typrecall::iterator iter=recall.begin();iter!=recall.end();iter++)
00086   //MAC_REV_FREE<mon>(iter->nf,iter->size*sizeof(mon));
00087   //Tue Dec  4 16:12:10 MET 2001
00088   for(typename typrecall::iterator iter=recall.begin();iter!=recall.end();iter++)
00089     MAC_REV_FREE<coeff>(iter->nf,iter->size*sizeof(coeff));
00090   recall.erase(recall.begin(),recall.end());
00091   //cout<<"destruction dans B"<<endl;
00092   for(typename Base::iterator iter=b.begin();iter!=b.end();iter++)
00093     {
00094       mon *tmp=(mon*)MAC_REV_MALLOC<mon>(iter->taille1*sizeof(mon));
00095       int tmptaille=0;
00096       for(int i=0;i<iter->taille1;i++)
00097         if(iter->accept[i].GetDegree()<=k)
00098           //27/08/2001(iter->refuse[i].GetDegree()<=k)
00099           {
00100             tmp[tmptaille++]=iter->accept[i];
00101           }
00102       //on suppose que le monomes se detruisent tout seuls
00103       //rajouter un destroy mon sinon
00104       if(tmptaille==0) 
00105         {
00106           MAC_REV_FREE<mon>(tmp,iter->taille1*sizeof(mon));
00107           MAC_REV_FREE<mon>(iter->accept,iter->taille1*sizeof(mon));
00108           MAC_REV_FREE<mon>(iter->refuse,iter->taille2*sizeof(mon));
00109           b.erase(iter--);
00110           continue;
00111           //tmp[tmptaille++]=mon(1);
00112         }
00113       MAC_REV_FREE<mon>(iter->accept,iter->taille1*sizeof(mon));
00114       iter->accept=(mon*)MAC_REV_REALLOC<mon>((void*)tmp
00115                                         ,iter->taille1*sizeof(mon)
00116                                          ,tmptaille*sizeof(mon));
00117       iter->taille1=tmptaille;
00118       //pour les refuses
00119       tmp=(mon*)MAC_REV_MALLOC<mon>(iter->taille2*sizeof(mon));
00120       tmptaille=0;
00121       for(int i=0;i<iter->taille2;i++)
00122         if(iter->refuse[i].GetDegree()<=k)
00123           //27/08/2001(iter->refuse[i].GetDegree()<=k)
00124           {
00125             tmp[tmptaille++]=iter->refuse[i];
00126           }
00127       //on suppose que les monomes se detruisent tout seuls
00128       //rajouter un destroy mon sinon
00129       MAC_REV_FREE<mon>(iter->refuse,iter->taille2*sizeof(mon));
00130       //iter->taille2=tmptaille;
00131       //if(tmptaille==0) 
00132       //{
00133           /*free(iter->refuse);*/
00134       //  iter->refuse=NULL;
00135       //}
00136       //else
00137         {
00138           iter->refuse=(mon*)MAC_REV_REALLOC<mon>((void*)tmp
00139                                                   ,iter->taille2*sizeof(mon)
00140                                              ,tmptaille*sizeof(mon));
00141         }
00142       iter->taille2=tmptaille;
00143     }
00144   //on vire des differentes composantes B les monomes de degre>k
00145   //ca ralentit l'algo mais c coherent sinon on cherche des nf 
00146   //que l'on ne connait pas
00147   //ya un opti a faire ici
00148 
00149   for(iterdump=dump.begin();iterdump!=stockiter/*dump.end()*/ && iterdump->k<k;iterdump++);
00150   // cout<<"je detruit tout a partir du degre "<<k<<endl;
00151   if(iterdump!=stockiter)
00152     stockiter=iterdump++;//on suppose qu'on a fait
00153   if(stockiter!=dump.end())
00154     free(stockiter->nf);
00155   //un recover avant du meme degre sinon il y a fuite de memoire
00156   
00157   if(k==0) {cout<<"pas de sol"<<endl;exit(0);}
00158   //cout<<"iter!=dump.end()"<<(iter!=dump.end())<<endl;
00159   if(0&&iterdump!=dump.end())
00160     {
00161       for(int i=0;i<iterdump->size;i++)
00162         recall.push_back(iterdump->nf[i]);
00163         iterdump++;
00164     }
00165   for(;iterdump!=dump.end();iterdump++)
00166     {
00167       //destruction de pol de cette couche
00168       //for(int i=0;i<iterdump->size;i++)
00169       //        recall.push_back(iterdump->nf[i]);
00170         //recall.push_back(invconv<typename typP::value_type>(iterdump->nf[i]));
00171         {
00172           
00173           // cout<<"le pointeur "<<(double*)iterdump->nf[i].nf<<endl;
00174           //Tue Dec 4
00175           //for(int ii=0;ii<(iterdump->size);ii++)
00176           //  MAC_REV_FREE<mon>(iterdump->nf[ii].nf
00177           //                    ,iterdump->nf[ii].size*sizeof(mon));
00178           //Tue Dec 4
00179           for(int ii=0;ii<(iterdump->size);ii++)
00180             MAC_REV_FREE<coeff>(iterdump->nf[ii].nf
00181                                 ,iterdump->nf[ii].size*sizeof(coeff));
00182           MAC_REV_FREE<pol>(iterdump->nf,iterdump->size*sizeof(pol));
00183         }
00184         //free(iterdump->nf);
00185     }
00186   //cout<<"au tour de B "<<endl;
00187   dump.erase(stockiter,dump.end());
00188 
00189 }

void recover ( typPk &  Pk,
typMk &  Mk,
const typdump &  dump,
int  k 
) [inline]

Definition at line 192 of file dump.cc.

Referenced by algo(), NewCrochetchoix(), and newPkMkMatrixof().

00193 {
00194   typedef typename typPk::value_type pol;
00195   typename typdump::const_iterator iter;
00196   typedef typename pol::coeff_t coeff;
00197   //if (k!=Pk.front().GetDegree())
00198     {
00199       //les mecs dans Pkont ete dumpe normalment donc il faut pas les detruire
00200       //sinon on est embette par forget qui va chercher a la faire aussi
00201       Pk.erase(Pk.begin(),Pk.end());
00202       Mk.erase(Mk.begin(),Mk.end());
00203       for(iter=dump.begin();(iter!=dump.end())&&(iter->k<k);iter++);
00204       //        if (iter!=dump.end()) cout<<"iter->k "<<iter->k<<endl;
00205       if ((iter!=dump.end())&&(iter->k==k))
00206         for(int i=0;i<iter->size;i++)
00207           {
00208             //Tue Dec  4 16:12:10 MET 2001
00209             //      pol tmppol;
00210             //densify(iter->nf[i],tmppol);
00211             //Pk.push_back(tmppol);
00212             //Tue Dec  4 16:12:10 MET 2001
00213             Pk.push_back(iter->nf[i]);
00214             Mk.push_back(Pk.rbegin()->ind);
00215           }
00216     }
00217   return;
00218 }

void sparsify ( const poldense &  p,
polsparse &  res 
) [inline]

Definition at line 10 of file dump.cc.

References int2mon(), and Iszero().

00011 {
00012   typedef typename poldense::monom_t mon;
00013   mon tmpmon;
00014   int comp=0;
00015   res.ind=p.ind;
00016   res.size=0;
00017   for(int i=0;i<p.size;i++)
00018     if(!Iszero(p.nf[i])) res.size++;
00019   res.nf=(mon*)MAC_REV_MALLOC<mon>(res.size*sizeof(mon));
00020   for(int i=0;i<p.size;i++)
00021      if(!Iszero(p.nf[i]))
00022        {
00023          int2mon(i,tmpmon);
00024          tmpmon.SetCoeff(p.nf[i]);
00025          res.nf[comp++]=tmpmon;
00026        }
00027 }

Generated on 6 Dec 2012 for borderbasix by  doxygen 1.6.1