include/borderbasix/corealgo.cc File Reference

Go to the source code of this file.

Functions

Function Documentation

void algo ( typP  P,
typdump &  dump,
Base &  b 
) [inline]

Definition at line 2852 of file corealgo.cc.

References compress(), Dump(), forget(), Iszero(), Listedejafait(), mindeg(), my_merge(), NewCrochetchoix(), NewDestroyredspol(), newPkMkMatrixof(), recover(), ReduceSpol(), Spolordsup(), and stop_degree().

02853 {
02854   // int toto=0;
02855   typedef list<typename typPk::value_type::monom_t> typMk;
02856   typedef typename typMk::value_type mon;
02857   typMk Mk;
02858   typMk Spoldejavu;
02859   typPk Pk,S;
02860   //typP recall 
02861   typPk recall;
02862   //Base b;
02863   int go_on=1;
02864   typedef tmptypmat<typename typP::value_type::coeff_t> typMat;
02865   typMat Mat;
02866   int nouveaumon,allpolused=0,maxdeg,k,*pr,*pc;
02867   //cout<<"avant init"<<endl;
02868   init_algo<typMat>(P,nouveaumon,maxdeg,k,Pk,Mk,b,dump);
02869   //cout<<"apres init"<<endl;
02870 #ifdef dimpos
02871   go_on=stop_degree(b);
02872   cout<<"je m'arrete a ce degre "<<go_on<<endl;
02873   while((nouveaumon||(k<=maxdeg))&& ((go_on>=k)||(k<=maxdeg)))
02874 #else
02875   while((nouveaumon||(k<=maxdeg)))
02876 #endif 
02877     {
02878     //    if (toto>=3) {exit(10);}
02879     //toto++;
02880     int killspol;
02881     //  for(typename Base::const_iterator p=b.begin();p!=b.end();p++)
02882 //        {
02883 
02884 //      for(int i=0;i<p->taille1;i++)
02885 //        {
02886 //          cout<<"p.accept[i] "<<p->accept[i]<<endl;
02887 //        }
02888 //      for(int i=0;i<p->taille2;i++)
02889 //        {
02890 //          cout<<"p.refuse[i] "<<p->refuse[i]<<endl;
02891 //        }
02892 //        }
02893 //#define DEB
02894 #ifdef DEB
02895     cout<<"poly a la fin de la boulcle de l'algo"<<endl;
02896     for(typename typPk::iterator iter=Pk.begin();iter!=Pk.end();iter++)
02897        //cout<<"les sizes "<<iter->size<<endl;
02898     cout<<invconv<typename typP::value_type>(*iter)<<endl;       
02899 #endif
02900     //#undef DEB
02901     //cout<<"Spolordsup"<<endl;
02902 #ifdef NO_TWICE    
02903     S=Spolordsup(Pk,b,Spoldejavu);
02904 #else
02905     S=Spolordsup(Pk,b);
02906 #endif
02907 
02908 #ifdef experiment
02909     cout<<"S.back().ind.GetCoeff().rep "<<S.back().ind.GetCoeff().rep<<" k "<<k<<endl;
02910     if((S.back().ind.GetCoeff().rep<k) && (k>=maxdeg))
02911       {go_on=0;continue;}
02912     S.pop_back();
02913 #endif 
02914     //cout<<"newpkmkmatrixof"<<endl;
02915     //cout<<"Pk.size() "<<Pk.size()<<endl;
02916 #ifdef NO_TWICE
02917     killspol=!newPkMkMatrixof(Mat,Pk,P,Mk,k,b,dump,recall,Spoldejavu);
02918 #else    
02919     killspol=!newPkMkMatrixof(Mat,Pk,P,Mk,k,b,dump,recall);
02920 #endif    
02921     // killspol=!newPkMkMatrixof(Mat,Pk,P,Mk,k,b,dump);
02922     if(killspol) S.erase(S.begin(),S.end());
02923     if (k+1>=maxdeg) allpolused=1;
02924     if(Mk.size()==0) nouveaumon=0;
02925     //cout<<"j'en suis a k="<<k<<endl;
02926     //cout<<"Ici dans algo Mat"<<endl;
02927     //affdebug(Mat);
02928     //Solve affecte a Mat la valeur U
02929     //cout<<"solve"<<endl;
02930     //for(typename typPk::iterator iter=Pk.begin();iter!=Pk.end();iter++)
02931     //  cout<<"avant solve les ind "<<iter->ind<<endl;
02932     //for(typename typPk::iterator iter=Pk.begin();iter!=Pk.end();iter++)
02933     //  cout<<"avant solve les pol "<<invconv<Poly>(*iter)<<endl;
02934     //if(k==3) exit(-10);
02935     //for(typename typMk::iterator iter=Mk.begin();iter!=Mk.end();iter++)
02936     //  cout<<"monomes dans Mk "<<*iter<<endl;
02937     if (Mat.ncol!=0)
02938       {
02939         Solve(Mat,Pk,&pr,&pc);
02940         //for(int kk=0;kk<Mk.size();kk++)
02941         //  cout<<"permc "<<kk<<" "<<pc[kk]<<endl;
02942         inverse(pc,Mk.size());
02943         Dopermu(Mk,pc);
02944         {
02945           //ici on remet les ind a la bonne valuer 
02946           //a inclure dans une petite fonction inline apres
02947           int j=0;
02948           typename typMk::iterator itermon=Mk.begin();
02949           typename typPk::iterator iter;
02950           for(iter=Pk.begin();
02951               itermon!=Mk.end();iter++,itermon++,j++)
02952             {
02953               if(!Iszero(Mat(j,j)))
02954                 {
02955                   //              cout<<"ligne "<<j<<" je mets le monome "<<*itermon<<endl;
02956                   iter->ind=*itermon*(iter->ind.GetCoeff());
02957                 }
02958               else
02959                 {
02960                   iter->ind=mon(0);
02961                 }
02962             }
02963           //for(;itermon!=Mk.end();iter++,itermon++)
02964           //  iter->ind=mon(0);
02965         }
02966         free(pr);
02967         free(pc);
02968       }
02969     
02970  //appliquer les permutation a MK!!!!!!!!
02971     // for(typename typPk::iterator iter=Pk.begin();iter!=Pk.end();iter++)
02972       //  cout<<"apres solve les ind "<<iter->ind<<endl;
02973     //for(typename typPk::iterator iter=Pk.begin();iter!=Pk.end();iter++)
02974     // cout<<"apres solve les pol "<<invconv<Poly>(*iter)<<endl;
02975     //
02976     //
02977     //APPLIQUER LES PERMUTYATIONS A MK!!
02978     //
02979     //
02980     //
02981     //
02982     if ((unsigned)my_rank(Mat)==Mk.size())
02983       //matrice de rang plein
02984       {
02985         typPk redspol,secd=secondmembre(Mat,Pk);;
02986         //secondmembre2(Mat,Pk,secd);
02987         //typename typPk::iterator iter=Pk.begin();
02988         cout<<"matrice de rang plein "<<endl;
02989         //for(unsigned int i=0;i<Mk.size();i++,iter++);
02990         //Pk.erase(iter,Pk.end());
02991         //cout<<"Dump "<<endl;
02992         Dump(Pk,dump);
02993         //cout<<"Reduce Spol "<<endl;
02994         ReduceSpol(S,dump,redspol,b);
02995         //cout<<"secd.size() "<<secd.size()<<endl;
02996         my_merge(redspol,secd);
02997         if(redspol.size()==0)
02998           {
02999             //a voir....    Dump(Pk,dump);
03000             k++;
03001             continue;
03002             //la matrice a rang plein 
03003             //ET les Spol\secondmembre de ce niveau se ,reduisent a 0
03004           }
03005         else
03006           {
03007             //on a des spol\secondmembre qui se reduisent pas a 0
03008             //cad un defaut de commuatation
03009             nouveaumon=1;
03010             cout<<"redspol.size() "<<redspol.size()<<endl;
03011             //cout<<invconv<typename typP::value_type>(redspol.front())<<endl;
03012             k=mindeg(redspol);
03013             //cout<<"le mindeg ici vaut "<<k<<endl;
03014             //cout<<"Pk.size() avant recover "<<Pk.size()<<endl;
03015             recover(Pk,Mk,dump,k);
03016 #ifdef NO_TWICE
03017             Listedejafait(Mk,Spoldejavu);
03018 #endif
03019             //cout<<"Pk.size() apres recover "<<Pk.size()<<endl;
03020             forget(b,dump,k,recall);
03021             //forget(b,dump,k);
03022             //cout<<"Pk.size() avant Crochetchoix "<<Pk.size()<<endl;
03023 #ifdef NO_TWICE
03024             NewCrochetchoix(P,Pk,Mk,redspol,k,dump,b,recall,Spoldejavu);
03025 #else    
03026             NewCrochetchoix(P,Pk,Mk,redspol,k,dump,b,recall);
03027 #endif      
03028             //NewCrochetchoix(P,Pk,Mk,redspol,k,dump,b);
03029             //cout<<"Pk.size apres Crochetchoix "<<Pk.size()<<" et k "<<k<<endl;
03030             NewDestroyredspol(redspol,Pk);
03031             compress(Pk,dump,b,k);
03032             Dump(Pk,dump);
03033             //misa jour de B dans crochet choix!!
03034 #ifdef dimpos
03035             go_on=stop_degree(b);
03036             cout<<"go on ici vaut "<<go_on<<endl;
03037 #endif
03038 
03039             continue;
03040           }
03041       }
03042     else
03043       //la matrice n'est pas de rang plein
03044       {
03045         cout<<"matrice de rang pas plein "<<endl;
03046         typPk secd;
03047         AddB(Mat,Pk,Mk,dump,b);
03048         //
03049         //secondmembre supprime des trucs dans Pk!!
03050         //
03051         secd=secondmembre(Mat,Pk);
03052         rajoute_voisins(Pk,Mk,dump,b);
03053         //ne selectionne que les non nuls
03054        if(secd.size()==0)
03055          {
03056            typPk redspol;
03057            //for(int i=Pk.size();i>rank(Mat);i--)
03058            //{
03059            //  if(Pk.back().size!=0)
03060            // MAC_REV_FREE<typename typMat::coeff_t>(Pk.rbegin()->nf
03061            //    ,Pk.rbegin()->size*sizeof(typename typMat::coeff_t));
03062            //  Pk.pop_back();
03063            //}//on vire les 0 avant de dumper
03064            //      AddB(Mat,Pk,Mk,dump,b);
03065            Dump(Pk,dump);
03066            ReduceSpol(S,dump,redspol,b);
03067            if(redspol.size()==0)
03068              {
03069                // forget(b,dump,k);
03070                //AddB(Mat,Pk,Mk,b);
03071                //Dump(Pk,dump);
03072                //ici on modifie Pk dans AddB 
03073                //<=> forget(b,dump,k) AddB(..) Dump(Pk,dump);
03074                k++;
03075 #ifdef dimpos
03076                go_on=stop_degree(b);
03077                cout<<"go on ici vaut "<<go_on<<endl;
03078 #endif
03079 
03080                continue;
03081                //la matrice a pas rang plein second membre =0 
03082                //ET les Spol de ce niveau se ,reduisent a 0
03083              }
03084            else
03085              {
03086                //on a des spol qui se reduisent pas a 0
03087                //cad un defaut de commutation 
03088                k=mindeg(redspol);
03089                recover(Pk,Mk,dump,k);
03090 #ifdef NO_TWICE
03091                Listedejafait(Mk,Spoldejavu);
03092 #endif         
03093                forget(b,dump,k,recall);
03094                //forget(b,dump,k);
03095                cout<<"il ya un passage par mat rang pas"
03096                    <<"plein et pol non zero"<<endl;
03097 #ifdef NO_TWICE
03098                NewCrochetchoix(P,Pk,Mk,redspol,k,dump,b,recall,Spoldejavu);
03099 #else          
03100                NewCrochetchoix(P,Pk,Mk,redspol,k,dump,b,recall);
03101 #endif         
03102                //NewCrochetchoix(P,Pk,Mk,redspol,k,dump,b);
03103                NewDestroyredspol(redspol,Pk);
03104                compress(Pk,dump,b,k);
03105                Dump(Pk,dump); 
03106 #ifdef dimpos
03107                go_on=stop_degree(b);
03108                cout<<"go on ici vaut "<<go_on<<endl;
03109 #endif
03110 
03111                continue;
03112              }
03113          }
03114        else
03115          {
03116            //on a des pol qui se reduisent pas a 0
03117            //cad un defaut de commuatation dans les coins
03118            typPk redspol;
03119            //for(int i=Pk.size();i>rank(Mat);i--)
03120            //  Pk.pop_back();
03121            //cout<<"PK. size "<<Pk.size()<<" Mat.nbcol "<<Mat.ncol<<endl;
03122            //cout<<"rank(Mat) "<<rank(Mat)<<endl;
03123            //int j=0;
03124            //cout<<"avant recover et meme avant le dump "<<endl;
03125            //for(typename typPk::iterator iter = secd.begin();iter!=secd.end()
03126            //    ;iter++,j++)
03127            // cout<<"pol de secd num "<<j<<endl<<invconv<Poly>(*iter)<<endl;
03128            //      AddB(Mat,Pk,Mk,b);
03129            //cout<<"apres ADDB le dump "<<endl;
03130            //for(typename typPk::iterator iter = Pk.begin();iter!=Pk.end()
03131            //    ;iter++)
03132            // cout<<invconv<Poly>(*iter)<<endl;
03133            Dump(Pk,dump);
03134            //cout<<"secd.size()" <<secd.size()<<endl;
03135            ReduceSpol(S,dump,redspol,b);
03136            my_merge(secd,redspol);
03137            k=mindeg(secd);
03138            recover(Pk,Mk,dump,k);
03139 #ifdef NO_TWICE    
03140            Listedejafait(Mk,Spoldejavu);
03141 #endif
03142            //cout<<"apres recover"<<endl;
03143            //      for(typename typPk::iterator iter = Pk.begin();iter!=Pk.end()
03144            //    ;iter++)
03145            //  cout<<invconv<Poly>(*iter)<<endl;
03146            //cout<<"les Spol non reduits"<<endl;
03147            //for(typename typPk::iterator iter = secd.begin();iter!=secd.end()
03148            //    ;iter++)
03149            //  cout<<invconv<Poly>(*iter)<<endl;
03150            forget(b,dump,k,recall);
03151            //forget(b,dump,k);
03152            //cout<<"il ya un passage par mat pas rang plein et Spol non zero"<<endl;
03153            //for(typename typPk::iterator iter = secd.begin();iter!=secd.end()
03154            //    ;iter++)
03155            // cout<<invconv<Poly>(*iter)<<endl;
03156 #ifdef NO_TWICE    
03157            NewCrochetchoix(P,Pk,Mk,redspol,k,dump,b,recall,Spoldejavu);
03158 #else      
03159            NewCrochetchoix(P,Pk,Mk,secd,k,dump,b,recall);
03160 #endif     
03161            //NewCrochetchoix(P,Pk,Mk,secd,k,dump,b);
03162            NewDestroyredspol(secd,Pk);
03163            //for(typename typPk::iterator iter = Pk.begin();iter!=Pk.end()
03164            //    ;iter++)
03165            // cout<<invconv<Poly>(*iter)<<endl;
03166            compress(Pk,dump,b,k);
03167            Dump(Pk,dump);
03168 #ifdef dimpos
03169        go_on=stop_degree(b);
03170        cout<<"go on ici vaut "<<go_on<<endl;
03171 #endif
03172            
03173            continue;
03174          }
03175       }
03176   }
03177   
03178   Mat.destroystore();
03179   //while nouveau mon etc...
03180   // Pk=recomposePk(dump);
03181   //return Pk;
03182   //  return;
03183 #ifdef DEBUG
03184   for(typename Base::const_iterator p=b.begin();p!=b.end();p++)
03185     {
03186       for(int i=0;i<p->taille1;i++)
03187         {
03188           cout<<"p.accept[i] "<<p->accept[i]<<endl;
03189         }
03190       for(int i=0;i<p->taille2;i++)
03191         {
03192           cout<<"p.refuse[i] "<<p->refuse[i]<<endl;
03193         }
03194     }
03195 #endif
03196   cout<<"sortie d'algo flash"<<endl;
03197   return ;//dump;
03198   //comme ca on conserve le tri par degre des formes normales et 
03199   //donc la construction des operateurs de multiplication se 
03200   //fait plus vite.. :-)
03201 
03202 }

int compute_ppcm ( typppcm &  ppcm,
const Base &  b 
) [inline]

Definition at line 53 of file corealgo.cc.

References isdivisible(), lcm(), and Base< predicat >::rbegin().

Referenced by Spolordsup().

00054 {
00055   typedef typename Base::mon mon;
00056   //typppcm tmpppcm;
00057   int maxdeg=-1;
00058   list<mon> list1,list2;
00059   for(typename Base::const_reverse_iterator iter=b.rbegin()
00060         ;iter==b.rbegin();iter++)
00061     {
00062       for(int i=0;i<iter->taille2;i++)
00063         for(int j=i+1;j<iter->taille2;j++)
00064           {
00065             mon tmpmon=lcm(iter->refuse[i],iter->refuse[j]);
00066 #ifndef oldppcm
00067             if((!ppcm.count(tmpmon))&& 
00068                (tmpmon.GetDegree()!=
00069                 (iter->refuse[i].GetDegree()+iter->refuse[j].GetDegree())))
00070               ppcm[tmpmon]=1;
00071             //cout<<"ppcm rajoute "<<tmpmon<<" "<<iter->refuse[i]<<" "<<iter->refuse[j]<<endl;
00072 #else
00073             if((tmpmon.GetDegree()!=
00074                 (iter->refuse[i].GetDegree()+iter->refuse[j].GetDegree())))
00075               list1.push_back(tmpmon);
00076 #endif  
00077           }
00078     }
00079 #ifdef oldppcm  
00080   for(typename list<mon>::iterator iter1=list1.begin();
00081       iter1!=list1.end();iter1++)
00082     list2.push_back(*iter1);
00083   for(typename list<mon>::iterator iter1=list1.begin();
00084       iter1!=list1.end();iter1++)
00085     {
00086       for(typename list<mon>::iterator iter2=list2.begin();
00087           iter2!=list2.end();iter2++)
00088         if(isdivisible(*iter1,*iter2,b))
00089           list2.erase(iter2--);
00090     }
00091   maxdeg=0;
00092 #ifdef DEB
00093   cout<<"liste2.size "<<list2.size()<<endl;
00094 #endif
00095   for(typename list<mon>::iterator iter2=list2.begin();
00096           iter2!=list2.end();iter2++)
00097     {
00098       cout<<"je passe ici "<<*iter2<<endl;
00099       ppcm[*iter2]=1;
00100       if(iter2->GetDegree()>maxdeg)
00101         maxdeg=iter2->GetDegree();
00102     }
00103 #endif
00104   return maxdeg;
00105 }

void conv_merge ( typPk &  Pk,
typP &  P,
typexceed &  ex,
typsize &  sizeex,
const Base &  b 
) [inline]

Definition at line 1297 of file corealgo.cc.

