Borderbasix

corealgo.hpp
Go to the documentation of this file.
1 template<typename typP,typename typPk,typename Base>
2 void Crochetchoix(const typP & P,typPk & Pk, typPk & redspol,int k,
3  Base &b);
4 
5 template<template<typename> class cont,typename mon, typename T>
6 cont<pol<mon,T> > Crochet(const cont<pol<mon,T> > &P, int k)
7 {
8  cont<pol<mon,T> > res;
9  for(typename cont<pol<mon,T> >::const_iterator iter=P.begin()
10  ;iter!=P.end();iter++)
11  {
12  if(Degree(*iter)==k) res.push_back(*iter);
13  }
14  return res;
15 }
16 
17 template<typename typPk>
18 void stab(typPk & Pk)
19 {
20  typedef typename typPk::value_type pol;
21  for(typename typPk::iterator iter=Pk.begin();iter!=Pk.end();iter++)
22  {
23  pol tmpres=mon(0);
24  for(typename pol::iterator iterpol=iter->begin();iterpol!=iter->end();
25  iterpol++)
26  {
27  if(!Iszero(iterpol->GetCoeff()))
28  tmpres+=*iterpol;
29  }
30  *iter=tmpres;
31  }
32 }
33 
34 template<typename T>
35 void my_merge(T &l1,const T &l2)
36 {
37  typename T::const_iterator iter=l2.begin();
38  for(;iter!=l2.end();iter++)
39  l1.push_back(*iter);
40 }
41 
42 template<typename mon>
43 mon lcm(const mon &m1,const mon &m2)
44 {
45  mon m(1);
46  int maxi=max(lvar(m1.rep),lvar(m2.rep));
47  for(int i=0;i<=maxi;i++)
48  m*=mon(i,max(m1.GetDegree(i),m2.GetDegree(i)));
49  return m;
50 }
51 
52 template<typename typppcm,typename Base>
53 int compute_ppcm(typppcm &ppcm,const Base & b)
54 {
55  typedef typename Base::mon mon;
56  //typppcm tmpppcm;
57  int maxdeg=-1;
58  list<mon> list1,list2;
59  for(typename Base::const_reverse_iterator iter=b.rbegin()
60  ;iter==b.rbegin();iter++)
61  {
62  for(int i=0;i<iter->taille2;i++)
63  for(int j=i+1;j<iter->taille2;j++)
64  {
65  mon tmpmon=lcm(iter->refuse[i],iter->refuse[j]);
66 #ifndef oldppcm
67  if((!ppcm.count(tmpmon))&&
68  (tmpmon.GetDegree()!=
69  (iter->refuse[i].GetDegree()+iter->refuse[j].GetDegree())))
70  ppcm[tmpmon]=1;
71  //cout<<"ppcm rajoute "<<tmpmon<<" "<<iter->refuse[i]<<" "<<iter->refuse[j]<<endl;
72 #else
73  if((tmpmon.GetDegree()!=
74  (iter->refuse[i].GetDegree()+iter->refuse[j].GetDegree())))
75  list1.push_back(tmpmon);
76 #endif
77  }
78  }
79 #ifdef oldppcm
80  for(typename list<mon>::iterator iter1=list1.begin();
81  iter1!=list1.end();iter1++)
82  list2.push_back(*iter1);
83  for(typename list<mon>::iterator iter1=list1.begin();
84  iter1!=list1.end();iter1++)
85  {
86  for(typename list<mon>::iterator iter2=list2.begin();
87  iter2!=list2.end();iter2++)
88  if(isdivisible(*iter1,*iter2,b))
89  list2.erase(iter2--);
90  }
91  maxdeg=0;
92 #ifdef DEB
93  cout<<"liste2.size "<<list2.size()<<endl;
94 #endif
95  for(typename list<mon>::iterator iter2=list2.begin();
96  iter2!=list2.end();iter2++)
97  {
98  cout<<"je passe ici "<<*iter2<<endl;
99  ppcm[*iter2]=1;
100  if(iter2->GetDegree()>maxdeg)
101  maxdeg=iter2->GetDegree();
102  }
103 #endif
104  return maxdeg;
105 }
106 
107 template<typename mon,typename Base,typename typppcm>
108 int goodspol(const mon &m1,const mon &m2, typppcm & ppcm,const Base &b
109 #ifdef NO_TWICE
110  ,const typMk &Spoldejavu)
111 #else
112  )
113 #endif
114 {
115  //list<mon> ppcm;
116  int res=0,comp=0;//,nobplus=1;
117  mon m=m1;
118  for(int i=0;i<b.nbvar();i++)
119  if(m1.GetDegree(i)!=m2.GetDegree(i))
120  {
121  comp++;
122  if (m1.GetDegree(i)-m2.GetDegree(i)==1)
123  res+=1;
124  if (m1.GetDegree(i)-m2.GetDegree(i)==-1)
125  {
126  res+=1;
127  m*=mon(i,1);
128  }
129  };
130  //compute_ppcm(ppcm,b);
131  //if((res==2)&&(comp==2))
132  // for(int i=0;i<b.nbvar();i++)
133  // if(m.GetDegree(i)>0)
134  // nobplus=nobplus && !IsinB(my_divmon(m,i,b),b);
135  //cout<<"m1 "<<m1<<" m2 "<<m2<<" resultat "<<((res==2)&&(comp==2))<<endl;
136  //return ((res==2)&&(comp==2)&&nobplus);
137  //cout<<m1<<" < "<<m2<<" res "<<(member(ppcm,m)&&(res==2)&&(comp==2))<<endl;
138  #ifdef NO_TWICE
139  return (res==2)&&(comp==2)&&ppcm[m]&&!member(Spoldejavu,m);
140  #else
141  return (res==2)&&(comp==2)&&ppcm[m];
142  #endif
143 //return (res==2)&&(comp==2)&&ppcm.count(m);//&&!member(Spoldejavu,m);
144 }
145 
146 template<typename typPk,typename Base>
147 typPk Spolordsup(typPk Pk,const Base & b
148 #ifndef NO_TWICE
149 )
150 #else
151 ,const typMk & Spoldejavu)
152 #endif
153 {
154  typedef typename typPk::value_type::monom_t mon;
155  //typedef typename typ::order_t O;
156 #ifdef experiment
157  typename typPk::value_type tmp;
158 #endif
159  map<mon,int> ppcm;
160  typPk res;
161  int maxdeg;
162  //cout<<"compute ppcm"<<endl;
163  maxdeg=compute_ppcm(ppcm,b);
164  //cout<<"test goodspol"<<endl;
165  for(typename typPk::iterator iter1=Pk.begin();iter1!=Pk.end();iter1++)
166  for(typename typPk::iterator iter2=iter1;iter2!=Pk.end();iter2++)
167 #ifndef NO_TWICE
168  if (goodspol(iter1->ind,iter2->ind,ppcm,b))
169 #else
170  if (goodspol(iter1->ind,iter2->ind,ppcm,b,Spoldejavu))
171 #endif
172  {
173  //cout<<"goospol "<<iter1->ind<<" "<<iter2->ind<<endl;
174  res.push_back(*iter1);
175  res.push_back(*iter2);
176  }
177 #ifdef experiment
178  tmp.ind.SetCoeff(maxdeg);
179  res.push_back(tmp);
180 #endif
181  return res;
182 }
183 template<typename typP>
184 int minmaxdegP(typP P,int &maxdeg)
185 {
186  int res=Degree(P.front());
187  maxdeg=res;
188  for(typename typP::iterator iter=P.begin();iter!=P.end();iter++)
189  {
190  res=(res>Degree(*iter))?Degree(*iter):res;
191  maxdeg=(maxdeg<Degree(*iter))?Degree(*iter):maxdeg;
192  }
193  return res;
194 }
195 template<typename typP>
196 typP Crochet(const typP &P, int k)
197 {
198  typP res;
199  for(typename typP::const_iterator iter=P.begin();iter!=P.end();iter++)
200  if(Degree(*iter)==k) res.push_back(*iter);
201  return res;
202 }
203 template<typename typP, typename Base>
204 void Setnbvars(const typP &tmpPk,Base& b)
205 {
206  int tmpvar=0;
207  for(typename typP::const_iterator iter=tmpPk.begin();iter!=tmpPk.end();iter++)
208  for(typename typP::value_type::const_iterator iterpol=iter->begin();
209  iterpol!=iter->end();iterpol++)
210  if(tmpvar<lvar(iterpol->rep)) tmpvar=lvar(iterpol->rep);
211  b.nbvars=tmpvar+1;
212 }
213 
214 template<typename typP, typename typMk, typename Base>
215 void DoBaseMk(const typP &tmpPk, typMk &Mk, Base &b)
216 {
217  typedef typename typMk::value_type mon;
218  typename Base::predicat_t tmp;
219  int i=0;
220  //int tmpvar=0;
221 
222  for(typename typP::const_iterator iter=tmpPk.begin();iter!=tmpPk.end();iter++)
223  {
224  mon tmp(choice(*iter,b));
225  int yes=1;
226  // cout<<"pol dans DoBaseMk "<<endl<<*iter<<endl<<"g choisi "<<tmp<<endl;
227  tmp.SetCoeff(1);//*=mon(1/tmp.GetCoeff());
228  for(typename typMk::iterator iter=Mk.begin();iter!=Mk.end();iter++)
229  if(*iter==tmp) {yes=0;break;};
230  if(yes) Mk.push_back(tmp);
231  }
232  //cout<<"Mk.size()"<<Mk.size()<<endl;
233  tmp.taille2=Mk.size();
234  tmp.refuse=(mon*)MAC_REV_MALLOC<mon>(tmp.taille2*sizeof(mon));
235  tmp.taille1=1;
236  tmp.accept=(mon*)MAC_REV_MALLOC<mon>(sizeof(mon));
237  tmp.accept[0]=mon(1);
238  i=0;//pour en etre bien sur
239  for(typename typMk::iterator iter=Mk.begin();iter!=Mk.end();iter++,i++)
240  {
241  tmp.refuse[i]=*iter;
242  };
243  if(!b.def.empty())
244  {
245  typename Base::predicat_t verytmp;
246  for(typename Base::iterator iter=b.begin();iter!=b.end();iter++)
247  {
248  verytmp=*iter;
249  MAC_REV_FREE<mon>(verytmp.refuse,verytmp.taille2*sizeof(mon));
250  MAC_REV_FREE<mon>(verytmp.accept,verytmp.taille1*sizeof(mon));
251  }
252  b.erase(b.begin(),b.end());
253  }
254  b.def.push_back(tmp);
255  return;
256 }
257 
258 template <typename typPk,typename typMk,typename typmat >
259 typmat*
260 MatrixOf(const typPk & L,
261  const typMk & lm,const typmat &mat)
262 {
263  typedef typename typPk::value_type POL;
264  typedef typename typMk::value_type monom_t;
265  typmat *res=NULL;
266  map<monom_t,int> index;
267  int l=1;
268  if (res!=NULL) {delete res;};
269  for(typename typMk::const_iterator m = lm.begin(); m!=lm.end(); m++){
270  index[*m]=l;
271  l++;
272  }
273  int c;
274  res=new typmat(L.size(),lm.size());
275  l=0;
276  // cout<<"L.size() "<<L.size()<<" lm.size() "<<lm.size()<<endl;
277  for(typename typPk::const_iterator pi = L.begin(); pi != L.end(); ++pi){
278  for(typename POL::const_iterator m = pi->begin(); m!=pi->end(); m++)
279  {
280 
281  if((index.count(*m)))
282  {
283  c=index[*m];
284  (*res)(l,c-1,m->GetCoeff());
285  }
286  }
287  l++;
288  }
289  return res;
290 }
291 
292 template<typename typMat,typename typP,typename typPk,typename typMk, typename Base,typename typdump>
293 void init_algo(typP &P,int &nouveaumon, int &maxdeg, int & k
294  ,typPk &Pk, typMk & Mk, Base & b, typdump & dump)
295 {
296  typedef typename typPk::value_type pol;
297  typedef typename pol::coeff_t coeff;
298  typedef typename pol::monom_t mon;
299  const typename typP::value_type::order_t (tmpord)(const mon,const mon);
300  typP tmpPk=P;
301  pol debugpol;
302  typMat *Mat;
303  int *pr,*pc,flag=1;
304  setorder(my_ord);
305  nouveaumon=1;
306  Setnbvars(P,b);
307 #ifdef unimul
308  init_multiple(b.nbvars);
309 #endif
310 #ifdef uninf
311  init_nf<pol>(b.nbvars);
312 #endif
313  while(flag)
314  {
315  Mk.erase(Mk.begin(),Mk.end());
316  //cout<<"mindeg"<<endl;
317  k=minmaxdegP(tmpPk,maxdeg);
318  //cout<<"Crochet"<<endl;
319  //tmpPk.push_back(Crochet(P,k).front());
320  tmpPk=Crochet(tmpPk,k);
321 #ifdef DEB
322  for(typename typP::iterator iter=tmpPk.begin();iter!=tmpPk.end();iter++)
323  cout<<"pol pendant init"<<endl<<*iter<<endl;
324 #endif
325  DoBaseMk(tmpPk,Mk,b);
327  // for(typename typMk::iterator iter=Mk.begin();iter!=Mk.end();iter++)
328  // cout<<*iter<<endl;
329  //cout<<"Matrixof"<<endl;
330  Mat=MatrixOf(tmpPk,Mk,typMat());
331  //affdebug(*Mat);
332  //cout<<"solve"<<endl;
333  tmpPk=Solve(*Mat,tmpPk,&pr,&pc);
334  selectnozero(tmpPk);
335  //affdebug(*Mat);
336  stab(tmpPk);
337  //for(typename typP::iterator iter=tmpPk.begin();iter!=tmpPk.end();iter++)
338  // cout<<"pol pendant init"<<endl<<*iter<<endl;
339  // cout<<"deletemat"<<endl;
340  if(my_rank(*Mat)==(int)tmpPk.size()) flag=0;
341  Mat->destroystore();
342  delete(Mat);
343  free(pr);
344  free(pc);
345  }
346  //cout<<"Pk,apres solve"<<endl<<tmpPk.front()<<endl;
347  // cout<<"convertion"<<endl;
348  // for(typename typP::value_type::iterator iter=tmpPk.front().begin();
349  // iter!=tmpPk.front().end();iter++)
350  // cout<<"*iter "<<*iter<<" IsinB "<<IsinB(*iter,b)<<endl;
351  //for(typename typP::iterator iter=tmpPk.begin();iter!=tmpPk.end();iter++)
352  //cout<<"pol apres les solve "<<endl<<*iter<<endl;
353  for(typename typP::iterator iter=tmpPk.begin();iter!=tmpPk.end();iter++)
354  {
355  Pk.push_back(convert<pol>(*iter,b));
356  //cout<<"le pol apres invconv"<<endl
357  // <<invconv<typename typP::value_type>(*Pk.rbegin())<<endl;
358  // cout<<"le pol original "<<endl<<*iter<<endl;
359  }
360  // for(typename typPk::iterator iter=Pk.begin();iter!=Pk.end();iter++)
361  // cout<<"pol apres les solve "<<endl<<iter->ind<<endl;
362  debugpol=Pk.front();
363  //for(typename typPk::iterator iter=Pk.begin();iter!=Pk.end();iter++)
364  // cout<<"apres convertion "<<endl<<
365  // invconv<typename typP::value_type>(*iter)<<endl;
366  //cout<<"size "<<debugpol.size<<endl;
367  //cout<<"Dump "<<Pk.front().ind.GetCoeff()<<endl;
368  Dump(Pk,dump);
369  //cout<<"apres Dump "<<invconv<typename typP::value_type>(Pk.front())<<endl;
370  //cout<<"je sort d'init_algo "<<endl;
371  //cout<<"k vaut "<<k<<endl;
372  // cout<<" Pk.size() "<<Pk.size()<<endl;
373  return ;
374 }
375 
376 template<typename pol,typename coeff>
377 void inline my_plus2(pol &res1, pol & res2,const pol& nf,
378  const coeff &toto1,const coeff &toto2 )
379 {
380  typedef typename pol::monom_t mon;
381  unsigned int i=0,stock;;
382  unsigned int ttmp;
383  unsigned int tmp;
384  register coeff *res1nf,*res2nf,*nfnf,*tmpcoeff;
385  tmp=nf.size;
386  if(res1.size<tmp)
387  {
388  res1.nf=(coeff*)MAC_REV_REALLOC<coeff>(res1.nf,res1.size*sizeof(coeff)
389  ,tmp*sizeof(coeff));
390  for(i=res1.size;i<tmp;i++)
391  res1.nf[i]=0;
392  res1.size=tmp;
393  }
394  if(res2.size<tmp)
395  {
396  res2.nf=(coeff*)MAC_REV_REALLOC<coeff>(res2.nf,res2.size*sizeof(coeff)
397  ,tmp*sizeof(coeff));
398  for(i=res2.size;i<tmp;i++)
399  res2.nf[i]=0;
400  res2.size=tmp;
401  }
402  tmp=nf.size;
403  ttmp=(tmp/8)*8;
404  tmp=tmp & 7;//15;//16 pourquoi... PARCE QUE!!!!! :-))
405  res1nf=res1.nf;
406  res2nf=res2.nf;
407  nfnf=nf.nf;
408  for(i=0;i<ttmp;i+=8)
409  {
410  //1
411  tmpcoeff=nfnf+i;
412  res1nf[i]-=*tmpcoeff*toto1;
413  res2nf[i]-=*tmpcoeff*toto2;
414  //2
415  tmpcoeff=nfnf+i+1;
416  res1nf[i+1]-=*tmpcoeff*toto1;
417  res2nf[i+1]-=*tmpcoeff*toto2;
418  //3
419  tmpcoeff=nfnf+i+2;
420  res1nf[i+2]-=*tmpcoeff*toto1;
421  res2nf[i+2]-=*tmpcoeff*toto2;
422  //4
423  tmpcoeff=nfnf+i+3;
424  res1nf[i+3]-=*tmpcoeff*toto1;
425  res2nf[i+3]-=*tmpcoeff*toto2;
426  //5
427  tmpcoeff=nfnf+i+4;
428  res1nf[i+4]-=*tmpcoeff*toto1;
429  res2nf[i+4]-=*tmpcoeff*toto2;
430  //6
431  tmpcoeff=nfnf+i+5;
432  res1nf[i+5]-=*tmpcoeff*toto1;
433  res2nf[i+5]-=*tmpcoeff*toto2;
434  //7
435  tmpcoeff=nfnf+i+6;
436  res1nf[i+6]-=*tmpcoeff*toto1;
437  res2nf[i+6]-=*tmpcoeff*toto2;
438  //8
439  tmpcoeff=nfnf+i+7;
440  res1nf[i+7]-=*tmpcoeff*toto1;
441  res2nf[i+7]-=*tmpcoeff*toto2;
442 #if 0
443  //9
444  tmpcoeff=nfnf+i+8;
445  res1nf[i+8]-=*tmpcoeff*toto1;
446  res2nf[i+8]-=*tmpcoeff*toto2;
447  //10
448  tmpcoeff=nfnf+i+9;
449  res1nf[i+9]-=*tmpcoeff*toto1;
450  res2nf[i+9]-=*tmpcoeff*toto2;
451 
452  //11
453  tmpcoeff=nfnf+i+10;
454  res1nf[i+10]-=*tmpcoeff*toto1;
455  res2nf[i+10]-=*tmpcoeff*toto2;
456 
457  //12
458  tmpcoeff=nfnf+i+11;
459  res1nf[i+11]-=*tmpcoeff*toto1;
460  res2nf[i+11]-=*tmpcoeff*toto2;
461 
462  //13
463  tmpcoeff=nfnf+i+12;
464  res1nf[i+12]-=*tmpcoeff*toto1;
465  res2nf[i+12]-=*tmpcoeff*toto2;
466 
467  //14
468  tmpcoeff=nfnf+i+13;
469  res1nf[i+13]-=*tmpcoeff*toto1;
470  res2nf[i+13]-=*tmpcoeff*toto2;
471 
472  //15
473  tmpcoeff=nfnf+i+14;
474  res1nf[i+14]-=*tmpcoeff*toto1;
475  res2nf[i+14]-=*tmpcoeff*toto2;
476 
477  //16
478  tmpcoeff=nfnf+i+15;
479  res1nf[i+15]-=*tmpcoeff*toto1;
480  res2nf[i+15]-=*tmpcoeff*toto2;
481 
482 #endif
483  }
484  for(register unsigned int j=i;j<nf.size;j++)
485  {
486  res1nf[j]-=nfnf[j]*toto1;
487  res2nf[j]-=nfnf[j]*toto2;
488  }
489 }
490 
491 template<typename pol,typename coeff>
492 void inline my_plustmp(pol &res,const pol & nf,const coeff toto)
493 {
494  typedef typename pol::monom_t mon;
495  unsigned int i=0,stock;;
496  unsigned int ttmp;//=taillequotient/16;
497  unsigned int tmp;//=taillequotient % 16;
498  // cout<<"nf.size "<<nf.size<<endl;
499  //cout<<"nf.ind "<<nf.ind<<endl;
500  //cout<<"nf.nf "<<nf.nf<<endl;
501  //cout<<"res.nf "<<res.nf<<endl;
502  //cout<<"res.size "<<res.size<<endl;
503  register coeff *resnf,*nfnf;
504  if (toto==0) return;
505  if(res.size<nf.size)
506  {
507  // cout<<"je realloue res.nf avant "<<res.nf<<endl;
508  res.nf=(coeff*)MAC_REV_REALLOC<coeff>(res.nf,res.size*sizeof(coeff)
509  ,nf.size*sizeof(coeff));
510  //cout<<"res.nf apres "<<res.nf<<endl;
511  for(i=res.size;i<nf.size;i++)
512  res.nf[i]=0;
513  res.size=nf.size;
514  }
515  ttmp=nf.size/16;
516  tmp=nf.size & 15;//16 pourquoi... PARCE QUE!!!!! :-))
517  resnf=res.nf;
518  nfnf=nf.nf;
519  for(i=0;i<ttmp;++i)
520  {
521  *resnf++-=*nfnf++*toto;
522  *resnf++-=*nfnf++*toto;
523  *resnf++-=*nfnf++*toto;
524  *resnf++-=*nfnf++*toto;
525  *resnf++-=*nfnf++*toto;
526  *resnf++-=*nfnf++*toto;
527  *resnf++-=*nfnf++*toto;
528  *resnf++-=*nfnf++*toto;
529  *resnf++-=*nfnf++*toto;
530  *resnf++-=*nfnf++*toto;
531  *resnf++-=*nfnf++*toto;
532  *resnf++-=*nfnf++*toto;
533  *resnf++-=*nfnf++*toto;
534  *resnf++-=*nfnf++*toto;
535  *resnf++-=*nfnf++*toto;
536  *resnf++-=*nfnf++*toto;
537  }
538  for(register unsigned j=0;j<tmp;j++)
539  *resnf++-=*nfnf++*toto;
540 }
541 //#define DEB
542 template<typename pol,typename coeff>
543 void inline my_plus(pol &res,const pol & nf,const coeff toto)
544 {
545 #ifdef DEB
546  cout<<"dans myplus je calcul"<<endl<<invconv<Poly>(res)<<endl<<
547  "toto "<<toto<<endl<<"nf"<<endl<<invconv<Poly>(nf)<<endl;
548 #endif
549  typedef typename pol::monom_t mon;
550  register unsigned int i=0;
551  register unsigned int ttmp,tmp;//=taillequotient/16;
552  register coeff *nfnf=nf.nf,*resnf;
553  coeff *ptr1,*ptr2;
554  //register unsigned int tmp;//=taillequotient % 16;
555  tmp=nf.size;
556  if(res.size<tmp)
557  {
558  res.nf=(coeff*)MAC_REV_REALLOC<coeff>(res.nf,res.size*sizeof(coeff)
559  ,tmp*sizeof(coeff));
560  for(int i=res.size;i<tmp;i++)
561  res.nf[i]=0;
562  res.size=tmp;
563  }
564  resnf=res.nf;
565  ttmp=(tmp/16)*16;
566  ptr1=resnf;
567  ptr2=nfnf;
568  //resnf=res.nf;
569  //tmp=nf.size & 15;//16 pourquoi... PARCE QUE!!!!! :-))
570  for(;i<ttmp;i+=16,resnf+=16,nfnf+=16)
571  {
572  {
573  resnf[0]-=nfnf[0]*toto;
574  resnf[1]-=nfnf[1]*toto;
575  resnf[2]-=nfnf[2]*toto;
576  resnf[3]-=nfnf[3]*toto;
577  resnf[4]-=nfnf[4]*toto;
578  resnf[5]-=nfnf[5]*toto;
579  resnf[6]-=nfnf[6]*toto;
580  resnf[7]-=nfnf[7]*toto;
581  resnf[8]-=nfnf[8]*toto;
582  resnf[9]-=nfnf[9]*toto;
583  resnf[10]-=nfnf[10]*toto;
584  resnf[11]-=nfnf[11]*toto;
585  resnf[12]-=nfnf[12]*toto;
586  resnf[13]-=nfnf[13]*toto;
587  resnf[14]-=nfnf[14]*toto;
588  resnf[15]-=nfnf[15]*toto;
589  }
590  }
591  resnf=ptr1;nfnf=ptr2;
592  for(register unsigned int j=i;j<tmp;j++)
593  resnf[j]-=nfnf[j]*toto;
594 #ifdef DEB
595  cout<<"les resultat "<<endl<<invconv<Poly>(res)<<endl;
596 #endif
597 }
598 //#undef DEB
599 
600 template<typename pol>
601 void inline my_plus(pol &res,const pol & nf)
602 {
603  typedef typename pol::monom_t mon;
604  typedef typename pol::coeff_t coeff;
605  register unsigned int i=0;
606  register unsigned int ttmp,tmp;//=taillequotient/16;
607  register coeff *nfnf=nf.nf,*resnf;;
608  //register unsigned int tmp;//=taillequotient % 16;
609  tmp=nf.size;
610  if(res.size<tmp)
611  {
612  res.nf=(coeff*)MAC_REV_REALLOC<coeff>(res.nf,res.size*sizeof(coeff)
613  ,tmp*sizeof(coeff));
614  for(int i=res.size;i<tmp;i++)
615  res.nf[i]=0;
616  res.size=tmp;
617  }
618  ttmp=(tmp/16)*16;
619  resnf=res.nf;
620  //tmp=nf.size & 15;//16 pourquoi... PARCE QUE!!!!! :-))
621  for(;i<ttmp;i+=16)
622  {
623  {
624  resnf[i]-=nfnf[i];
625  resnf[i+1]-=nfnf[i+1];
626  resnf[i+2]-=nfnf[i+2];
627  resnf[i+3]-=nfnf[i+3];
628  resnf[i+4]-=nfnf[i+4];
629  resnf[i+5]-=nfnf[i+5];
630  resnf[i+6]-=nfnf[i+6];
631  resnf[i+7]-=nfnf[i+7];
632  resnf[i+8]-=nfnf[i+8];
633  resnf[i+9]-=nfnf[i+9];
634  resnf[i+10]-=nfnf[i+10];
635  resnf[i+11]-=nfnf[i+11];
636  resnf[i+12]-=nfnf[i+12];
637  resnf[i+13]-=nfnf[i+13];
638  resnf[i+14]-=nfnf[i+14];
639  resnf[i+15]-=nfnf[i+15];
640  }
641  }
642  for(register unsigned int j=i;j<tmp;j++)
643  resnf[j]-=nfnf[j];
644 }
645 
646 template<typename pol,typename coeff>
647 void inline myplus22(pol &res,const pol & nf,const coeff toto, const pol &nf2,const coeff toto2)
648 {
649  typedef typename pol::monom_t mon;
650  register unsigned int i=0;
651  register unsigned int ttmp;//=taillequotient/16;
652  register unsigned int tmp;//=taillequotient % 16;
653  register coeff *resnf,*nfnf,*nf2nf;
654  coeff tmp1,tmp2;
655  int maxsize=max(nf.size,nf2.size);
656  if(res.size<maxsize)
657  {
658  res.nf=(coeff*)MAC_REV_REALLOC<coeff>(res.nf,res.size*sizeof(coeff)
659  ,maxsize*sizeof(coeff));
660  for(int i=res.size;i<maxsize;i++)
661  res.nf[i]=0;
662  res.size=maxsize;
663  }
664  resnf=res.nf;
665  nfnf=nf.nf;
666  nf2nf=nf2.nf;
667  if(nf.size<nf2.size)
668  {
669  ttmp=(nf.size/16)*16;
670  tmp=nf.size & 15;//16 pourquoi... PARCE QUE!!!!! :-))
671  for(;i<ttmp;i+=16)
672  {
673  {
674  // tmp1=nfnf[i];
675 // tmp1*=toto;
676 // tmp2=nf2nf[i];
677 // tmp2*=toto2;
678 // resnf[i]-=tmp1+tmp2;
679  resnf[i]-=nfnf[i]*toto+nf2nf[i]*toto2;
680 // tmp1=nfnf[i+1];
681 // tmp1*=toto;
682 // tmp2=nf2nf[i+1];
683 // tmp2*=toto2;
684 // resnf[i+1]-=tmp1+tmp2;
685 resnf[i+1]-=nfnf[i+1]*toto+nf2nf[i+1]*toto2;
686 // tmp1=nfnf[i+2];
687 // tmp1*=toto;
688 // tmp2=nf2nf[i+2];
689 // tmp2*=toto2;
690 // resnf[i+2]-=tmp1+tmp2;
691 resnf[i+2]-=nfnf[i+2]*toto+nf2nf[i+2]*toto2;
692 // tmp1=nfnf[i+3];
693 // tmp1*=toto;
694 // tmp2=nf2nf[i+3];
695 // tmp2*=toto2;
696 // resnf[i+3]-=tmp1+tmp2;
697 resnf[i+3]-=nfnf[i+3]*toto+nf2nf[i+3]*toto2;
698 // tmp1=nfnf[i+4];
699 // tmp1*=toto;
700 // tmp2=nf2nf[i+4];
701 // tmp2*=toto2;
702 // resnf[i+4]-=tmp1+tmp2;
703 resnf[i+4]-=nfnf[i+4]*toto+nf2nf[i+4]*toto2;
704 // tmp1=nfnf[i+5];
705 // tmp1*=toto;
706 // tmp2=nf2nf[i+5];
707 // tmp2*=toto2;
708 // resnf[i+5]-=tmp1+tmp2;
709 resnf[i+5]-=nfnf[i+5]*toto+nf2nf[i+5]*toto2;
710 // tmp1=nfnf[i+6];
711 // tmp1*=toto;
712 // tmp2=nf2nf[i+6];
713 // tmp2*=toto2;
714 // resnf[i+6]-=tmp1+tmp2;
715 resnf[i+6]-=nfnf[i+6]*toto+nf2nf[i+6]*toto2;
716 // tmp1=nfnf[i+7];
717 // tmp1*=toto;
718 // tmp2=nf2nf[i+7];
719 // tmp2*=toto2;
720 // resnf[i+7]-=tmp1+tmp2;
721 resnf[i+7]-=nfnf[i+7]*toto+nf2nf[i+7]*toto2;
722 // tmp1=nfnf[i+8];
723 // tmp1*=toto;
724 // tmp2=nf2nf[i+8];
725 // tmp2*=toto2;
726 // resnf[i+8]-=tmp1+tmp2;
727 resnf[i+8]-=nfnf[i+8]*toto+nf2nf[i+8]*toto2;
728 // tmp1=nfnf[i+9];
729 // tmp1*=toto;
730 // tmp2=nf2nf[i+9];
731 // tmp2*=toto2;
732 // resnf[i+9]-=tmp1+tmp2;
733 resnf[i+9]-=nfnf[i+9]*toto+nf2nf[i+9]*toto2;
734 // tmp1=nfnf[i+10];
735 // tmp1*=toto;
736 // tmp2=nf2nf[i+10];
737 // tmp2*=toto2;
738 // resnf[i+10]-=tmp1+tmp2;
739 resnf[i+10]-=nfnf[i+10]*toto+nf2nf[i+10]*toto2;
740 // tmp1=nfnf[i+11];
741 // tmp1*=toto;
742 // tmp2=nf2nf[i+11];
743 // tmp2*=toto2;
744 // resnf[i+11]-=tmp1+tmp2;
745 resnf[i+11]-=nfnf[i+11]*toto+nf2nf[i+11]*toto2;
746 // tmp1=nfnf[i+12];
747 // tmp1*=toto;
748 // tmp2=nf2nf[i+12];
749 // tmp2*=toto2;
750 // resnf[i+12]-=tmp1+tmp2;
751 resnf[i+12]-=nfnf[i+12]*toto+nf2nf[i+12]*toto2;
752 // tmp1=nfnf[i+13];
753 // tmp1*=toto;
754 // tmp2=nf2nf[i+13];
755 // tmp2*=toto2;
756 // resnf[i+13]-=tmp1+tmp2;
757 resnf[i+13]-=nfnf[i+13]*toto+nf2nf[i+13]*toto2;
758 // tmp1=nfnf[i+14];
759 // tmp1*=toto;
760 // tmp2=nf2nf[i+14];
761 // tmp2*=toto2;
762 // resnf[i+14]-=tmp1+tmp2;
763 resnf[i+14]-=nfnf[i+14]*toto+nf2nf[i+14]*toto2;
764 // tmp1=nfnf[i+15];
765 // tmp1*=toto;
766 // tmp2=nf2nf[i+15];
767 // tmp2*=toto2;
768 // resnf[i+15]-=tmp1+tmp2;
769 
770  resnf[i+15]-=nfnf[i+15]*toto+nf2nf[i+15]*toto2;
771  }
772  }
773  for(register unsigned int j=i;j<nf.size;j++)
774  resnf[j]-=nfnf[j]*toto+nf2nf[j]*toto2;
775  for(register unsigned int j=nf.size;j<nf2.size;j++)
776  resnf[j]-=nf2nf[j]*toto2;
777 
778  }
779  else
780  {
781  ttmp=(nf2.size/16)*16;
782  tmp=nf2.size & 15;//16 pourquoi... PARCE QUE!!!!! :-))
783  for(;i<ttmp;i+=16)
784  {
785  {
786  tmp1=nfnf[i];
787  tmp1*=toto;
788  tmp2=nf2nf[i];
789  tmp2*=toto2;
790  resnf[i]-=tmp1+tmp2;
791  // resnf[i]-=nfnf[i]*toto+nf2nf[i]*toto2;
792  tmp1=nfnf[i+1];
793  tmp1*=toto;
794  tmp2=nf2nf[i+1];
795  tmp2*=toto2;
796  resnf[i+1]-=tmp1+tmp2;
797  // resnf[i+1]-=nfnf[i+1]*toto+nf2nf[i+1]*toto2;
798  tmp1=nfnf[i+2];
799  tmp1*=toto;
800  tmp2=nf2nf[i+2];
801  tmp2*=toto2;
802  resnf[i+2]-=tmp1+tmp2;
803  // resnf[i+2]-=nfnf[i+2]*toto+nf2nf[i+2]*toto2;
804  tmp1=nfnf[i+3];
805  tmp1*=toto;
806  tmp2=nf2nf[i+3];
807  tmp2*=toto2;
808  resnf[i+3]-=tmp1+tmp2;
809  // resnf[i+3]-=nfnf[i+3]*toto+nf2nf[i+3]*toto2;
810  tmp1=nfnf[i+4];
811  tmp1*=toto;
812  tmp2=nf2nf[i+4];
813  tmp2*=toto2;
814  resnf[i+4]-=tmp1+tmp2;
815  // resnf[i+4]-=nfnf[i+4]*toto+nf2nf[i+4]*toto2;
816  tmp1=nfnf[i+5];
817  tmp1*=toto;
818  tmp2=nf2nf[i+5];
819  tmp2*=toto2;
820  resnf[i+5]-=tmp1+tmp2;
821  // resnf[i+5]-=nfnf[i+5]*toto+nf2nf[i+5]*toto2;
822  tmp1=nfnf[i+6];
823  tmp1*=toto;
824  tmp2=nf2nf[i+6];
825  tmp2*=toto2;
826  resnf[i+6]-=tmp1+tmp2;
827  // resnf[i+6]-=nfnf[i+6]*toto+nf2nf[i+6]*toto2;
828  tmp1=nfnf[i+7];
829  tmp1*=toto;
830  tmp2=nf2nf[i+7];
831  tmp2*=toto2;
832  resnf[i+7]-=tmp1+tmp2;
833  // resnf[i+7]-=nfnf[i+7]*toto+nf2nf[i+7]*toto2;
834  tmp1=nfnf[i+8];
835  tmp1*=toto;
836  tmp2=nf2nf[i+8];
837  tmp2*=toto2;
838  resnf[i+8]-=tmp1+tmp2;
839  // resnf[i+8]-=nfnf[i+8]*toto+nf2nf[i+8]*toto2;
840  tmp1=nfnf[i+9];
841  tmp1*=toto;
842  tmp2=nf2nf[i+9];
843  tmp2*=toto2;
844  resnf[i+9]-=tmp1+tmp2;
845  // resnf[i+9]-=nfnf[i+9]*toto+nf2nf[i+9]*toto2;
846  tmp1=nfnf[i+10];
847  tmp1*=toto;
848  tmp2=nf2nf[i+10];
849  tmp2*=toto2;
850  resnf[i+10]-=tmp1+tmp2;
851  // resnf[i+10]-=nfnf[i+10]*toto+nf2nf[i+10]*toto2;
852  tmp1=nfnf[i+11];
853  tmp1*=toto;
854  tmp2=nf2nf[i+11];
855  tmp2*=toto2;
856  resnf[i+11]-=tmp1+tmp2;
857  // resnf[i+11]-=nfnf[i+11]*toto+nf2nf[i+11]*toto2;
858  tmp1=nfnf[i+12];
859  tmp1*=toto;
860  tmp2=nf2nf[i+12];
861  tmp2*=toto2;
862  resnf[i+12]-=tmp1+tmp2;
863  // resnf[i+12]-=nfnf[i+12]*toto+nf2nf[i+12]*toto2;
864  tmp1=nfnf[i+13];
865  tmp1*=toto;
866  tmp2=nf2nf[i+13];
867  tmp2*=toto2;
868  resnf[i+13]-=tmp1+tmp2;
869  // resnf[i+13]-=nfnf[i+13]*toto+nf2nf[i+13]*toto2;
870  tmp1=nfnf[i+14];
871  tmp1*=toto;
872  tmp2=nf2nf[i+14];
873  tmp2*=toto2;
874  resnf[i+14]-=tmp1+tmp2;
875  // resnf[i+14]-=nfnf[i+14]*toto+nf2nf[i+14]*toto2;
876  tmp1=nfnf[i+15];
877  tmp1*=toto;
878  tmp2=nf2nf[i+15];
879  tmp2*=toto2;
880  resnf[i+15]-=tmp1+tmp2;
881  }
882  }
883  for(register unsigned int j=i;j<nf2.size;j++)
884  resnf[j]-=nfnf[j]*toto+nf2nf[j]*toto2;
885  for(register unsigned int j=nf2.size;j<nf.size;j++)
886  resnf[j]-=nfnf[j]*toto;
887 
888  }
889 }
890 
891 template<typename pol,typename coeff>
892 void inline myplus44(pol &res,const pol & nf,const coeff toto,
893  const pol &nf2,const coeff toto2,
894  const pol &nf3,const coeff toto3,
895  const pol &nf4,const coeff toto4)
896 {
897  typedef typename pol::monom_t mon;
898  register unsigned int i=0;
899  register unsigned int ttmp;//=taillequotient/16;
900  register unsigned int tmp;//=taillequotient % 16;
901  coeff *resnf,*nfnf,*nf2nf,*nf3nf,*nf4nf;
902  int maxsize=max(max(nf.size,nf2.size),max(nf3.size,nf4.size));
903  int minsize=min(min(nf.size,nf2.size),min(nf3.size,nf4.size));
904  if(res.size<maxsize)
905  {
906  res.nf=(coeff*)MAC_REV_REALLOC<coeff>(res.nf,res.size*sizeof(coeff)
907  ,maxsize*sizeof(coeff));
908  for(int i=res.size;i<maxsize;i++)
909  res.nf[i]=0;
910  res.size=maxsize;
911  }
912  resnf=res.nf;
913  nfnf=nf.nf;
914  nf2nf=nf2.nf;
915  nf3nf=nf3.nf;
916  nf4nf=nf4.nf;
917  ttmp=(minsize/16)*16;
918  tmp=minsize & 15;//16 pourquoi... PARCE QUE!!!!! :-))
919  for(;i<ttmp;i+=16)
920  {
921  {
922  resnf[i]-=nfnf[i]*toto+nf2nf[i]*toto2
923  +nf3nf[i]*toto3+nf4nf[i]*toto4;
924  resnf[i+1]-=nfnf[i+1]*toto+nf2nf[i+1]*toto2
925  +nf3nf[i+1]*toto3+nf4nf[i+1]*toto4;
926  resnf[i+2]-=nfnf[i+2]*toto+nf2nf[i+2]*toto2
927  +nf3nf[i+2]*toto3+nf4nf[i+2]*toto4;
928  resnf[i+3]-=nfnf[i+3]*toto+nf2nf[i+3]*toto2
929  +nf3nf[i+3]*toto3+nf4nf[i+3]*toto4;
930  resnf[i+4]-=nfnf[i+4]*toto+nf2nf[i+4]*toto2
931  +nf3nf[i+4]*toto3+nf4nf[i+4]*toto4;
932  resnf[i+5]-=nfnf[i+5]*toto+nf2nf[i+5]*toto2
933  +nf3nf[i+5]*toto3+nf4nf[i+5]*toto4;
934  resnf[i+6]-=nfnf[i+6]*toto+nf2nf[i+6]*toto2
935  +nf3nf[i+6]*toto3+nf4nf[i+6]*toto4;
936  resnf[i+7]-=nfnf[i+7]*toto+nf2nf[i+7]*toto2
937  +nf3nf[i+7]*toto3+nf4nf[i+7]*toto4;
938  resnf[i+8]-=nfnf[i+8]*toto+nf2nf[i+8]*toto2
939  +nf3nf[i+8]*toto3+nf4nf[i+8]*toto4;
940  resnf[i+9]-=nfnf[i+9]*toto+nf2nf[i+9]*toto2
941  +nf3nf[i+9]*toto3+nf4nf[i+9]*toto4;
942  resnf[i+10]-=nfnf[i+10]*toto+nf2nf[i+10]*toto2
943  +nf3nf[i+10]*toto3+nf4nf[i+10]*toto4;
944  resnf[i+11]-=nfnf[i+11]*toto+nf2nf[i+11]*toto2
945  +nf3nf[i+11]*toto3+nf4nf[i+11]*toto4;
946  resnf[i+12]-=nfnf[i+12]*toto+nf2nf[i+12]*toto2
947  +nf3nf[i+12]*toto3+nf4nf[i+12]*toto4;
948  resnf[i+13]-=nfnf[i+13]*toto+nf2nf[i+13]*toto2
949  +nf3nf[i+13]*toto3+nf4nf[i+13]*toto4;
950  resnf[i+14]-=nfnf[i+14]*toto+nf2nf[i+14]*toto2
951  +nf3nf[i+14]*toto3+nf4nf[i+14]*toto4;
952  resnf[i+15]-=nfnf[i+15]*toto+nf2nf[i+15]*toto2
953  +nf3nf[i+15]*toto3+nf4nf[i+15]*toto4;
954  }
955  }
956  for(register unsigned int j=i;j<nf.size;j++)
957  resnf[j]-=nfnf[j]*toto;
958  for(register unsigned int j=i;j<nf2.size;j++)
959  resnf[j]-=nf2nf[j]*toto2;
960  for(register unsigned int j=i;j<nf3.size;j++)
961  resnf[j]-=nf3nf[j]*toto3;
962  for(register unsigned int j=i;j<nf4.size;j++)
963  resnf[j]-=nf4nf[j]*toto4;
964 
965 }
966 
967 //renvoit l'indice du monome x_i*m_j
968 template<typename mon,typename Base>
969 int indice2(int i,int j,const Base & b)
970 {
971  int res=-1;
972  mon tmp;
973  int2mon(j,tmp);
974  tmp*=mon(i,1);//on suppose qd meme que j correspond a qqchose
975  //cout<<"indice2 IsinB("<<mon(i,1)*tmp<<",b) "<<IsinB(mon(i,1)*tmp,b)<<endl;
976  if(IsinB(tmp,b))
977  {
978  res=mon2int(tmp);
979  // cout<<"le monome "<<mon(i,1)*tmp<<" l'indice "<<res<<endl;
980  }
981  return res;
982 }
983 
984 template<typename mon,typename Base>
985 int indice2(const mon &tmp,const Base & b)
986 {
987  int res=-1;
988  if(IsinB(tmp,b))
989  {
990  res=mon2int(tmp);
991  // cout<<"le monome "<<mon(i,1)*tmp<<" l'indice "<<res<<endl;
992  }
993  return res;
994 }
995 
996 //on lui donne l'ensemble des formes normales, dump, l'indice de b(cf ci dessus)
997 // le numero de la variable par laquelle on multiplie
998 //et elle renvoie un pol(cf def du type) sur la forme normale de var*m_{indmon}
999 #ifndef uninf
1000 template<typename typpol,typename typdump,typename Base>
1001 typpol nf(int var ,int indmon,const typdump &dump,const Base & b)
1002 {
1003  //on cherche dans dump...
1004  //a optimiser plus tard
1005  typedef typename typdump::value_type dumpstruct;
1006  typedef typpol pol;
1007  typedef typename pol::monom_t mon;
1008  pol res;
1009  res.nf=NULL;
1010  res.size=-1;
1011  mon tmpmon;//=mon(1,var)*int2mon<mon>(indmon);
1012  int deg=0;//=tmpmon.GetDegree()+1;
1013  typename typdump::const_iterator iter;
1014  int2mon(indmon,tmpmon);
1015  deg=tmpmon.GetDegree()+1;
1016  //cout<<"mon("<<var<<",1) "<<mon(var,1)<<" et deg "<<deg<<endl;
1017  tmpmon*=mon(var,1);
1018  for(iter=dump.begin();
1019  (iter!=dump.end()) && (iter->k!=deg);iter++);
1020  // cout<<"iter-k "<<iter->k<<endl;
1021  // if(iter!=dump.end()) cout<<"iter->k en sortie "<<iter->k<<" et deg "<<deg<<endl;
1022  //cout<<"valuer a la sortie "<<(--iter)++->k<<endl;
1023  // cout<<"iter!=dump.end() "<<(iter!=dump.end())
1024  // <<" dump.empty() "<<dump.empty()<<endl;
1025  if(iter!=dump.end())//on cherche pas n'importe quoi qd meme
1026  {
1027  int i;
1028  for(i=0;i<iter->size;i++)
1029  {
1030  // cout<<"dans nf iter->nf[i].ind "<<iter->nf[i].ind<<endl;
1031  if(iter->nf[i].ind.rep==tmpmon.rep)
1032  break;
1033  }
1034  if(i!=iter->size)
1035  //Tue Dec 4 16:39:25 MET 2001
1036  // densify(iter->nf[i],res);
1037 
1038  res=(iter->nf[i]);
1039  }
1040  //cout<<"la gueule de res "<<res<<endl;
1041  //if (res!=NULL) cout<<"suite de res "<<res->ind<<" "<<res->nf<<endl;
1042  return res;
1043 }
1044 #endif
1045 
1046 template<typename typpol,typename typdump,typename Base, typename mon>
1047 typpol nf(const mon &ind,const typdump &dump,const Base & b)
1048 {
1049  //on cherche dans dump...
1050  //a optimiser plus tard
1051  typedef typename typdump::value_type dumpstruct;
1052  typedef typpol pol;
1053  pol res;
1054  res.nf=NULL;
1055  res.size=-1;
1056  int deg=0;//=tmpmon.GetDegree()+1;
1057  typename typdump::const_iterator iter;
1058  deg=ind.GetDegree();
1059  for(iter=dump.begin();
1060  (iter!=dump.end()) && (iter->k!=deg);iter++);
1061  if(iter!=dump.end())//on cherche pas n'importe quoi qd meme
1062  {
1063  int i;
1064  for(i=0;i<iter->size;i++)
1065  {
1066  if(iter->nf[i].ind.rep==ind.rep)
1067  break;
1068  }
1069  if(i!=iter->size)
1070  res=(iter->nf[i]);
1071  }
1072  return res;
1073 }
1074 
1075 //effectue la multiplication du pol T par la variable x_i
1076 template<typename typpol,typename typdump,typename Base,typename mon>
1077 typpol inline mult(int i,const typpol &pol,const typdump &dump,
1078  const Base &b,mon **exce,int &exsize)
1079 {
1080  typedef typename typpol::coeff_t coeff;
1081  //static const mon monzero=mon(0);
1082  typpol ret;
1083  coeff *res=NULL,*polnf;
1084 #ifndef unimul
1085  mon *stockmontab=(mon*)MAC_REV_MALLOC<mon>(pol.size*sizeof(mon));
1086 #endif
1087  ret.nf=res;
1088  (*exce)=(mon*)MAC_REV_MALLOC<mon>((pol.size+1)*sizeof(mon));
1089  int *stockindicetab=(int*)malloc(pol.size*sizeof(int)),*tmpptr;
1090  int noquo=0;
1091  static int nbmyplus=0;
1092 #ifdef plus2
1093  int flagplus=0;
1094  coeff stockcoeffplus;
1095  typpol stockpolplus;
1096 #endif
1097 #ifdef plus4
1098  int flagplus=0;
1099  coeff stockcoeffplus[4];
1100  typpol stockpolplus[4];
1101 #endif
1102  int maxind=0;
1103  tmpptr=stockindicetab;
1104  //cout<<"pol.size "<<pol.size<<endl;
1105  for(int j=0;j<pol.size;++j)
1106  if (!Iszero(pol.nf[j]))
1107  {
1108 #ifdef unimul
1109  int stockindice2=mulind(j,i,b);
1110  *tmpptr++=stockindice2;
1111 #else
1112  mon tmpmon;
1113  int2mon(j,tmpmon);
1114  tmpmon*=mon(i,1);
1115  stockmontab[j]=tmpmon;
1116  int stockindice2=indice2<mon>(tmpmon,b);
1117  *tmpptr++=stockindice2;
1118 #endif
1119 
1120  //cout<<"stockindice2 "<<stockindice2<<" pol.size "<<
1121  //pol.size<<" J "<<j<<endl;
1122 
1123  if (maxind<stockindice2)
1124  maxind=stockindice2;
1125  }
1126  //cout<<"maxind "<<maxind<<endl;
1127  // maxind=size;
1128  ret.nf=(coeff*)MAC_REV_MALLOC<coeff>((maxind+1)*sizeof(coeff));
1129  for(int j=0;j<=maxind;j++)
1130  ((coeff*)(ret.nf))[j]=0;
1131  ret.size=maxind+1;
1132  //ret.nf=res;
1133  tmpptr=stockindicetab;
1134  polnf=pol.nf;
1135  for(int j=0;j<pol.size;++j,polnf++)
1136  {
1137  const coeff stockpol=*polnf;
1138  if (!Iszero(stockpol))//ici introduire les epsilon si on veut gagner un peu..
1139  {// pas necessaire pour les epsilon parce que ca marche !!
1140  int stockindice2=*tmpptr++;//indice2<mon>(i,j,b);
1141  //cout<<"stockindice2 avant le test "<<stockindice2<<endl;
1142  if (stockindice2>=0)
1143  {
1144  ret.nf[stockindice2]+=stockpol;
1145  // cout<<"stocvkindice2 "<<stockindice2<<" pol.size "<<
1146  // pol.size<<" J "<<j<<endl;
1147  }
1148  else
1149  {
1150  //
1151  //
1152  //
1153  //
1154  //typename typpol::monom_t tmpmon;
1155  //cout<<" j vaut dans mult "<<j<<endl;
1156  // cout<<"et int2mon de ce j vaut "<<tmpmon<<endl;
1157  //cout<<"je recherche la nf de "<<tmpmon<<endl;
1158  typpol tmp;
1159  //tmp.ind=monzero;
1160 #ifdef unimul
1161  tmp=nf<typpol>(i,j,dump,b);
1162 #else
1163  tmp=nf<typpol>(stockmontab[j],dump,b);
1164 #endif
1165  //cout<<"tmpind vaut alors "<<tmp.ind<<endl;
1166  //
1167  //
1168  //
1169  if (tmp.size!=-1)
1170  {
1171 #ifdef plus4
1172  if(flagplus==3)
1173  {
1174  flagplus=0;
1175  myplus44(ret,tmp,stockpol,
1176  stockpolplus[0],stockcoeffplus[0],
1177  stockpolplus[1],stockcoeffplus[1],
1178  stockpolplus[2],stockcoeffplus[2]);
1179  }
1180  else
1181  {
1182  stockcoeffplus[flagplus]=stockpol;
1183  stockpolplus[flagplus]=tmp;
1184  flagplus++;
1185  }
1186 #endif
1187 
1188 #ifdef plus2
1189  if(flagplus==1)
1190  {
1191  flagplus=0;
1192  myplus22(ret,tmp,stockpol,stockpolplus,stockcoeffplus);
1193  }
1194  else
1195  {
1196  stockcoeffplus=stockpol;
1197  stockpolplus=tmp;
1198  flagplus=1;
1199  }
1200 #else
1201  //nbmyplus++;
1202  //cout<<"tmp "<<tmp<<endl;
1203  //cout<<"tmp.ind "<<tmp->ind<<endl;
1204  //cout<<"tmp.nf "<<tmp->nf<<endl;
1205  my_plus(ret,tmp,stockpol);
1206  //Tue Dec 4
1207  //MAC_REV_FREE<mon>(tmp.nf,tmp.size*sizeof(coeff));
1208  //res=ret.nf;//car my_plus realloc la chose
1209 #endif
1210  }
1211  else
1212  {
1213  mon tmpmon;
1214  (*exce)[noquo]=mon(i,1);
1215  int2mon(j,tmpmon);
1216  //cout<<"je rajoute ala fin listes exceed "<<tmpmon*mon(i,1)<<endl;
1217  (*exce)[noquo]*=tmpmon;//int2mon<mon>(j);
1218  (*exce)[noquo]*=stockpol;
1219  ++noquo;
1220  };
1221 
1222  //dans plus qd nf renvois NULL il faut rien faire!!!!
1223  }
1224  }
1225  }
1226  //(*exce)=(mon*)MAC_REV_REALLOC<mon>((*exce),pol.size*sizeof(mon)
1227  // ,(noquo)*sizeof(mon));
1228  //cout<<"fin "<<nbmyplus<<endl;
1229 #ifdef plus4
1230  for(int ii=0;ii<flagplus;ii++)
1231  my_plus(ret,stockpolplus[ii],stockcoeffplus[ii]);
1232 #endif
1233 
1234 #ifdef plus2
1235  if(flagplus)
1236  {
1237  my_plus(ret,stockpolplus,stockcoeffplus);
1238  }
1239 #endif
1240 
1241  ret.ind=pol.ind;
1242  ret.ind*=mon(i,1);
1243  //Fri Nov 16 14:42:34 MET 2001
1244  (*exce)[noquo++]=ret.ind;
1245  exsize=noquo;
1246  (*exce)=(mon*)MAC_REV_REALLOC<mon>((*exce),(pol.size+1)*sizeof(mon)
1247  ,(noquo)*sizeof(mon));
1248  ret.ind.SetCoeff(noquo+1);
1249 #ifndef unimul
1250  MAC_REV_FREE<mon>(stockmontab,pol.size*sizeof(mon));
1251 #endif
1252  free(stockindicetab);
1253  // cout<<"ret.size "<<ret.size<<endl;
1254  // cout<<invconv<Poly>(ret)<<endl;
1255  //cout<<"-----------------------------------"<<endl;
1256  return ret;
1257 
1258 }
1259 
1260 // renvoit mon/x_i .... mais suppose qu'on ne fait pas n'importe quoi
1261 template <typename Mon,typename Base>
1262 Mon my_divmon(const Mon &mon,int i,const Base& b)
1263 {
1264  Mon res(1);
1265  for(int j=0;j<b.nbvar();j++)
1266  if(i==j)
1267  {
1268  res*=Mon(j,mon.GetDegree(j)-1);
1269  }
1270  else
1271  {
1272  res*=Mon(j,mon.GetDegree(j));
1273  }
1274  return res;
1275 }
1276 
1277 template<typename typmon,typename Base>
1278 int GoodDir(const typmon &m,int i, const Base & b)
1279 {
1280  int res=0;
1281  mon tmpm=m*mon(i,1);
1282  //cout<<"dans GoodDir les monomes "<<m<<"********"<<typmon(i,1)<<endl;
1283  //cout<<"b.nbvar() "<<b.nbvar()<<endl;
1284  for(int j=0;j<b.nbvar();j++)
1285  {
1286  if(tmpm.GetDegree(j)>=1)
1287  if(IsinB(my_divmon(tmpm,j,b),b)) {res=1;break;};
1288  }
1289  //cout<<" le verdict de GoodDir "<<res<<endl;
1290  return res;
1291 }
1292 
1293 //fonct\ion adhoc qui merge une liste de polyalp avec une liste de pol
1294 //en cours de calcul cad liste de pol + liste excedentaire
1295 template<typename typPk,typename typP,typename typexceed,
1296  typename typsize ,typename Base>
1297 void conv_merge(typPk &Pk,typP &P,typexceed &ex,typsize &sizeex,const Base &b)
1298 {
1299  typedef typename typP::value_type polalp;
1300  typedef typename polalp::order_t ord;
1301  typedef typename polalp::monom_t mon;
1302  typedef typename typPk::value_type pol;
1303  typedef typename pol::coeff_t coeff;
1304  coeff * tabcoeff=NULL;
1305  int * tabindices=NULL;
1306  int tabsize=0;
1307 #ifdef DEBUG
1308  cout<<"entree dans conv_merge"<<endl;
1309  for(typename Base::const_iterator p=b.begin();p!=b.end();p++)
1310  {
1311  for(int i=0;i<p->taille1;i++)
1312  {
1313  cout<<"p.accept[i] "<<p->accept[i]<<endl;
1314  }
1315  for(int i=0;i<p->taille2;i++)
1316  {
1317  cout<<"p.refuse[i] "<<p->refuse[i]<<endl;
1318  }
1319  }
1320  cout<<"p-taille2 "<<b.begin()->taille2<<" "<<b.begin()->taille2-1<<endl;
1321  cout<<"I=ideal("<<endl;
1322  {
1323  typename Base::const_iterator p=b.begin();
1324  for(int i=0;i<p->taille2-1;i++)
1325  {
1326  cout<<p->refuse[i]<<","<<endl;
1327  }
1328  if(p->taille2>=1) cout<<p->refuse[p->taille2-1]<<")"<<endl;
1329  }
1330 #endif //DEBUG
1331  for(typename typP::iterator iter=P.begin();iter!=P.end();iter++)
1332  {
1333  //cout<<"dans for"<<endl;
1334  pol tmp;
1335  int max=0;
1336  tmp.ind=mon(1);
1337 
1338  tabcoeff=(coeff*)MAC_REV_REALLOC<coeff>((void*)tabcoeff,
1339  tabsize*sizeof(coeff),
1340  iter->size()*sizeof(coeff));
1341  tabindices=(int*)realloc((void*)tabindices,iter->size()*sizeof(int));
1342  tabsize=iter->size();
1343  //ici il faudrait un type template
1344  for(int i=0;i<tabsize;i++)
1345  {
1346  tabcoeff[i]=0;
1347  }
1348  //memset((void*)tabcoeff,0,tabsize*sizeof(coeff));
1349  //ici aussi
1350  mon * tmpex=NULL;
1351  tmpex=(mon*)MAC_REV_REALLOC<mon>((void*)tmpex,0,tabsize*sizeof(mon));
1352  {
1353  int comp=0;int i=0;
1354  for(typename polalp::iterator iterpol=iter->begin();
1355  iterpol!=iter->end();iterpol++)
1356  {
1357  // cout<<"IsinB("<<*iterpol<<","<<"b)"<<endl;
1358  if (IsinB(*iterpol,b))
1359  {
1360  tabcoeff[i]=iterpol->GetCoeff();
1361  tabindices[i]=mon2int(*iterpol);
1362  if(tabindices[i]>max) max=tabindices[i];
1363  i++;
1364  }
1365  else
1366  {
1367  //cout<<"y en a un qu'est pas dans B "<<*iterpol<<endl;
1368  if(!Iszero(iterpol->GetCoeff()))
1369  tmpex[comp++]=*iterpol;
1370  }
1371  }
1372  tmpex=(mon*)MAC_REV_REALLOC<mon>((void*)tmpex,tabsize*sizeof(mon)
1373  ,(comp+1)*sizeof(mon));
1374  tmp.size=max+1;
1375  tmp.nf=(coeff*)MAC_REV_MALLOC<coeff>(tmp.size*sizeof(coeff));
1376  for(int j=0;j<tmp.size;j++)
1377  tmp.nf[j]=0;
1378  for(int j=0;j<i;j++)
1379  tmp.nf[tabindices[j]]=tabcoeff[j];
1380  tmp.ind=mon(comp+1);
1381  Pk.push_back(tmp);
1382  ex.push_back(tmpex);
1383  sizeex.push_back(comp);
1384  }
1385  }
1386  MAC_REV_FREE<coeff>(tabcoeff,tabsize*sizeof(coeff));
1387  free(tabindices);
1388 }
1389 //member ne test que les exposant pas les coefficients
1390 template<typename typMk>
1391 int member(const typMk & tmpMk,const typename typMk::value_type mon)
1392 {
1393  int res=0;
1394  for(typename typMk::const_iterator iter=tmpMk.begin();
1395  iter!=tmpMk.end();iter++)
1396  if(iter->rep==mon.rep) {res=1;break;}
1397  return res;
1398 }
1399 
1400 template<typename typP,typename typPk, typename typMk,typename typexceed
1401 ,typename typsize,typename typdump,typename Base>
1402 void putingoodshape(const typP & P,typPk &workvect,const typMk & tmpMk
1403  ,typexceed & exceed,typsize & sizeex
1404  ,const typdump & dump,const Base & b)
1405 {
1406  typedef typename typPk::value_type pol;
1407  typedef typename pol::coeff_t coeff;
1408  typedef typename typexceed::value_type typex;
1409  typedef typename typMk::value_type mon;
1410  typedef typename typP::value_type polyalp;
1411  typP tobeproj;
1412  for(typename typPk::iterator iter=workvect.begin();
1413  iter!=workvect.end();iter++)
1414  {
1415  int sizeexceed=0;
1416  polyalp projpol(0);
1417  typex tmpex=(mon*)MAC_REV_MALLOC<mon>(sizeof(mon)*tmpMk.size());
1418  for(unsigned int i=0;i<tmpMk.size();i++)
1419  tmpex[i]=mon(0);
1420  // cout<<"proj pol au debaut "<<projpol<<endl;
1421  for(int i=0;i<iter->size;i++)
1422  {
1423  if(!Iszero(iter->nf[i]))
1424  {
1425  mon tmpmon;
1426  int2mon(i,tmpmon);
1427  if(!IsinB(tmpmon,b))
1428  {
1429  if(member(tmpMk,tmpmon))
1430  {
1431  tmpex[sizeexceed++]=tmpmon*iter->nf[i];
1432  iter->nf[i]=0;
1433  }
1434  else
1435  {
1436  projpol+=tmpmon*iter->nf[i];
1437  iter->nf[i]=0;
1438  };
1439  }
1440  }
1441  }
1442  if(iter->ind.GetDegree()>0)
1443  tmpex[sizeexceed++]=iter->ind;
1444  exceed.push_back(tmpex);
1445  tobeproj.push_back(projpol);
1446  //cout<<"tobeproj avant push back "<<endl<<projpol<<endl;
1447  //cout<<"sizeexced pushbacke "<<sizeexceed<<endl;
1448  sizeex.push_back(sizeexceed);
1449  }
1450  //bon on a isole les monomes a projeter
1451  proj(tobeproj,dump,b);
1452  {
1453  typename typPk::iterator iter=workvect.begin();
1454  typename typexceed::iterator iterex=exceed.begin();
1455  typename typsize::iterator itersize=sizeex.begin();
1456  for(typename typP::iterator iterproj=tobeproj.begin();
1457  iterproj!=tobeproj.end();iterproj++,iter++,iterex++,itersize++)
1458  {
1459  // cout<<"*itersize "<<(*itersize)<<" et tmpMk.size() "<<tmpMk.size()<<endl;
1460  int maxend=iter->size-1;
1461  for(typename polyalp::iterator iterpol=iterproj->begin();
1462  iterpol!=iterproj->end();iterpol++)
1463  {
1464  if(IsinB(*iterpol,b)&&maxend<mon2int(*iterpol))
1465  maxend=mon2int(*iterpol);
1466  }
1467  iter->nf=(coeff*)MAC_REV_REALLOC<coeff>(iter->nf
1468  ,iter->size*sizeof(coeff)
1469  ,(maxend+1)*sizeof(coeff));
1470  for(int i=iter->size;i<=maxend;i++)
1471  iter->nf[i]=0;
1472  for(typename polyalp::iterator iterpol=iterproj->begin();
1473  iterpol!=iterproj->end();iterpol++)
1474  {
1475  if(IsinB(*iterpol,b))
1476  {
1477  iter->nf[mon2int(*iterpol)]+=iterpol->GetCoeff();
1478  }
1479  else
1480  {
1481  int i=0;
1482 
1483  for(;(i<(*itersize))&&((*iterex)[i].rep!=iterpol->rep);i++);
1484  if(i<(*itersize))
1485  {
1486  (*iterex)[i]+=*iterpol;
1487  }
1488  else
1489  {
1490  (*iterex)[(*itersize)++]=*iterpol;
1491  // cout<<"rajoute "<<*iterpol<<" a la pos "<<*itersize<<endl;
1492  }
1493  }
1494  }
1495  *iterex=(typex)MAC_REV_REALLOC<mon>(*iterex,tmpMk.size()*sizeof(mon)
1496  ,(*itersize)*sizeof(mon));
1497  iter->size=maxend+1;
1498  //cout<<"relecture itersize "<<*itersize<<endl;
1499  }
1500 
1501  }
1502 }
1503 
1504 template<typename typMat,typename typPk,typename typP,
1505  typename typMk,typename Base,typename typdump,typename typrecall>
1506 int newPkMkMatrixof(typMat &mat,typPk &Pk, typP &P,typMk &Mk,
1507  int &k,Base &b, typdump &dump,typrecall &recall
1508 #ifndef NO_TWICE
1509 )
1510 #else
1511 ,typMk &Spoldejavu)
1512 #endif
1513  //template<typename typMat,typename typPk,typename typP,
1514  // typename typMk,typename Base,typename typdump>
1515  //int newPkMkMatrixof(typMat &mat,typPk &Pk,const typP &P,typMk &Mk,
1516  // int &k,Base &b, typdump &dump)
1517 {
1518  typedef typename typMk::value_type mon;
1519  typedef typename typP::value_type::order_t ord;
1520  typedef typename typPk::value_type pol;
1521  typedef typename pol::coeff_t coeff;
1522  typedef typename typP::value_type polyalp;
1523  typPk tmpPk,workvect;
1524  typMk tmpMk;
1525  list<mon *> exceed;
1526  list<int> sizeexceed;
1527  int nbproj=0,flagdoplus=1;
1528  //prise en compte des pol pas encore introduits
1529  cout<<endl;
1530  cerr<<"k on entering newpkmkmatrixof "<<k<<endl;
1531  //cout<<"crochet"<<endl;
1532  typP ttmpP=Crochet(P,k+1);//
1533  //typrecall verytmp=Crochet(recall,k+1);//verytmpP 24/08/2001
1534  //recall.erase(recall.begin(),recall.end());
1535  //my_merge(ttmpP,verytmpP);//le 24/08/2001
1536  //nbproj=ttmpP.size();
1537  //for(typename typPk::iterator iter=Pk.begin();iter!=Pk.end();iter++)
1538  // cout<<"ind au debut"<<iter->ind<<endl;
1539  //for(typename typPk::iterator iter=verytmp.begin();iter!=verytmp.end();iter++)
1540  // cout<<"ind au debut"<<iter->ind<<endl;
1541  // cout<<"pol au debut"<<invconv<typename typP::value_type>(*iter)<<endl;
1542  if (!ttmpP.empty())
1543  {
1544  int tmpdeg;
1545  // cout<<"proj "<<endl;
1546  proj(ttmpP,dump,b);
1547  // cout<<"selectnozero"<<endl;
1548  selectnozero(ttmpP);
1549 #ifdef NO_TWICE_FALL
1550  for(typename typP::iterator iter=P.begin();iter!=P.end();iter++)
1551  if(Degree(*iter)==k+1) P.erase(iter--);
1552  for(typename typP::iterator iter=ttmpP.begin()
1553  ;iter!=ttmpP.end();iter++)
1554  P.push_back(*iter);
1555 #endif
1556 // for(typename typP::iterator iter=P.begin();iter!=P.end();iter++)
1557  //if(Degree(*iter)==k+1) P.erase(iter--);
1558  //for(typename typP::iterator iter=ttmpP.begin();iter!=ttmpP.end();iter++)
1559  // P.push_back(*iter);
1560  // cout<<"pol mal red "<<*iter<<endl;
1561  //cout<<"passage par ici"<<endl;
1562  nbproj=ttmpP.size();
1563  if (!ttmpP.empty())
1564  {
1565  // cout<<"apres select non zero "<<ttmpP.size()<<endl;
1566  tmpdeg=minmaxdegP(ttmpP,tmpdeg);
1567  // cout<<"apres minmax deg "<<tmpdeg<<" "<<k<<endl;
1568  if(tmpdeg<k+1)
1569  {
1570  flagdoplus=0;
1571  // cout<<"un des pol de pretendu degre le bon se reduit mal"<<endl;
1572  //en fait a un polynome de degre inferieur
1573  typPk tmpconv;
1574  //cout<<"recover"<<endl;
1575  recover(tmpPk,Mk,dump,tmpdeg);
1576 #ifdef NO_TWICE
1577  Listedejafait(Mk,Spoldejavu);
1578 #endif
1579  // for (typename typPk::iterator iter=tmpPk.begin();iter!=tmpPk.end();iter++)
1580  // cout<<"pol ICI "<<invconv<typename typP::value_type>(*iter)<<endl;
1581  // cout<<"forget "<<tmpdeg<<endl;
1582  // recall=verytmp;
1583  forget(b,dump,tmpdeg,recall);
1584  compress(tmpPk,dump,b,tmpdeg);
1585  //verytmp.erase(verytmp.begin(),verytmp.end());
1586 
1587 
1588 
1589  //forget(b,dump,tmpdeg);
1590 
1591  ttmpP=Crochet(ttmpP,tmpdeg);
1592 #ifdef NO_TWICE_BUG
1593  for(typename typP::iterator iter=P.begin()
1594  ;iter!=P.end();iter++)
1595  if(Degree(*iter)==tmpdeg)
1596  P.erase(iter--);
1597 #endif
1598  // for(typename typP::iterator iter=ttmpP.begin()
1599  // ;iter!=ttmpP.end();iter++)
1600  //P.push_back(*iter);
1601  nbproj=ttmpP.size();
1602  //for(typename typP::iterator iter=ttmpP.begin();iter!=ttmpP.end();iter++)
1603  // tmpconv.push_back(convert<pol>(*iter,b));
1604  //ttmpP.erase(ttmpP.begin(),ttmpP.end());//samedi 24 aout
1605  //nbproj=1;// samedi 24 aout
1606  //Crochetchoix(P,Pk,tmpconv,tmpdeg,b);
1607  //ttmpP.push_back(invconv<typename typP::value_type>(Pk.back()));
1608  //Pk.pop_back();//on elimine de Pk le pol de proj choisi
1609  //pour se ramner au cas ou proj != 0 et P ok
1610  Mk.erase(Mk.begin(),Mk.end());
1611  for (typename typPk::iterator iterpk=tmpPk.begin();
1612  iterpk!=tmpPk.end();iterpk++)
1613  {
1614  // cout<<"iterpk->ind "<<iterpk->ind
1615  // <<"et Isinb(iterpk-ind,b) "<<IsinB(iterpk->ind,b)<<endl;
1616  if (IsinB(iterpk->ind,b))
1617  {
1618  for(typename Base::iterator iterb=b.begin()
1619  ;iterb!=b.end();iterb++)
1620  {
1621  iterb->refuse=(mon*)MAC_REV_REALLOC<mon>
1622  (iterb->refuse,(iterb->taille2)*sizeof(mon),
1623  (iterb->taille2+1)*sizeof(mon));
1624  iterb->refuse[iterb->taille2]=iterpk->ind;
1625  iterb->refuse[iterb->taille2].SetCoeff(1);
1626  iterb->taille2++;
1627  }
1628  }
1629  }
1630  for(typename typPk::iterator iter=tmpPk.begin()
1631  ;iter!=tmpPk.end();iter++)
1632  {
1633  mon *tmp=(mon*)MAC_REV_MALLOC<mon>(sizeof(mon));
1634  *tmp=iter->ind;
1635  tmpMk.push_back(*tmp);
1636  exceed.push_back(tmp);
1637  sizeexceed.push_back(1);
1638  // cout<<"pour Mk iter->ind "<<iter->ind<<endl;
1639  }
1640  //on vient de chuter de
1641  //degre et on a reconstitue les bons mk et pk
1642  k=tmpdeg-1;
1643  //Dump(Pk,dump);
1644  }
1645  }
1646  }
1647  if(flagdoplus)
1648  {
1649 #ifdef unimul
1650  reinit_multiple();
1651 #endif
1652 #ifdef uninf
1653  reinit_nf<pol>();
1654 #endif
1655  map<mon,int,ord> monmember;
1656  // int nbmult=0;
1657  //list<mon> dejavu;
1658  //consttruction des pol ord sup
1659  for(int i=0;i<b.nbvar();i++)
1660  {
1661  for(typename typPk::iterator iter=Pk.begin();iter!=Pk.end();iter++)
1662  {
1663  //cout<<"avant gooddir l'ind "<<iter->ind<<endl;
1664  if(GoodDir((*iter).ind,i,b))
1665  {
1666  mon tmpmon=iter->ind*mon(i,1);
1667  //tmpmon.SetCoeff(1);
1668  //if(!member(tmpMk,tmpmon))
1669  if(!(monmember).count(tmpmon))
1670  {
1671  typename typrecall::iterator iterrec;
1672  (monmember)[tmpmon]=1;
1673  tmpMk.push_back(tmpmon);
1674 #if 0
1675  for(iterrec=verytmp.begin();
1676  (iterrec!=verytmp.end())
1677  &&(!(iterrec->ind.rep==tmpmon.rep));
1678  iterrec++);
1679  if(iterrec!=verytmp.end())
1680  {
1681  // cout<<"g un candidat "<<tmpmon<<" son ind "<<iterrec->ind<<"la comparaison "<<(iterrec->ind.rep==tmpmon.rep)<<endl;
1682  // putingoodshape(P,workvect,Mk,exceed,sizeex,dump,b);
1683  workvect.push_back(*iterrec);
1684  verytmp.erase(iterrec);
1685  continue;
1686  }
1687 #endif
1688  //cout<<"aprfes gooddir"<<endl;
1689  mon * tmp=NULL;
1690  int tmpsize;
1691  //cout<<"avant mult"<<endl;
1692  tmpPk.push_back(mult(i,*iter,dump,b,&tmp,tmpsize));
1693  //attention le coefficient de ind est la taille de
1694  // l'exceed correspondant
1695  // cout<<"apres mult"<<endl;
1696  exceed.push_back(tmp);
1697  sizeexceed.push_back(tmpsize);
1698 #ifdef DEB
1699  cout<<"coucou"<<endl;
1700  for(int j=0;j<tmpsize;j++)
1701  cout<<" "<<tmp[j];
1702  cout<<endl;
1703 #endif
1704  // nbmult++;
1705  }
1706  }
1707  }
1708  }
1709  // recall=verytmp;
1710  // cout<<"nbmult "<<nbmult<<endl;
1711  }
1712 
1713  // cout<<"tmpPK.size "<<tmpPk.size()<<endl;
1714  //Constructyion de pol terminee
1715  //cout<<"ttmpP.size "<<ttmpP.size()<<endl;
1716  //cout<<"avant conv merge"<<endl;
1717 #if 1
1718  {
1719 #if 0
1720  for(typename typPk::iterator iter=verytmp.begin();iter!=verytmp.end();iter++)
1721  {
1722  int good=0;
1723  for(int i=0;i<b.nbvar();i++)
1724  {
1725  if((iter->ind.GetDegree(i)>0)&&(IsinB(my_divmon(iter->ind,i,b),b)))
1726  {
1727  good=1;break;
1728  }
1729  }
1730  if(good)
1731  {
1732  //NON il faut virer les ind de B avant de les pushbacker
1733  if(mon2int(iter->ind)>=iter->size)
1734  {
1735  iter->nf=(coeff*)MAC_REV_REALLOC<coeff>(iter->nf,
1736  iter->size*sizeof(coeff)
1737  ,(mon2int(iter->ind)+1)*sizeof(coeff));
1738  }
1739  iter->nf[mon2int(iter->ind)]=iter->ind.GetCoeff();
1740  iter->ind=mon(0);
1741  workvect.push_back(*iter);
1742  verytmp.erase(iter--);
1743  }
1744  }
1745 #endif
1746  //recall=verytmp;
1747  list<mon*> tmpexceed;
1748  list<int> tmpsizeex;
1749  putingoodshape(P,workvect,tmpMk,tmpexceed,tmpsizeex,dump,b);
1750  my_merge(tmpPk,workvect);
1751  my_merge(exceed,tmpexceed);
1752  my_merge(sizeexceed,tmpsizeex);
1753  }
1754 #endif
1755  conv_merge(tmpPk,ttmpP,exceed,sizeexceed,b);
1756  //cout<<"apres conv merge"<<endl;
1757  //cout<<"tmpMK==empty?? "<<tmpMk.empty()<<endl;
1758  // for(typename typPk::iterator iter=tmpPk.begin();iter!=tmpPk.end();iter++)
1759  // {
1760  // cout<<"iter->ind.GetCoeff() "<<iter->ind.GetCoeff()-1
1761  // <<" et ind "<<iter->ind<<endl;
1762  // }
1763  //cout<<"tmpPK.size "<<tmpPk.size()<<endl;
1764 
1765  //Tue Nov 27 15:57:25 MET 2001
1766  /*
1767  for(typename typPk::iterator iter=tmpPk.begin();iter!=tmpPk.end();iter++)
1768 
1769  {
1770  mon tmp=iter->ind;
1771  tmp.SetCoeff(1);
1772  if((iter->ind.GetDegree()!=0)&&(!member(tmpMk,tmp)))
1773  {
1774  //cout<<"iter->ind.GetCoeff()"<<iter->ind.GetCoeff()-(coeff)1<<" "
1775  // <<tmp<<endl;
1776  tmpMk.push_back(tmp);
1777  //tmpMk.back().SetCoeff(1);
1778  }
1779  }
1780  */
1781  //construction de la matrice maintenant
1782  //positionnement des pointeurs de matrices pour gagner en tps
1783  {
1784  int nnz=0;
1785  //-----------------
1786  //for(typename typMk::iterator iter=tmpMk.begin();iter!=tmpMk.end();iter++)
1787  // cout<<"mon "<<*iter<<endl;
1788  //-----------------
1789  // cout<<"nb proj "<<nbproj<<endl;
1790  for(list<int>::iterator iter=sizeexceed.begin();iter!=sizeexceed.end()
1791  ;iter++)
1792  {
1793  nnz+=*iter;
1794  // cout<<"on a donc de monme pour celui la "<<
1795  // (int)((iter->ind).GetCoeff()-1)<<" d'ou nnz "<<nnz<<endl;
1796  }
1797  //for(typename typPk::iterator iter=tmpPk.begin();iter!=tmpPk.end();iter++)
1798  // {
1799  // int tmp=0;
1800  // for(;(iter->ind).GetCoeff()>(coeff)tmp;tmp++);
1801  // nnz+=tmp-1;
1802  // cout<<"on a donc de monme pour celui la "<<
1803  // (int)((iter->ind).GetCoeff()-1)<<" d'ou nnz "<<nnz<<endl;
1804  // }
1805  // nnz+=tmpPk.size()-nbproj;//le 10/05/2001 avant: nnz+=tmpMk.size()-nbproj;
1806  //le -nbproj rajoute le 23/01/2001!!
1807  // #define DEBUG
1808 #ifdef DEBUG
1809  typename typPk::iterator tmpiter=tmpPk.begin();
1810  list<int>::iterator itersize=sizeexceed.begin();
1811  for(typename list<mon*>::iterator iter=exceed.begin();iter!=exceed.end()
1812  ;tmpiter++,iter++,itersize++)
1813  {
1814  cout<<"pour un exceeed la taille attendue est "
1815  <<*itersize<<endl;
1816  for(int i=0;*itersize>i;i++)//;tmpiter->ind.GetCoeff()>i+1;i++)
1817  {
1818  cout<<"le gus que je regarde "<<(*iter)[i]<<endl;
1819  if(!member(tmpMk,(*iter)[i]))
1820  {
1821  cout<<(*iter)[i]<<endl;
1822  cout<<"dans ce pol "<<invconv<Poly>(*tmpiter)<<endl;
1823  cout<<"l'ind "<<tmpiter->ind<<endl;
1824  exit(-10);
1825  }
1826  }
1827  }
1828 #endif
1829  // #undef DEBUG
1830  cout<<"nnz of matrix "<<nnz<<endl;
1831  //en general la matrice est rectangulaire
1832  void * toto=MAC_REV_MALLOC<coeff>(nnz*sizeof(typename typMat::coeff_t));
1833  //+nnz*sizeof(int)+((*mat)->ncol+1)*sizeof(int));
1834  if (mat.nzval!=NULL) MAC_REV_FREE<typename typMat::coeff_t>
1835  (mat.nzval,mat.nnz
1836  *sizeof(typename typMat::coeff_t));
1837  mat.nrow=tmpPk.size();
1838  mat.ncol=tmpMk.size();
1839  mat.nnz=nnz;
1840  mat.nzval=toto;
1841 #ifdef DEBUG
1842  for(int i=0;i<nnz;i++)
1843  ((typename typMat::coeff_t*)mat.nzval)[i]=(coeff)1000000000000.0;
1844 #endif
1845  // mstore->rowind=(int*)((double*)toto+nnz);
1846  if(mat.rowind!=NULL) free(mat.rowind);
1847  mat.rowind=(int*)malloc(nnz*sizeof(int));
1848  //mstore->colptr=(int*)(mstore->rowind+nnz);//
1849  if(mat.colptr!=NULL) free(mat.colptr);
1850  mat.colptr=(int*)malloc((mat.ncol+1)*sizeof(int));
1851  }
1852  cout<<"matrix of size "<<mat.nrow<<"x"<<mat.ncol<<endl;
1853  //matrice cree rest plus qu'a ecrire dedans ca
1854  {
1855  int *ncol=(int*)calloc(mat.ncol,sizeof(int));
1856  //memset((void*)ncol,0,(*mat)->ncol*sizeof(int));
1857  map<mon,int,ord> mapint;
1858  typename typMk::iterator itermk=tmpMk.begin();
1859  typename typPk::iterator iterpk=tmpPk.begin();
1860  typename list<mon*>::iterator iterex=exceed.begin();
1861  list<int>::iterator itersize=sizeexceed.begin();
1862  int line_num=0;
1863 #ifdef nomap
1864  int **indmonmk=malloc(b.nbvar()*sizeof(int));
1865  for(int i=0;i<b.nbvars();i++)
1866  {
1867  indmon[i]=malloc(size*sizeof(int));
1868  }
1869  for(int i=0;itermk!=tmpMk.end();i++,itermk++)
1870  {
1871  for(int j=0;j<b.nbvars;j++)
1872  {
1873  mon tmp=my_divmon(*itermk,mon(j,1));
1874  indmon[mon2int(tmp)]=i;
1875  }
1876  }
1877 #endif
1878  for(int i=0;itermk!=tmpMk.end();i++,itermk++)
1879  {
1880  mapint[*itermk]=i;
1881  }
1882  iterpk=tmpPk.begin();
1883  for(;iterpk!=tmpPk.end();iterpk++,iterex++,itersize++,line_num++)
1884  {
1885  // if(iterpk->ind.GetDegree()>0)
1886  // {
1887  // mon tmpmon=iterpk->ind;
1888  // tmpmon.SetCoeff(1);
1889  // ncol[mapint[tmpmon]]++;
1890  // cout<<"on est a la ligne "<<line_num<<" ai augmente "<<mapint[(iterpk->ind*(1/iterpk->ind.GetCoeff()))]<<" a cause de son monome dom "<<endl;
1891  // cout<<"le voila "<<(iterpk->ind*(1/iterpk->ind.GetCoeff()))<<endl;
1892  //}
1893  {
1894  // coeff tmpcoeff=(iterpk->ind).GetCoeff()-(coeff)1;
1895 #ifdef nomap
1896  for(int i=0;*itersize>i;i+=2)
1897  ++ncol[indmon[(*iterex)[i]][(*iterex)[i+1]]];
1898 #else
1899  for(int i=0;*itersize>i;i++)
1900  {
1901  //cout<<"iterpk icici ->GetCoeff()"<<iterpk->ind.GetCoeff()<<endl;
1902  // if (mapint.count((*iterex)[i]))
1903  {
1904  ++ncol[mapint[(*iterex)[i]]];
1905  // cout<<" ai augmente "<<mapint[(*iterex)[i]]<<"a cause de iterex "<<endl;
1906  }
1907 #endif
1908  }
1909  }
1910  }
1911  //rajoute le 23/01/2001
1912  //enleve le 17.05/2001
1913  // for(int i=mat.nrow-nbproj;i<mat.nrow;i++)
1914  // ncol[i]--;
1915  //fin rajout c pour prendre en compte que lors de
1916  //de la proj le monome de tete se trouve dans exceed
1917  //fin enlevement
1918  typename typMat::coeff_t* nzval=(typename typMat::coeff_t*)mat.nzval;
1919  int *rowind=mat.rowind;
1920  int *colptr=mat.colptr;
1921  //mise en place des colptr
1922  *colptr=0;
1923  for(int i=0;i<mat.ncol-1;i++)
1924  {
1925  colptr[i+1]=colptr[i]+ncol[i];
1926  //cout<<"nb element colonne "<<i<<" "<<ncol[i]<<endl;
1927  //cout<<"les valeurs de debut de colonne "<<8*colptr[i+1]<<endl;
1928  }
1929  colptr[mat.ncol]=mat.nnz;
1930  //cout<<"mat.nnz "<<mat.nnz<<" "<<mat.nnz*8<<endl;
1931  //fin mise en place
1932  //la on fait des manip symboliques pour savoir ou ecrire
1933  //les coeffs de chaques colonnes ca evite d'avoir a les
1934  //recopier 50000 fois pour construire la matrice
1935  //c bcp plus rapide
1936  itermk=tmpMk.begin();
1937  iterpk=tmpPk.begin();
1938  iterex=exceed.begin();
1939  itersize=sizeexceed.begin();
1940  line_num=0;
1941  //cout<<"nbproj "<<nbproj<<endl;
1942 #if 0
1943 for(;0&&(line_num < (int)(tmpPk.size()-nbproj));
1944  iterpk++,iterex++,itersize++,line_num++)
1945  //les polynome projette sont foutut au bout de la liste!!
1946  //d'ou le tmpPk.size()-nbproj
1947  {
1948  mon tmpmon=iterpk->ind;
1949  tmpmon.SetCoeff(1);
1950  //const unsigned int tmpplus=line_num+1,tmp=line_num;
1951  const unsigned int tmpplus
1952  =mapint[tmpmon]+1,tmp=tmpplus-1;
1953  // cout<<"ici line_num"<<line_num<<" le mon dom est col "<<tmp<<endl;
1954  //ici couille car le ind n'est pas forcement le mon diag
1955  nzval[colptr[tmpplus]-ncol[tmp]]=1;
1956  //fin couille changer un truc
1957  // cout<<"mat.nnz "<<mat.nnz<<endl;
1958  //cout<<"colptr[...]"<<colptr[tmpplus]<<endl;
1959  //cout<<"ncol[....]"<<ncol[tmp]<<endl;
1960  //cout<<"1 a la pos "<<colptr[tmpplus]-ncol[tmp]<<endl;
1961  rowind[colptr[tmpplus]-ncol[tmp]]=line_num;
1962  //cout<<"1 a la ligne "<<rowind[colptr[tmpplus]-ncol[tmp]]<<endl;
1963  ncol[tmp]--;
1964  {
1965  //coeff tmpcoeff=iterpk->ind.GetCoeff()-(coeff)1;
1966  for(int i=0;*itersize>i;i++)
1967  {
1968  const coeff stock=(*iterex)[i].GetCoeff();
1969  (*iterex)[i].SetCoeff(1);
1970  const unsigned int tmpplusex=mapint[(*iterex)[i]]+1;
1971  const unsigned int tmpex=mapint[(*iterex)[i]];
1972  nzval[colptr[tmpplusex]-ncol[tmpex]]
1973  =stock;
1974  rowind[colptr[tmpplusex]-ncol[tmpex]]=line_num;
1975  ncol[tmpex]--;
1976  // cout<<"valeur de ncol["<<tmpex<<"] "<<ncol[tmpex]<<endl;
1977  }
1978  }
1979  MAC_REV_FREE<mon>(*iterex,*itersize*sizeof(mon));
1980  }
1981 #endif
1982  for(;(iterpk!=tmpPk.end());iterpk++,iterex++,itersize++,line_num++)
1983  {
1984  //const unsigned int tmpplus=line_num+1,tmp=line_num;
1985  {
1986  //coeff tmpcoeff=iterpk->ind.GetCoeff()-(coeff)1;
1987  for(int i=0;*itersize>i;i++)
1988  {
1989  const coeff stock=(*iterex)[i].GetCoeff();
1990  (*iterex)[i].SetCoeff(1);
1991  const unsigned int tmpplusex=mapint[(*iterex)[i]]+1;
1992  const unsigned int tmpex=tmpplusex-1;
1993  nzval[colptr[tmpplusex]-ncol[tmpex]]
1994  =stock;
1995  rowind[colptr[tmpplusex]-ncol[tmpex]]=line_num;
1996  ncol[tmpex]--;
1997  }
1998  }
1999  MAC_REV_FREE<mon>(*iterex,*itersize*sizeof(mon));
2000  //free(*iterex);
2001  }
2002  free(ncol);
2003  }
2005  for(typename typPk::iterator iterpk=tmpPk.begin()
2006  ;iterpk!=tmpPk.end();iterpk++)
2007  iterpk->ind.SetCoeff(1);
2008  //iterpk->ind*=1/iterpk->ind.GetCoeff();
2009  // cout<<"la matrice dans newpkmkmatrixof"<<endl;
2010  //cout<<" nombre de non zero "<<mat.nnz<<endl;
2011 #ifdef DEB
2012  affdebug(mat);
2013 #endif
2014  //cout<<"le colptr "<<endl;
2015  //for(int i=0;i<mat.ncol;i++)
2016  // cout<<mat.colptr[i]<<" "<<endl;
2017  // cout<<"les indices de lignes et le nnz"<<endl;
2018  //for(int i=0;i<mat.nnz;i++)
2019  // cout<<mat.rowind[i]<<" "<<((typename typMat::coeff_t*)mat.nzval)[i]<<endl;
2020  //cout<<"fin matrice"<<endl;
2021  Pk.swap(tmpPk);
2022  Mk.swap(tmpMk);
2023 
2024  // for(int i=0;i<mat.nnz;i++)
2025  // cout<<"coeff mat "<<((typename typMat::coeff_t*)mat.nzval)[i]<<" et i "<<i<<endl;
2026  return flagdoplus;
2027 }
2028 //newpkmkmatrixof termine reste plus qu'a tester .... ;-(
2029 
2030 template<typename typdump,typename mon,typename pol>
2031 void findcorresppol(const mon & m,const typdump &dump,pol &res)
2032 {
2033  typedef typename pol::monom_t mondump;
2034  int i,d=m.GetDegree();
2035  typename typdump::const_iterator iter=dump.begin();
2036  for(;(iter!=dump.end())&&(iter->k!=d);iter++);
2037  //localise la dump struct de bon degre
2038  if(iter!=dump.end())
2039  {
2040  for(i=0;(i<iter->size)&&(iter->nf[i].ind.rep!=m.rep);i++);
2041  //cout<<"monomes passe en revue pour chercher "<<m<<" : "<<iter->nf[i].ind<<endl;;
2042  //trouve dans la dump struct le pol qui marche
2043  if (i<iter->size)//estce que je connais?
2044  //oui super
2045  {
2046  //cout<<"g trouve un gus qui convient"<<endl;
2047  //for(int j=0;j<iter->nf[i].size;j++)
2048  // cout<<"et ses coeff sont "<<iter->nf[i].nf[j]<<endl;
2049  //Tue Dec 4 16:12:10 MET 2001
2050  //densify(iter->nf[i],res);}
2051  //Tue Dec 4 16:12:10 MET 2001
2052  res=iter->nf[i];}
2053  else {
2054  //non ben alors il se reecrit en lui meme
2055  res.ind=mondump(0);//m*(1/m.GetCoeff());
2056  res.size=-1;
2057  res.nf=NULL;
2058  }
2059  }
2060  return;
2061 }
2062 
2063 template<typename iterator, typename mon,typename Base>
2064 void varmult(iterator iter1,iterator iter2,mon &var1, mon &var2,const Base &b)
2065 {
2066  for(int i=0;i<b.nbvar();i++)
2067  {
2068  if(iter1->ind.GetDegree(i)>iter2->ind.GetDegree(i))
2069  var2=mon(i,1);
2070  if(iter2->ind.GetDegree(i)>iter1->ind.GetDegree(i))
2071  var1=mon(i,1);
2072  }
2073 }
2074 
2075 template <typename mon,typename pol, typename typdump,typename Base>
2076 pol halfred(const mon &targetind, const pol & p, const typdump & dump
2077  , const Base & b)
2078 {
2079  typedef typename pol::coeff_t coeff;
2080  static const mon monzero=mon(0);
2081  static const typename pol::coeff_t zero(0);
2082  pol res;
2083  int *place=(int*)MAC_REV_MALLOC<int>(p.size*sizeof(int));
2084 #ifdef uninf
2085  int varref;
2086  int flagplus=0;
2087  pol stockpol;
2088  coeff stockcoeff;
2089 #else
2090  mon varref;
2091 
2092 #endif
2093  int maxref=0,i;
2094  for(i=0;i<b.nbvar();i++)
2095  {
2096  if(targetind.GetDegree(i)>p.ind.GetDegree(i))
2097  break;
2098  }
2099 #ifdef uninf
2100  varref=i;
2101 #else
2102  varref=mon(i,1);
2103 #endif
2104 #ifdef DEB
2105  cout<<"p en entree"<<invconv<Poly>(p)<<endl;
2106  cout<<"target "<<targetind<<" et ind "<<p.ind<<" et var "<<varref<<endl;
2107 #endif
2108 #ifdef nosize
2109  maxref=size;
2110 #else
2111  for(int i=0;i<p.size;i++)
2112  {
2113  if(p.nf[i]!=zero)
2114  {
2115 #ifdef uninf
2116  place[i]=mulind(i,varref,b);
2117  if (place[i]>maxref)
2118  maxref=place[i];
2119 #else
2120  int indtmpmon;
2121  mon tmpmon;
2122  int2mon(i,tmpmon);
2123  tmpmon*=varref;
2124  if(IsinB(tmpmon,b))
2125  {
2126  indtmpmon=mon2int(tmpmon);
2127  if(maxref<indtmpmon)
2128  maxref=indtmpmon;
2129  place[i]=indtmpmon;
2130  }
2131  else
2132  {
2133  place[i]=-1;
2134  }
2135 #endif //nored
2136  }
2137  }
2138 #endif //nosize
2139  res.nf=(typename pol::coeff_t*)
2140  MAC_REV_MALLOC<typename pol::coeff_t>
2141  ((maxref+1)*sizeof(typename pol::coeff_t));
2142  for(int i=0;i<=maxref;i++)
2143  res.nf[i]=0;
2144  res.size=maxref+1;
2145  i=0;
2146  for(;i<p.size;i++)
2147  {
2148  if(p.nf[i]!=zero)
2149  {
2150 #ifdef uninf
2151  if(place[i]==-1)
2152  {
2153  pol stock=nf<pol,typdump,Base>(varref,i,dump,b);
2154 #ifdef plus2
2155  if (!flagplus)
2156  {
2157  flagplus=1;
2158  stockpol=stock;
2159  stockcoeff=p.nf[i];
2160  }
2161  else
2162  {
2163  myplus22(res,stockpol,stockcoeff,stock,p.nf[i]);
2164  flagplus=0;
2165  stockcoeff=0;
2166  }
2167 #else
2168  //cout<<" je reduit prr lui"<<endl<<invconv<Poly>(stock)<<endl;
2169  my_plus(res,stock,p.nf[i]);
2170 #endif
2171  }
2172  else
2173  {
2174  res.nf[place[i]]+=p.nf[i];
2175  }
2176 #else
2177  mon tmpmon;
2178  int2mon(i,tmpmon);
2179  tmpmon*=varref;
2180 
2181  if(place[i]==-1)
2182  {
2183  pol stock;
2184  //cout<<"halfred "<<varref*tmpmon<<endl;
2185  findcorresppol(tmpmon,dump,stock);
2186  //cout<<"en retour "<<invconv<Poly>(stock)<<endl;
2187  //res*stock.ind.GetCoeff();
2188  //cout<<"le coeff ici "<<stock.ind.GetCoeff()<<endl;
2189  my_plus(res,stock,p.nf[i]);
2190  //Tue Dec 4 17:29:06 MET 2001
2191  //MAC_REV_FREE<coeff>(stock.nf,stock.size*sizeof(coeff));
2192  //Tue Dec 4 17:29:06 MET 2001
2193  }
2194  else
2195  {
2196  res.nf[mon2int(tmpmon)]+=p.nf[i];
2197  }
2198 #endif
2199  }
2200  }
2201 #ifdef uninf
2202 #ifdef plus2
2203  if(flagplus)
2204  my_plus(res,stockpol,stockcoeff);
2205 #endif
2206 #endif
2207 
2208  res.ind=monzero;
2209  MAC_REV_FREE<int>(place,p.size*sizeof(int));
2210 #ifdef DEB
2211  cout<<" apres reduction "<<invconv<Poly>(res)<<endl;
2212 #endif
2213  return res;
2214 }
2215 
2216 template <typename typPk, typename typdump,typename Base>
2217 void ReduceSpol(typPk &S,const typdump & dump,typPk &redspol,const Base &b)
2218 {
2219  typedef typename typPk::value_type pol;
2220  typedef typename pol::monom_t mon;
2221  typedef typename pol::coeff_t coeff;
2222  list<mon> leadmon;
2223  list<typPk> membermon;
2224 
2225  cout<<"en entree de RedSpol S.size "<<S.size()/2<<endl;
2226  for(typename typPk::iterator iterS=S.begin();iterS!=S.end();iterS++,iterS++)
2227  {
2228  typename typPk::iterator iterS2=iterS;
2229  typename list<mon>::iterator itermon=leadmon.begin();
2230  typename list<typPk>::iterator itermemb=membermon.begin();
2231  mon var1,var2,tmpleadmon;
2232  iterS2++;
2233  varmult(iterS,iterS2,var1,var2,b);
2234  tmpleadmon=iterS->ind*var1;
2235  for(;itermon!=leadmon.end()&&itermon->rep!=tmpleadmon.rep;
2236  itermon++,itermemb++);
2237  if(itermon!=leadmon.end())
2238  {
2239  int yes1=1,yes2=1;
2240  for(typename typPk::iterator tmpiter=itermemb->begin();
2241  tmpiter!=itermemb->end();tmpiter++)
2242  {
2243  if(tmpiter->ind.rep==iterS->ind.rep) yes1=0;
2244  if(tmpiter->ind.rep==iterS2->ind.rep) yes2=0;
2245  }
2246  if(yes1) itermemb->push_back(*iterS);
2247  if(yes2) itermemb->push_back(*iterS2);
2248  }
2249  else
2250  {
2251  typPk verytmp;
2252  leadmon.push_back(tmpleadmon);
2253  membermon.push_back(verytmp);
2254  membermon.back().push_back(*iterS);
2255  membermon.back().push_back(*iterS2);
2256  }
2257  }
2258  //maintenant on a mis en place la structure de Redspol
2259  //reste plus qu'a calculer les bons et a reduire tout ca!!
2260  {
2261  typename list<mon>::iterator itermon=leadmon.begin();
2262  typename list<typPk>::iterator itermemb=membermon.begin();
2263  for(;itermon!=leadmon.end();itermon++,itermemb++)
2264  {
2265  typename typPk::value_type ref;
2266  typename typPk::iterator tmpiter=itermemb->begin();
2267  ref=halfred(*itermon,*tmpiter,dump,b);
2268  // cout<<"ref.size "<<ref.size<<endl;
2269  //cout<<"ref en entier"<<endl<<invconv<Poly>(ref)<<endl;
2270  tmpiter++;
2271  for(;tmpiter!=itermemb->end();tmpiter++)
2272  {
2273  typename typPk::value_type redcur;
2274  redcur=halfred(*itermon,*tmpiter,dump,b);
2275  my_plus(redcur,ref);
2276  if(!Ispolzero(redcur))
2277  {
2278  // cout<<"un redspol pas 0"<<endl<<invconv<Poly>(redcur)<<endl;
2279 // for(int i=0;i<redcur.size;i++)
2280 // cout<<int2mon_[i]<<" ";
2281 // cout<<endl;
2282  redspol.push_back(redcur);
2283  }
2284  else
2285  {
2286  MAC_REV_FREE<coeff>(redcur.nf,redcur.size*sizeof(coeff));
2287  }
2288  }
2289  MAC_REV_FREE<coeff>(ref.nf,ref.size*sizeof(coeff));
2290  }
2291  }
2292 }
2293 
2294 template <typename typPk, typename typdump,typename Base>
2295 void OLD_ReduceSpol(typPk &S,const typdump & dump,typPk &redspol,const Base &b)
2296 {
2297  typedef typename typPk::value_type pol;
2298  typedef typename pol::monom_t mon;
2299  typedef typename pol::coeff_t coeff;
2300  const coeff zero(0);
2301  //cout<<"en entree de RedSpol S.size "<<S.size()/2<<endl;
2302  for(typename typPk::iterator iterS=S.begin();iterS!=S.end();iterS++,iterS++)
2303  {
2304  typename typPk::iterator iterS2=iterS;
2305  mon var1,var2;
2306  typename typPk::value_type res;
2307  int max=0;
2308  mon tmpmon;
2309  iterS2++;
2310  //cout<<"les deux pol sont dans redspol "<<endl;
2311  //cout<<invconv<Poly>(*iterS)<<endl;
2312  //cout<<"et"<<endl;
2313  //cout<<invconv<Poly>(*iterS2)<<endl;
2314  varmult(iterS,iterS2,var1,var2,b);
2315  //cout<<"les var mult "<<var1<<" "<<var2<<endl;
2316  res.ind=mon(zero);
2317  for(int i=0;i<iterS->size;i++)
2318  {
2319  //if(!Iszero(iterS->nf[i]))
2320  if(iterS->nf[i]!=zero)
2321  {
2322  int2mon(i,tmpmon);
2323  //cout<<"les mon red "<<(var1*tmpmon)<<endl;
2324  if(IsinB(var1*tmpmon,b))
2325  if(max<mon2int(var1*tmpmon)) max=mon2int(var1*tmpmon);
2326  }
2327  }
2328  for(int i=0;i<iterS2->size;i++)
2329  {
2330  //if(!Iszero(iterS2->nf[i]))
2331  if(iterS2->nf[i]!=zero)
2332  {
2333  int2mon(i,tmpmon);
2334  // cout<<"les mon red "<<(var1*tmpmon)<<endl;
2335  if(IsinB(var2*tmpmon,b))
2336  if(max<mon2int(var2*tmpmon)) max=mon2int(var2*tmpmon);
2337  }
2338  }
2339  res.nf=(typename typPk::value_type::coeff_t*)
2340  MAC_REV_MALLOC<typename typPk::value_type::coeff_t>
2341  ((max+1)*sizeof(typename typPk::value_type::coeff_t));
2342  for(int i=0;i<=max;i++)
2343  res.nf[i]=0;
2344  res.size=max+1;
2345  for(int i=0;i<iterS->size;i++)
2346  {
2347  //if(!Iszero(iterS->nf[i]))
2348  if(iterS->nf[i]!=zero)
2349  {
2350  mon tmpmon;
2351  int2mon(i,tmpmon);
2352  if(!IsinB(var1*tmpmon,b))
2353  {
2354  pol stock;
2355  //cout<<"je cheche le monome "<<(var1*tmpmon)<<" et var1 vaut "
2356  // <<var1<<endl;
2357  findcorresppol(var1*tmpmon,dump,stock);
2358  //cout<<"stock trouve "<<endl<<invconv<Poly>(stock)<<endl;
2359  //cout<<"stock.size "<<stock.size<<endl;
2360  res*stock.ind.GetCoeff();
2361  my_plus(res,stock,iterS->nf[i]);
2362  }
2363  else
2364  {
2365  // cout<<"je rajoute a "<<var1*tmpmon<<" "<<iterS->nf[i]<<endl;
2366  res.nf[mon2int(var1*tmpmon)]+=iterS->nf[i];
2367  }
2368  // cout<<"a ce tour de boucle res vaut"<<endl<<invconv<Poly>(res)<<endl;
2369  }
2370  }
2371  //cout<<"entre deux boucle res vaut"<<endl<<invconv<Poly>(res)<<endl;
2372  for(int i=0;i<iterS2->size;i++)
2373  {
2374  //if (!Iszero(iterS2->nf[i]))
2375  if(iterS2->nf[i]!=zero)
2376  {
2377  mon tmpmon;
2378  //cout<<"iterS2->size "<<iterS2->size<<endl;
2379  //cout<<" et i "<<i<<endl;
2380  int2mon(i,tmpmon);
2381  //cout<<"mon en cours "<<tmpmon<<" et Is in B "<<
2382  // IsinB(var2*tmpmon,b)<<endl;
2383  if(!IsinB(var2*tmpmon,b))
2384  {
2385  pol stock;
2386  findcorresppol(var2*tmpmon,dump,stock);
2387  // cout<<"stock trouve "<<endl<<invconv<Poly>(stock)<<endl;
2388  res*stock.ind.GetCoeff();
2389  my_plus(res,stock,(coeff)((coeff)(-1)*iterS2->nf[i]));
2390  }
2391  else
2392  {
2393  // int toto=mon2int(var2*tmpmon),tutu=mon2int(var2*tmpmon);
2394  //cout<<"res.size "<<res.size<<endl;
2395  //cout<<"et j'acced a "<<toto
2396  // <<" "<<tutu<<endl;
2397  res.nf[mon2int(var2*tmpmon)]-=iterS2->nf[i];
2398  }
2399  }
2400  //cout<<"a ce tour de boucle res vaut"<<endl<<invconv<Poly>(res)<<endl;
2401  }
2402  if(!Ispolzero(res))
2403  {
2404  // cout<<"un spol qui se reduiot pas a 0"<<endl;
2405  //for(int i=0;i<res.size;i++)
2406  // cout<<"les coeff du qui se reduit pas a 0 "<<res.nf[i]<<endl;
2407  // cout<<"invconv<Poly>"<<endl<<invconv<Poly>(res)<<endl;
2408  redspol.push_back(res);
2409  //break;//ca c pour pas faire 50 tours
2410  // //qd on cherche juste a extraire 1 seul sopl non 0
2411  }
2412  else
2413  {
2414  MAC_REV_FREE<coeff>(res.nf,res.size*sizeof(coeff));
2415  // free(res.nf);
2416  }
2417  }
2418  //cout<<"en sortie redspol.size() "<<redspol.size()<<endl;
2419 }
2420 
2421 template<typename typPk>
2422 int mindeg(const typPk &l)
2423 {
2424  typedef typename typPk::value_type::monom_t mon;
2425  typedef typename mon::coeff_t coeff;
2426  int res=-1;
2427  // cout<<"dans mindeg res au debut"<<res<<endl;
2428  for(typename typPk::const_iterator iter=l.begin() ;iter!=l.end();iter++)
2429  {
2430  int mmax=-1;
2431  // cout<<"tour de boucle de mindeg "<<endl;
2432  for(int i=0;i<iter->size;i++)
2433  if(!Iszero(iter->nf[i]))
2434  {
2435  mon tmpmon;
2436  int2mon(i,tmpmon);
2437  mmax=(mmax<tmpmon.GetDegree())?tmpmon.GetDegree():mmax;
2438  }
2439  // cout<<"mmax ici "<<mmax<<endl;
2440  if (iter->ind.GetCoeff()==(coeff)1)
2441  mmax=(mmax<iter->ind.GetDegree())?iter->ind.GetDegree():mmax;
2442  //cout<<"les gens que je regarde "<<iter->ind<<endl;
2443  if(mmax!=-1)
2444  {
2445  if(res==-1) res=mmax;
2446  res=(mmax>res)?res:mmax;
2447  }
2448  }
2449  //cout<<"resultat de mindeg "<<res<<endl;
2450  return res;
2451 }
2452 
2453 template<typename typP,typename typPk,typename typMk,typename Base
2454 ,typename typdump>
2455 void Crochetchoix(const typP & P,typPk & Pk, typMk & Mk, typPk & redspol,int k
2456  ,typdump & dump, Base &b)
2457 {
2458  typedef typename typP::value_type polyalp;
2459  typedef typename polyalp::monom_t mon;
2460  typedef typename polyalp::coeff_t coeff;
2461  typPk res=Crochet(redspol,k),tmpres;
2462  //typename typPk::iterator iter=res.begin();
2463  // cout<<"entree dans Crochetchoix et k vaut "<<k<<endl;
2464  //cout<<"res.size "<<res.size()<<endl;
2465  for(typename typPk::iterator iter=res.begin();iter!=res.end();iter++)
2466  {
2467  for(typename typPk::iterator iterredspol=redspol.begin();
2468  iterredspol!=redspol.end();iterredspol++)
2469  if(iter->nf==iterredspol->nf)
2470  {
2471  redspol.erase(iterredspol);
2472  break;
2473  }
2474  }
2475  for(typename typPk::iterator iter=res.begin();iter!=res.end();iter++)
2476  {
2477  // cout<<"un nouveau tour de boucle "<<endl;
2478  if (!Ispolzero(*iter))
2479  {
2480  iter->ind=choice(invconv<polyalp>(*iter),b);
2481  //cout<<"g choisi dans Crochetchoix "<<iter->ind<<endl;
2482  //cout<<"a t'il un mon2int ?"<<IsinB(iter->ind,b)<<endl;
2483  //mon tmp10,tmp11;
2484  // int2mon(10,tmp10);int2mon(11,tmp11);
2485  //cout<<"qu'en est il de int2mon(10) et 11 "<<tmp10<<" "<<tmp11<<endl;
2486  //
2487  //
2488  //
2489  //UGLY HACK
2490  remiseenforme(*iter);
2491  //SALE HACK
2492  //
2493  //
2494  //
2495  //
2496  //
2497  *iter/=iter->ind.GetCoeff();//pour la "nf"
2498  iter->ind*=(coeff)1/iter->ind.GetCoeff();//pour l'ind
2499  iter->nf[mon2int(iter->ind)]=0;
2500  //
2501  //
2502  //
2503  //UGLY HACK
2504  remiseenforme(*iter);
2505  //SALE HACK
2506  //
2507  //
2508  //
2509  //
2510  //
2511 
2512  tmpres.push_back(*iter);
2513  //on met a 0 le coeff du mon passe en ind
2514  //maintenant on a une regle en forme comme il faut reste a:
2515  //-reduire les regles deja existantes par rapport acelle ci
2516  //-reduire les autres redspol par rapport a celle ci
2517  for(typename typPk::iterator iterPk=Pk.begin();iterPk!=Pk.end();iterPk++)
2518  if((mon2int(iter->ind)<iterPk->size)&&
2519  (iterPk->nf[mon2int(iter->ind)]!=(coeff)0))//test a zero!!!
2520  {
2521  // cout<<"g trouve un gus qui a un coeff du mon choisi "
2522  // <<iterPk->nf[mon2int(iter->ind)]<<endl;
2523  my_plus(*iterPk,*iter,iterPk->nf[mon2int(iter->ind)]);
2524  iterPk->nf[mon2int(iter->ind)]=0;
2525  //cout<<"apres plus le coeff vaut "
2526  // <<iterPk->nf[mon2int(iter->ind)]<<endl;
2527  }
2528  //attention plus(a,b)==a-coeff_de_ind_b_dans_a*b;
2529  for(typename typPk::iterator iterredspol=iter;iterredspol!=res.end()
2530  ;iterredspol++)
2531  {
2532  // cout<<"redspol.size() "<<redspol.size()<<endl;
2533  //cout<<"iterredspol-ind "<<iterredspol->ind<<" "<<iterredspol->nf<<endl;
2534  if(mon2int(iter->ind)<iterredspol->size &&
2535  iterredspol->nf[mon2int(iter->ind)]!=(coeff)0)//test a 0 ici
2536  {
2537  my_plus(*iterredspol,*iter,iterredspol->nf[mon2int(iter->ind)]);
2538  iterredspol->nf[mon2int(iter->ind)]=0;
2539  }
2540  //cout<<"coucou je suis ici"<<endl;
2541  }
2542  //voila c fait
2543  //maintenant on met a jour la Base b.
2544  for(typename Base::iterator iterb=b.begin();iterb!=b.end();iterb++)
2545  {
2546  iterb->refuse=(mon*)MAC_REV_REALLOC<mon>
2547  (iterb->refuse,(iterb->taille2)*sizeof(mon),
2548  (iterb->taille2+1)*sizeof(mon));
2549  iterb->refuse[iterb->taille2]=iter->ind;
2550  iterb->refuse[iterb->taille2].SetCoeff(1);
2551  iterb->taille2++;
2552  }
2553  res.erase(iter--);
2554  break;//comme ca on fait pas 50 tours.
2555  }
2556  }
2557  for (typename typPk::iterator iterpk=Pk.begin();iterpk!=Pk.end();iterpk++)
2558  {
2559  // cout<<"iterpk->ind "<<iterpk->ind<<"et Isinb(iterpk-ind,b) "<<IsinB(iterpk->ind,b)<<endl;
2560  if (IsinB(iterpk->ind,b))
2561  {
2562  for(typename Base::iterator iterb=b.begin();iterb!=b.end();iterb++)
2563  {
2564  iterb->refuse=(mon*)MAC_REV_REALLOC<mon>
2565  (iterb->refuse,(iterb->taille2)*sizeof(mon),
2566  (iterb->taille2+1)*sizeof(mon));
2567  iterb->refuse[iterb->taille2]=iterpk->ind;
2568  iterb->refuse[iterb->taille2].SetCoeff(1);
2569  iterb->taille2++;
2570  }
2571  }
2572  }
2573  my_merge(Pk,tmpres);//les gens dans res\tmpres ne sont pas detruits!!!
2574  my_merge(redspol,res);
2575  return;
2576 }
2577 //assomption de Destroy Crochet choix met le "gagnant " a la fin
2578 template<typename typPk>
2579 void Destroyredspol(typPk &redspol,const typPk &Pk)
2580 {
2581  typename typPk::const_iterator iterpk=--Pk.end();
2582  for(typename typPk::iterator iter=redspol.begin();
2583  iter!=redspol.end();iter++)
2584  {
2585  if(iter->nf!=iterpk->nf)
2586  MAC_REV_FREE<typename typPk::value_type::coeff_t>(iter->nf
2587  ,iter->size
2588  *sizeof(typename typPk::value_type::coeff_t));
2589  }
2590 }
2591 #ifndef NO_TWICE
2592 template<typename typP,typename typPk,typename typMk
2593  ,typename Base,typename typdump, typename typrecall>
2594 void NewCrochetchoix(typP & P,typPk & Pk,typMk & Mk, typPk & redspol
2595  ,int &k,typdump &dump, Base &b, typrecall & recall)
2596 #else
2597 template<typename typP,typename typPk,typename typMk
2598  ,typename Base,typename typdump, typename typrecall>
2599 void NewCrochetchoix(typP & P,typPk & Pk,typMk & Mk, typPk & redspol
2600  ,int &k,typdump &dump, Base &b, typrecall & recall
2601  ,typMk &Spoldejavu)
2602 #endif
2603  //template<typename typP,typename typPk,typename typMk,typename Base,typename typdump>
2604 //void NewCrochetchoix(const typP & P,typPk & Pk,typMk & Mk, typPk & redspol
2605 // ,int &k,typdump &dump, Base &b)
2606  //en cours d'ecriutre inoperationnel ,pour le moment
2607  //comme le Newdestroystore...
2608 {
2609  //displaymon();
2610  typedef typename typP::value_type polyalp;
2611  typedef typename polyalp::monom_t mon;
2612  typedef typename polyalp::coeff_t coeff;
2613  // for(typename typPk::iterator iter=redspol.begin();iter!=redspol.end();iter++)
2614  //cout<<"les gens dans redspol "<<endl<<invconv<polyalp>(*iter)<<endl;
2615 
2616  typPk res=Crochet(redspol,k),tmpres;
2617  for(typename typPk::iterator iter=res.begin();iter!=res.end();iter++)
2618  {
2619  for(typename typPk::iterator iterredspol=redspol.begin();
2620  iterredspol!=redspol.end();iterredspol++)
2621  if(iter->nf==iterredspol->nf)
2622  {
2623  redspol.erase(iterredspol);
2624  break;
2625  }
2626  }
2627 
2628  for(typename typPk::iterator iter=res.begin();iter!=res.end();iter++)
2629  {
2630  // cout<<"un nouveau tour de boucle "<<endl;
2631  if (!Ispolzero(*iter))
2632  {
2633  //iter->ind=choice(invconv<polyalp>(*iter));
2634  iter->ind=choice(*iter,b);
2635  //cout<<"le pol pas zero "<<(invconv<polyalp>(*iter))<<endl;
2636  if(iter->ind.GetDegree()<k)
2637  {
2638 
2639  k=iter->ind.GetDegree();
2640  iter->ind=mon(0);
2641 #ifdef NO_TWICE_FALL
2642  P.push_back(invconv<polyalp>(*iter));
2643 #endif
2644  //cout<<"le pol pas zero "<<(invconv<polyalp>(*iter))<<endl;
2645  //cout<<"passage par bout de code en plus "<<endl;
2646  my_merge(res,tmpres);
2647  my_merge(redspol,res);
2648  tmpres.erase(tmpres.begin(),tmpres.end());
2649  res.erase(res.begin(),res.end());
2650  res=Crochet(redspol,k);
2651  //cout<<"newres.size "<<res.size()<<endl;
2652  for(typename typPk::iterator iterres=res.begin()
2653  ;iterres!=res.end();iterres++)
2654  {
2655  for(typename typPk::iterator iterredspol=redspol.begin();
2656  iterredspol!=redspol.end();iterredspol++)
2657  if(iterres->nf==iterredspol->nf)
2658  {
2659  redspol.erase(iterredspol);
2660  break;
2661  }
2662  }
2663  iter=res.begin();
2664  //iter->ind=choice(invconv<polyalp>(*iter));
2665  iter->ind=choice(*iter,b);
2666  Dump(Pk,dump);//c pour detruire Pk dans forget
2667  //ca ne respecte pas la structure du dump!!!
2668  recover(Pk,Mk,dump,k);
2669 #ifdef NO_TWICE
2670  Listedejafait(Mk,Spoldejavu);
2671 #endif
2672  forget(b,dump,k,recall);
2673  //forget(b,dump,k);
2674  compress(Pk,redspol,dump,b,k);
2675  //swap(*iter,*res.rbegin());//on veut ne plus
2676  //iter=--res.end();//refaire d'autre tours
2677  }
2678  //cout<<"g choisi dans Crochetchoix "<<iter->ind<<endl;
2679  //cout<<"a t'il un mon2int ?"<<IsinB(iter->ind,b)<<endl;
2680  //mon tmp10,tmp11;
2681  // int2mon(10,tmp10);int2mon(11,tmp11);
2682  //cout<<"qu'en est il de int2mon(10) et 11 "<<tmp10<<" "<<tmp11<<endl;
2683  //
2684  //
2685  //
2686 #ifdef UGLY_HACK
2687  remiseenforme(*iter);
2688 #endif
2689  //SALE HACK
2690  //
2691  //
2692  //
2693  //
2694  //
2695  *iter/=iter->ind.GetCoeff();//pour la "nf"
2696  iter->ind*=(coeff)1/iter->ind.GetCoeff();//pour l'ind
2697  iter->nf[mon2int(iter->ind)]=0;
2698  //
2699  //
2700  //
2701 #ifdef UGLY_HACK
2702  remiseenforme(*iter);
2703 #endif
2704  //SALE HACK
2705  //
2706  //
2707  //
2708  //
2709  //
2710 
2711  tmpres.push_back(*iter);
2712  //on met a 0 le coeff du mon passe en ind
2713  //maintenant on a une regle en forme comme il faut reste a:
2714  //-reduire les regles deja existantes par rapport acelle ci
2715  //-reduire les autres redspol par rapport a celle ci
2716  for(typename typPk::iterator iterPk=Pk.begin();iterPk!=Pk.end();iterPk++)
2717  if((mon2int(iter->ind)<iterPk->size)&&
2718  (iterPk->nf[mon2int(iter->ind)]!=(coeff)0))//test a zero!!!
2719  {
2720  //cout<<"g trouve un gus qui a un coeff du mon choisi "<<endl;
2721  //cout<<"le voila "<<invconv<Poly>(*iterPk)<<endl;
2722  //<<iterPk->nf[mon2int(iter->ind)]<<endl;
2723  coeff tmpcoeff=iterPk->nf[mon2int(iter->ind)];
2724  //cout<<"le coeff "<<tmpcoeff<<" tmpind "<<mon2int(iter->ind)<<endl;
2725  my_plus(*iterPk,*iter,tmpcoeff);
2726  iterPk->nf[mon2int(iter->ind)]=0;
2727  //cout<<"apres plus le coeff vaut "
2728  // <<iterPk->nf[mon2int(iter->ind)]<<endl;
2729  //cout<<"apres mise a jour"<<endl<<invconv<Poly>(*iterPk)<<endl;
2730  }
2731  //attention plus(a,b)==a-coeff_de_ind_b_dans_a*b;
2732  typename typPk::iterator iterredspol=iter;
2733  iterredspol++;
2734  for(;iterredspol!=res.end();iterredspol++)
2735  {
2736  //cout<<"redspol.size() "<<redspol.size()<<endl;
2737  //cout<<"iterredspol-ind "<<iterredspol->ind<<" "<<iterredspol->nf<<endl;
2738  if(mon2int(iter->ind)<iterredspol->size &&
2739  iterredspol->nf[mon2int(iter->ind)]!=(coeff)0)//test a 0 ici
2740  {
2741  coeff tmpcoeff=iterredspol->nf[mon2int(iter->ind)];
2742  my_plus(*iterredspol,*iter,tmpcoeff);
2743  iterredspol->nf[mon2int(iter->ind)]=0;
2744  // cout<<"coucou je suis ici "<<
2745  // iterredspol->nf[mon2int(iter->ind)]<<endl;
2746  }
2747  }
2748  //au tour de tmpres...
2749  for(iterredspol=tmpres.begin();iterredspol!=tmpres.end();iterredspol++)
2750  {
2751  //cout<<"redspol.size() "<<redspol.size()<<endl;
2752  //cout<<"iterredspol-ind "<<iterredspol->ind<<" "<<iterredspol->nf<<endl;
2753  if(mon2int(iter->ind)<iterredspol->size &&
2754  iterredspol->nf[mon2int(iter->ind)]!=(coeff)0)//test a 0 ici
2755  {
2756  coeff tmpcoeff=iterredspol->nf[mon2int(iter->ind)];
2757  my_plus(*iterredspol,*iter,tmpcoeff);
2758  iterredspol->nf[mon2int(iter->ind)]=0;
2759  // cout<<"coucou je suis ici "<<
2760  // iterredspol->nf[mon2int(iter->ind)]<<endl;
2761  }
2762  }
2763  //voila c fait
2764  //maintenant on met a jour la Base b.
2765  for(typename Base::iterator iterb=b.begin();iterb!=b.end();iterb++)
2766  {
2767  int tmptaille1=0;
2768  mon *tmp=(mon*)MAC_REV_MALLOC<mon>(iterb->taille1*sizeof(mon));
2769  for(int i=0;i<iterb->taille1;i++)
2770  if(!isdivisible(iter->ind,iterb->accept[i],b))
2771  tmp[tmptaille1++]=iterb->accept[i];
2772  tmp=(mon*)MAC_REV_REALLOC<mon>(tmp,iterb->taille1*sizeof(mon)
2773  ,tmptaille1*sizeof(mon));
2774  MAC_REV_FREE<mon>(iterb->accept,iterb->taille1*sizeof(mon));
2775  iterb->accept=tmp;
2776  iterb->taille1=tmptaille1;
2777  if(iterb->taille1==0)
2778  {
2779  MAC_REV_FREE<mon>(iterb->refuse,iterb->taille2*sizeof(mon));
2780  b.erase(iterb--);
2781  continue;
2782  }
2783  iterb->refuse=(mon*)MAC_REV_REALLOC<mon>
2784  (iterb->refuse,(iterb->taille2)*sizeof(mon),
2785  (iterb->taille2+1)*sizeof(mon));
2786  iterb->refuse[iterb->taille2]=iter->ind;
2787  // cout<<"reffuse rajoute "<<iter->ind<<endl;
2788  iterb->refuse[iterb->taille2].SetCoeff(1);
2789  iterb->taille2++;
2790  }
2791  res.erase(iter--);
2792  }
2793  //break;//comme ca on fait pas 50 tours.
2794  }
2795 
2796  for (typename typPk::iterator iterpk=Pk.begin();iterpk!=Pk.end();iterpk++)
2797  {
2798  //cout<<"iterpk->ind "<<iterpk->ind<<"et Isinb(iterpk-ind,b) "<<IsinB(iterpk->ind,b)<<endl;
2799  //cout<<"le pol "<<invconv<Poly>(*iterpk)<<endl;
2800  if (IsinB(iterpk->ind,b))
2801  {
2802  for(typename Base::iterator iterb=b.begin();iterb!=b.end();iterb++)
2803  {
2804  iterb->refuse=(mon*)MAC_REV_REALLOC<mon>
2805  (iterb->refuse,(iterb->taille2)*sizeof(mon),
2806  (iterb->taille2+1)*sizeof(mon));
2807  iterb->refuse[iterb->taille2]=iterpk->ind;
2808  iterb->refuse[iterb->taille2].SetCoeff(1);
2809  iterb->taille2++;
2810  }
2811  }
2812  }
2813 #ifdef NO_TWICE_FALL_CHOICE
2814  for(typename typPk::iterator iter=tmpres.begin();iter!=tmpres.end();iter++)
2815  P.push_back(invconv<polyalp>(*iter));
2816 #endif
2817  my_merge(Pk,tmpres);//les gens dans res\tmpres ne sont pas detruits ici!!
2818  my_merge(redspol,res);
2819  //displaymon();
2820  return;
2821 }
2822 
2823 template<typename typPk>
2824 void NewDestroyredspol(typPk &redspol,const typPk &Pk)
2825 {
2826  // typename typPk::const_iterator iterpk=--Pk.end();
2827  for(typename typPk::iterator iter=redspol.begin();
2828  iter!=redspol.end();iter++)
2829  {
2830  // if(iter->nf!=iterpk->nf)
2831  MAC_REV_FREE<typename typPk::value_type::coeff_t>(iter->nf,iter->size*sizeof(typename typPk::value_type::coeff_t));
2832  }
2833 }
2834 
2835 template<typename typMk>
2836 void Listedejafait(const typMk &Mk,typMk &Spoldejavu)
2837 {
2838  Spoldejavu.erase(Spoldejavu.begin(),Spoldejavu.end());
2839  for(typename typMk::const_iterator iter1=Mk.begin();iter1!=Mk.end();
2840  iter1++)
2841  for(typename typMk::const_iterator iter2=iter1;iter2!=Mk.end();
2842  iter2++)
2843  {
2844  typename typMk::value_type tmp=lcm(*iter1,*iter2);
2845  if (tmp.GetDegree()==iter1->GetDegree()+1)
2846  Spoldejavu.push_back(tmp);
2847  }
2848 }
2849 
2850 template<typename typP,typename typPk,typename typdump,typename Base
2851 , template<typename T> class tmptypmat >
2852 void algo(typP P,typdump &dump,Base &b)
2853 {
2854  // int toto=0;
2855  typedef list<typename typPk::value_type::monom_t> typMk;
2856  typedef typename typMk::value_type mon;
2857  typMk Mk;
2858  typMk Spoldejavu;
2859  typPk Pk,S;
2860  //typP recall
2861  typPk recall;
2862  //Base b;
2863  int go_on=1;
2864  typedef tmptypmat<typename typP::value_type::coeff_t> typMat;
2865  typMat Mat;
2866  int nouveaumon,allpolused=0,maxdeg,k,*pr,*pc;
2867  //cout<<"avant init"<<endl;
2868  init_algo<typMat>(P,nouveaumon,maxdeg,k,Pk,Mk,b,dump);
2869  //cout<<"apres init"<<endl;
2870 #ifdef dimpos
2871  go_on=stop_degree(b);
2872  cout<<"je m'arrete a ce degre "<<go_on<<endl;
2873  while((nouveaumon||(k<=maxdeg))&& ((go_on>=k)||(k<=maxdeg)))
2874 #else
2875  while((nouveaumon||(k<=maxdeg)))
2876 #endif
2877  {
2878  // if (toto>=3) {exit(10);}
2879  //toto++;
2880  int killspol;
2881  // for(typename Base::const_iterator p=b.begin();p!=b.end();p++)
2882 // {
2883 
2884 // for(int i=0;i<p->taille1;i++)
2885 // {
2886 // cout<<"p.accept[i] "<<p->accept[i]<<endl;
2887 // }
2888 // for(int i=0;i<p->taille2;i++)
2889 // {
2890 // cout<<"p.refuse[i] "<<p->refuse[i]<<endl;
2891 // }
2892 // }
2893 //#define DEB
2894 #ifdef DEB
2895  cout<<"poly a la fin de la boulcle de l'algo"<<endl;
2896  for(typename typPk::iterator iter=Pk.begin();iter!=Pk.end();iter++)
2897  //cout<<"les sizes "<<iter->size<<endl;
2898  cout<<invconv<typename typP::value_type>(*iter)<<endl;
2899 #endif
2900  //#undef DEB
2901  //cout<<"Spolordsup"<<endl;
2902 #ifdef NO_TWICE
2903  S=Spolordsup(Pk,b,Spoldejavu);
2904 #else
2905  S=Spolordsup(Pk,b);
2906 #endif
2907 
2908 #ifdef experiment
2909  cout<<"S.back().ind.GetCoeff().rep "<<S.back().ind.GetCoeff().rep<<" k "<<k<<endl;
2910  if((S.back().ind.GetCoeff().rep<k) && (k>=maxdeg))
2911  {go_on=0;continue;}
2912  S.pop_back();
2913 #endif
2914  //cout<<"newpkmkmatrixof"<<endl;
2915  //cout<<"Pk.size() "<<Pk.size()<<endl;
2916 #ifdef NO_TWICE
2917  killspol=!newPkMkMatrixof(Mat,Pk,P,Mk,k,b,dump,recall,Spoldejavu);
2918 #else
2919  killspol=!newPkMkMatrixof(Mat,Pk,P,Mk,k,b,dump,recall);
2920 #endif
2921  // killspol=!newPkMkMatrixof(Mat,Pk,P,Mk,k,b,dump);
2922  if(killspol) S.erase(S.begin(),S.end());
2923  if (k+1>=maxdeg) allpolused=1;
2924  if(Mk.size()==0) nouveaumon=0;
2925  //cout<<"j'en suis a k="<<k<<endl;
2926  //cout<<"Ici dans algo Mat"<<endl;
2927  //affdebug(Mat);
2928  //Solve affecte a Mat la valeur U
2929  //cout<<"solve"<<endl;
2930  //for(typename typPk::iterator iter=Pk.begin();iter!=Pk.end();iter++)
2931  // cout<<"avant solve les ind "<<iter->ind<<endl;
2932  //for(typename typPk::iterator iter=Pk.begin();iter!=Pk.end();iter++)
2933  // cout<<"avant solve les pol "<<invconv<Poly>(*iter)<<endl;
2934  //if(k==3) exit(-10);
2935  //for(typename typMk::iterator iter=Mk.begin();iter!=Mk.end();iter++)
2936  // cout<<"monomes dans Mk "<<*iter<<endl;
2937  if (Mat.ncol!=0)
2938  {
2939  Solve(Mat,Pk,&pr,&pc);
2940  //for(int kk=0;kk<Mk.size();kk++)
2941  // cout<<"permc "<<kk<<" "<<pc[kk]<<endl;
2942  inverse(pc,Mk.size());
2943  Dopermu(Mk,pc);
2944  {
2945  //ici on remet les ind a la bonne valuer
2946  //a inclure dans une petite fonction inline apres
2947  int j=0;
2948  typename typMk::iterator itermon=Mk.begin();
2949  typename typPk::iterator iter;
2950  for(iter=Pk.begin();
2951  itermon!=Mk.end();iter++,itermon++,j++)
2952  {
2953  if(!Iszero(Mat(j,j)))
2954  {
2955  // cout<<"ligne "<<j<<" je mets le monome "<<*itermon<<endl;
2956  iter->ind=*itermon*(iter->ind.GetCoeff());
2957  }
2958  else
2959  {
2960  iter->ind=mon(0);
2961  }
2962  }
2963  //for(;itermon!=Mk.end();iter++,itermon++)
2964  // iter->ind=mon(0);
2965  }
2966  free(pr);
2967  free(pc);
2968  }
2969 
2970  //appliquer les permutation a MK!!!!!!!!
2971  // for(typename typPk::iterator iter=Pk.begin();iter!=Pk.end();iter++)
2972  // cout<<"apres solve les ind "<<iter->ind<<endl;
2973  //for(typename typPk::iterator iter=Pk.begin();iter!=Pk.end();iter++)
2974  // cout<<"apres solve les pol "<<invconv<Poly>(*iter)<<endl;
2975  //
2976  //
2977  //APPLIQUER LES PERMUTYATIONS A MK!!
2978  //
2979  //
2980  //
2981  //
2982  if ((unsigned)my_rank(Mat)==Mk.size())
2983  //matrice de rang plein
2984  {
2985  typPk redspol,secd=secondmembre(Mat,Pk);;
2986  //secondmembre2(Mat,Pk,secd);
2987  //typename typPk::iterator iter=Pk.begin();
2988  cout<<"matrice de rang plein "<<endl;
2989  //for(unsigned int i=0;i<Mk.size();i++,iter++);
2990  //Pk.erase(iter,Pk.end());
2991  //cout<<"Dump "<<endl;
2992  Dump(Pk,dump);
2993  //cout<<"Reduce Spol "<<endl;
2994  ReduceSpol(S,dump,redspol,b);
2995  //cout<<"secd.size() "<<secd.size()<<endl;
2996  my_merge(redspol,secd);
2997  if(redspol.size()==0)
2998  {
2999  //a voir.... Dump(Pk,dump);
3000  k++;
3001  continue;
3002  //la matrice a rang plein
3003  //ET les Spol\secondmembre de ce niveau se ,reduisent a 0
3004  }
3005  else
3006  {
3007  //on a des spol\secondmembre qui se reduisent pas a 0
3008  //cad un defaut de commuatation
3009  nouveaumon=1;
3010  cout<<"redspol.size() "<<redspol.size()<<endl;
3011  //cout<<invconv<typename typP::value_type>(redspol.front())<<endl;
3012  k=mindeg(redspol);
3013  //cout<<"le mindeg ici vaut "<<k<<endl;
3014  //cout<<"Pk.size() avant recover "<<Pk.size()<<endl;
3015  recover(Pk,Mk,dump,k);
3016 #ifdef NO_TWICE
3017  Listedejafait(Mk,Spoldejavu);
3018 #endif
3019  //cout<<"Pk.size() apres recover "<<Pk.size()<<endl;
3020  forget(b,dump,k,recall);
3021  //forget(b,dump,k);
3022  //cout<<"Pk.size() avant Crochetchoix "<<Pk.size()<<endl;
3023 #ifdef NO_TWICE
3024  NewCrochetchoix(P,Pk,Mk,redspol,k,dump,b,recall,Spoldejavu);
3025 #else
3026  NewCrochetchoix(P,Pk,Mk,redspol,k,dump,b,recall);
3027 #endif
3028  //NewCrochetchoix(P,Pk,Mk,redspol,k,dump,b);
3029  //cout<<"Pk.size apres Crochetchoix "<<Pk.size()<<" et k "<<k<<endl;
3030  NewDestroyredspol(redspol,Pk);
3031  compress(Pk,dump,b,k);
3032  Dump(Pk,dump);
3033  //misa jour de B dans crochet choix!!
3034 #ifdef dimpos
3035  go_on=stop_degree(b);
3036  cout<<"go on ici vaut "<<go_on<<endl;
3037 #endif
3038 
3039  continue;
3040  }
3041  }
3042  else
3043  //la matrice n'est pas de rang plein
3044  {
3045  cout<<"matrice de rang pas plein "<<endl;
3046  typPk secd;
3047  AddB(Mat,Pk,Mk,dump,b);
3048  //
3049  //secondmembre supprime des trucs dans Pk!!
3050  //
3051  secd=secondmembre(Mat,Pk);
3052  rajoute_voisins(Pk,Mk,dump,b);
3053  //ne selectionne que les non nuls
3054  if(secd.size()==0)
3055  {
3056  typPk redspol;
3057  //for(int i=Pk.size();i>rank(Mat);i--)
3058  //{
3059  // if(Pk.back().size!=0)
3060  // MAC_REV_FREE<typename typMat::coeff_t>(Pk.rbegin()->nf
3061  // ,Pk.rbegin()->size*sizeof(typename typMat::coeff_t));
3062  // Pk.pop_back();
3063  //}//on vire les 0 avant de dumper
3064  // AddB(Mat,Pk,Mk,dump,b);
3065  Dump(Pk,dump);
3066  ReduceSpol(S,dump,redspol,b);
3067  if(redspol.size()==0)
3068  {
3069  // forget(b,dump,k);
3070  //AddB(Mat,Pk,Mk,b);
3071  //Dump(Pk,dump);
3072  //ici on modifie Pk dans AddB
3073  //<=> forget(b,dump,k) AddB(..) Dump(Pk,dump);
3074  k++;
3075 #ifdef dimpos
3076  go_on=stop_degree(b);
3077  cout<<"go on ici vaut "<<go_on<<endl;
3078 #endif
3079 
3080  continue;
3081  //la matrice a pas rang plein second membre =0
3082  //ET les Spol de ce niveau se ,reduisent a 0
3083  }
3084  else
3085  {
3086  //on a des spol qui se reduisent pas a 0
3087  //cad un defaut de commutation
3088  k=mindeg(redspol);
3089  recover(Pk,Mk,dump,k);
3090 #ifdef NO_TWICE
3091  Listedejafait(Mk,Spoldejavu);
3092 #endif
3093  forget(b,dump,k,recall);
3094  //forget(b,dump,k);
3095  cout<<"il ya un passage par mat rang pas"
3096  <<"plein et pol non zero"<<endl;
3097 #ifdef NO_TWICE
3098  NewCrochetchoix(P,Pk,Mk,redspol,k,dump,b,recall,Spoldejavu);
3099 #else
3100  NewCrochetchoix(P,Pk,Mk,redspol,k,dump,b,recall);
3101 #endif
3102  //NewCrochetchoix(P,Pk,Mk,redspol,k,dump,b);
3103  NewDestroyredspol(redspol,Pk);
3104  compress(Pk,dump,b,k);
3105  Dump(Pk,dump);
3106 #ifdef dimpos
3107  go_on=stop_degree(b);
3108  cout<<"go on ici vaut "<<go_on<<endl;
3109 #endif
3110 
3111  continue;
3112  }
3113  }
3114  else
3115  {
3116  //on a des pol qui se reduisent pas a 0
3117  //cad un defaut de commuatation dans les coins
3118  typPk redspol;
3119  //for(int i=Pk.size();i>rank(Mat);i--)
3120  // Pk.pop_back();
3121  //cout<<"PK. size "<<Pk.size()<<" Mat.nbcol "<<Mat.ncol<<endl;
3122  //cout<<"rank(Mat) "<<rank(Mat)<<endl;
3123  //int j=0;
3124  //cout<<"avant recover et meme avant le dump "<<endl;
3125  //for(typename typPk::iterator iter = secd.begin();iter!=secd.end()
3126  // ;iter++,j++)
3127  // cout<<"pol de secd num "<<j<<endl<<invconv<Poly>(*iter)<<endl;
3128  // AddB(Mat,Pk,Mk,b);
3129  //cout<<"apres ADDB le dump "<<endl;
3130  //for(typename typPk::iterator iter = Pk.begin();iter!=Pk.end()
3131  // ;iter++)
3132  // cout<<invconv<Poly>(*iter)<<endl;
3133  Dump(Pk,dump);
3134  //cout<<"secd.size()" <<secd.size()<<endl;
3135  ReduceSpol(S,dump,redspol,b);
3136  my_merge(secd,redspol);
3137  k=mindeg(secd);
3138  recover(Pk,Mk,dump,k);
3139 #ifdef NO_TWICE
3140  Listedejafait(Mk,Spoldejavu);
3141 #endif
3142  //cout<<"apres recover"<<endl;
3143  // for(typename typPk::iterator iter = Pk.begin();iter!=Pk.end()
3144  // ;iter++)
3145  // cout<<invconv<Poly>(*iter)<<endl;
3146  //cout<<"les Spol non reduits"<<endl;
3147  //for(typename typPk::iterator iter = secd.begin();iter!=secd.end()
3148  // ;iter++)
3149  // cout<<invconv<Poly>(*iter)<<endl;
3150  forget(b,dump,k,recall);
3151  //forget(b,dump,k);
3152  //cout<<"il ya un passage par mat pas rang plein et Spol non zero"<<endl;
3153  //for(typename typPk::iterator iter = secd.begin();iter!=secd.end()
3154  // ;iter++)
3155  // cout<<invconv<Poly>(*iter)<<endl;
3156 #ifdef NO_TWICE
3157  NewCrochetchoix(P,Pk,Mk,redspol,k,dump,b,recall,Spoldejavu);
3158 #else
3159  NewCrochetchoix(P,Pk,Mk,secd,k,dump,b,recall);
3160 #endif
3161  //NewCrochetchoix(P,Pk,Mk,secd,k,dump,b);
3162  NewDestroyredspol(secd,Pk);
3163  //for(typename typPk::iterator iter = Pk.begin();iter!=Pk.end()
3164  // ;iter++)
3165  // cout<<invconv<Poly>(*iter)<<endl;
3166  compress(Pk,dump,b,k);
3167  Dump(Pk,dump);
3168 #ifdef dimpos
3169  go_on=stop_degree(b);
3170  cout<<"go on ici vaut "<<go_on<<endl;
3171 #endif
3172 
3173  continue;
3174  }
3175  }
3176  }
3177 
3178  Mat.destroystore();
3179  //while nouveau mon etc...
3180  // Pk=recomposePk(dump);
3181  //return Pk;
3182  // return;
3183 #ifdef DEBUG
3184  for(typename Base::const_iterator p=b.begin();p!=b.end();p++)
3185  {
3186  for(int i=0;i<p->taille1;i++)
3187  {
3188  cout<<"p.accept[i] "<<p->accept[i]<<endl;
3189  }
3190  for(int i=0;i<p->taille2;i++)
3191  {
3192  cout<<"p.refuse[i] "<<p->refuse[i]<<endl;
3193  }
3194  }
3195 #endif
3196  cout<<"sortie d'algo flash"<<endl;
3197  return ;//dump;
3198  //comme ca on conserve le tri par degre des formes normales et
3199  //donc la construction des operateurs de multiplication se
3200  //fait plus vite.. :-)
3201 
3202 }
Setnbvars
void Setnbvars(const typP &tmpPk, Base &b)
Definition: corealgo.hpp:204
init_algo
void init_algo(typP &P, int &nouveaumon, int &maxdeg, int &k, typPk &Pk, typMk &Mk, Base &b, typdump &dump)
Definition: corealgo.hpp:293
remiseenforme
void remiseenforme(typpol &p)
Definition: ugly.hpp:2
my_plus2
void my_plus2(pol &res1, pol &res2, const pol &nf, const coeff &toto1, const coeff &toto2)
Definition: corealgo.hpp:377
minmaxdegP
int minmaxdegP(typP P, int &maxdeg)
Definition: corealgo.hpp:184
dumpstruct
Definition: dump.hpp:2
putingoodshape
void putingoodshape(const typP &P, typPk &workvect, const typMk &tmpMk, typexceed &exceed, typsize &sizeex, const typdump &dump, const Base &b)
Definition: corealgo.hpp:1402
AddB
void AddB(const typmat &mat, typPk &Pk, const typMk &Mk, const typexceed &exceed, const typsizeexceed &sizeexceed, const typdump &dump, typB &b, monomial_server &serv)
Definition: pol2terspecial.hpp:2470
affdebug
void affdebug(const typmat &m)
Definition: io.hpp:30
max
#define max(a, b)
Definition: alp_f2c.H:167
compress
MSKCONST char int int compress
Definition: mosek.h:4502
Solve
list< polbis< mono, T > > & Solve(typmat &S, std::list< polbis< mono, T > > &TildePk, int **pr, int **pc, workspace &w)
Definition: pol2bisspecial.hpp:609
my_plus
void my_plus(pol &res, const pol &nf, const coeff toto)
Definition: corealgo.hpp:543
isdivisible
int isdivisible(const mon &m1, const mon &m2, int nbvar)
Definition: isdivisible.hpp:5
proj
void proj(T &Crochet, const typdump &dump, const Base &b)
Definition: proj.hpp:51
lvar
int lvar(const dynamicexp< X, E > &A)
Definition: dynamicexp.hpp:178
free
void free(void *)
myplus44
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)
Definition: corealgo.hpp:892
varmult
void varmult(iterator iter1, iterator iter2, mon &var1, mon &var2, const Base &b)
Definition: corealgo.hpp:2064
compute_ppcm
int compute_ppcm(typppcm &ppcm, const Base &b)
Definition: corealgo.hpp:53
Crochetchoix
void Crochetchoix(const typP &P, typPk &Pk, typPk &redspol, int k, Base &b)
Monom::GetCoeff
C GetCoeff() const
Definition: Monom.hpp:67
pol
Definition: pol.hpp:6
Base::iterator
list< predicat >::iterator iterator
Definition: types.hpp:20
my_merge
void my_merge(T &l1, const T &l2)
Definition: corealgo.hpp:35
DoBaseMk
void DoBaseMk(const typP &tmpPk, typMk &Mk, Base &b)
Definition: corealgo.hpp:215
findcorresppol
void findcorresppol(const mon &m, const typdump &dump, pol &res)
Definition: corealgo.hpp:2031
Ispolzero
int Ispolzero(const pol &p)
Definition: Iszero.hpp:30
nf
typpol nf(int var, int indmon, const typdump &dump, const Base &b)
Definition: corealgo.hpp:1001
mult
typpol mult(int i, const typpol &pol, const typdump &dump, const Base &b, mon **exce, int &exsize)
Definition: corealgo.hpp:1077
Listedejafait
void Listedejafait(const typMk &Mk, typMk &Spoldejavu)
Definition: corealgo.hpp:2836
predicat::accept
mon * accept
Definition: types.hpp:6
my_ord
int my_ord(const mon &m1, const mon &m2)
Definition: ord.hpp:2
NewDestroyredspol
void NewDestroyredspol(typPk &redspol, const typPk &Pk)
Definition: corealgo.hpp:2824
member
int member(const typMk &tmpMk, const typename typMk::value_type mon)
Definition: corealgo.hpp:1391
flag
long flag
Definition: alp_f2c.H:52
inverse
void inverse(int *&, int)
Base::const_iterator
list< predicat >::const_iterator const_iterator
Definition: types.hpp:21
malloc
void * malloc(YYSIZE_T)
recover
void recover(typPk &Pk, typMk &Mk, const typdump &dump, int k)
Definition: dump.hpp:192
predicat
Definition: types.hpp:3
Dump
void Dump(const typPk &Pk, typdump &dump)
Definition: dump.hpp:48
pol::coeff_t
T coeff_t
Definition: pol.hpp:9
predicat::taille1
int taille1
Definition: types.hpp:5
selectnozero
void selectnozero(typP &ttmp)
Definition: Iszero.hpp:40
Base::nbvar
int nbvar()
Definition: types.hpp:37
mon2int
int mon2int(const mon &mm)
Definition: placemon.hpp:294
j
MSKconetypee MSKrealt MSKint32t MSKint32t j
Definition: mosek.h:2421
my_plustmp
void my_plustmp(pol &res, const pol &nf, const coeff toto)
Definition: corealgo.hpp:492
Spolordsup
typPk Spolordsup(typPk Pk, const Base &b)
Definition: corealgo.hpp:147
int2mon
void int2mon(const int &i, mon &res)
Definition: placemon.hpp:288
k
MSKint32t k
Definition: mosek.h:2713
Monom::rep
R rep
Definition: Monom.hpp:30
rajoute_voisins
void rajoute_voisins(typPk &Pk, const typMk &Mk, const typdump &dump, Base &b, workspace &w, monomial_server &serv)
Definition: IsinB3.hpp:111
Monom::coeff_t
C coeff_t
Definition: Monom.hpp:26
OLD_ReduceSpol
void OLD_ReduceSpol(typPk &S, const typdump &dump, typPk &redspol, const Base &b)
Definition: corealgo.hpp:2295
Destroyredspol
void Destroyredspol(typPk &redspol, const typPk &Pk)
Definition: corealgo.hpp:2579
index
MSKCONST char MSKint32t MSKint32t * index
Definition: mosek.h:2860
Degree
dynamicexp< X, E >::degree_t Degree(const dynamicexp< X, E > &t)
Definition: dynamicexp.hpp:91
Base::end
iterator end()
Definition: types.hpp:30
conv_merge
void conv_merge(typPk &Pk, typP &P, typexceed &ex, typsize &sizeex, const Base &b)
Definition: corealgo.hpp:1297
ReduceSpol
void ReduceSpol(typPk &S, const typdump &dump, typPk &redspol, const Base &b)
Definition: corealgo.hpp:2217
IsinB
int IsinB(const mon &m, const Base &b)
Definition: IsinB3.hpp:68
Base::def
list< predicat > def
Definition: types.hpp:16
mon
Mon mon
Definition: solver_bb_floating.cpp:136
Base::nbvars
int nbvars
Definition: types.hpp:17
predicat::taille2
int taille2
Definition: types.hpp:7
Base
Definition: types.hpp:14
Monom::GetDegree
exponent_t GetDegree() const
Definition: Monom.hpp:70
NewCrochetchoix
void NewCrochetchoix(typP &P, typPk &Pk, typMk &Mk, typPk &redspol, int &k, typdump &dump, Base &b, typrecall &recall)
Definition: corealgo.hpp:2594
goodspol
int goodspol(const mon &m1, const mon &m2, typppcm &ppcm, const Base &b)
Definition: corealgo.hpp:108
c
MSKrealt * c
Definition: mosek.h:2678
my_divmon
Mon my_divmon(const Mon &mon, int i, const Base &b)
Definition: corealgo.hpp:1262
i
MSKint32t MSKint32t MSKint32t i
Definition: mosek.h:2278
Iszero
int Iszero(const Scl< MPQ > &c)
Definition: Iszero.hpp:14
GoodDir
int GoodDir(const typmon &m, int i, const Base &b)
Definition: corealgo.hpp:1278
Mon
Monom< COEFF, dynamicexp<'x'> > Mon
Definition: solver_bb_floating.cpp:134
indice2
int indice2(int i, int j, const Base &b)
Definition: corealgo.hpp:969
lcm
mon lcm(const mon &m1, const mon &m2)
Definition: corealgo.hpp:43
pol::size
int size
Definition: pol.hpp:10
newPkMkMatrixof
int newPkMkMatrixof(typMat &mat, typPk &Pk, typP &P, typMk &Mk, int &k, Base &b, typdump &dump, typrecall &recall)
Definition: corealgo.hpp:1506
forget
void forget(Base &b, typdump &dump, int k, typrecall &recall)
Definition: dump.hpp:75
predicat::refuse
mon * refuse
Definition: types.hpp:8
Crochet
cont< pol< mon, T > > Crochet(const cont< pol< mon, T > > &P, int k)
Definition: corealgo.hpp:6
Base::begin
iterator begin()
Definition: types.hpp:25
Base::const_reverse_iterator
list< predicat >::const_reverse_iterator const_reverse_iterator
Definition: types.hpp:23
algo
void algo(typP P, typdump &dump, Base &b)
Definition: corealgo.hpp:2852
stop_degree
int stop_degree(const typB &b)
Definition: dimpos.hpp:49
Base::mon
predicat::monom_t mon
Definition: types.hpp:19
pol
#define pol
Definition: pol2ter.hpp:3
myplus22
void myplus22(pol &res, const pol &nf, const coeff toto, const pol &nf2, const coeff toto2)
Definition: corealgo.hpp:647
Monom::SetCoeff
void SetCoeff(const C &c)
Definition: Monom.hpp:68
stab
void stab(typPk &Pk)
Definition: corealgo.hpp:18
mindeg
int mindeg(const typPk &l)
Definition: corealgo.hpp:2422
pol::ind
mon ind
Definition: pol.hpp:11
Monom
Multivariate monomials.
Definition: Monom.hpp:21
setorder
void setorder(ptrfun tmpord)
Definition: placemon.hpp:132
Base::erase
iterator erase(iterator first, iterator last)
Definition: types.hpp:35
pol::nf
T * nf
Definition: pol.hpp:12
halfred
pol halfred(const mon &targetind, const pol &p, const typdump &dump, const Base &b)
Definition: corealgo.hpp:2076
Base::rbegin
reverse_iterator rbegin()
Definition: types.hpp:27
min
long min(long a, long b)
Definition: workspace.hpp:3
MatrixOf
typmat * MatrixOf(const typPk &L, const typMk &lm, const typmat &mat)
Definition: corealgo.hpp:260
Home  |  Download & Install |  Contributions
Generated on Tue Sep 29 2015 11:43:20 for Borderbasix by 1.8.9.1