borderbasix: include/borderbasix/choice.cc Source File

00001 #ifndef ALREADY_choice
00002 #define ALREADY_choice
00003 template<typename pol,typename Base, typename monomial_server>
00004 typename pol::monom_t choice_old(const pol & p,const Base &b, 
00005                                  monomial_server &serv)
00006 {
00007   typename pol::const_iterator iter,stockpos=p.end();
00008   typename pol::coeff_t max=0;
00009   static int tmp=0;
00010   if (tmp<2) {return typename pol::monom_t(tmp++,2);};
00011   for(iter=p.begin();iter!=p.end();iter++)
00012     if(iter->GetDegree()==Degree(p))
00013       {
00014         if(iter->GetCoeff()*iter->GetCoeff()>max) {
00015           max=iter->GetCoeff()*iter->GetCoeff();
00016           cout<<"newmax "<<max<<endl;
00017           cout<<" les monomes "<<*iter<<endl;
00018           stockpos=iter;
00019         }
00020       }
00021   //break;
00022   //return *iter;
00023   return *stockpos;
00024 }
00025 
00026 template<typename pol,typename Base, typename monomial_server>
00027 typename pol::monom_t choice_naif(const pol & p,const Base &b,
00028                                   monomial_server &serv)
00029 {
00030   typename pol::const_iterator iter,stockpos=p.end();
00031   typename pol::coeff_t max(0);
00032   for(iter=p.begin();iter!=p.end();iter++)
00033     if(iter->GetDegree()==Degree(p))
00034       {
00035         stockpos=iter;
00036         break;
00037       }
00038   //break;
00039   //return *iter;
00040   return *stockpos;
00041 }
00042 
00043 template<typename pol,typename Base, typename monomial_server>
00044 typename pol::monom_t choice_num(const pol & p,const Base &b,
00045                                  monomial_server &serv)
00046 {
00047   typename pol::const_iterator iter,stockpos=p.end();
00048   typename pol::coeff_t max(0);
00049   for(iter=p.begin();iter!=p.end();iter++)
00050     if(iter->GetDegree()==Degree(p))
00051       {
00052         if(iter->GetCoeff()*iter->GetCoeff()>max) {
00053           max=iter->GetCoeff()*iter->GetCoeff();
00054           //cout<<"newmax "<<max<<endl;
00055           //cout<<" les monomes "<<*iter<<endl;
00056           stockpos=iter;
00057         }
00058       }
00059   //break;
00060   //return *iter;
00061   return *stockpos;
00062 }
00063 
00064 
00065 template<typename pol,typename Base, typename monomial_server>
00066 typename pol::monom_t choice_grevlex(const pol & p,const Base &b,
00067                                      monomial_server &serv)
00068 {
00069   typename pol::const_iterator iter;//
00070    list<typename pol::monom_t> tmp;
00071   typename pol::monom_t m; 
00072   int degp=Degree(p);
00073   cout<<"p"<<p;
00074   for(iter=p.begin();iter!=p.end();iter++)
00075    if(iter->GetDegree()==degp)
00076       {
00077         tmp.push_back(*iter);
00078       }
00079   m=tmp.front();
00080   for(typename list<typename pol::monom_t>::iterator itertmp=tmp.begin();itertmp!=tmp.end();itertmp++)
00081     {
00082       if(my_ord(*itertmp,m)<0) {m=*itertmp;};
00083     }
00084   cout<<"monom choisi "<<m<<endl;
00085   return m;
00086 }
00087 
00088 
00089 
00090 template<typename pol,typename Base, typename monomial_server>
00091 typename pol::monom_t choice_dlex(const pol & p,const Base &b,
00092                                   monomial_server &serv)
00093 {
00094   typename pol::const_iterator iter;//
00095    list<typename pol::monom_t> tmp;
00096   typename pol::monom_t m; 
00097   int degp=Degree(p);
00098   for(iter=p.begin();iter!=p.end();iter++)
00099     if(iter->GetDegree()==degp)
00100       {
00101         tmp.push_back(*iter);
00102       }
00103   m=tmp.front();
00104   for(typename list<typename pol::monom_t>::iterator itertmp=tmp.begin();itertmp!=tmp.end();itertmp++)
00105     {
00106       if(my_ord(*itertmp,m)>0) {m=*itertmp;};
00107     }
00108   return m;
00109 }
00110 
00111 
00112 
00113 template<typename pol,typename Base, typename monomial_server>
00114 typename pol::monom_t choice_mac(const pol & p,const Base &b,
00115                                  monomial_server &serv)
00116 {
00117   typename pol::const_iterator iter;//
00118    list<typename pol::monom_t> tmp;
00119   typename pol::monom_t tmpmon; 
00120   int maxtmpdeg=0,degp=Degree(p);
00121   for(iter=p.begin();iter!=p.end();iter++)
00122     if(iter->GetDegree()==degp)
00123       {
00124         tmp.push_back(*iter);
00125       }
00126   for(typename list<typename pol::monom_t>::iterator itertmp=tmp.begin();
00127       itertmp!=tmp.end();itertmp++)
00128     {
00129       //cout<<"monomes regarde "<<*itertmp<<" Lavr  "<<lvar(itertmp->rep)<<endl;
00130       for(int i=0;i<=lvar(itertmp->rep);i++)
00131         {
00132           if(itertmp->GetDegree(i)>=maxtmpdeg)
00133             {
00134               maxtmpdeg=itertmp->GetDegree(i);
00135               tmpmon=*itertmp;
00136             }
00137         }
00138     }
00139   return tmpmon;
00140 }
00141 
00142 
00143 template<typename pol,typename Base, typename monomial_server>
00144 typename pol::monom_t choice_mix(const pol & p,const Base &b,
00145                                  monomial_server &serv)
00146 {
00147   static unsigned int compt=0;
00148   compt++;
00149   if((compt/3)%2) return choice_grevlex(p,b);
00150   return choice_mac(p,b);
00151 }
00152 
00153 #if 1
00154 template<typename pol,typename Base, typename monomial_server>
00155 typename pol::monom_t choice_mpq(const pol & p,const Base &b,
00156                                  monomial_server &serv)
00157 {
00158   typename pol::const_iterator iter,stockpos=p.begin();
00159   int mini=INT_MAX,degp=Degree(p);
00160   for(iter=p.begin();iter!=p.end();iter++)
00161     if(iter->GetDegree()==degp)
00162       {
00163         if(mpz_size(mpq_numref(&(iter->GetCoeff().rep())))+
00164            mpz_size(mpq_denref(&(iter->GetCoeff().rep())))<mini) {
00165           mini=mpz_size(mpq_numref(&(iter->GetCoeff().rep())))+
00166             mpz_size(mpq_denref(&(iter->GetCoeff().rep())));
00167           //cout<<"newmax "<<max<<endl;
00168           //cout<<" les monomes "<<*iter<<endl;
00169           stockpos=iter;
00170         }
00171       }
00172   //break;
00173   //return *iter;
00174   return *stockpos;
00175 }
00176 
00177 #endif
00178 
00179 
00180 
00181 #if 1
00182 template<typename pol,typename Base, typename monomial_server>
00183 typename pol::monom_t choice_fall(const pol & p,const Base &b,
00184                                   monomial_server &serv)
00185 {
00186   typedef typename pol::monom_t mon;
00187   typename pol::const_iterator iter,stockpos=p.begin();
00188   int maxi=-1;
00189   mon res=choice_mac(p,b,serv);
00190   return res;
00191   typename Base::const_iterator iterb;
00192   list<mon> tmplist;
00193   int degp=Degree(p);
00194   for(iter=p.begin();iter!=p.end();iter++)
00195     if(iter->GetDegree()==degp)
00196       tmplist.push_back(*iter);
00197   for(typename list<mon>::iterator iterlist=tmplist.begin()
00198         ;iterlist!=tmplist.end();iterlist++)
00199     {
00200       for(iterb=b.begin();iterb!=b.end();iterb++)
00201         {
00202           int isgood=0;
00203           for(int i=0;i<iterb->taille1;i++)
00204             if(isdivisible(iterb->accept[i],*iterlist,b))
00205               {isgood=1;break;}
00206           for(int i=0;i<iterb->taille2;i++)
00207             if(isdivisible(iterb->refuse[i],*iterlist,b))
00208               {isgood=0;break;}
00209           if(isgood)
00210             {
00211               for(int i=0;i<iterb->taille2;i++)
00212                 {
00213                   mon m=lcm(*iterlist,iterb->refuse[i]);
00214                   int dist=0;
00215                   for(int j=0;j<iterb->taille2;j++)
00216                     if ((j!=i) && (isdivisible(iterb->refuse[j],m,b)))
00217                       isgood=0;
00218                   if(isgood)
00219                     {
00220                       
00221                       for(int j=0;j<b.nbvar();j++)
00222                         if(m.GetDegree(j)>iterb->refuse[i].GetDegree(j))
00223                           dist+=m.GetDegree(j)-iterb->refuse[i].GetDegree(j);
00224                       if(dist>maxi)
00225                         {
00226                           res=*iterlist;
00227                           maxi=dist;
00228                         }
00229                     }
00230                 }
00231             }
00232           
00233         }
00234     }
00235   // cout<<"le pol "<<endl<<p<<endl<<"le mon, "<<res<<endl;
00236   return res;
00237 }
00238 
00239 #endif
00240 
00241 #ifdef DENSE
00242 template<typename pol,typename Base>
00243 typename pol::monom_t choice_old(const pol & p,const Base &b)
00244 {
00245   typename pol::const_iterator iter,stockpos=p.end();
00246   typename pol::coeff_t max=0;
00247   static int tmp=0;
00248   if (tmp<2) {return typename pol::monom_t(tmp++,2);};
00249   for(iter=p.begin();iter!=p.end();iter++)
00250     if(iter->GetDegree()==Degree(p))
00251       {
00252         if(iter->GetCoeff()*iter->GetCoeff()>max) {
00253           max=iter->GetCoeff()*iter->GetCoeff();
00254           cout<<"newmax "<<max<<endl;
00255           cout<<" les monomes "<<*iter<<endl;
00256           stockpos=iter;
00257         }
00258       }
00259   //break;
00260   //return *iter;
00261   return *stockpos;
00262 }
00263 
00264 template<typename pol,typename Base>
00265 typename pol::monom_t choice_naif(const pol & p,const Base &b)
00266 {
00267   typename pol::const_iterator iter,stockpos=p.end();
00268   typename pol::coeff_t max(0);
00269   for(iter=p.begin();iter!=p.end();iter++)
00270     if(iter->GetDegree()==Degree(p))
00271       {
00272         stockpos=iter;
00273         break;
00274       }
00275   //break;
00276   //return *iter;
00277   return *stockpos;
00278 }
00279 
00280 template<typename pol,typename Base>
00281 typename pol::monom_t choice_num(const pol & p,const Base &b)
00282                               
00283 {
00284   typename pol::const_iterator iter,stockpos=p.end();
00285   typename pol::coeff_t max(0);
00286   for(iter=p.begin();iter!=p.end();iter++)
00287     if(iter->GetDegree()==Degree(p))
00288       {
00289         if(iter->GetCoeff()*iter->GetCoeff()>max) {
00290           max=iter->GetCoeff()*iter->GetCoeff();
00291           //cout<<"newmax "<<max<<endl;
00292           //cout<<" les monomes "<<*iter<<endl;
00293           stockpos=iter;
00294         }
00295       }
00296   //break;
00297   //return *iter;
00298   return *stockpos;
00299 }
00300 
00301 
00302 template<typename pol,typename Base>
00303 typename pol::monom_t choice_grevlex(const pol & p,const Base &b)
00304 {
00305   typename pol::const_iterator iter;//
00306    list<typename pol::monom_t> tmp;
00307   typename pol::monom_t m; 
00308   int degp=Degree(p);
00309   for(iter=p.begin();iter!=p.end();iter++)
00310     if(iter->GetDegree()==degp)
00311       {
00312         tmp.push_back(*iter);
00313       }
00314   m=tmp.front();
00315   for(typename list<typename pol::monom_t>::iterator itertmp=tmp.begin();itertmp!=tmp.end();itertmp++)
00316     {
00317       if(my_ord(*itertmp,m)<0) {m=*itertmp;};
00318     }
00319   //cout<<"monom choisi "<<m<<endl;
00320   return m;
00321 }
00322 
00323 
00324 
00325 template<typename pol,typename Base>
00326 typename pol::monom_t choice_dlex(const pol & p,const Base &b)
00327 {
00328   typename pol::const_iterator iter;//
00329    list<typename pol::monom_t> tmp;
00330   typename pol::monom_t m; 
00331   int degp=Degree(p);
00332   for(iter=p.begin();iter!=p.end();iter++)
00333     if(iter->GetDegree()==degp)
00334       {
00335         tmp.push_back(*iter);
00336       }
00337   m=tmp.front();
00338   for(typename list<typename pol::monom_t>::iterator itertmp=tmp.begin();itertmp!=tmp.end();itertmp++)
00339     {
00340       if(my_ord(*itertmp,m)>0) {m=*itertmp;};
00341     }
00342   return m;
00343 }
00344 
00345 
00346 
00347 template<typename pol,typename Base>
00348 typename pol::monom_t choice_mac(const pol & p,const Base &b)
00349 {
00350   typename pol::const_iterator iter;//
00351    list<typename pol::monom_t> tmp;
00352   typename pol::monom_t tmpmon; 
00353   int maxtmpdeg=0,degp=Degree(p);
00354   for(iter=p.begin();iter!=p.end();iter++)
00355     if(iter->GetDegree()==degp)
00356       {
00357         tmp.push_back(*iter);
00358       }
00359   for(typename list<typename pol::monom_t>::iterator itertmp=tmp.begin();itertmp!=tmp.end();itertmp++)
00360     {
00361       //cout<<"monomes regarde "<<*itertmp<<" Lavr  "<<lvar(itertmp->rep)<<endl;
00362       for(int i=0;i<=lvar(itertmp->rep);i++)
00363         {
00364           if(itertmp->GetDegree(i)>=maxtmpdeg)
00365             {
00366               maxtmpdeg=itertmp->GetDegree(i);
00367               tmpmon=*itertmp;
00368             }
00369         }
00370     }
00371   return tmpmon;
00372 }
00373 
00374 
00375 template<typename pol,typename Base>
00376 typename pol::monom_t choice_mix(const pol & p,const Base &b)
00377 {
00378   static unsigned int compt=0;
00379   compt++;
00380   if((compt/3)%2) return choice_grevlex(p,b);
00381   return choice_mac(p,b);
00382 }
00383 
00384 #if 1
00385 template<typename pol,typename Base>
00386 typename pol::monom_t choice_mpq(const pol & p,const Base &b)
00387 {
00388   typename pol::const_iterator iter,stockpos=p.begin();
00389   int mini=INT_MAX,degp=Degree(p);
00390   for(iter=p.begin();iter!=p.end();iter++)
00391     if(iter->GetDegree()==degp)
00392       {
00393         if(mpz_size(mpq_numref(&(iter->GetCoeff().rep())))+
00394            mpz_size(mpq_denref(&(iter->GetCoeff().rep())))<mini) {
00395           mini=mpz_size(mpq_numref(&(iter->GetCoeff().rep())))+
00396             mpz_size(mpq_denref(&(iter->GetCoeff().rep())));
00397           //cout<<"newmax "<<max<<endl;
00398           //cout<<" les monomes "<<*iter<<endl;
00399           stockpos=iter;
00400         }
00401       }
00402   //break;
00403   //return *iter;
00404   return *stockpos;
00405 }
00406 
00407 #endif
00408 
00409 
00410 
00411 #if 1
00412 template<typename pol,typename Base>
00413 typename pol::monom_t choice_fall(const pol & p,const Base &b)
00414 {
00415   typedef typename pol::monom_t mon;
00416   typename pol::const_iterator iter,stockpos=p.begin();
00417   int maxi=-1;
00418   mon res=choice_mac(p,b);
00419   return res;
00420   typename Base::const_iterator iterb;
00421   list<mon> tmplist;
00422   int degp=Degree(p);
00423   for(iter=p.begin();iter!=p.end();iter++)
00424     if(iter->GetDegree()==degp)
00425       tmplist.push_back(*iter);
00426   for(typename list<mon>::iterator iterlist=tmplist.begin()
00427         ;iterlist!=tmplist.end();iterlist++)
00428     {
00429       for(iterb=b.begin();iterb!=b.end();iterb++)
00430         {
00431           int isgood=0;
00432           for(int i=0;i<iterb->taille1;i++)
00433             if(isdivisible(iterb->accept[i],*iterlist,b))
00434               {isgood=1;break;}
00435           for(int i=0;i<iterb->taille2;i++)
00436             if(isdivisible(iterb->refuse[i],*iterlist,b))
00437               {isgood=0;break;}
00438           if(isgood)
00439             {
00440               for(int i=0;i<iterb->taille2;i++)
00441                 {
00442                   mon m=lcm(*iterlist,iterb->refuse[i]);
00443                   int dist=0;
00444                   for(int j=0;j<iterb->taille2;j++)
00445                     if ((j!=i) && (isdivisible(iterb->refuse[j],m,b)))
00446                       isgood=0;
00447                   if(isgood)
00448                     {
00449                       
00450                       for(int j=0;j<b.nbvar();j++)
00451                         if(m.GetDegree(j)>iterb->refuse[i].GetDegree(j))
00452                           dist+=m.GetDegree(j)-iterb->refuse[i].GetDegree(j);
00453                       if(dist>maxi)
00454                         {
00455                           res=*iterlist;
00456                           maxi=dist;
00457                         }
00458                     }
00459                 }
00460             }
00461           
00462         }
00463     }
00464   // cout<<"le pol "<<endl<<p<<endl<<"le mon, "<<res<<endl;
00465   return res;
00466 }
00467 
00468 #endif
00469 
00470 #endif
00471 
00472 #endif //ALREADY_choice