References Base< predicat >::begin(), Base< predicat >::end(), pol< mon, T >::ind, Iszero(), mon2int(), pol< mon, T >::nf, and pol< mon, T >::size.

Referenced by newPkMkMatrixof().

01298 {
01299   typedef typename typP::value_type polalp;
01300   typedef typename polalp::order_t ord;
01301   typedef typename polalp::monom_t mon;
01302   typedef typename typPk::value_type pol;
01303   typedef typename pol::coeff_t coeff;
01304   coeff * tabcoeff=NULL;
01305   int * tabindices=NULL;
01306   int tabsize=0;
01307 #ifdef DEBUG
01308   cout<<"entree dans conv_merge"<<endl;
01309   for(typename Base::const_iterator p=b.begin();p!=b.end();p++)
01310     {
01311       for(int i=0;i<p->taille1;i++)
01312         {
01313           cout<<"p.accept[i] "<<p->accept[i]<<endl;
01314         }
01315       for(int i=0;i<p->taille2;i++)
01316         {
01317           cout<<"p.refuse[i] "<<p->refuse[i]<<endl;
01318         }
01319     }
01320   cout<<"p-taille2 "<<b.begin()->taille2<<" "<<b.begin()->taille2-1<<endl;
01321   cout<<"I=ideal("<<endl;
01322   {
01323     typename Base::const_iterator p=b.begin();
01324     for(int i=0;i<p->taille2-1;i++)
01325         {
01326           cout<<p->refuse[i]<<","<<endl;
01327         }
01328     if(p->taille2>=1) cout<<p->refuse[p->taille2-1]<<")"<<endl;
01329   }
01330 #endif //DEBUG
01331   for(typename typP::iterator iter=P.begin();iter!=P.end();iter++)
01332     {
01333       //cout<<"dans for"<<endl;
01334       pol tmp;
01335       int max=0;
01336       tmp.ind=mon(1);
01337       
01338       tabcoeff=(coeff*)MAC_REV_REALLOC<coeff>((void*)tabcoeff,
01339                                               tabsize*sizeof(coeff),
01340                                               iter->size()*sizeof(coeff));
01341       tabindices=(int*)realloc((void*)tabindices,iter->size()*sizeof(int));
01342       tabsize=iter->size();
01343       //ici il faudrait un type template
01344       for(int i=0;i<tabsize;i++)
01345         {
01346           tabcoeff[i]=0;
01347         }
01348       //memset((void*)tabcoeff,0,tabsize*sizeof(coeff));
01349       //ici aussi
01350       mon * tmpex=NULL;
01351       tmpex=(mon*)MAC_REV_REALLOC<mon>((void*)tmpex,0,tabsize*sizeof(mon));
01352       {
01353         int comp=0;int i=0;
01354         for(typename polalp::iterator iterpol=iter->begin();
01355             iterpol!=iter->end();iterpol++)
01356           {
01357             //      cout<<"IsinB("<<*iterpol<<","<<"b)"<<endl;
01358             if (IsinB(*iterpol,b))
01359               {
01360                 tabcoeff[i]=iterpol->GetCoeff();
01361                 tabindices[i]=mon2int(*iterpol);
01362                 if(tabindices[i]>max) max=tabindices[i];
01363                 i++;
01364               }
01365             else
01366               { 
01367                 //cout<<"y en a un qu'est pas dans B "<<*iterpol<<endl;
01368                 if(!Iszero(iterpol->GetCoeff()))
01369                    tmpex[comp++]=*iterpol;
01370               }
01371           }
01372         tmpex=(mon*)MAC_REV_REALLOC<mon>((void*)tmpex,tabsize*sizeof(mon)
01373                                          ,(comp+1)*sizeof(mon));
01374         tmp.size=max+1;
01375         tmp.nf=(coeff*)MAC_REV_MALLOC<coeff>(tmp.size*sizeof(coeff));
01376         for(int j=0;j<tmp.size;j++)
01377           tmp.nf[j]=0;
01378         for(int j=0;j<i;j++)
01379           tmp.nf[tabindices[j]]=tabcoeff[j];
01380         tmp.ind=mon(comp+1);
01381         Pk.push_back(tmp);
01382         ex.push_back(tmpex);
01383         sizeex.push_back(comp);
01384       }
01385     }
01386   MAC_REV_FREE<coeff>(tabcoeff,tabsize*sizeof(coeff));
01387   free(tabindices);
01388 }

typP Crochet ( const typP &  P,
int  k 
) [inline]

Definition at line 196 of file corealgo.cc.

References Degree().

00197 {
00198   typP res;
00199   for(typename typP::const_iterator iter=P.begin();iter!=P.end();iter++)
00200     if(Degree(*iter)==k) res.push_back(*iter);
00201   return res;
00202 }

cont<pol<mon,T> > Crochet ( const cont< pol< mon, T > > &  P,
int  k 
) [inline]

Definition at line 6 of file corealgo.cc.

References Degree().

Referenced by Crochetchoix(), init_algo(), NewCrochetchoix(), and newPkMkMatrixof().

00007 {
00008   cont<pol<mon,T> > res;
00009   for(typename cont<pol<mon,T> >::const_iterator iter=P.begin()
00010         ;iter!=P.end();iter++)
00011     {
00012       if(Degree(*iter)==k) res.push_back(*iter);
00013     }
00014   return res;
00015 }

void Crochetchoix ( const typP &  P,
typPk &  Pk,
typMk &  Mk,
typPk &  redspol,
int  k,
typdump &  dump,
Base &  b 
) [inline]

Definition at line 2455 of file corealgo.cc.

References Base< predicat >::begin(), Crochet(), Base< predicat >::end(), mon2int(), my_merge(), my_plus(), and remiseenforme().

02457 {
02458   typedef typename typP::value_type polyalp;
02459   typedef typename polyalp::monom_t mon;
02460   typedef typename polyalp::coeff_t coeff;
02461   typPk res=Crochet(redspol,k),tmpres;
02462   //typename typPk::iterator iter=res.begin();
02463   //  cout<<"entree dans Crochetchoix et k vaut "<<k<<endl;
02464   //cout<<"res.size "<<res.size()<<endl;
02465   for(typename typPk::iterator iter=res.begin();iter!=res.end();iter++)
02466     {
02467       for(typename typPk::iterator iterredspol=redspol.begin();
02468           iterredspol!=redspol.end();iterredspol++)
02469         if(iter->nf==iterredspol->nf)
02470           {
02471             redspol.erase(iterredspol);
02472             break;
02473           }
02474     }
02475   for(typename typPk::iterator iter=res.begin();iter!=res.end();iter++)
02476     {
02477       //  cout<<"un nouveau tour de boucle "<<endl;
02478       if (!Ispolzero(*iter))
02479         {
02480           iter->ind=choice(invconv<polyalp>(*iter),b);
02481           //cout<<"g choisi dans Crochetchoix "<<iter->ind<<endl;
02482           //cout<<"a t'il un mon2int ?"<<IsinB(iter->ind,b)<<endl;
02483           //mon tmp10,tmp11;
02484           //      int2mon(10,tmp10);int2mon(11,tmp11);
02485           //cout<<"qu'en est il de int2mon(10) et 11 "<<tmp10<<" "<<tmp11<<endl;
02486            //     
02487           //
02488           //
02489           //UGLY HACK
02490           remiseenforme(*iter);
02491           //SALE HACK
02492           //
02493           //
02494           //
02495           //
02496           //
02497           *iter/=iter->ind.GetCoeff();//pour la "nf"
02498           iter->ind*=(coeff)1/iter->ind.GetCoeff();//pour l'ind
02499           iter->nf[mon2int(iter->ind)]=0;
02500           //      
02501           //
02502           //
02503           //UGLY HACK
02504           remiseenforme(*iter);
02505           //SALE HACK
02506           //
02507           //
02508           //
02509           //
02510           //
02511 
02512           tmpres.push_back(*iter);
02513           //on met a 0 le coeff du mon passe en ind
02514           //maintenant on a une regle en forme comme il faut reste a:
02515           //-reduire les regles deja existantes par rapport acelle ci
02516           //-reduire les autres redspol par rapport a celle ci
02517           for(typename typPk::iterator iterPk=Pk.begin();iterPk!=Pk.end();iterPk++)
02518             if((mon2int(iter->ind)<iterPk->size)&&
02519                (iterPk->nf[mon2int(iter->ind)]!=(coeff)0))//test a zero!!!
02520               {
02521                 //      cout<<"g trouve un gus qui a un coeff du mon choisi "
02522                 //    <<iterPk->nf[mon2int(iter->ind)]<<endl;
02523                 my_plus(*iterPk,*iter,iterPk->nf[mon2int(iter->ind)]);
02524                 iterPk->nf[mon2int(iter->ind)]=0;
02525                 //cout<<"apres plus le coeff vaut "
02526                 //    <<iterPk->nf[mon2int(iter->ind)]<<endl; 
02527               }
02528                 //attention plus(a,b)==a-coeff_de_ind_b_dans_a*b;
02529           for(typename typPk::iterator iterredspol=iter;iterredspol!=res.end()
02530                 ;iterredspol++)
02531             {
02532               // cout<<"redspol.size() "<<redspol.size()<<endl;
02533               //cout<<"iterredspol-ind "<<iterredspol->ind<<" "<<iterredspol->nf<<endl;
02534               if(mon2int(iter->ind)<iterredspol->size && 
02535                  iterredspol->nf[mon2int(iter->ind)]!=(coeff)0)//test a 0 ici
02536                 {
02537                   my_plus(*iterredspol,*iter,iterredspol->nf[mon2int(iter->ind)]);
02538                   iterredspol->nf[mon2int(iter->ind)]=0;
02539                 }
02540                   //cout<<"coucou je suis ici"<<endl;
02541             }
02542               //voila c fait 
02543           //maintenant on met a jour la Base b.
02544           for(typename Base::iterator iterb=b.begin();iterb!=b.end();iterb++)
02545             {
02546               iterb->refuse=(mon*)MAC_REV_REALLOC<mon>
02547                 (iterb->refuse,(iterb->taille2)*sizeof(mon),
02548                  (iterb->taille2+1)*sizeof(mon));
02549               iterb->refuse[iterb->taille2]=iter->ind;
02550               iterb->refuse[iterb->taille2].SetCoeff(1);
02551               iterb->taille2++;
02552             }
02553           res.erase(iter--);
02554           break;//comme ca on fait pas 50 tours.
02555         }
02556     }
02557   for (typename typPk::iterator iterpk=Pk.begin();iterpk!=Pk.end();iterpk++)
02558     {
02559       //      cout<<"iterpk->ind "<<iterpk->ind<<"et Isinb(iterpk-ind,b) "<<IsinB(iterpk->ind,b)<<endl;
02560       if (IsinB(iterpk->ind,b))
02561         {
02562           for(typename Base::iterator iterb=b.begin();iterb!=b.end();iterb++)
02563             {
02564               iterb->refuse=(mon*)MAC_REV_REALLOC<mon>
02565                 (iterb->refuse,(iterb->taille2)*sizeof(mon),
02566                  (iterb->taille2+1)*sizeof(mon));
02567               iterb->refuse[iterb->taille2]=iterpk->ind;
02568               iterb->refuse[iterb->taille2].SetCoeff(1);
02569               iterb->taille2++;
02570             }
02571         }
02572     }
02573   my_merge(Pk,tmpres);//les gens dans res\tmpres ne sont pas detruits!!!
02574   my_merge(redspol,res);
02575   return;
02576 }

void Crochetchoix ( const typP &  P,
typPk &  Pk,
typPk &  redspol,
int  k,
Base &  b 
) [inline]
void Destroyredspol ( typPk &  redspol,
const typPk &  Pk 
) [inline]

Definition at line 2579 of file corealgo.cc.

02580 {
02581   typename typPk::const_iterator iterpk=--Pk.end(); 
02582   for(typename typPk::iterator iter=redspol.begin();
02583       iter!=redspol.end();iter++)
02584     {
02585       if(iter->nf!=iterpk->nf)
02586         MAC_REV_FREE<typename typPk::value_type::coeff_t>(iter->nf
02587                                                   ,iter->size
02588                                  *sizeof(typename typPk::value_type::coeff_t));
02589     }
02590 }

void DoBaseMk ( const typP &  tmpPk,
typMk &  Mk,
Base &  b 
) [inline]

Definition at line 215 of file corealgo.cc.

References predicat< monom >::accept, Base< predicat >::begin(), Base< predicat >::def, Base< predicat >::end(), Base< predicat >::erase(), predicat< monom >::refuse, predicat< monom >::taille1, and predicat< monom >::taille2.

00216 {
00217   typedef typename typMk::value_type mon;
00218   typename Base::predicat_t tmp;
00219   int i=0;
00220   //int tmpvar=0;
00221    
00222   for(typename typP::const_iterator iter=tmpPk.begin();iter!=tmpPk.end();iter++)
00223     {
00224       mon tmp(choice(*iter,b));
00225       int yes=1;
00226       //  cout<<"pol dans DoBaseMk "<<endl<<*iter<<endl<<"g choisi "<<tmp<<endl;
00227       tmp.SetCoeff(1);//*=mon(1/tmp.GetCoeff());
00228       for(typename typMk::iterator iter=Mk.begin();iter!=Mk.end();iter++)
00229         if(*iter==tmp) {yes=0;break;};
00230       if(yes) Mk.push_back(tmp);
00231     }
00232   //cout<<"Mk.size()"<<Mk.size()<<endl;
00233   tmp.taille2=Mk.size();
00234   tmp.refuse=(mon*)MAC_REV_MALLOC<mon>(tmp.taille2*sizeof(mon));
00235   tmp.taille1=1;
00236   tmp.accept=(mon*)MAC_REV_MALLOC<mon>(sizeof(mon));
00237   tmp.accept[0]=mon(1);
00238   i=0;//pour en etre bien sur
00239   for(typename typMk::iterator iter=Mk.begin();iter!=Mk.end();iter++,i++)
00240     {
00241       tmp.refuse[i]=*iter;
00242     };
00243   if(!b.def.empty())
00244     {
00245       typename Base::predicat_t verytmp;
00246       for(typename Base::iterator iter=b.begin();iter!=b.end();iter++)
00247         {
00248           verytmp=*iter;
00249           MAC_REV_FREE<mon>(verytmp.refuse,verytmp.taille2*sizeof(mon));
00250           MAC_REV_FREE<mon>(verytmp.accept,verytmp.taille1*sizeof(mon));
00251         }
00252       b.erase(b.begin(),b.end());
00253     }
00254   b.def.push_back(tmp);
00255   return;
00256 }

void findcorresppol ( const mon &  m,
const typdump &  dump,
pol &  res 
) [inline]

Definition at line 2031 of file corealgo.cc.

References pol< mon, T >::ind, pol< mon, T >::nf, and pol< mon, T >::size.

Referenced by halfred(), OLD_ReduceSpol(), and rewrite().

02032 {
02033   typedef typename pol::monom_t mondump;
02034   int i,d=m.GetDegree();
02035   typename typdump::const_iterator iter=dump.begin();
02036   for(;(iter!=dump.end())&&(iter->k!=d);iter++);
02037   //localise la dump struct de bon degre
02038   if(iter!=dump.end())
02039     {
02040       for(i=0;(i<iter->size)&&(iter->nf[i].ind.rep!=m.rep);i++);
02041       //cout<<"monomes passe en revue pour chercher "<<m<<" : "<<iter->nf[i].ind<<endl;;
02042       //trouve dans la dump struct le pol qui marche
02043       if (i<iter->size)//estce que je connais?
02044         //oui super
02045         {
02046           //cout<<"g trouve un gus qui convient"<<endl;
02047           //for(int j=0;j<iter->nf[i].size;j++)
02048           // cout<<"et ses coeff sont "<<iter->nf[i].nf[j]<<endl;
02049           //Tue Dec  4 16:12:10 MET 2001
02050           //densify(iter->nf[i],res);}
02051           //Tue Dec  4 16:12:10 MET 2001
02052           res=iter->nf[i];}
02053       else {
02054         //non ben alors il se reecrit en lui meme
02055         res.ind=mondump(0);//m*(1/m.GetCoeff());
02056         res.size=-1;
02057         res.nf=NULL;
02058       }
02059     }
02060   return;
02061 }

int GoodDir ( const typmon &  m,
int  i,
const Base &  b 
) [inline]

Definition at line 1278 of file corealgo.cc.

References my_divmon(), and Base< predicat >::nbvar().

Referenced by newPkMkMatrixof().

01279 {
01280   int res=0;
01281   mon tmpm=m*mon(i,1);
01282   //cout<<"dans GoodDir les monomes "<<m<<"********"<<typmon(i,1)<<endl;
01283   //cout<<"b.nbvar() "<<b.nbvar()<<endl;
01284   for(int j=0;j<b.nbvar();j++)
01285     {
01286       if(tmpm.GetDegree(j)>=1)
01287         if(IsinB(my_divmon(tmpm,j,b),b)) {res=1;break;};
01288     }
01289   //cout<<" le verdict de GoodDir "<<res<<endl;
01290   return res;
01291 }

int goodspol ( const mon &  m1,
const mon &  m2,
typppcm &  ppcm,
const Base &  b 
) [inline]

Definition at line 108 of file corealgo.cc.

References member().

Referenced by Spolordsup().

00114 {
00115   //list<mon> ppcm;
00116   int res=0,comp=0;//,nobplus=1;
00117   mon m=m1;
00118   for(int i=0;i<b.nbvar();i++)
00119     if(m1.GetDegree(i)!=m2.GetDegree(i))
00120       {
00121         comp++;
00122         if (m1.GetDegree(i)-m2.GetDegree(i)==1)
00123           res+=1;
00124         if (m1.GetDegree(i)-m2.GetDegree(i)==-1)
00125           {
00126             res+=1;
00127             m*=mon(i,1);
00128           }
00129       };
00130   //compute_ppcm(ppcm,b);
00131   //if((res==2)&&(comp==2)) 
00132   //  for(int i=0;i<b.nbvar();i++)
00133   //    if(m.GetDegree(i)>0)
00134   //    nobplus=nobplus && !IsinB(my_divmon(m,i,b),b);
00135    //cout<<"m1 "<<m1<<" m2 "<<m2<<" resultat "<<((res==2)&&(comp==2))<<endl;
00136    //return ((res==2)&&(comp==2)&&nobplus);
00137   //cout<<m1<<" < "<<m2<<" res "<<(member(ppcm,m)&&(res==2)&&(comp==2))<<endl;
00138   #ifdef NO_TWICE
00139   return (res==2)&&(comp==2)&&ppcm[m]&&!member(Spoldejavu,m);
00140   #else
00141   return (res==2)&&(comp==2)&&ppcm[m];
00142   #endif
00143 //return (res==2)&&(comp==2)&&ppcm.count(m);//&&!member(Spoldejavu,m);
00144 }

pol halfred ( const mon &  targetind,
const pol &  p,
const typdump &  dump,
const Base &  b 
) [inline]

Definition at line 2076 of file corealgo.cc.

References findcorresppol(), pol< mon, T >::ind, int2mon(), mon2int(), my_plus(), myplus22(), Base< predicat >::nbvar(), pol< mon, T >::nf, and pol< mon, T >::size.

Referenced by ReduceSpol().

02078 {
02079   typedef typename pol::coeff_t coeff;
02080   static const mon monzero=mon(0);
02081   static const typename pol::coeff_t zero(0);
02082   pol res;
02083   int *place=(int*)MAC_REV_MALLOC<int>(p.size*sizeof(int));
02084 #ifdef uninf
02085   int varref;
02086   int flagplus=0;
02087   pol stockpol;
02088   coeff stockcoeff;
02089 #else
02090   mon varref;
02091   
02092 #endif  
02093   int maxref=0,i;
02094   for(i=0;i<b.nbvar();i++)
02095     {
02096       if(targetind.GetDegree(i)>p.ind.GetDegree(i))
02097         break;
02098     }
02099 #ifdef uninf
02100   varref=i;
02101 #else
02102   varref=mon(i,1); 
02103 #endif
02104 #ifdef DEB  
02105   cout<<"p en entree"<<invconv<Poly>(p)<<endl;
02106   cout<<"target "<<targetind<<" et ind "<<p.ind<<" et var "<<varref<<endl;
02107 #endif
02108 #ifdef nosize
02109   maxref=size;
02110 #else
02111   for(int i=0;i<p.size;i++)
02112     {
02113       if(p.nf[i]!=zero)
02114         {
02115 #ifdef uninf    
02116           place[i]=mulind(i,varref,b);
02117           if (place[i]>maxref)
02118             maxref=place[i];
02119 #else
02120           int indtmpmon;
02121           mon tmpmon;
02122           int2mon(i,tmpmon);
02123           tmpmon*=varref;
02124           if(IsinB(tmpmon,b))
02125             {
02126               indtmpmon=mon2int(tmpmon);
02127               if(maxref<indtmpmon) 
02128                 maxref=indtmpmon;
02129               place[i]=indtmpmon;
02130             }
02131           else
02132             {
02133               place[i]=-1;
02134             }
02135 #endif //nored
02136         }
02137     }
02138 #endif //nosize
02139   res.nf=(typename pol::coeff_t*)
02140     MAC_REV_MALLOC<typename pol::coeff_t>
02141     ((maxref+1)*sizeof(typename pol::coeff_t));
02142   for(int i=0;i<=maxref;i++)
02143     res.nf[i]=0;
02144   res.size=maxref+1;
02145   i=0;
02146   for(;i<p.size;i++)
02147     {
02148       if(p.nf[i]!=zero)
02149         {
02150 #ifdef uninf
02151           if(place[i]==-1)
02152             {
02153               pol stock=nf<pol,typdump,Base>(varref,i,dump,b);
02154 #ifdef plus2          
02155               if (!flagplus)
02156                 {
02157                   flagplus=1;
02158                   stockpol=stock;
02159                   stockcoeff=p.nf[i];
02160                 }
02161               else
02162                 {
02163                   myplus22(res,stockpol,stockcoeff,stock,p.nf[i]);
02164                   flagplus=0;
02165                   stockcoeff=0;
02166                 }
02167 #else
02168               //cout<<" je reduit prr lui"<<endl<<invconv<Poly>(stock)<<endl;
02169               my_plus(res,stock,p.nf[i]);
02170 #endif
02171             }
02172           else
02173             {
02174               res.nf[place[i]]+=p.nf[i];
02175             }
02176 #else
02177           mon tmpmon;
02178           int2mon(i,tmpmon);
02179           tmpmon*=varref;
02180           
02181           if(place[i]==-1)
02182             {
02183               pol stock;
02184               //cout<<"halfred "<<varref*tmpmon<<endl;
02185               findcorresppol(tmpmon,dump,stock);
02186               //cout<<"en retour "<<invconv<Poly>(stock)<<endl;
02187               //res*stock.ind.GetCoeff();
02188               //cout<<"le coeff ici "<<stock.ind.GetCoeff()<<endl;
02189               my_plus(res,stock,p.nf[i]);
02190               //Tue Dec  4 17:29:06 MET 2001
02191               //MAC_REV_FREE<coeff>(stock.nf,stock.size*sizeof(coeff));
02192               //Tue Dec  4 17:29:06 MET 2001
02193             }
02194           else
02195             {
02196               res.nf[mon2int(tmpmon)]+=p.nf[i];
02197             }
02198 #endif
02199         }
02200     }
02201 #ifdef uninf
02202 #ifdef plus2
02203   if(flagplus)
02204     my_plus(res,stockpol,stockcoeff);
02205 #endif
02206 #endif
02207 
02208   res.ind=monzero;
02209   MAC_REV_FREE<int>(place,p.size*sizeof(int));
02210 #ifdef DEB
02211   cout<<" apres reduction "<<invconv<Poly>(res)<<endl;
02212 #endif
02213   return res;
02214 }

int indice2 ( const mon &  tmp,
const Base &  b 
) [inline]

Definition at line 985 of file corealgo.cc.

References mon2int().

00986 {
00987  int res=-1;
00988  if(IsinB(tmp,b))
00989    {
00990      res=mon2int(tmp);
00991      //  cout<<"le monome "<<mon(i,1)*tmp<<" l'indice "<<res<<endl;
00992    }
00993  return res;
00994 }

int indice2 ( int  i,
int  j,
const Base &  b 
) [inline]

Definition at line 969 of file corealgo.cc.

References int2mon(), and mon2int().

00970 {
00971  int res=-1;
00972  mon tmp;
00973  int2mon(j,tmp);
00974  tmp*=mon(i,1);//on suppose qd meme que j correspond a qqchose
00975  //cout<<"indice2 IsinB("<<mon(i,1)*tmp<<",b) "<<IsinB(mon(i,1)*tmp,b)<<endl;
00976  if(IsinB(tmp,b))
00977    {
00978      res=mon2int(tmp);
00979      //  cout<<"le monome "<<mon(i,1)*tmp<<" l'indice "<<res<<endl;
00980    }
00981  return res;
00982 }

void init_algo ( typP &  P,
int &  nouveaumon,
int &  maxdeg,
int &  k,
typPk &  Pk,
typMk &  Mk,
Base &  b,
typdump &  dump 
) [inline]

cout<<"doBaseMk"<<endl;

Definition at line 293 of file corealgo.cc.

References Crochet(), Dump(), MatrixOf(), minmaxdegP(), my_ord(), Base< predicat >::nbvars, Setnbvars(), setorder(), and stab().

00295 {
00296   typedef typename typPk::value_type pol;
00297   typedef typename pol::coeff_t coeff;
00298   typedef typename pol::monom_t mon;
00299   const typename typP::value_type::order_t (tmpord)(const mon,const mon);
00300   typP tmpPk=P;
00301   pol debugpol;
00302   typMat *Mat;
00303   int *pr,*pc,flag=1;
00304   setorder(my_ord);
00305   nouveaumon=1;
00306   Setnbvars(P,b);
00307 #ifdef unimul
00308   init_multiple(b.nbvars);
00309 #endif
00310 #ifdef uninf
00311   init_nf<pol>(b.nbvars);
00312 #endif 
00313   while(flag)
00314     {
00315       Mk.erase(Mk.begin(),Mk.end());
00316       //cout<<"mindeg"<<endl;
00317       k=minmaxdegP(tmpPk,maxdeg);
00318       //cout<<"Crochet"<<endl;
00319       //tmpPk.push_back(Crochet(P,k).front());
00320       tmpPk=Crochet(tmpPk,k);
00321 #ifdef DEB
00322       for(typename typP::iterator iter=tmpPk.begin();iter!=tmpPk.end();iter++)
00323       cout<<"pol pendant init"<<endl<<*iter<<endl;
00324 #endif 
00326       DoBaseMk(tmpPk,Mk,b);
00327       // for(typename typMk::iterator iter=Mk.begin();iter!=Mk.end();iter++)
00328       //        cout<<*iter<<endl;
00329       //cout<<"Matrixof"<<endl;
00330       Mat=MatrixOf(tmpPk,Mk,typMat());
00331       //affdebug(*Mat);
00332       //cout<<"solve"<<endl;
00333       tmpPk=Solve(*Mat,tmpPk,&pr,&pc);
00334       selectnozero(tmpPk);
00335       //affdebug(*Mat);
00336       stab(tmpPk);
00337       //for(typename typP::iterator iter=tmpPk.begin();iter!=tmpPk.end();iter++)
00338       //        cout<<"pol pendant init"<<endl<<*iter<<endl;
00339       //  cout<<"deletemat"<<endl;
00340       if(my_rank(*Mat)==(int)tmpPk.size()) flag=0;
00341       Mat->destroystore();
00342       delete(Mat);
00343       free(pr);
00344       free(pc);
00345     }
00346   //cout<<"Pk,apres solve"<<endl<<tmpPk.front()<<endl;
00347   //   cout<<"convertion"<<endl;
00348   // for(typename typP::value_type::iterator iter=tmpPk.front().begin();
00349   //   iter!=tmpPk.front().end();iter++)
00350   // cout<<"*iter "<<*iter<<" IsinB "<<IsinB(*iter,b)<<endl;
00351   //for(typename typP::iterator iter=tmpPk.begin();iter!=tmpPk.end();iter++)
00352   //cout<<"pol apres les solve "<<endl<<*iter<<endl;
00353       for(typename typP::iterator iter=tmpPk.begin();iter!=tmpPk.end();iter++)
00354         {
00355           Pk.push_back(convert<pol>(*iter,b));
00356           //cout<<"le pol apres invconv"<<endl
00357           //  <<invconv<typename typP::value_type>(*Pk.rbegin())<<endl;
00358           //  cout<<"le pol original "<<endl<<*iter<<endl;
00359         }
00360       //      for(typename typPk::iterator iter=Pk.begin();iter!=Pk.end();iter++)
00361       //        cout<<"pol apres les solve "<<endl<<iter->ind<<endl;
00362       debugpol=Pk.front();
00363       //for(typename typPk::iterator iter=Pk.begin();iter!=Pk.end();iter++)
00364         //      cout<<"apres convertion "<<endl<<
00365         //  invconv<typename typP::value_type>(*iter)<<endl;
00366       //cout<<"size "<<debugpol.size<<endl;
00367       //cout<<"Dump "<<Pk.front().ind.GetCoeff()<<endl;
00368       Dump(Pk,dump);
00369       //cout<<"apres Dump "<<invconv<typename typP::value_type>(Pk.front())<<endl;
00370       //cout<<"je sort d'init_algo "<<endl;
00371       //cout<<"k vaut "<<k<<endl;
00372       //      cout<<" Pk.size() "<<Pk.size()<<endl;
00373   return ;
00374 }

mon lcm ( const mon &  m1,
const mon &  m2 
) [inline]

Definition at line 43 of file corealgo.cc.

Referenced by choice_fall(), compute_ppcm(), countmon(), Listedejafait(), and stop_degree().

00044 {
00045   mon m(1);
00046   int maxi=max(lvar(m1.rep),lvar(m2.rep));
00047   for(int i=0;i<=maxi;i++)
00048     m*=mon(i,max(m1.GetDegree(i),m2.GetDegree(i)));
00049   return m;
00050 }

void Listedejafait ( const typMk &  Mk,
typMk &  Spoldejavu 
) [inline]

Definition at line 2836 of file corealgo.cc.

References lcm().

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

02837 {
02838   Spoldejavu.erase(Spoldejavu.begin(),Spoldejavu.end());
02839   for(typename typMk::const_iterator iter1=Mk.begin();iter1!=Mk.end();
02840       iter1++)
02841     for(typename typMk::const_iterator iter2=iter1;iter2!=Mk.end();
02842       iter2++)
02843       {
02844         typename typMk::value_type tmp=lcm(*iter1,*iter2);
02845         if (tmp.GetDegree()==iter1->GetDegree()+1)
02846           Spoldejavu.push_back(tmp);
02847       }
02848 }

typmat* MatrixOf ( const typPk &  L,
const typMk &  lm,
const typmat &  mat 
) [inline]

Definition at line 260 of file corealgo.cc.

Referenced by init_algo().

00262 {
00263   typedef typename typPk::value_type POL;
00264   typedef typename typMk::value_type monom_t;  
00265   typmat *res=NULL;
00266   map<monom_t,int> index;
00267   int l=1;
00268   if (res!=NULL) {delete res;};
00269   for(typename typMk::const_iterator m = lm.begin(); m!=lm.end(); m++){
00270     index[*m]=l;
00271     l++;
00272   }
00273   int c;
00274   res=new typmat(L.size(),lm.size());
00275   l=0;
00276   // cout<<"L.size() "<<L.size()<<" lm.size() "<<lm.size()<<endl;
00277   for(typename typPk::const_iterator pi = L.begin(); pi != L.end(); ++pi){
00278     for(typename POL::const_iterator m = pi->begin(); m!=pi->end(); m++)
00279       {
00280         
00281         if((index.count(*m))) 
00282           {
00283             c=index[*m];
00284             (*res)(l,c-1,m->GetCoeff());
00285           }
00286       }
00287     l++;
00288   }
00289   return res;   
00290 }

int member ( const typMk &  tmpMk,
const typename typMk::value_type  mon 
) [inline]

Definition at line 1391 of file corealgo.cc.

Referenced by countpoint(), goodspol(), has_b_index(), MonomialBase(), newPkMkMatrixof(), putingoodshape(), and stop_degree().

01392 {
01393   int res=0;
01394   for(typename typMk::const_iterator iter=tmpMk.begin();
01395       iter!=tmpMk.end();iter++)
01396     if(iter->rep==mon.rep) {res=1;break;}
01397   return res;
01398 }

int mindeg ( const typPk &  l  )  [inline]

Definition at line 2422 of file corealgo.cc.

References int2mon(), and Iszero().

Referenced by algo().

02423 {
02424   typedef typename typPk::value_type::monom_t mon;
02425   typedef typename mon::coeff_t coeff;
02426   int res=-1;
02427   //  cout<<"dans mindeg res au debut"<<res<<endl;
02428   for(typename typPk::const_iterator iter=l.begin() ;iter!=l.end();iter++)
02429    {
02430      int mmax=-1;
02431      // cout<<"tour de boucle de mindeg "<<endl;
02432      for(int i=0;i<iter->size;i++)
02433        if(!Iszero(iter->nf[i]))
02434          {
02435            mon tmpmon;
02436            int2mon(i,tmpmon);
02437            mmax=(mmax<tmpmon.GetDegree())?tmpmon.GetDegree():mmax;
02438          }
02439      // cout<<"mmax ici "<<mmax<<endl;
02440      if (iter->ind.GetCoeff()==(coeff)1)
02441        mmax=(mmax<iter->ind.GetDegree())?iter->ind.GetDegree():mmax;
02442      //cout<<"les gens que je regarde "<<iter->ind<<endl;
02443      if(mmax!=-1)
02444      {
02445        if(res==-1) res=mmax;
02446        res=(mmax>res)?res:mmax;
02447      }
02448    }
02449   //cout<<"resultat de mindeg "<<res<<endl;
02450   return res;
02451 }

int minmaxdegP ( typP  P,
int &  maxdeg 
) [inline]

Definition at line 184 of file corealgo.cc.

References Degree().

Referenced by init_algo(), and newPkMkMatrixof().

00185 {
00186   int res=Degree(P.front());
00187   maxdeg=res;
00188   for(typename typP::iterator iter=P.begin();iter!=P.end();iter++)
00189     {
00190       res=(res>Degree(*iter))?Degree(*iter):res;
00191       maxdeg=(maxdeg<Degree(*iter))?Degree(*iter):maxdeg;
00192     }
00193   return res;
00194 }

typpol mult ( int  i,
const typpol &  pol,
const typdump &  dump,
const Base &  b,
mon **  exce,
int &  exsize 
) [inline]

Definition at line 1077 of file corealgo.cc.

References int2mon(), Iszero(), my_plus(), myplus22(), and myplus44().

Referenced by main(), newPkMkMatrixof(), and proj().

01079 {
01080   typedef typename typpol::coeff_t coeff;
01081   //static const mon monzero=mon(0);
01082   typpol ret;
01083   coeff *res=NULL,*polnf;
01084 #ifndef unimul
01085   mon *stockmontab=(mon*)MAC_REV_MALLOC<mon>(pol.size*sizeof(mon));
01086 #endif 
01087   ret.nf=res;
01088   (*exce)=(mon*)MAC_REV_MALLOC<mon>((pol.size+1)*sizeof(mon));
01089   int *stockindicetab=(int*)malloc(pol.size*sizeof(int)),*tmpptr;
01090   int noquo=0;
01091   static int nbmyplus=0;
01092 #ifdef plus2
01093  int flagplus=0;
01094  coeff stockcoeffplus;
01095  typpol stockpolplus;
01096 #endif 
01097 #ifdef plus4
01098  int flagplus=0;
01099  coeff stockcoeffplus[4];
01100  typpol stockpolplus[4];
01101 #endif
01102  int maxind=0;
01103   tmpptr=stockindicetab;
01104   //cout<<"pol.size "<<pol.size<<endl;
01105   for(int j=0;j<pol.size;++j)
01106     if (!Iszero(pol.nf[j]))
01107      {
01108 #ifdef unimul
01109        int stockindice2=mulind(j,i,b);
01110        *tmpptr++=stockindice2;
01111 #else
01112        mon tmpmon;
01113        int2mon(j,tmpmon);
01114        tmpmon*=mon(i,1);
01115        stockmontab[j]=tmpmon;
01116        int stockindice2=indice2<mon>(tmpmon,b);
01117        *tmpptr++=stockindice2;
01118 #endif
01119 
01120        //cout<<"stockindice2 "<<stockindice2<<" pol.size "<<
01121        //pol.size<<" J "<<j<<endl;
01122 
01123        if (maxind<stockindice2)
01124          maxind=stockindice2;
01125      }
01126   //cout<<"maxind "<<maxind<<endl;
01127   //  maxind=size;
01128   ret.nf=(coeff*)MAC_REV_MALLOC<coeff>((maxind+1)*sizeof(coeff));
01129   for(int j=0;j<=maxind;j++)
01130     ((coeff*)(ret.nf))[j]=0;
01131   ret.size=maxind+1;
01132   //ret.nf=res;
01133   tmpptr=stockindicetab;
01134   polnf=pol.nf;
01135   for(int j=0;j<pol.size;++j,polnf++)
01136     {
01137       const coeff stockpol=*polnf;
01138       if (!Iszero(stockpol))//ici introduire les epsilon si on veut gagner un peu..
01139      {// pas necessaire pour les epsilon parce que ca marche !!
01140        int stockindice2=*tmpptr++;//indice2<mon>(i,j,b);
01141       //cout<<"stockindice2 avant le test "<<stockindice2<<endl;
01142       if (stockindice2>=0) 
01143         {
01144           ret.nf[stockindice2]+=stockpol;
01145           //  cout<<"stocvkindice2 "<<stockindice2<<" pol.size "<<
01146           //   pol.size<<" J "<<j<<endl;
01147         }
01148       else  
01149         {
01150           //
01151           //
01152           //
01153           //
01154           //typename typpol::monom_t tmpmon;
01155           //cout<<" j vaut dans mult "<<j<<endl;
01156           // cout<<"et int2mon de ce j vaut "<<tmpmon<<endl;
01157           //cout<<"je recherche la nf de "<<tmpmon<<endl;
01158           typpol tmp;
01159           //tmp.ind=monzero;
01160 #ifdef unimul      
01161           tmp=nf<typpol>(i,j,dump,b);
01162 #else
01163           tmp=nf<typpol>(stockmontab[j],dump,b);
01164 #endif    
01165           //cout<<"tmpind  vaut alors "<<tmp.ind<<endl;
01166            //
01167            //
01168            //
01169           if (tmp.size!=-1)
01170           {
01171 #ifdef plus4
01172             if(flagplus==3)
01173               {
01174                 flagplus=0;
01175                 myplus44(ret,tmp,stockpol,
01176                          stockpolplus[0],stockcoeffplus[0],
01177                          stockpolplus[1],stockcoeffplus[1],
01178                          stockpolplus[2],stockcoeffplus[2]);
01179               }
01180             else
01181               {
01182                 stockcoeffplus[flagplus]=stockpol;
01183                 stockpolplus[flagplus]=tmp;
01184                 flagplus++;
01185               }
01186 #endif
01187 
01188 #ifdef plus2
01189             if(flagplus==1)
01190               {
01191                 flagplus=0;
01192                 myplus22(ret,tmp,stockpol,stockpolplus,stockcoeffplus);
01193               }
01194             else
01195               {
01196                 stockcoeffplus=stockpol;
01197                 stockpolplus=tmp;
01198                 flagplus=1;
01199               }
01200 #else
01201             //nbmyplus++;
01202             //cout<<"tmp "<<tmp<<endl;
01203             //cout<<"tmp.ind "<<tmp->ind<<endl;
01204             //cout<<"tmp.nf "<<tmp->nf<<endl;
01205             my_plus(ret,tmp,stockpol);
01206             //Tue Dec 4
01207             //MAC_REV_FREE<mon>(tmp.nf,tmp.size*sizeof(coeff));
01208             //res=ret.nf;//car my_plus realloc la chose
01209 #endif
01210           }
01211           else  
01212             {
01213               mon tmpmon;
01214               (*exce)[noquo]=mon(i,1);
01215               int2mon(j,tmpmon);
01216               //cout<<"je rajoute ala fin listes exceed "<<tmpmon*mon(i,1)<<endl;
01217               (*exce)[noquo]*=tmpmon;//int2mon<mon>(j);
01218               (*exce)[noquo]*=stockpol;
01219               ++noquo;
01220             };
01221           
01222           //dans plus qd nf renvois NULL il faut rien faire!!!!
01223         }
01224       }
01225     }
01226   //(*exce)=(mon*)MAC_REV_REALLOC<mon>((*exce),pol.size*sizeof(mon)
01227   //                           ,(noquo)*sizeof(mon));
01228   //cout<<"fin "<<nbmyplus<<endl;
01229 #ifdef plus4
01230   for(int ii=0;ii<flagplus;ii++)
01231     my_plus(ret,stockpolplus[ii],stockcoeffplus[ii]);
01232 #endif
01233 
01234 #ifdef plus2
01235   if(flagplus)
01236     {
01237       my_plus(ret,stockpolplus,stockcoeffplus);
01238     }
01239 #endif
01240 
01241   ret.ind=pol.ind;
01242   ret.ind*=mon(i,1);
01243   //Fri Nov 16 14:42:34 MET 2001
01244   (*exce)[noquo++]=ret.ind;
01245   exsize=noquo;
01246   (*exce)=(mon*)MAC_REV_REALLOC<mon>((*exce),(pol.size+1)*sizeof(mon)
01247                                ,(noquo)*sizeof(mon));
01248    ret.ind.SetCoeff(noquo+1);
01249 #ifndef unimul
01250    MAC_REV_FREE<mon>(stockmontab,pol.size*sizeof(mon));
01251 #endif 
01252    free(stockindicetab);
01253    //   cout<<"ret.size "<<ret.size<<endl;
01254    // cout<<invconv<Poly>(ret)<<endl;
01255    //cout<<"-----------------------------------"<<endl;
01256    return ret;
01257 
01258 }

Mon my_divmon ( const Mon &  mon,
int  i,
const Base &  b 
) [inline]

Definition at line 1262 of file corealgo.cc.

References Base< predicat >::nbvar().

Referenced by GoodDir(), has_b_index(), and newPkMkMatrixof().

01263 {
01264   Mon res(1);
01265   for(int j=0;j<b.nbvar();j++)
01266     if(i==j)
01267       {
01268         res*=Mon(j,mon.GetDegree(j)-1);
01269       }
01270      else 
01271        {
01272          res*=Mon(j,mon.GetDegree(j));
01273        }
01274   return res;
01275 }

void my_merge ( T &  l1,
const T &  l2 
) [inline]

Definition at line 35 of file corealgo.cc.

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

00036 {
00037   typename T::const_iterator iter=l2.begin();
00038   for(;iter!=l2.end();iter++)
00039     l1.push_back(*iter);
00040 }

void my_plus ( pol &  res,
const pol &  nf 
) [inline]

Definition at line 601 of file corealgo.cc.

References pol< mon, T >::nf, and pol< mon, T >::size.

00602 {
00603   typedef typename pol::monom_t mon;
00604   typedef typename pol::coeff_t coeff;
00605   register unsigned int i=0;
00606   register unsigned int ttmp,tmp;//=taillequotient/16;
00607   register coeff *nfnf=nf.nf,*resnf;;
00608   //register unsigned int tmp;//=taillequotient % 16;
00609   tmp=nf.size;
00610   if(res.size<tmp)
00611    {
00612      res.nf=(coeff*)MAC_REV_REALLOC<coeff>(res.nf,res.size*sizeof(coeff)
00613                                            ,tmp*sizeof(coeff));
00614      for(int i=res.size;i<tmp;i++)
00615        res.nf[i]=0;
00616      res.size=tmp;
00617    }
00618   ttmp=(tmp/16)*16;
00619   resnf=res.nf;
00620   //tmp=nf.size & 15;//16 pourquoi... PARCE QUE!!!!! :-))
00621   for(;i<ttmp;i+=16)
00622     {
00623       {
00624         resnf[i]-=nfnf[i];
00625         resnf[i+1]-=nfnf[i+1];
00626         resnf[i+2]-=nfnf[i+2];
00627         resnf[i+3]-=nfnf[i+3];
00628         resnf[i+4]-=nfnf[i+4];
00629         resnf[i+5]-=nfnf[i+5];
00630         resnf[i+6]-=nfnf[i+6];
00631         resnf[i+7]-=nfnf[i+7];
00632         resnf[i+8]-=nfnf[i+8];
00633         resnf[i+9]-=nfnf[i+9];
00634         resnf[i+10]-=nfnf[i+10];
00635         resnf[i+11]-=nfnf[i+11];
00636         resnf[i+12]-=nfnf[i+12];
00637         resnf[i+13]-=nfnf[i+13];
00638         resnf[i+14]-=nfnf[i+14];
00639         resnf[i+15]-=nfnf[i+15];
00640       } 
00641     }
00642   for(register unsigned int j=i;j<tmp;j++)
00643     resnf[j]-=nfnf[j];
00644 }

void my_plus ( pol &  res,
const pol &  nf,
const coeff  toto 
) [inline]

Definition at line 543 of file corealgo.cc.

References pol< mon, T >::nf, and pol< mon, T >::size.

Referenced by Crochetchoix(), halfred(), mult(), NewCrochetchoix(), OLD_ReduceSpol(), and ReduceSpol().

00544 {
00545 #ifdef DEB
00546   cout<<"dans myplus je calcul"<<endl<<invconv<Poly>(res)<<endl<<
00547   "toto "<<toto<<endl<<"nf"<<endl<<invconv<Poly>(nf)<<endl;
00548 #endif
00549   typedef typename pol::monom_t mon;
00550   register unsigned int i=0;
00551   register unsigned int ttmp,tmp;//=taillequotient/16;
00552   register coeff *nfnf=nf.nf,*resnf;
00553   coeff *ptr1,*ptr2;
00554   //register unsigned int tmp;//=taillequotient % 16;
00555   tmp=nf.size;
00556   if(res.size<tmp)
00557    {
00558      res.nf=(coeff*)MAC_REV_REALLOC<coeff>(res.nf,res.size*sizeof(coeff)
00559                                            ,tmp*sizeof(coeff));
00560      for(int i=res.size;i<tmp;i++)
00561        res.nf[i]=0;
00562      res.size=tmp;
00563    }
00564   resnf=res.nf;
00565   ttmp=(tmp/16)*16;
00566   ptr1=resnf;
00567   ptr2=nfnf;
00568   //resnf=res.nf;
00569   //tmp=nf.size & 15;//16 pourquoi... PARCE QUE!!!!! :-))
00570   for(;i<ttmp;i+=16,resnf+=16,nfnf+=16)
00571     {
00572       {
00573         resnf[0]-=nfnf[0]*toto;
00574         resnf[1]-=nfnf[1]*toto;
00575         resnf[2]-=nfnf[2]*toto;
00576         resnf[3]-=nfnf[3]*toto;
00577         resnf[4]-=nfnf[4]*toto;
00578         resnf[5]-=nfnf[5]*toto;
00579         resnf[6]-=nfnf[6]*toto;
00580         resnf[7]-=nfnf[7]*toto;
00581         resnf[8]-=nfnf[8]*toto;
00582         resnf[9]-=nfnf[9]*toto;
00583         resnf[10]-=nfnf[10]*toto;
00584         resnf[11]-=nfnf[11]*toto;
00585         resnf[12]-=nfnf[12]*toto;
00586         resnf[13]-=nfnf[13]*toto;
00587         resnf[14]-=nfnf[14]*toto;
00588         resnf[15]-=nfnf[15]*toto;
00589       } 
00590     }
00591   resnf=ptr1;nfnf=ptr2;
00592   for(register unsigned int j=i;j<tmp;j++)
00593     resnf[j]-=nfnf[j]*toto;
00594 #ifdef DEB
00595      cout<<"les resultat "<<endl<<invconv<Poly>(res)<<endl;
00596 #endif
00597 }

void my_plus2 ( pol &  res1,
pol &  res2,
const pol &  nf,
const coeff &  toto1,
const coeff &  toto2 
) [inline]

Definition at line 377 of file corealgo.cc.

References pol< mon, T >::nf, and pol< mon, T >::size.

00379 {
00380   typedef typename pol::monom_t mon;
00381    unsigned int i=0,stock;;
00382    unsigned int ttmp;
00383    unsigned int tmp;
00384    register coeff *res1nf,*res2nf,*nfnf,*tmpcoeff;
00385   tmp=nf.size;
00386   if(res1.size<tmp)
00387     {
00388       res1.nf=(coeff*)MAC_REV_REALLOC<coeff>(res1.nf,res1.size*sizeof(coeff)
00389                                      ,tmp*sizeof(coeff));
00390       for(i=res1.size;i<tmp;i++)
00391         res1.nf[i]=0;
00392       res1.size=tmp;
00393     }
00394   if(res2.size<tmp)
00395     {
00396       res2.nf=(coeff*)MAC_REV_REALLOC<coeff>(res2.nf,res2.size*sizeof(coeff)
00397                                              ,tmp*sizeof(coeff));
00398       for(i=res2.size;i<tmp;i++)
00399         res2.nf[i]=0;
00400       res2.size=tmp;
00401     }
00402   tmp=nf.size;
00403   ttmp=(tmp/8)*8;
00404   tmp=tmp & 7;//15;//16 pourquoi... PARCE QUE!!!!! :-))
00405   res1nf=res1.nf;
00406   res2nf=res2.nf;
00407   nfnf=nf.nf;
00408   for(i=0;i<ttmp;i+=8)
00409     {
00410       //1
00411       tmpcoeff=nfnf+i;
00412       res1nf[i]-=*tmpcoeff*toto1;
00413       res2nf[i]-=*tmpcoeff*toto2;
00414       //2 
00415       tmpcoeff=nfnf+i+1;
00416       res1nf[i+1]-=*tmpcoeff*toto1;
00417       res2nf[i+1]-=*tmpcoeff*toto2;
00418       //3
00419       tmpcoeff=nfnf+i+2;
00420       res1nf[i+2]-=*tmpcoeff*toto1;
00421       res2nf[i+2]-=*tmpcoeff*toto2;
00422       //4
00423       tmpcoeff=nfnf+i+3;
00424       res1nf[i+3]-=*tmpcoeff*toto1;
00425       res2nf[i+3]-=*tmpcoeff*toto2;
00426       //5
00427       tmpcoeff=nfnf+i+4;
00428       res1nf[i+4]-=*tmpcoeff*toto1;
00429       res2nf[i+4]-=*tmpcoeff*toto2;
00430       //6
00431       tmpcoeff=nfnf+i+5;
00432       res1nf[i+5]-=*tmpcoeff*toto1;
00433       res2nf[i+5]-=*tmpcoeff*toto2;
00434       //7
00435       tmpcoeff=nfnf+i+6;
00436       res1nf[i+6]-=*tmpcoeff*toto1;
00437       res2nf[i+6]-=*tmpcoeff*toto2;
00438       //8
00439       tmpcoeff=nfnf+i+7;
00440       res1nf[i+7]-=*tmpcoeff*toto1;
00441       res2nf[i+7]-=*tmpcoeff*toto2;
00442 #if 0 
00443      //9
00444       tmpcoeff=nfnf+i+8;
00445       res1nf[i+8]-=*tmpcoeff*toto1;
00446       res2nf[i+8]-=*tmpcoeff*toto2;
00447       //10
00448       tmpcoeff=nfnf+i+9;
00449       res1nf[i+9]-=*tmpcoeff*toto1;
00450       res2nf[i+9]-=*tmpcoeff*toto2;
00451       
00452       //11
00453       tmpcoeff=nfnf+i+10;
00454       res1nf[i+10]-=*tmpcoeff*toto1;
00455       res2nf[i+10]-=*tmpcoeff*toto2;
00456       
00457       //12
00458       tmpcoeff=nfnf+i+11;
00459       res1nf[i+11]-=*tmpcoeff*toto1;
00460       res2nf[i+11]-=*tmpcoeff*toto2;
00461 
00462       //13
00463       tmpcoeff=nfnf+i+12;
00464       res1nf[i+12]-=*tmpcoeff*toto1;
00465       res2nf[i+12]-=*tmpcoeff*toto2;
00466       
00467       //14
00468       tmpcoeff=nfnf+i+13;
00469       res1nf[i+13]-=*tmpcoeff*toto1;
00470       res2nf[i+13]-=*tmpcoeff*toto2;
00471       
00472       //15
00473       tmpcoeff=nfnf+i+14;
00474       res1nf[i+14]-=*tmpcoeff*toto1;
00475       res2nf[i+14]-=*tmpcoeff*toto2;
00476       
00477       //16
00478       tmpcoeff=nfnf+i+15;
00479       res1nf[i+15]-=*tmpcoeff*toto1;
00480       res2nf[i+15]-=*tmpcoeff*toto2;
00481 
00482 #endif
00483     }
00484   for(register unsigned int j=i;j<nf.size;j++)
00485     {
00486       res1nf[j]-=nfnf[j]*toto1;
00487       res2nf[j]-=nfnf[j]*toto2; 
00488     }
00489 }

void my_plustmp ( pol &  res,
const pol &  nf,
const coeff  toto 
) [inline]

Definition at line 492 of file corealgo.cc.

References pol< mon, T >::nf, and pol< mon, T >::size.

00493 {
00494   typedef typename pol::monom_t mon;
00495   unsigned int i=0,stock;;
00496   unsigned int ttmp;//=taillequotient/16;
00497   unsigned int tmp;//=taillequotient % 16;
00498   // cout<<"nf.size "<<nf.size<<endl;
00499   //cout<<"nf.ind "<<nf.ind<<endl;
00500   //cout<<"nf.nf "<<nf.nf<<endl;
00501   //cout<<"res.nf "<<res.nf<<endl;
00502   //cout<<"res.size "<<res.size<<endl;
00503   register coeff *resnf,*nfnf;
00504   if (toto==0) return;
00505   if(res.size<nf.size)
00506     {
00507       //  cout<<"je realloue res.nf avant "<<res.nf<<endl;
00508       res.nf=(coeff*)MAC_REV_REALLOC<coeff>(res.nf,res.size*sizeof(coeff)
00509                                      ,nf.size*sizeof(coeff));
00510       //cout<<"res.nf apres "<<res.nf<<endl;
00511       for(i=res.size;i<nf.size;i++)
00512         res.nf[i]=0;
00513       res.size=nf.size;
00514     }
00515   ttmp=nf.size/16;
00516   tmp=nf.size & 15;//16 pourquoi... PARCE QUE!!!!! :-))
00517   resnf=res.nf;
00518   nfnf=nf.nf;
00519   for(i=0;i<ttmp;++i)
00520       {
00521             *resnf++-=*nfnf++*toto;
00522             *resnf++-=*nfnf++*toto;
00523             *resnf++-=*nfnf++*toto;
00524             *resnf++-=*nfnf++*toto;
00525             *resnf++-=*nfnf++*toto;
00526             *resnf++-=*nfnf++*toto;
00527             *resnf++-=*nfnf++*toto;
00528             *resnf++-=*nfnf++*toto;
00529             *resnf++-=*nfnf++*toto;
00530             *resnf++-=*nfnf++*toto;
00531             *resnf++-=*nfnf++*toto;
00532             *resnf++-=*nfnf++*toto;
00533             *resnf++-=*nfnf++*toto;
00534             *resnf++-=*nfnf++*toto;
00535             *resnf++-=*nfnf++*toto;
00536             *resnf++-=*nfnf++*toto;
00537       }
00538    for(register unsigned j=0;j<tmp;j++)
00539     *resnf++-=*nfnf++*toto;
00540 }

void myplus22 ( pol &  res,
const pol &  nf,
const coeff  toto,
const pol &  nf2,
const coeff  toto2 
) [inline]

Definition at line 647 of file corealgo.cc.

References pol< mon, T >::nf, and pol< mon, T >::size.

Referenced by halfred(), and mult().

00648 {
00649   typedef typename pol::monom_t mon;
00650   register unsigned int i=0;
00651   register unsigned int ttmp;//=taillequotient/16;
00652   register unsigned int tmp;//=taillequotient % 16;
00653   register coeff *resnf,*nfnf,*nf2nf;
00654   coeff tmp1,tmp2;
00655   int maxsize=max(nf.size,nf2.size);
00656   if(res.size<maxsize)
00657    {
00658      res.nf=(coeff*)MAC_REV_REALLOC<coeff>(res.nf,res.size*sizeof(coeff)
00659                                            ,maxsize*sizeof(coeff));
00660      for(int i=res.size;i<maxsize;i++)
00661        res.nf[i]=0;
00662      res.size=maxsize;
00663    }
00664   resnf=res.nf;
00665   nfnf=nf.nf;
00666   nf2nf=nf2.nf;
00667   if(nf.size<nf2.size)
00668     {
00669       ttmp=(nf.size/16)*16;
00670       tmp=nf.size & 15;//16 pourquoi... PARCE QUE!!!!! :-))
00671       for(;i<ttmp;i+=16)
00672         {
00673           {
00674             // tmp1=nfnf[i];
00675 //          tmp1*=toto;
00676 //          tmp2=nf2nf[i];
00677 //          tmp2*=toto2;
00678 //          resnf[i]-=tmp1+tmp2;
00679             resnf[i]-=nfnf[i]*toto+nf2nf[i]*toto2;
00680 //           tmp1=nfnf[i+1];
00681 //          tmp1*=toto;
00682 //          tmp2=nf2nf[i+1];
00683 //          tmp2*=toto2;
00684 //          resnf[i+1]-=tmp1+tmp2;
00685 resnf[i+1]-=nfnf[i+1]*toto+nf2nf[i+1]*toto2;
00686 //          tmp1=nfnf[i+2];
00687 //          tmp1*=toto;
00688 //          tmp2=nf2nf[i+2];
00689 //          tmp2*=toto2;
00690 //          resnf[i+2]-=tmp1+tmp2;
00691 resnf[i+2]-=nfnf[i+2]*toto+nf2nf[i+2]*toto2;
00692 //          tmp1=nfnf[i+3];
00693 //          tmp1*=toto;
00694 //          tmp2=nf2nf[i+3];
00695 //          tmp2*=toto2;
00696 //          resnf[i+3]-=tmp1+tmp2;
00697 resnf[i+3]-=nfnf[i+3]*toto+nf2nf[i+3]*toto2;
00698 //          tmp1=nfnf[i+4];
00699 //          tmp1*=toto;
00700 //          tmp2=nf2nf[i+4];
00701 //          tmp2*=toto2;
00702 //          resnf[i+4]-=tmp1+tmp2;
00703 resnf[i+4]-=nfnf[i+4]*toto+nf2nf[i+4]*toto2;
00704 //          tmp1=nfnf[i+5];
00705 //          tmp1*=toto;
00706 //          tmp2=nf2nf[i+5];
00707 //          tmp2*=toto2;
00708 //          resnf[i+5]-=tmp1+tmp2;
00709 resnf[i+5]-=nfnf[i+5]*toto+nf2nf[i+5]*toto2;
00710 //          tmp1=nfnf[i+6];
00711 //          tmp1*=toto;
00712 //          tmp2=nf2nf[i+6];
00713 //          tmp2*=toto2;
00714 //          resnf[i+6]-=tmp1+tmp2;
00715 resnf[i+6]-=nfnf[i+6]*toto+nf2nf[i+6]*toto2;
00716 //          tmp1=nfnf[i+7];
00717 //          tmp1*=toto;
00718 //          tmp2=nf2nf[i+7];
00719 //          tmp2*=toto2;
00720 //          resnf[i+7]-=tmp1+tmp2;
00721 resnf[i+7]-=nfnf[i+7]*toto+nf2nf[i+7]*toto2;
00722 //          tmp1=nfnf[i+8];
00723 //          tmp1*=toto;
00724 //          tmp2=nf2nf[i+8];
00725 //          tmp2*=toto2;
00726 //          resnf[i+8]-=tmp1+tmp2;
00727 resnf[i+8]-=nfnf[i+8]*toto+nf2nf[i+8]*toto2;
00728 //          tmp1=nfnf[i+9];
00729 //          tmp1*=toto;
00730 //          tmp2=nf2nf[i+9];
00731 //          tmp2*=toto2;
00732 //          resnf[i+9]-=tmp1+tmp2;
00733 resnf[i+9]-=nfnf[i+9]*toto+nf2nf[i+9]*toto2;
00734 //          tmp1=nfnf[i+10];
00735 //          tmp1*=toto;
00736 //          tmp2=nf2nf[i+10];
00737 //          tmp2*=toto2;
00738 //          resnf[i+10]-=tmp1+tmp2;
00739 resnf[i+10]-=nfnf[i+10]*toto+nf2nf[i+10]*toto2;
00740 //          tmp1=nfnf[i+11];
00741 //          tmp1*=toto;
00742 //          tmp2=nf2nf[i+11];
00743 //          tmp2*=toto2;
00744 //          resnf[i+11]-=tmp1+tmp2;
00745 resnf[i+11]-=nfnf[i+11]*toto+nf2nf[i+11]*toto2;
00746 //          tmp1=nfnf[i+12];
00747 //          tmp1*=toto;
00748 //          tmp2=nf2nf[i+12];
00749 //          tmp2*=toto2;
00750 //          resnf[i+12]-=tmp1+tmp2;
00751 resnf[i+12]-=nfnf[i+12]*toto+nf2nf[i+12]*toto2;
00752 //          tmp1=nfnf[i+13];
00753 //          tmp1*=toto;
00754 //          tmp2=nf2nf[i+13];
00755 //          tmp2*=toto2;
00756 //          resnf[i+13]-=tmp1+tmp2;
00757 resnf[i+13]-=nfnf[i+13]*toto+nf2nf[i+13]*toto2;
00758 //          tmp1=nfnf[i+14];
00759 //          tmp1*=toto;
00760 //          tmp2=nf2nf[i+14];
00761 //          tmp2*=toto2;
00762 //          resnf[i+14]-=tmp1+tmp2;
00763 resnf[i+14]-=nfnf[i+14]*toto+nf2nf[i+14]*toto2;
00764 //          tmp1=nfnf[i+15];
00765 //          tmp1*=toto;
00766 //          tmp2=nf2nf[i+15];
00767 //          tmp2*=toto2;
00768 //          resnf[i+15]-=tmp1+tmp2;
00769             
00770             resnf[i+15]-=nfnf[i+15]*toto+nf2nf[i+15]*toto2;
00771           } 
00772         }
00773       for(register unsigned int j=i;j<nf.size;j++)
00774         resnf[j]-=nfnf[j]*toto+nf2nf[j]*toto2;
00775       for(register unsigned int j=nf.size;j<nf2.size;j++)
00776         resnf[j]-=nf2nf[j]*toto2;
00777       
00778     }
00779   else
00780     {
00781       ttmp=(nf2.size/16)*16;
00782       tmp=nf2.size & 15;//16 pourquoi... PARCE QUE!!!!! :-))
00783       for(;i<ttmp;i+=16)
00784         {
00785           {
00786             tmp1=nfnf[i];
00787             tmp1*=toto;
00788             tmp2=nf2nf[i];
00789             tmp2*=toto2;
00790             resnf[i]-=tmp1+tmp2;
00791             //      resnf[i]-=nfnf[i]*toto+nf2nf[i]*toto2;
00792              tmp1=nfnf[i+1];
00793             tmp1*=toto;
00794             tmp2=nf2nf[i+1];
00795             tmp2*=toto2;
00796             resnf[i+1]-=tmp1+tmp2;
00797             //      resnf[i+1]-=nfnf[i+1]*toto+nf2nf[i+1]*toto2;
00798             tmp1=nfnf[i+2];
00799             tmp1*=toto;
00800             tmp2=nf2nf[i+2];
00801             tmp2*=toto2;
00802             resnf[i+2]-=tmp1+tmp2;
00803             //      resnf[i+2]-=nfnf[i+2]*toto+nf2nf[i+2]*toto2;
00804             tmp1=nfnf[i+3];
00805             tmp1*=toto;
00806             tmp2=nf2nf[i+3];
00807             tmp2*=toto2;
00808             resnf[i+3]-=tmp1+tmp2;
00809             //      resnf[i+3]-=nfnf[i+3]*toto+nf2nf[i+3]*toto2;
00810             tmp1=nfnf[i+4];
00811             tmp1*=toto;
00812             tmp2=nf2nf[i+4];
00813             tmp2*=toto2;
00814             resnf[i+4]-=tmp1+tmp2;
00815             //      resnf[i+4]-=nfnf[i+4]*toto+nf2nf[i+4]*toto2;
00816             tmp1=nfnf[i+5];
00817             tmp1*=toto;
00818             tmp2=nf2nf[i+5];
00819             tmp2*=toto2;
00820             resnf[i+5]-=tmp1+tmp2;
00821             //      resnf[i+5]-=nfnf[i+5]*toto+nf2nf[i+5]*toto2;
00822             tmp1=nfnf[i+6];
00823             tmp1*=toto;
00824             tmp2=nf2nf[i+6];
00825             tmp2*=toto2;
00826             resnf[i+6]-=tmp1+tmp2;
00827             //      resnf[i+6]-=nfnf[i+6]*toto+nf2nf[i+6]*toto2;
00828             tmp1=nfnf[i+7];
00829             tmp1*=toto;
00830             tmp2=nf2nf[i+7];
00831             tmp2*=toto2;
00832             resnf[i+7]-=tmp1+tmp2;
00833             //      resnf[i+7]-=nfnf[i+7]*toto+nf2nf[i+7]*toto2;
00834             tmp1=nfnf[i+8];
00835             tmp1*=toto;
00836             tmp2=nf2nf[i+8];
00837             tmp2*=toto2;
00838             resnf[i+8]-=tmp1+tmp2;
00839             //      resnf[i+8]-=nfnf[i+8]*toto+nf2nf[i+8]*toto2;
00840             tmp1=nfnf[i+9];
00841             tmp1*=toto;
00842             tmp2=nf2nf[i+9];
00843             tmp2*=toto2;
00844             resnf[i+9]-=tmp1+tmp2;
00845             //      resnf[i+9]-=nfnf[i+9]*toto+nf2nf[i+9]*toto2;
00846             tmp1=nfnf[i+10];
00847             tmp1*=toto;
00848             tmp2=nf2nf[i+10];
00849             tmp2*=toto2;
00850             resnf[i+10]-=tmp1+tmp2;
00851             //      resnf[i+10]-=nfnf[i+10]*toto+nf2nf[i+10]*toto2;
00852             tmp1=nfnf[i+11];
00853             tmp1*=toto;
00854             tmp2=nf2nf[i+11];
00855             tmp2*=toto2;
00856             resnf[i+11]-=tmp1+tmp2;
00857             //      resnf[i+11]-=nfnf[i+11]*toto+nf2nf[i+11]*toto2;
00858             tmp1=nfnf[i+12];
00859             tmp1*=toto;
00860             tmp2=nf2nf[i+12];
00861             tmp2*=toto2;
00862             resnf[i+12]-=tmp1+tmp2;
00863             //      resnf[i+12]-=nfnf[i+12]*toto+nf2nf[i+12]*toto2;
00864             tmp1=nfnf[i+13];
00865             tmp1*=toto;
00866             tmp2=nf2nf[i+13];
00867             tmp2*=toto2;
00868             resnf[i+13]-=tmp1+tmp2;
00869             //      resnf[i+13]-=nfnf[i+13]*toto+nf2nf[i+13]*toto2;
00870             tmp1=nfnf[i+14];
00871             tmp1*=toto;
00872             tmp2=nf2nf[i+14];
00873             tmp2*=toto2;
00874             resnf[i+14]-=tmp1+tmp2;
00875             //      resnf[i+14]-=nfnf[i+14]*toto+nf2nf[i+14]*toto2;
00876             tmp1=nfnf[i+15];
00877             tmp1*=toto;
00878             tmp2=nf2nf[i+15];
00879             tmp2*=toto2;
00880             resnf[i+15]-=tmp1+tmp2;
00881           } 
00882         }
00883       for(register unsigned int j=i;j<nf2.size;j++)
00884         resnf[j]-=nfnf[j]*toto+nf2nf[j]*toto2;
00885       for(register unsigned int j=nf2.size;j<nf.size;j++)
00886         resnf[j]-=nfnf[j]*toto;
00887       
00888     }
00889 }

void myplus44 ( pol &  res,
const pol &  nf,
const coeff  toto,
const pol &  nf2,
const coeff  toto2,
const pol &  nf3,
const coeff  toto3,
const pol &  nf4,
const coeff  toto4 
) [inline]

Definition at line 892 of file corealgo.cc.

References min(), pol< mon, T >::nf, and pol< mon, T >::size.

Referenced by mult().

00896 {
00897   typedef typename pol::monom_t mon;
00898   register unsigned int i=0;
00899   register unsigned int ttmp;//=taillequotient/16;
00900   register unsigned int tmp;//=taillequotient % 16;
00901   coeff *resnf,*nfnf,*nf2nf,*nf3nf,*nf4nf;
00902   int maxsize=max(max(nf.size,nf2.size),max(nf3.size,nf4.size));
00903   int minsize=min(min(nf.size,nf2.size),min(nf3.size,nf4.size));
00904   if(res.size<maxsize)
00905    {
00906      res.nf=(coeff*)MAC_REV_REALLOC<coeff>(res.nf,res.size*sizeof(coeff)
00907                                            ,maxsize*sizeof(coeff));
00908      for(int i=res.size;i<maxsize;i++)
00909        res.nf[i]=0;
00910      res.size=maxsize;
00911    }
00912   resnf=res.nf;
00913   nfnf=nf.nf;
00914   nf2nf=nf2.nf;
00915   nf3nf=nf3.nf;
00916   nf4nf=nf4.nf;
00917   ttmp=(minsize/16)*16;
00918   tmp=minsize & 15;//16 pourquoi... PARCE QUE!!!!! :-))
00919   for(;i<ttmp;i+=16)
00920         {
00921           {
00922             resnf[i]-=nfnf[i]*toto+nf2nf[i]*toto2
00923               +nf3nf[i]*toto3+nf4nf[i]*toto4;
00924             resnf[i+1]-=nfnf[i+1]*toto+nf2nf[i+1]*toto2
00925               +nf3nf[i+1]*toto3+nf4nf[i+1]*toto4;
00926             resnf[i+2]-=nfnf[i+2]*toto+nf2nf[i+2]*toto2
00927                 +nf3nf[i+2]*toto3+nf4nf[i+2]*toto4;
00928             resnf[i+3]-=nfnf[i+3]*toto+nf2nf[i+3]*toto2
00929                 +nf3nf[i+3]*toto3+nf4nf[i+3]*toto4;
00930             resnf[i+4]-=nfnf[i+4]*toto+nf2nf[i+4]*toto2
00931                 +nf3nf[i+4]*toto3+nf4nf[i+4]*toto4;
00932             resnf[i+5]-=nfnf[i+5]*toto+nf2nf[i+5]*toto2
00933                 +nf3nf[i+5]*toto3+nf4nf[i+5]*toto4;
00934             resnf[i+6]-=nfnf[i+6]*toto+nf2nf[i+6]*toto2
00935                 +nf3nf[i+6]*toto3+nf4nf[i+6]*toto4;
00936             resnf[i+7]-=nfnf[i+7]*toto+nf2nf[i+7]*toto2
00937                 +nf3nf[i+7]*toto3+nf4nf[i+7]*toto4;
00938             resnf[i+8]-=nfnf[i+8]*toto+nf2nf[i+8]*toto2
00939                 +nf3nf[i+8]*toto3+nf4nf[i+8]*toto4;
00940             resnf[i+9]-=nfnf[i+9]*toto+nf2nf[i+9]*toto2
00941                 +nf3nf[i+9]*toto3+nf4nf[i+9]*toto4;
00942             resnf[i+10]-=nfnf[i+10]*toto+nf2nf[i+10]*toto2
00943                 +nf3nf[i+10]*toto3+nf4nf[i+10]*toto4;
00944             resnf[i+11]-=nfnf[i+11]*toto+nf2nf[i+11]*toto2
00945                 +nf3nf[i+11]*toto3+nf4nf[i+11]*toto4;
00946             resnf[i+12]-=nfnf[i+12]*toto+nf2nf[i+12]*toto2
00947                 +nf3nf[i+12]*toto3+nf4nf[i+12]*toto4;
00948             resnf[i+13]-=nfnf[i+13]*toto+nf2nf[i+13]*toto2
00949                 +nf3nf[i+13]*toto3+nf4nf[i+13]*toto4;
00950             resnf[i+14]-=nfnf[i+14]*toto+nf2nf[i+14]*toto2
00951                 +nf3nf[i+14]*toto3+nf4nf[i+14]*toto4;
00952             resnf[i+15]-=nfnf[i+15]*toto+nf2nf[i+15]*toto2
00953               +nf3nf[i+15]*toto3+nf4nf[i+15]*toto4;
00954           } 
00955         }
00956   for(register unsigned int j=i;j<nf.size;j++)
00957     resnf[j]-=nfnf[j]*toto;
00958   for(register unsigned int j=i;j<nf2.size;j++)
00959     resnf[j]-=nf2nf[j]*toto2;
00960   for(register unsigned int j=i;j<nf3.size;j++)
00961     resnf[j]-=nf3nf[j]*toto3;
00962   for(register unsigned int j=i;j<nf4.size;j++)
00963     resnf[j]-=nf4nf[j]*toto4;
00964       
00965 }

void NewCrochetchoix ( typP &  P,
typPk &  Pk,
typMk &  Mk,
typPk &  redspol,
int &  k,
typdump &  dump,
Base &  b,
typrecall &  recall 
) [inline]

Definition at line 2594 of file corealgo.cc.

References Base< predicat >::begin(), compress(), Crochet(), Dump(), Base< predicat >::end(), Base< predicat >::erase(), forget(), isdivisible(), Listedejafait(), mon2int(), my_merge(), my_plus(), recover(), and remiseenforme().

Referenced by algo().

02608 {
02609   //displaymon();
02610   typedef typename typP::value_type polyalp;
02611   typedef typename polyalp::monom_t mon;
02612   typedef typename polyalp::coeff_t coeff;
02613   //  for(typename typPk::iterator iter=redspol.begin();iter!=redspol.end();iter++)
02614   //cout<<"les gens dans redspol "<<endl<<invconv<polyalp>(*iter)<<endl;
02615   
02616   typPk res=Crochet(redspol,k),tmpres;
02617   for(typename typPk::iterator iter=res.begin();iter!=res.end();iter++)
02618         {
02619           for(typename typPk::iterator iterredspol=redspol.begin();
02620               iterredspol!=redspol.end();iterredspol++)
02621             if(iter->nf==iterredspol->nf)
02622               {
02623                 redspol.erase(iterredspol);
02624                 break;
02625               }
02626         }
02627 
02628   for(typename typPk::iterator iter=res.begin();iter!=res.end();iter++)
02629     {
02630       // cout<<"un nouveau tour de boucle "<<endl;
02631       if (!Ispolzero(*iter))
02632         {
02633           //iter->ind=choice(invconv<polyalp>(*iter));
02634           iter->ind=choice(*iter,b);
02635           //cout<<"le pol pas zero "<<(invconv<polyalp>(*iter))<<endl;
02636           if(iter->ind.GetDegree()<k)
02637             {
02638 
02639               k=iter->ind.GetDegree();
02640               iter->ind=mon(0);
02641 #ifdef NO_TWICE_FALL
02642               P.push_back(invconv<polyalp>(*iter));
02643 #endif  
02644               //cout<<"le pol pas zero "<<(invconv<polyalp>(*iter))<<endl;
02645               //cout<<"passage par bout de code en plus "<<endl;
02646               my_merge(res,tmpres);
02647               my_merge(redspol,res);
02648               tmpres.erase(tmpres.begin(),tmpres.end());
02649               res.erase(res.begin(),res.end());
02650               res=Crochet(redspol,k);
02651               //cout<<"newres.size "<<res.size()<<endl;
02652               for(typename typPk::iterator iterres=res.begin()
02653                     ;iterres!=res.end();iterres++)
02654                 {
02655                   for(typename typPk::iterator iterredspol=redspol.begin();
02656                       iterredspol!=redspol.end();iterredspol++)
02657                     if(iterres->nf==iterredspol->nf)
02658                       {
02659                         redspol.erase(iterredspol);
02660                         break;
02661                       }
02662                 }
02663               iter=res.begin();
02664               //iter->ind=choice(invconv<polyalp>(*iter));
02665               iter->ind=choice(*iter,b);
02666               Dump(Pk,dump);//c pour detruire Pk dans forget
02667               //ca ne respecte pas la structure du dump!!!
02668               recover(Pk,Mk,dump,k);
02669 #ifdef NO_TWICE       
02670               Listedejafait(Mk,Spoldejavu);
02671 #endif
02672               forget(b,dump,k,recall);
02673               //forget(b,dump,k);
02674               compress(Pk,redspol,dump,b,k);
02675               //swap(*iter,*res.rbegin());//on veut ne plus 
02676               //iter=--res.end();//refaire d'autre tours
02677             }
02678           //cout<<"g choisi dans Crochetchoix "<<iter->ind<<endl;
02679           //cout<<"a t'il un mon2int ?"<<IsinB(iter->ind,b)<<endl;
02680           //mon tmp10,tmp11;
02681           //      int2mon(10,tmp10);int2mon(11,tmp11);
02682           //cout<<"qu'en est il de int2mon(10) et 11 "<<tmp10<<" "<<tmp11<<endl;
02683           //      
02684           //
02685           //
02686 #ifdef UGLY_HACK
02687           remiseenforme(*iter);
02688 #endif
02689           //SALE HACK
02690           //
02691           //
02692           //
02693           //
02694           //
02695           *iter/=iter->ind.GetCoeff();//pour la "nf"
02696           iter->ind*=(coeff)1/iter->ind.GetCoeff();//pour l'ind
02697           iter->nf[mon2int(iter->ind)]=0;
02698           //      
02699           //
02700               //
02701 #ifdef UGLY_HACK
02702           remiseenforme(*iter);
02703 #endif    
02704           //SALE HACK
02705               //
02706           //
02707               //
02708           //
02709           //
02710           
02711           tmpres.push_back(*iter);
02712           //on met a 0 le coeff du mon passe en ind
02713           //maintenant on a une regle en forme comme il faut reste a:
02714           //-reduire les regles deja existantes par rapport acelle ci
02715           //-reduire les autres redspol par rapport a celle ci
02716           for(typename typPk::iterator iterPk=Pk.begin();iterPk!=Pk.end();iterPk++)
02717             if((mon2int(iter->ind)<iterPk->size)&&
02718                (iterPk->nf[mon2int(iter->ind)]!=(coeff)0))//test a zero!!!
02719               {
02720                 //cout<<"g trouve un gus qui a un coeff du mon choisi "<<endl;
02721                 //cout<<"le voila "<<invconv<Poly>(*iterPk)<<endl;
02722                 //<<iterPk->nf[mon2int(iter->ind)]<<endl;
02723                 coeff tmpcoeff=iterPk->nf[mon2int(iter->ind)];
02724                 //cout<<"le coeff "<<tmpcoeff<<" tmpind "<<mon2int(iter->ind)<<endl;
02725                 my_plus(*iterPk,*iter,tmpcoeff);
02726                 iterPk->nf[mon2int(iter->ind)]=0;
02727                 //cout<<"apres plus le coeff vaut "
02728                 //  <<iterPk->nf[mon2int(iter->ind)]<<endl; 
02729                 //cout<<"apres mise a jour"<<endl<<invconv<Poly>(*iterPk)<<endl;
02730               }
02731           //attention plus(a,b)==a-coeff_de_ind_b_dans_a*b;
02732           typename typPk::iterator iterredspol=iter;
02733           iterredspol++;
02734           for(;iterredspol!=res.end();iterredspol++)
02735             {
02736               //cout<<"redspol.size() "<<redspol.size()<<endl;
02737               //cout<<"iterredspol-ind "<<iterredspol->ind<<" "<<iterredspol->nf<<endl;
02738               if(mon2int(iter->ind)<iterredspol->size && 
02739                  iterredspol->nf[mon2int(iter->ind)]!=(coeff)0)//test a 0 ici
02740                 {
02741                   coeff tmpcoeff=iterredspol->nf[mon2int(iter->ind)];
02742               my_plus(*iterredspol,*iter,tmpcoeff);
02743                   iterredspol->nf[mon2int(iter->ind)]=0;
02744                   //  cout<<"coucou je suis ici "<<
02745                   // iterredspol->nf[mon2int(iter->ind)]<<endl;
02746                 }
02747             }
02748           //au tour de tmpres...
02749           for(iterredspol=tmpres.begin();iterredspol!=tmpres.end();iterredspol++)
02750             {
02751               //cout<<"redspol.size() "<<redspol.size()<<endl;
02752               //cout<<"iterredspol-ind "<<iterredspol->ind<<" "<<iterredspol->nf<<endl;
02753               if(mon2int(iter->ind)<iterredspol->size && 
02754                  iterredspol->nf[mon2int(iter->ind)]!=(coeff)0)//test a 0 ici
02755                 {
02756                   coeff tmpcoeff=iterredspol->nf[mon2int(iter->ind)];
02757                   my_plus(*iterredspol,*iter,tmpcoeff);
02758                   iterredspol->nf[mon2int(iter->ind)]=0;
02759                   //  cout<<"coucou je suis ici "<<
02760                   //  iterredspol->nf[mon2int(iter->ind)]<<endl;
02761                 }
02762             }
02763           //voila c fait 
02764           //maintenant on met a jour la Base b.
02765           for(typename Base::iterator iterb=b.begin();iterb!=b.end();iterb++)
02766             {
02767               int tmptaille1=0;
02768               mon *tmp=(mon*)MAC_REV_MALLOC<mon>(iterb->taille1*sizeof(mon));
02769               for(int i=0;i<iterb->taille1;i++)
02770                 if(!isdivisible(iter->ind,iterb->accept[i],b))
02771                   tmp[tmptaille1++]=iterb->accept[i];
02772               tmp=(mon*)MAC_REV_REALLOC<mon>(tmp,iterb->taille1*sizeof(mon)
02773                                              ,tmptaille1*sizeof(mon));
02774               MAC_REV_FREE<mon>(iterb->accept,iterb->taille1*sizeof(mon));
02775               iterb->accept=tmp;
02776               iterb->taille1=tmptaille1;
02777               if(iterb->taille1==0)
02778                 {
02779                   MAC_REV_FREE<mon>(iterb->refuse,iterb->taille2*sizeof(mon));
02780                   b.erase(iterb--);
02781                   continue;
02782                 }
02783               iterb->refuse=(mon*)MAC_REV_REALLOC<mon>
02784                 (iterb->refuse,(iterb->taille2)*sizeof(mon),
02785                  (iterb->taille2+1)*sizeof(mon));
02786               iterb->refuse[iterb->taille2]=iter->ind;
02787               // cout<<"reffuse rajoute "<<iter->ind<<endl;
02788               iterb->refuse[iterb->taille2].SetCoeff(1);
02789               iterb->taille2++;
02790             }
02791           res.erase(iter--);
02792         }
02793       //break;//comme ca on fait pas 50 tours.
02794     }
02795 
02796   for (typename typPk::iterator iterpk=Pk.begin();iterpk!=Pk.end();iterpk++)
02797     {
02798       //cout<<"iterpk->ind "<<iterpk->ind<<"et Isinb(iterpk-ind,b) "<<IsinB(iterpk->ind,b)<<endl;
02799       //cout<<"le pol "<<invconv<Poly>(*iterpk)<<endl;
02800       if (IsinB(iterpk->ind,b))
02801         {
02802           for(typename Base::iterator iterb=b.begin();iterb!=b.end();iterb++)
02803             {
02804               iterb->refuse=(mon*)MAC_REV_REALLOC<mon>
02805                 (iterb->refuse,(iterb->taille2)*sizeof(mon),
02806                  (iterb->taille2+1)*sizeof(mon));
02807               iterb->refuse[iterb->taille2]=iterpk->ind;
02808               iterb->refuse[iterb->taille2].SetCoeff(1);
02809               iterb->taille2++;
02810             }
02811         }
02812     }
02813 #ifdef NO_TWICE_FALL_CHOICE
02814   for(typename typPk::iterator iter=tmpres.begin();iter!=tmpres.end();iter++)
02815     P.push_back(invconv<polyalp>(*iter));
02816 #endif  
02817   my_merge(Pk,tmpres);//les gens dans res\tmpres ne sont pas detruits ici!!
02818   my_merge(redspol,res);
02819   //displaymon();
02820   return;
02821 }

void NewDestroyredspol ( typPk &  redspol,
const typPk &  Pk 
) [inline]

Definition at line 2824 of file corealgo.cc.

Referenced by algo().

02825 {
02826   //  typename typPk::const_iterator iterpk=--Pk.end(); 
02827   for(typename typPk::iterator iter=redspol.begin();
02828       iter!=redspol.end();iter++)
02829     {
02830       //    if(iter->nf!=iterpk->nf)
02831         MAC_REV_FREE<typename typPk::value_type::coeff_t>(iter->nf,iter->size*sizeof(typename typPk::value_type::coeff_t));
02832     }
02833 }

int newPkMkMatrixof ( typMat &  mat,
typPk &  Pk,
typP &  P,
typMk &  Mk,
int &  k,
Base &  b,
typdump &  dump,
typrecall &  recall 
) [inline]

!! ATTENTION C VITAL DE PAS FAIRE N'IMPORTE QUOI AVEC LES IND

Definition at line 1506 of file corealgo.cc.

References affdebug(), Base< predicat >::begin(), compress(), conv_merge(), Crochet(), Degree(), Base< predicat >::end(), forget(), GoodDir(), Listedejafait(), member(), minmaxdegP(), mon2int(), mult(), my_divmon(), my_merge(), Base< predicat >::nbvar(), Base< predicat >::nbvars, proj(), putingoodshape(), and recover().

Referenced by algo().

01517 {
01518   typedef typename typMk::value_type mon;
01519   typedef typename typP::value_type::order_t ord;
01520   typedef typename typPk::value_type pol;
01521   typedef typename pol::coeff_t coeff;
01522   typedef typename typP::value_type polyalp;
01523   typPk tmpPk,workvect;
01524   typMk tmpMk;
01525   list<mon *> exceed;
01526   list<int> sizeexceed;
01527   int nbproj=0,flagdoplus=1;
01528   //prise en compte des pol pas encore introduits
01529   cout<<endl;
01530   cerr<<"k on entering newpkmkmatrixof "<<k<<endl;
01531   //cout<<"crochet"<<endl;
01532   typP ttmpP=Crochet(P,k+1);//
01533   //typrecall verytmp=Crochet(recall,k+1);//verytmpP 24/08/2001
01534   //recall.erase(recall.begin(),recall.end());
01535   //my_merge(ttmpP,verytmpP);//le 24/08/2001
01536   //nbproj=ttmpP.size();
01537   //for(typename typPk::iterator iter=Pk.begin();iter!=Pk.end();iter++)
01538   //   cout<<"ind au debut"<<iter->ind<<endl;
01539   //for(typename typPk::iterator iter=verytmp.begin();iter!=verytmp.end();iter++)
01540   // cout<<"ind au debut"<<iter->ind<<endl;
01541   //    cout<<"pol au debut"<<invconv<typename typP::value_type>(*iter)<<endl; 
01542   if (!ttmpP.empty()) 
01543     {
01544       int tmpdeg;
01545       // cout<<"proj "<<endl;
01546       proj(ttmpP,dump,b);
01547       //  cout<<"selectnozero"<<endl;
01548       selectnozero(ttmpP);
01549 #ifdef NO_TWICE_FALL
01550       for(typename typP::iterator iter=P.begin();iter!=P.end();iter++)
01551         if(Degree(*iter)==k+1) P.erase(iter--);
01552       for(typename typP::iterator iter=ttmpP.begin()
01553             ;iter!=ttmpP.end();iter++)
01554         P.push_back(*iter);
01555 #endif    
01556 //  for(typename typP::iterator iter=P.begin();iter!=P.end();iter++)
01557       //if(Degree(*iter)==k+1) P.erase(iter--);
01558       //for(typename typP::iterator iter=ttmpP.begin();iter!=ttmpP.end();iter++)
01559       //        P.push_back(*iter);
01560       //        cout<<"pol mal red "<<*iter<<endl;
01561       //cout<<"passage par ici"<<endl;
01562       nbproj=ttmpP.size();
01563       if (!ttmpP.empty())
01564         {
01565           //  cout<<"apres select non zero "<<ttmpP.size()<<endl;
01566           tmpdeg=minmaxdegP(ttmpP,tmpdeg);
01567           //      cout<<"apres minmax deg "<<tmpdeg<<" "<<k<<endl;
01568           if(tmpdeg<k+1)
01569             {
01570               flagdoplus=0;
01571               // cout<<"un des pol de pretendu degre le bon se reduit mal"<<endl;
01572               //en fait a un polynome de degre inferieur
01573               typPk tmpconv;
01574               //cout<<"recover"<<endl;
01575               recover(tmpPk,Mk,dump,tmpdeg);
01576 #ifdef NO_TWICE       
01577               Listedejafait(Mk,Spoldejavu);
01578 #endif
01579               // for (typename typPk::iterator iter=tmpPk.begin();iter!=tmpPk.end();iter++)
01580                 //      cout<<"pol ICI "<<invconv<typename typP::value_type>(*iter)<<endl;
01581                 // cout<<"forget "<<tmpdeg<<endl;
01582               //      recall=verytmp;
01583               forget(b,dump,tmpdeg,recall);
01584               compress(tmpPk,dump,b,tmpdeg);
01585               //verytmp.erase(verytmp.begin(),verytmp.end());
01586 
01587 
01588               
01589               //forget(b,dump,tmpdeg);
01590               
01591               ttmpP=Crochet(ttmpP,tmpdeg);
01592 #ifdef NO_TWICE_BUG        
01593               for(typename typP::iterator iter=P.begin()
01594                     ;iter!=P.end();iter++)
01595                 if(Degree(*iter)==tmpdeg)
01596                   P.erase(iter--);
01597 #endif  
01598               //      for(typename typP::iterator iter=ttmpP.begin()
01599               //    ;iter!=ttmpP.end();iter++)
01600               //P.push_back(*iter);
01601               nbproj=ttmpP.size();
01602               //for(typename typP::iterator iter=ttmpP.begin();iter!=ttmpP.end();iter++)
01603               //        tmpconv.push_back(convert<pol>(*iter,b));
01604               //ttmpP.erase(ttmpP.begin(),ttmpP.end());//samedi 24 aout
01605               //nbproj=1;//                              samedi 24 aout
01606               //Crochetchoix(P,Pk,tmpconv,tmpdeg,b);
01607               //ttmpP.push_back(invconv<typename typP::value_type>(Pk.back()));
01608               //Pk.pop_back();//on elimine de Pk le pol de proj choisi
01609               //pour se ramner au cas ou proj != 0 et P ok
01610               Mk.erase(Mk.begin(),Mk.end());
01611               for (typename typPk::iterator iterpk=tmpPk.begin();
01612                    iterpk!=tmpPk.end();iterpk++)
01613                 {
01614                   // cout<<"iterpk->ind "<<iterpk->ind
01615                   //    <<"et Isinb(iterpk-ind,b) "<<IsinB(iterpk->ind,b)<<endl;
01616                   if (IsinB(iterpk->ind,b))
01617                     {
01618                       for(typename Base::iterator iterb=b.begin()
01619                             ;iterb!=b.end();iterb++)
01620                         {
01621                           iterb->refuse=(mon*)MAC_REV_REALLOC<mon>
01622                             (iterb->refuse,(iterb->taille2)*sizeof(mon),
01623                              (iterb->taille2+1)*sizeof(mon));
01624                           iterb->refuse[iterb->taille2]=iterpk->ind;
01625                           iterb->refuse[iterb->taille2].SetCoeff(1);
01626                           iterb->taille2++;
01627                         }
01628                     }
01629                 }
01630               for(typename typPk::iterator iter=tmpPk.begin()
01631                     ;iter!=tmpPk.end();iter++)
01632                 {
01633                   mon *tmp=(mon*)MAC_REV_MALLOC<mon>(sizeof(mon));
01634                   *tmp=iter->ind;
01635                   tmpMk.push_back(*tmp);
01636                   exceed.push_back(tmp);
01637                   sizeexceed.push_back(1);
01638                   //      cout<<"pour Mk iter->ind "<<iter->ind<<endl;
01639                 }
01640               //on vient de chuter de 
01641               //degre et on a reconstitue les bons mk et pk
01642               k=tmpdeg-1;
01643               //Dump(Pk,dump);
01644             }
01645         }
01646     }
01647   if(flagdoplus)
01648     {
01649 #ifdef unimul
01650         reinit_multiple();
01651 #endif      
01652 #ifdef uninf
01653         reinit_nf<pol>();
01654 #endif 
01655         map<mon,int,ord> monmember;
01656       //      int nbmult=0;
01657       //list<mon> dejavu;
01658       //consttruction des pol ord sup
01659       for(int i=0;i<b.nbvar();i++)
01660         {
01661           for(typename typPk::iterator iter=Pk.begin();iter!=Pk.end();iter++)
01662             {
01663               //cout<<"avant gooddir l'ind "<<iter->ind<<endl;
01664               if(GoodDir((*iter).ind,i,b))
01665                 {
01666                   mon tmpmon=iter->ind*mon(i,1);
01667                   //tmpmon.SetCoeff(1);
01668                   //if(!member(tmpMk,tmpmon))
01669                   if(!(monmember).count(tmpmon))
01670                     {
01671                       typename typrecall::iterator iterrec;
01672                       (monmember)[tmpmon]=1;
01673                       tmpMk.push_back(tmpmon);
01674 #if 0         
01675                       for(iterrec=verytmp.begin();
01676                           (iterrec!=verytmp.end())
01677                             &&(!(iterrec->ind.rep==tmpmon.rep));
01678                           iterrec++);
01679                         if(iterrec!=verytmp.end())
01680                           {
01681                             //                      cout<<"g un candidat "<<tmpmon<<" son ind "<<iterrec->ind<<"la comparaison "<<(iterrec->ind.rep==tmpmon.rep)<<endl;
01682                             // putingoodshape(P,workvect,Mk,exceed,sizeex,dump,b);                          
01683                             workvect.push_back(*iterrec);
01684                             verytmp.erase(iterrec);
01685                             continue;
01686                           }
01687 #endif
01688                         //cout<<"aprfes gooddir"<<endl;
01689                       mon * tmp=NULL;
01690                       int tmpsize;
01691                       //cout<<"avant mult"<<endl;
01692                       tmpPk.push_back(mult(i,*iter,dump,b,&tmp,tmpsize));
01693                       //attention le coefficient de ind est la taille de 
01694                       // l'exceed correspondant
01695                       //      cout<<"apres mult"<<endl;
01696                       exceed.push_back(tmp);
01697                       sizeexceed.push_back(tmpsize);
01698 #ifdef DEB                  
01699                       cout<<"coucou"<<endl;
01700                       for(int j=0;j<tmpsize;j++)
01701                         cout<<" "<<tmp[j];
01702                       cout<<endl; 
01703 #endif
01704                       //              nbmult++;
01705                     }
01706                 }
01707             }
01708         }
01709       //      recall=verytmp;
01710       //      cout<<"nbmult "<<nbmult<<endl;
01711     }
01712 
01713   //  cout<<"tmpPK.size "<<tmpPk.size()<<endl;
01714   //Constructyion de pol terminee
01715   //cout<<"ttmpP.size "<<ttmpP.size()<<endl;
01716   //cout<<"avant conv merge"<<endl;
01717 #if 1
01718   {  
01719 #if 0
01720     for(typename typPk::iterator iter=verytmp.begin();iter!=verytmp.end();iter++)
01721       {
01722         int good=0;
01723         for(int i=0;i<b.nbvar();i++)
01724           {
01725             if((iter->ind.GetDegree(i)>0)&&(IsinB(my_divmon(iter->ind,i,b),b)))
01726             {
01727               good=1;break;
01728             }
01729           }
01730         if(good)
01731           { 
01732             //NON il faut virer les ind de B avant de les pushbacker
01733             if(mon2int(iter->ind)>=iter->size)
01734               {
01735                 iter->nf=(coeff*)MAC_REV_REALLOC<coeff>(iter->nf,
01736                                      iter->size*sizeof(coeff)
01737                                      ,(mon2int(iter->ind)+1)*sizeof(coeff));
01738                 }
01739             iter->nf[mon2int(iter->ind)]=iter->ind.GetCoeff();
01740             iter->ind=mon(0);
01741             workvect.push_back(*iter);
01742             verytmp.erase(iter--);
01743           }
01744       }
01745 #endif
01746     //recall=verytmp;
01747     list<mon*> tmpexceed;
01748     list<int> tmpsizeex;
01749     putingoodshape(P,workvect,tmpMk,tmpexceed,tmpsizeex,dump,b);
01750     my_merge(tmpPk,workvect);
01751     my_merge(exceed,tmpexceed);
01752     my_merge(sizeexceed,tmpsizeex);
01753   }
01754 #endif
01755   conv_merge(tmpPk,ttmpP,exceed,sizeexceed,b);
01756   //cout<<"apres conv merge"<<endl;
01757   //cout<<"tmpMK==empty?? "<<tmpMk.empty()<<endl;
01758   //   for(typename typPk::iterator iter=tmpPk.begin();iter!=tmpPk.end();iter++)
01759   //   {
01760   //    cout<<"iter->ind.GetCoeff() "<<iter->ind.GetCoeff()-1
01761   //        <<" et ind "<<iter->ind<<endl;
01762   //   }
01763     //cout<<"tmpPK.size "<<tmpPk.size()<<endl;
01764 
01765   //Tue Nov 27 15:57:25 MET 2001
01766   /*
01767    for(typename typPk::iterator iter=tmpPk.begin();iter!=tmpPk.end();iter++)
01768     
01769    {
01770    mon tmp=iter->ind;
01771    tmp.SetCoeff(1);
01772    if((iter->ind.GetDegree()!=0)&&(!member(tmpMk,tmp)))
01773    {
01774    //cout<<"iter->ind.GetCoeff()"<<iter->ind.GetCoeff()-(coeff)1<<" "
01775    //    <<tmp<<endl;
01776    tmpMk.push_back(tmp);
01777    //tmpMk.back().SetCoeff(1);
01778    }
01779    }
01780   */
01781   //construction de la matrice maintenant
01782   //positionnement des pointeurs de matrices pour gagner en tps
01783    {
01784      int nnz=0;
01785      //-----------------
01786      //for(typename typMk::iterator iter=tmpMk.begin();iter!=tmpMk.end();iter++)
01787      // cout<<"mon "<<*iter<<endl;
01788      //-----------------
01789      //     cout<<"nb proj "<<nbproj<<endl;
01790      for(list<int>::iterator iter=sizeexceed.begin();iter!=sizeexceed.end()
01791            ;iter++)
01792        {
01793          nnz+=*iter;
01794          //      cout<<"on a donc de monme pour celui la "<<
01795          //  (int)((iter->ind).GetCoeff()-1)<<" d'ou nnz "<<nnz<<endl;
01796        }
01797      //for(typename typPk::iterator iter=tmpPk.begin();iter!=tmpPk.end();iter++)
01798      //  {
01799      //  int tmp=0;
01800      //  for(;(iter->ind).GetCoeff()>(coeff)tmp;tmp++);
01801      //  nnz+=tmp-1;
01802          //      cout<<"on a donc de monme pour celui la "<<
01803          //  (int)((iter->ind).GetCoeff()-1)<<" d'ou nnz "<<nnz<<endl;
01804      //       }
01805      // nnz+=tmpPk.size()-nbproj;//le 10/05/2001 avant: nnz+=tmpMk.size()-nbproj;
01806      //le -nbproj rajoute le 23/01/2001!!
01807      //     #define DEBUG
01808 #ifdef DEBUG
01809      typename typPk::iterator tmpiter=tmpPk.begin();
01810      list<int>::iterator itersize=sizeexceed.begin();
01811      for(typename list<mon*>::iterator iter=exceed.begin();iter!=exceed.end()
01812       ;tmpiter++,iter++,itersize++)
01813       {
01814         cout<<"pour un exceeed la taille attendue est "
01815             <<*itersize<<endl;
01816         for(int i=0;*itersize>i;i++)//;tmpiter->ind.GetCoeff()>i+1;i++)
01817            {
01818              cout<<"le gus que je regarde "<<(*iter)[i]<<endl;
01819              if(!member(tmpMk,(*iter)[i]))
01820              {
01821                cout<<(*iter)[i]<<endl;
01822                cout<<"dans ce pol "<<invconv<Poly>(*tmpiter)<<endl;
01823                cout<<"l'ind "<<tmpiter->ind<<endl;
01824                exit(-10);
01825              }
01826            }
01827      }
01828 #endif
01829      // #undef DEBUG
01830      cout<<"nnz of matrix "<<nnz<<endl;
01831      //en general la matrice est rectangulaire
01832      void * toto=MAC_REV_MALLOC<coeff>(nnz*sizeof(typename typMat::coeff_t));
01833      //+nnz*sizeof(int)+((*mat)->ncol+1)*sizeof(int));
01834      if (mat.nzval!=NULL) MAC_REV_FREE<typename typMat::coeff_t>
01835                             (mat.nzval,mat.nnz
01836                              *sizeof(typename typMat::coeff_t));
01837      mat.nrow=tmpPk.size();
01838      mat.ncol=tmpMk.size();
01839      mat.nnz=nnz;
01840      mat.nzval=toto;
01841 #ifdef DEBUG
01842      for(int i=0;i<nnz;i++)
01843        ((typename typMat::coeff_t*)mat.nzval)[i]=(coeff)1000000000000.0;
01844 #endif
01845      // mstore->rowind=(int*)((double*)toto+nnz);
01846      if(mat.rowind!=NULL) free(mat.rowind);
01847      mat.rowind=(int*)malloc(nnz*sizeof(int));
01848      //mstore->colptr=(int*)(mstore->rowind+nnz);//
01849      if(mat.colptr!=NULL) free(mat.colptr);
01850      mat.colptr=(int*)malloc((mat.ncol+1)*sizeof(int));
01851    }
01852    cout<<"matrix of size "<<mat.nrow<<"x"<<mat.ncol<<endl;
01853    //matrice cree rest plus qu'a ecrire dedans ca
01854    {
01855      int *ncol=(int*)calloc(mat.ncol,sizeof(int));
01856      //memset((void*)ncol,0,(*mat)->ncol*sizeof(int));
01857      map<mon,int,ord> mapint;
01858      typename typMk::iterator itermk=tmpMk.begin();
01859      typename typPk::iterator iterpk=tmpPk.begin();
01860      typename list<mon*>::iterator iterex=exceed.begin();
01861      list<int>::iterator itersize=sizeexceed.begin();
01862      int line_num=0;
01863 #ifdef nomap
01864      int **indmonmk=malloc(b.nbvar()*sizeof(int));
01865      for(int i=0;i<b.nbvars();i++)
01866        {
01867          indmon[i]=malloc(size*sizeof(int));
01868        }
01869      for(int i=0;itermk!=tmpMk.end();i++,itermk++)
01870        {
01871          for(int j=0;j<b.nbvars;j++)
01872            {
01873              mon tmp=my_divmon(*itermk,mon(j,1));
01874              indmon[mon2int(tmp)]=i;
01875            }
01876        } 
01877 #endif
01878      for(int i=0;itermk!=tmpMk.end();i++,itermk++)
01879        {
01880          mapint[*itermk]=i;
01881        } 
01882      iterpk=tmpPk.begin();
01883      for(;iterpk!=tmpPk.end();iterpk++,iterex++,itersize++,line_num++)
01884        {
01885          // if(iterpk->ind.GetDegree()>0) 
01886          //  {
01887          //    mon tmpmon=iterpk->ind;
01888          //    tmpmon.SetCoeff(1);
01889          //   ncol[mapint[tmpmon]]++;
01890              //      cout<<"on est a la ligne "<<line_num<<" ai augmente "<<mapint[(iterpk->ind*(1/iterpk->ind.GetCoeff()))]<<" a cause de son monome dom "<<endl;
01891              // cout<<"le voila "<<(iterpk->ind*(1/iterpk->ind.GetCoeff()))<<endl;
01892          //}
01893         {
01894           // coeff tmpcoeff=(iterpk->ind).GetCoeff()-(coeff)1;
01895 #ifdef nomap
01896           for(int i=0;*itersize>i;i+=2)
01897             ++ncol[indmon[(*iterex)[i]][(*iterex)[i+1]]]; 
01898 #else    
01899           for(int i=0;*itersize>i;i++)
01900             {
01901              //cout<<"iterpk icici ->GetCoeff()"<<iterpk->ind.GetCoeff()<<endl;
01902              //     if (mapint.count((*iterex)[i]))
01903               {
01904                 ++ncol[mapint[(*iterex)[i]]];
01905                 // cout<<" ai augmente "<<mapint[(*iterex)[i]]<<"a cause de iterex "<<endl;
01906               }
01907 #endif  
01908            }
01909         }
01910        }
01911      //rajoute le 23/01/2001
01912      //enleve le 17.05/2001
01913      //     for(int i=mat.nrow-nbproj;i<mat.nrow;i++)
01914      // ncol[i]--;
01915      //fin rajout c pour prendre en compte que lors de 
01916      //de la proj le monome de tete se trouve dans exceed
01917      //fin enlevement
01918      typename typMat::coeff_t* nzval=(typename typMat::coeff_t*)mat.nzval;
01919      int *rowind=mat.rowind;
01920      int *colptr=mat.colptr;
01921     //mise  en place des colptr
01922     *colptr=0;
01923     for(int i=0;i<mat.ncol-1;i++)
01924       {
01925         colptr[i+1]=colptr[i]+ncol[i];
01926         //cout<<"nb element colonne "<<i<<" "<<ncol[i]<<endl;
01927         //cout<<"les valeurs de debut de colonne "<<8*colptr[i+1]<<endl;
01928       }
01929     colptr[mat.ncol]=mat.nnz;
01930     //cout<<"mat.nnz "<<mat.nnz<<" "<<mat.nnz*8<<endl;
01931     //fin mise en place
01932     //la on fait des manip symboliques pour savoir ou ecrire 
01933     //les coeffs de chaques colonnes ca evite d'avoir a les
01934     //recopier 50000 fois pour construire la matrice 
01935     //c bcp plus rapide
01936     itermk=tmpMk.begin();
01937     iterpk=tmpPk.begin();
01938     iterex=exceed.begin();
01939     itersize=sizeexceed.begin();
01940     line_num=0;
01941     //cout<<"nbproj "<<nbproj<<endl;
01942 #if 0    
01943 for(;0&&(line_num < (int)(tmpPk.size()-nbproj));
01944         iterpk++,iterex++,itersize++,line_num++)
01945       //les polynome projette sont foutut au bout de la liste!!
01946       //d'ou le tmpPk.size()-nbproj
01947       {
01948         mon tmpmon=iterpk->ind;
01949         tmpmon.SetCoeff(1);
01950         //const unsigned int tmpplus=line_num+1,tmp=line_num;
01951         const unsigned int tmpplus
01952           =mapint[tmpmon]+1,tmp=tmpplus-1;
01953         //      cout<<"ici line_num"<<line_num<<" le mon dom est col "<<tmp<<endl;
01954         //ici couille car le ind n'est pas forcement le mon diag
01955         nzval[colptr[tmpplus]-ncol[tmp]]=1;
01956         //fin couille changer un truc
01957         //      cout<<"mat.nnz "<<mat.nnz<<endl;
01958         //cout<<"colptr[...]"<<colptr[tmpplus]<<endl;
01959         //cout<<"ncol[....]"<<ncol[tmp]<<endl;
01960         //cout<<"1 a la pos "<<colptr[tmpplus]-ncol[tmp]<<endl;
01961         rowind[colptr[tmpplus]-ncol[tmp]]=line_num;
01962         //cout<<"1 a la ligne "<<rowind[colptr[tmpplus]-ncol[tmp]]<<endl;
01963         ncol[tmp]--;
01964         {
01965           //coeff tmpcoeff=iterpk->ind.GetCoeff()-(coeff)1;
01966           for(int i=0;*itersize>i;i++)
01967           {
01968             const coeff stock=(*iterex)[i].GetCoeff();
01969             (*iterex)[i].SetCoeff(1);
01970             const unsigned int tmpplusex=mapint[(*iterex)[i]]+1;
01971             const unsigned int tmpex=mapint[(*iterex)[i]];
01972             nzval[colptr[tmpplusex]-ncol[tmpex]]
01973               =stock;
01974             rowind[colptr[tmpplusex]-ncol[tmpex]]=line_num; 
01975             ncol[tmpex]--;
01976             //    cout<<"valeur de ncol["<<tmpex<<"] "<<ncol[tmpex]<<endl;
01977           }
01978         }
01979         MAC_REV_FREE<mon>(*iterex,*itersize*sizeof(mon));
01980       }
01981 #endif
01982     for(;(iterpk!=tmpPk.end());iterpk++,iterex++,itersize++,line_num++)
01983       {
01984         //const unsigned int tmpplus=line_num+1,tmp=line_num;
01985         {
01986           //coeff tmpcoeff=iterpk->ind.GetCoeff()-(coeff)1;
01987           for(int i=0;*itersize>i;i++)
01988           {
01989             const coeff stock=(*iterex)[i].GetCoeff();
01990             (*iterex)[i].SetCoeff(1);
01991             const unsigned int tmpplusex=mapint[(*iterex)[i]]+1;
01992             const unsigned int tmpex=tmpplusex-1;
01993             nzval[colptr[tmpplusex]-ncol[tmpex]]
01994               =stock;
01995             rowind[colptr[tmpplusex]-ncol[tmpex]]=line_num; 
01996             ncol[tmpex]--;
01997           }
01998         }
01999         MAC_REV_FREE<mon>(*iterex,*itersize*sizeof(mon));
02000         //free(*iterex);
02001       }
02002     free(ncol);
02003    }
02005    for(typename typPk::iterator iterpk=tmpPk.begin()
02006          ;iterpk!=tmpPk.end();iterpk++)
02007      iterpk->ind.SetCoeff(1);
02008      //iterpk->ind*=1/iterpk->ind.GetCoeff();
02009    //  cout<<"la matrice dans newpkmkmatrixof"<<endl;
02010    //cout<<" nombre de non zero "<<mat.nnz<<endl;
02011 #ifdef DEB
02012    affdebug(mat);
02013 #endif
02014    //cout<<"le colptr "<<endl;
02015    //for(int i=0;i<mat.ncol;i++)
02016    // cout<<mat.colptr[i]<<" "<<endl;
02017    //   cout<<"les indices de lignes et le nnz"<<endl;
02018    //for(int i=0;i<mat.nnz;i++)
02019    //  cout<<mat.rowind[i]<<" "<<((typename typMat::coeff_t*)mat.nzval)[i]<<endl;
02020    //cout<<"fin matrice"<<endl;
02021    Pk.swap(tmpPk);
02022    Mk.swap(tmpMk);
02023    
02024    //  for(int i=0;i<mat.nnz;i++)
02025    // cout<<"coeff mat "<<((typename typMat::coeff_t*)mat.nzval)[i]<<" et i "<<i<<endl; 
02026    return flagdoplus;
02027 }

typpol nf ( const mon &  ind,
const typdump &  dump,
const Base &  b 
) [inline]

Definition at line 1047 of file corealgo.cc.

References pol< mon, T >::nf, and pol< mon, T >::size.

01048 {
01049   //on cherche dans dump...
01050   //a optimiser plus tard
01051   typedef typename typdump::value_type dumpstruct;
01052   typedef typpol pol;
01053   pol res;
01054   res.nf=NULL;
01055   res.size=-1;
01056   int deg=0;//=tmpmon.GetDegree()+1;
01057   typename typdump::const_iterator iter;
01058   deg=ind.GetDegree();
01059   for(iter=dump.begin();
01060       (iter!=dump.end()) && (iter->k!=deg);iter++);
01061   if(iter!=dump.end())//on cherche pas n'importe quoi qd meme
01062     {
01063       int i;
01064       for(i=0;i<iter->size;i++)
01065         {
01066           if(iter->nf[i].ind.rep==ind.rep)
01067             break;
01068         }
01069       if(i!=iter->size)
01070         res=(iter->nf[i]);
01071     }
01072   return res;
01073 }

typpol nf ( int  var,
int  indmon,
const typdump &  dump,
const Base &  b 
) [inline]

Definition at line 1001 of file corealgo.cc.

References int2mon(), pol< mon, T >::nf, and pol< mon, T >::size.

01002 {
01003   //on cherche dans dump...
01004   //a optimiser plus tard
01005   typedef typename typdump::value_type dumpstruct;
01006   typedef typpol pol;
01007   typedef typename pol::monom_t mon;
01008   pol res;
01009   res.nf=NULL;
01010   res.size=-1;
01011   mon tmpmon;//=mon(1,var)*int2mon<mon>(indmon);
01012   int deg=0;//=tmpmon.GetDegree()+1;
01013   typename typdump::const_iterator iter;
01014   int2mon(indmon,tmpmon);
01015   deg=tmpmon.GetDegree()+1;
01016   //cout<<"mon("<<var<<",1) "<<mon(var,1)<<" et deg "<<deg<<endl;
01017   tmpmon*=mon(var,1);
01018    for(iter=dump.begin();
01019        (iter!=dump.end()) && (iter->k!=deg);iter++);
01020    //    cout<<"iter-k "<<iter->k<<endl;
01021    // if(iter!=dump.end()) cout<<"iter->k en sortie "<<iter->k<<" et deg "<<deg<<endl;
01022   //cout<<"valuer a la sortie "<<(--iter)++->k<<endl;
01023    // cout<<"iter!=dump.end() "<<(iter!=dump.end())
01024    //   <<" dump.empty() "<<dump.empty()<<endl;
01025   if(iter!=dump.end())//on cherche pas n'importe quoi qd meme
01026     {
01027       int i;
01028       for(i=0;i<iter->size;i++)
01029         {
01030           //  cout<<"dans nf iter->nf[i].ind "<<iter->nf[i].ind<<endl;
01031           if(iter->nf[i].ind.rep==tmpmon.rep)
01032             break;
01033         }
01034       if(i!=iter->size)
01035         //Tue Dec  4 16:39:25 MET 2001
01036         //      densify(iter->nf[i],res);
01037 
01038         res=(iter->nf[i]);
01039     }
01040   //cout<<"la gueule de res "<<res<<endl;
01041   //if (res!=NULL) cout<<"suite de res "<<res->ind<<" "<<res->nf<<endl;
01042   return res;
01043 }

void OLD_ReduceSpol ( typPk &  S,
const typdump &  dump,
typPk &  redspol,
const Base &  b 
) [inline]

Definition at line 2295 of file corealgo.cc.

References findcorresppol(), pol< mon, T >::ind, int2mon(), mon2int(), my_plus(), pol< mon, T >::nf, and varmult().

02296 {
02297   typedef typename typPk::value_type pol;
02298   typedef typename pol::monom_t mon;
02299   typedef typename pol::coeff_t coeff;
02300   const coeff  zero(0);
02301   //cout<<"en entree de RedSpol S.size "<<S.size()/2<<endl;
02302   for(typename typPk::iterator iterS=S.begin();iterS!=S.end();iterS++,iterS++)
02303     {
02304       typename typPk::iterator iterS2=iterS;
02305       mon var1,var2;
02306       typename typPk::value_type res;
02307       int max=0;
02308       mon tmpmon;
02309       iterS2++;
02310       //cout<<"les deux pol sont dans redspol "<<endl;
02311        //cout<<invconv<Poly>(*iterS)<<endl;
02312       //cout<<"et"<<endl;
02313       //cout<<invconv<Poly>(*iterS2)<<endl;
02314       varmult(iterS,iterS2,var1,var2,b);
02315       //cout<<"les var mult "<<var1<<" "<<var2<<endl;
02316       res.ind=mon(zero);
02317       for(int i=0;i<iterS->size;i++)
02318         {
02319           //if(!Iszero(iterS->nf[i]))
02320           if(iterS->nf[i]!=zero)
02321             {
02322               int2mon(i,tmpmon);
02323               //cout<<"les mon red "<<(var1*tmpmon)<<endl;
02324               if(IsinB(var1*tmpmon,b))
02325                 if(max<mon2int(var1*tmpmon)) max=mon2int(var1*tmpmon);
02326           }
02327         }
02328       for(int i=0;i<iterS2->size;i++)
02329         {
02330           //if(!Iszero(iterS2->nf[i]))
02331           if(iterS2->nf[i]!=zero)
02332           {
02333               int2mon(i,tmpmon);
02334               //  cout<<"les mon red "<<(var1*tmpmon)<<endl;
02335               if(IsinB(var2*tmpmon,b))
02336                 if(max<mon2int(var2*tmpmon)) max=mon2int(var2*tmpmon);
02337             }
02338         }
02339       res.nf=(typename typPk::value_type::coeff_t*)
02340         MAC_REV_MALLOC<typename typPk::value_type::coeff_t>
02341         ((max+1)*sizeof(typename typPk::value_type::coeff_t));
02342       for(int i=0;i<=max;i++)
02343         res.nf[i]=0;
02344       res.size=max+1;
02345       for(int i=0;i<iterS->size;i++)
02346         {
02347           //if(!Iszero(iterS->nf[i]))
02348           if(iterS->nf[i]!=zero)
02349           {
02350             mon tmpmon;
02351             int2mon(i,tmpmon);
02352             if(!IsinB(var1*tmpmon,b))
02353               {
02354                 pol stock;
02355                 //cout<<"je cheche le monome "<<(var1*tmpmon)<<"  et var1 vaut "
02356                 //   <<var1<<endl;
02357                 findcorresppol(var1*tmpmon,dump,stock);
02358                 //cout<<"stock trouve "<<endl<<invconv<Poly>(stock)<<endl;
02359                 //cout<<"stock.size "<<stock.size<<endl;
02360                 res*stock.ind.GetCoeff();
02361                 my_plus(res,stock,iterS->nf[i]);
02362               }
02363           else
02364             {
02365          //      cout<<"je rajoute a "<<var1*tmpmon<<" "<<iterS->nf[i]<<endl;
02366               res.nf[mon2int(var1*tmpmon)]+=iterS->nf[i];
02367             }
02368             // cout<<"a ce tour de boucle res vaut"<<endl<<invconv<Poly>(res)<<endl;
02369           }
02370         }
02371       //cout<<"entre deux boucle res vaut"<<endl<<invconv<Poly>(res)<<endl;
02372       for(int i=0;i<iterS2->size;i++)
02373         {
02374           //if (!Iszero(iterS2->nf[i]))
02375           if(iterS2->nf[i]!=zero)
02376           {
02377               mon tmpmon;
02378               //cout<<"iterS2->size "<<iterS2->size<<endl;
02379               //cout<<" et i "<<i<<endl;
02380               int2mon(i,tmpmon);
02381               //cout<<"mon en cours "<<tmpmon<<" et Is in B "<<
02382               //        IsinB(var2*tmpmon,b)<<endl;
02383               if(!IsinB(var2*tmpmon,b))
02384                 {
02385                   pol stock;
02386                   findcorresppol(var2*tmpmon,dump,stock);
02387                   //  cout<<"stock trouve "<<endl<<invconv<Poly>(stock)<<endl;
02388                   res*stock.ind.GetCoeff();
02389                   my_plus(res,stock,(coeff)((coeff)(-1)*iterS2->nf[i]));
02390                 }
02391               else
02392                 {
02393                   // int toto=mon2int(var2*tmpmon),tutu=mon2int(var2*tmpmon);
02394                   //cout<<"res.size "<<res.size<<endl;
02395                   //cout<<"et j'acced a "<<toto
02396                   //   <<" "<<tutu<<endl;
02397                   res.nf[mon2int(var2*tmpmon)]-=iterS2->nf[i];
02398                 }
02399             }
02400           //cout<<"a ce tour de boucle res vaut"<<endl<<invconv<Poly>(res)<<endl;
02401         }
02402       if(!Ispolzero(res))
02403         {
02404           //  cout<<"un spol qui se reduiot pas a 0"<<endl;
02405           //for(int i=0;i<res.size;i++)
02406           //  cout<<"les coeff du qui se reduit pas a 0 "<<res.nf[i]<<endl;
02407           // cout<<"invconv<Poly>"<<endl<<invconv<Poly>(res)<<endl;
02408           redspol.push_back(res);
02409           //break;//ca c pour pas faire 50 tours 
02410           //      //qd on cherche juste a extraire 1 seul sopl non 0
02411         }
02412       else
02413         {
02414           MAC_REV_FREE<coeff>(res.nf,res.size*sizeof(coeff));
02415           // free(res.nf);
02416         }
02417     }
02418   //cout<<"en sortie redspol.size() "<<redspol.size()<<endl;
02419 }

void putingoodshape ( const typP &  P,
typPk &  workvect,
const typMk &  tmpMk,
typexceed &  exceed,
typsize &  sizeex,
const typdump &  dump,
const Base &  b 
) [inline]

Definition at line 1402 of file corealgo.cc.

References int2mon(), Iszero(), member(), mon2int(), and proj().

Referenced by newPkMkMatrixof().

01405 {
01406   typedef typename typPk::value_type pol;
01407   typedef typename pol::coeff_t coeff;
01408   typedef typename typexceed::value_type typex;
01409   typedef typename typMk::value_type mon;
01410   typedef typename typP::value_type polyalp;
01411   typP tobeproj;
01412   for(typename typPk::iterator iter=workvect.begin();
01413       iter!=workvect.end();iter++)
01414     {
01415       int sizeexceed=0;
01416       polyalp projpol(0);
01417       typex tmpex=(mon*)MAC_REV_MALLOC<mon>(sizeof(mon)*tmpMk.size());
01418       for(unsigned int i=0;i<tmpMk.size();i++)
01419         tmpex[i]=mon(0);
01420       //      cout<<"proj pol au debaut "<<projpol<<endl;
01421       for(int i=0;i<iter->size;i++)
01422         {
01423           if(!Iszero(iter->nf[i]))
01424             {
01425               mon tmpmon;
01426               int2mon(i,tmpmon);
01427               if(!IsinB(tmpmon,b))
01428                 {
01429                   if(member(tmpMk,tmpmon)) 
01430                     {
01431                       tmpex[sizeexceed++]=tmpmon*iter->nf[i];
01432                       iter->nf[i]=0;
01433                     }
01434                   else
01435                     {
01436                       projpol+=tmpmon*iter->nf[i];
01437                       iter->nf[i]=0;
01438                     };
01439                 }
01440             }
01441         }
01442       if(iter->ind.GetDegree()>0)
01443         tmpex[sizeexceed++]=iter->ind;
01444       exceed.push_back(tmpex);
01445       tobeproj.push_back(projpol);
01446       //cout<<"tobeproj avant push back "<<endl<<projpol<<endl;
01447       //cout<<"sizeexced pushbacke "<<sizeexceed<<endl;
01448       sizeex.push_back(sizeexceed);
01449     }
01450   //bon on a isole les monomes a projeter 
01451   proj(tobeproj,dump,b);
01452   {
01453     typename typPk::iterator iter=workvect.begin();
01454     typename typexceed::iterator iterex=exceed.begin(); 
01455     typename typsize::iterator itersize=sizeex.begin();
01456     for(typename typP::iterator iterproj=tobeproj.begin();
01457         iterproj!=tobeproj.end();iterproj++,iter++,iterex++,itersize++)
01458       {
01459         //      cout<<"*itersize "<<(*itersize)<<" et tmpMk.size() "<<tmpMk.size()<<endl;       
01460         int maxend=iter->size-1;
01461         for(typename polyalp::iterator iterpol=iterproj->begin();
01462             iterpol!=iterproj->end();iterpol++)
01463           {
01464             if(IsinB(*iterpol,b)&&maxend<mon2int(*iterpol))
01465               maxend=mon2int(*iterpol);
01466           }
01467             iter->nf=(coeff*)MAC_REV_REALLOC<coeff>(iter->nf
01468                                                     ,iter->size*sizeof(coeff)
01469                                                     ,(maxend+1)*sizeof(coeff));
01470             for(int i=iter->size;i<=maxend;i++)
01471               iter->nf[i]=0;
01472             for(typename polyalp::iterator iterpol=iterproj->begin();
01473                   iterpol!=iterproj->end();iterpol++)
01474               {
01475                 if(IsinB(*iterpol,b))
01476                   {
01477                     iter->nf[mon2int(*iterpol)]+=iterpol->GetCoeff();
01478                   }
01479                 else
01480                   {
01481                     int i=0;
01482                     
01483                     for(;(i<(*itersize))&&((*iterex)[i].rep!=iterpol->rep);i++);
01484                     if(i<(*itersize))
01485                       {
01486                         (*iterex)[i]+=*iterpol;
01487                       }
01488                     else 
01489                       {
01490                         (*iterex)[(*itersize)++]=*iterpol;
01491                         //      cout<<"rajoute "<<*iterpol<<" a la pos "<<*itersize<<endl;
01492                       }
01493                   }
01494               }
01495             *iterex=(typex)MAC_REV_REALLOC<mon>(*iterex,tmpMk.size()*sizeof(mon)
01496                                                 ,(*itersize)*sizeof(mon));
01497         iter->size=maxend+1;
01498         //cout<<"relecture  itersize "<<*itersize<<endl;
01499       }
01500     
01501   }
01502 }

void ReduceSpol ( typPk &  S,
const typdump &  dump,
typPk &  redspol,
const Base &  b 
) [inline]

Definition at line 2217 of file corealgo.cc.

References halfred(), my_plus(), and varmult().

Referenced by algo().

02218 {
02219   typedef typename typPk::value_type pol;
02220   typedef typename pol::monom_t mon;
02221   typedef typename pol::coeff_t coeff;
02222   list<mon> leadmon;
02223   list<typPk> membermon;
02224   
02225    cout<<"en entree de RedSpol S.size "<<S.size()/2<<endl;
02226   for(typename typPk::iterator iterS=S.begin();iterS!=S.end();iterS++,iterS++)
02227     {
02228       typename typPk::iterator iterS2=iterS;
02229       typename list<mon>::iterator itermon=leadmon.begin();
02230       typename list<typPk>::iterator itermemb=membermon.begin();
02231       mon var1,var2,tmpleadmon;
02232       iterS2++;
02233       varmult(iterS,iterS2,var1,var2,b);
02234       tmpleadmon=iterS->ind*var1;
02235       for(;itermon!=leadmon.end()&&itermon->rep!=tmpleadmon.rep;
02236           itermon++,itermemb++);
02237       if(itermon!=leadmon.end())
02238         {
02239           int yes1=1,yes2=1;
02240           for(typename typPk::iterator tmpiter=itermemb->begin();
02241               tmpiter!=itermemb->end();tmpiter++)
02242             {
02243               if(tmpiter->ind.rep==iterS->ind.rep) yes1=0;
02244               if(tmpiter->ind.rep==iterS2->ind.rep) yes2=0;
02245             }
02246           if(yes1) itermemb->push_back(*iterS);
02247           if(yes2) itermemb->push_back(*iterS2);
02248         }
02249       else
02250         {
02251           typPk verytmp;
02252           leadmon.push_back(tmpleadmon);
02253           membermon.push_back(verytmp);
02254           membermon.back().push_back(*iterS); 
02255           membermon.back().push_back(*iterS2);
02256         }
02257     }
02258   //maintenant on a mis en place la structure de Redspol
02259   //reste plus qu'a calculer les bons et a reduire tout ca!!
02260   { 
02261     typename list<mon>::iterator itermon=leadmon.begin();
02262     typename list<typPk>::iterator itermemb=membermon.begin();
02263     for(;itermon!=leadmon.end();itermon++,itermemb++)
02264       {
02265         typename typPk::value_type ref;
02266         typename typPk::iterator tmpiter=itermemb->begin();
02267         ref=halfred(*itermon,*tmpiter,dump,b);
02268         //      cout<<"ref.size "<<ref.size<<endl;
02269         //cout<<"ref en entier"<<endl<<invconv<Poly>(ref)<<endl;
02270         tmpiter++;
02271         for(;tmpiter!=itermemb->end();tmpiter++)
02272           {
02273             typename typPk::value_type redcur;
02274             redcur=halfred(*itermon,*tmpiter,dump,b);
02275             my_plus(redcur,ref);
02276             if(!Ispolzero(redcur))
02277               {
02278                 // cout<<"un redspol pas 0"<<endl<<invconv<Poly>(redcur)<<endl;
02279 //              for(int i=0;i<redcur.size;i++)
02280 //                cout<<int2mon_[i]<<" ";
02281 //              cout<<endl;
02282                 redspol.push_back(redcur);
02283               }
02284             else
02285               {
02286                 MAC_REV_FREE<coeff>(redcur.nf,redcur.size*sizeof(coeff));
02287               }
02288           }
02289         MAC_REV_FREE<coeff>(ref.nf,ref.size*sizeof(coeff));
02290       }
02291   }
02292 }

void Setnbvars ( const typP &  tmpPk,
Base &  b 
) [inline]

Definition at line 204 of file corealgo.cc.

References Base< predicat >::nbvars.

Referenced by init_algo().

00205 {
00206   int tmpvar=0;
00207   for(typename typP::const_iterator iter=tmpPk.begin();iter!=tmpPk.end();iter++)
00208     for(typename typP::value_type::const_iterator iterpol=iter->begin();
00209         iterpol!=iter->end();iterpol++)
00210       if(tmpvar<lvar(iterpol->rep)) tmpvar=lvar(iterpol->rep);
00211   b.nbvars=tmpvar+1;
00212 }

typPk Spolordsup ( typPk  Pk,
const Base &  b 
) [inline]

Definition at line 147 of file corealgo.cc.

References compute_ppcm(), and goodspol().

Referenced by algo().

00153 {
00154   typedef typename typPk::value_type::monom_t mon;
00155   //typedef typename typ::order_t O;
00156 #ifdef experiment
00157   typename typPk::value_type tmp;
00158 #endif
00159   map<mon,int> ppcm;
00160   typPk res;
00161   int maxdeg;
00162   //cout<<"compute ppcm"<<endl;
00163   maxdeg=compute_ppcm(ppcm,b);
00164   //cout<<"test goodspol"<<endl;
00165   for(typename typPk::iterator iter1=Pk.begin();iter1!=Pk.end();iter1++)
00166     for(typename typPk::iterator iter2=iter1;iter2!=Pk.end();iter2++)
00167 #ifndef NO_TWICE      
00168       if (goodspol(iter1->ind,iter2->ind,ppcm,b))
00169 #else
00170         if (goodspol(iter1->ind,iter2->ind,ppcm,b,Spoldejavu))
00171 #endif
00172         {
00173           //cout<<"goospol "<<iter1->ind<<" "<<iter2->ind<<endl;
00174           res.push_back(*iter1);
00175           res.push_back(*iter2);
00176         }
00177 #ifdef experiment
00178   tmp.ind.SetCoeff(maxdeg);
00179   res.push_back(tmp);
00180 #endif
00181   return res;
00182 }

void stab ( typPk &  Pk  )  [inline]

Definition at line 18 of file corealgo.cc.

References Iszero().

Referenced by init_algo().

00019 {
00020   typedef typename typPk::value_type pol;
00021   for(typename typPk::iterator iter=Pk.begin();iter!=Pk.end();iter++)
00022     {
00023       pol tmpres=mon(0);
00024       for(typename pol::iterator iterpol=iter->begin();iterpol!=iter->end();
00025           iterpol++)
00026         {
00027           if(!Iszero(iterpol->GetCoeff()))
00028             tmpres+=*iterpol;
00029         }
00030       *iter=tmpres;
00031     }
00032 }

void varmult ( iterator  iter1,
iterator  iter2,
mon &  var1,
mon &  var2,
const Base &  b 
) [inline]

Definition at line 2064 of file corealgo.cc.

References Base< predicat >::nbvar().

Referenced by OLD_ReduceSpol(), and ReduceSpol().

02065 {
02066   for(int i=0;i<b.nbvar();i++)
02067     {
02068       if(iter1->ind.GetDegree(i)>iter2->ind.GetDegree(i))
02069         var2=mon(i,1);
02070       if(iter2->ind.GetDegree(i)>iter1->ind.GetDegree(i))
02071         var1=mon(i,1);
02072     }
02073 }

Generated on 6 Dec 2012 for borderbasix by  doxygen 1.6.1