Borderbasix

placemon3.hpp
Go to the documentation of this file.
1 #ifndef ALREADY_placemon3
2 #define ALREADY_placemon3
3 #ifdef REENTRANT
4 #include<mutex>
5 #endif
6 
7 //Requiers type mon to be defined somewhere else
8 //on tache de rendre l'acces a int2mon et mon2int
9 //aussi rapide que possible meme si ca coute
10 //un peu, d'inserer puisque par hypothese on fait plus
11 //d'appel a int2mon mon2int
12 //que l'on insere ou enleve de monomes dedans!
13 template<class mon,typename pol>
14 struct monomial_server{
15  typedef mon monom_t;
16  typedef pol pol_t;
17 #ifdef REENTRANT
18  recursive_mutex servmutex;
19 #endif
20  int sizeplace;
21  mon *int2mon_;
22  mon *mon2intmon;
23  int *mon2intint;
24  int (*ord)(const mon &m1,const mon &m2);
25  int nbvars;
26  int **multiple;
27  void **nfmul;
28 void displaymon()
29 {
30  cout<<"les mon"<<endl;
31  for(int i=0;i<sizeplace;i++)
32  cout<<int2mon_[i]<<" ";
33  cout<<endl;
34 }
35  ~monomial_server() {
36  MAC_REV_FREE<mon>(int2mon_,sizeplace*sizeof(mon));
37  MAC_REV_FREE<mon>(mon2intmon,sizeplace*sizeof(mon));
38  MAC_REV_FREE<int>(mon2intint,sizeplace*sizeof(int));
39  for(int i=0;i<nbvars;i++)
40  free(multiple[i]);
41  free(multiple);
42 
43  for(int i=0;i<nbvars;i++)
44  free(nfmul[i]);
45  free(nfmul);
46 
47  }
48  monomial_server() {
49  sizeplace=0;int2mon_=NULL;mon2intmon=NULL;mon2intint=NULL;
50  ord=NULL;
51  }
52 
53  //template<typename mon>
54  //void inline int2mon(const int &i,mon &res);
55 
56  //template<typename mon>
57  //int inline mon2int(const mon &mm);
58 
59 inline void init_multiple(int n)
60 {
61 #ifdef REENTRANT
62  servmutex.lock();
63 #endif
64  multiple=(int**)malloc(n*sizeof(int*));
65  for(int i=0;i<n;i++)
66  multiple[i]=NULL;
67  nbvars=n;
68 #ifdef REENTRANT
69  servmutex.unlock();
70 #endif
71 
72 }
73 #ifdef REENTRANT
74 void reinit_multiple_th()
75 {
76 
77  servmutex.lock();
78  for(int i=0;i<nbvars;i++)
79  for(int j=0;j<sizeplace;j++)
80  multiple[i][j]=-2;
81  servmutex.unlock();
82 }
83 #endif
84 
85 void reinit_multiple()
86 {
87 #ifdef REENTRANT_DEBUG
88  servmutex.lock();
89 #endif
90  for(int i=0;i<nbvars;i++)
91  for(int j=0;j<sizeplace;j++)
92  multiple[i][j]=-2;
93 #ifdef REENTRANT_DEBUG
94  servmutex.unlock();
95 #endif
96 }
97 
98 #ifdef REENTRANT
99 template<typename typBase>
100 inline int mulind_th(int indexbase, int var, const typBase &b)
101 {
102  // mon tmpdebug=mon(1,1)*mon(3,1);
103  int res;
104  servmutex.lock();
105  if(multiple[var][indexbase]==-2)//||(multiple[var][indexbase]>=size))
106  {
107  mon tmpmon;
108  int stock;
109  int2mon(indexbase,tmpmon);
110  tmpmon*=mon(var,1);
111  if(IsinB(tmpmon,b))
112  {
113  stock=mon2int_th(tmpmon);
114  multiple[var][indexbase]=stock;
115  }
116  else
117  multiple[var][indexbase]=-1;
118  }
119 
120  res=multiple[var][indexbase];
121  servmutex.unlock();
122  return res;
123 }
124 #endif
125 template<typename typBase>
126 inline int mulind(int indexbase, int var, const typBase &b)
127 {
128  int tmp;
129  #ifdef REENTRANT_DEBUG
130  servmutex.lock();
131 #endif
132  //mon tmpdebug=mon(1,1)*mon(3,1);
133  if(multiple[var][indexbase]==-2)//||(multiple[var][indexbase]>=size))
134  {
135  mon tmpmon;
136  int stock;
137  int2mon(indexbase,tmpmon);
138  tmpmon*=mon(var,1);
139  if(IsinB(tmpmon,b))
140  {
141  stock=mon2int(tmpmon);
142  multiple[var][indexbase]=stock;
143  }
144  else
145  multiple[var][indexbase]=-1;
146  }
147 // if (multiple[var][indexbase]>=0)
148 // cout<<int2mon_[indexbase]<<"*"<<mon(var,1)<<" donne "<<int2mon_[multiple[var][indexbase]]<<endl;
149  tmp=multiple[var][indexbase];
150 #ifdef REENTRANT_DEBUG
151  servmutex.unlock();
152 #endif
153 
154  return tmp;
155 }
156 
157 
158 #ifdef uninf
159 //template<typename pol>
160 inline void init_nf(int n)
161 {
162 #ifdef REENTRANT_DEBUG
163  servmutex.lock();
164 #endif
165 
166  nfmul=(void**)malloc(n*sizeof(pol*));
167  for(int i=0;i<n;i++)
168  *((pol**)nfmul+i)=NULL;
169 #ifdef REENTRANT_DEBUG
170  servmutex.unlock();
171 #endif
172 
173 }
174 
175 //template<typename pol>
176 #ifdef REENTRANT
177 void reinit_nf_th()
178 {
179  pol toto;
180  servmutex.lock();
181  toto.size=-1;
182  for(int i=0;i<nbvars;i++)
183  for(int j=0;j<sizeplace;j++)
184  (*((pol**)nfmul+i))[j]=toto;
185  servmutex.unlock();
186 }
187 #endif
188 void reinit_nf()
189 {
190 #ifdef REENTRANT_DEBUG
191  servmutex.lock();
192 #endif
193 
194  pol toto;
195  toto.size=-1;
196  for(int i=0;i<nbvars;i++)
197  for(int j=0;j<sizeplace;j++)
198  (*((pol**)nfmul+i))[j]=toto;
199 #ifdef REENTRANT_DEBUG
200  servmutex.unlock();
201 #endif
202 
203 }
204 
205 #ifdef REENTRANT
206 template<typename typdump,typename Base>
207 pol nf_th(int var ,int indmon,const typdump &dump,const Base & b)
208 {
209  // cout<<"c moi c moi"<<endl;
210  pol res;
211  servmutex.lock();
212  if(((*((pol**)nfmul+var)))[indmon].size==-1)
213  {
214  //CLEVER but wrong
215  //#ifdef REENTRANT
216  // servmutex.lock();
217  //#endif
218  if(((*((pol**)nfmul+var)))[indmon].size==-1)
219  {
220 
221  typedef typename typdump::value_type dumpstruct;
222  //typedef typename pol::monom_t mon;
223  res.nf=NULL;
224  res.size=-1;
225  mon tmpmon;//=mon(1,var)*int2mon<mon>(indmon);
226  int deg=0;//=tmpmon.GetDegree()+1;
227  typename typdump::const_iterator iter;
228  int2mon(indmon,tmpmon);
229  deg=tmpmon.GetDegree()+1;
230  tmpmon*=mon(var,1);
231  for(iter=dump.begin();
232  (iter!=dump.end()) && (iter->k!=deg);iter++);
233  if(iter!=dump.end())//on cherche pas n'importe quoi qd meme
234  {
235  int i;
236  for(i=0;i<iter->size;i++)
237  {
238  if(iter->nf[i].ind.rep==tmpmon.rep)
239  break;
240  }
241  if(i!=iter->size)
242  res=(iter->nf[i]);
243  }
244  ((*((pol**)nfmul+var)))[indmon]=res;
245  }
246  //CLEVER but wrong
247  //#ifdef REENTRANT
248  // servmutex.unlock();
249  //#endif
250  }
251  res=(*((pol**)nfmul+var))[indmon];
252  servmutex.unlock();
253  return res;
254 }
255 #endif
256 template<typename typdump,typename Base>
257 pol nf(int var ,int indmon,const typdump &dump,const Base & b)
258 {
259 #ifdef REENTRANT_DEBUG
260  servmutex.lock();
261 #endif
262 
263  // cout<<"c moi c moi"<<endl;
264  pol res;
265  if(((*((pol**)nfmul+var)))[indmon].size==-1)
266  {
267  typedef typename typdump::value_type dumpstruct;
268  //typedef typename pol::monom_t mon;
269  res.nf=NULL;
270  res.size=-1;
271  mon tmpmon;//=mon(1,var)*int2mon<mon>(indmon);
272  int deg=0;//=tmpmon.GetDegree()+1;
273  typename typdump::const_iterator iter;
274  int2mon(indmon,tmpmon);
275  deg=tmpmon.GetDegree()+1;
276  tmpmon*=mon(var,1);
277  for(iter=dump.begin();
278  (iter!=dump.end()) && (iter->k!=deg);iter++);
279  if(iter!=dump.end())//on cherche pas n'importe quoi qd meme
280  {
281  int i;
282  for(i=0;i<iter->size;i++)
283  {
284  if(iter->nf[i].ind.rep==tmpmon.rep)
285  break;
286  }
287  if(i!=iter->size)
288  res=(iter->nf[i]);
289  }
290  ((*((pol**)nfmul+var)))[indmon]=res;
291  }
292 
293 #ifdef REENTRANT_DEBUG
294  servmutex.unlock();
295 #endif
296  return (*((pol**)nfmul+var))[indmon];
297  }
298 #endif //uninf
299 
300 template<typename ptrfun>
301 void setorder(ptrfun tmpord)
302 {
303 #ifdef REENTRANT
304  servmutex.lock();
305 #endif
306 
307  ord=(int (*)(const mon &,const mon &))(tmpord);
308 #ifdef REENTRANT
309  servmutex.unlock();
310 #endif
311 
312 }
313 int sizeplacemon()
314 {
315  return sizeplace;
316 }
317 
318 #ifdef REENTRANT
319 void putmon2_th(const mon & m,const int poscurrent)
320 {
321  int i;
322  //si le monome est deja introduit on y touche pas
323  //cout<<"putmon2 atteint"<<endl;
324  //cout<<"poscurrent "<<poscurrent<<endl;
325  //cout<<"mon2intmon==NULL?? "<<(mon2intmon==NULL)<<" m "<<m<<endl;
326  //if (poscurrent<size)
327  // cout<<((mon2intmon==NULL)||(mon2intmon[poscurrent]==m))<<endl;
328 
329  servmutex.lock();
330 
331  if((mon2intmon==NULL)||(poscurrent==sizeplace)||
332  (mon2intmon[poscurrent].rep!=m.rep))
333  {
334  if((mon2intmon==NULL)||(poscurrent==sizeplace)||
335  (mon2intmon[poscurrent].rep!=m.rep))
336  {
337  // cout<<"moncurent etc passe etc vaut "<<endl;
338  sizeplace++;
339 
340 
341  mon2intmon=(mon*)MAC_REV_REALLOC<mon>(mon2intmon,(sizeplace-1)*sizeof(mon)
342  ,(sizeplace)*sizeof(mon));
343  mon2intint=(int*)realloc(mon2intint,sizeplace*sizeof(int));
344 
345  //int2mon=(mon*)realloc(int2mon,size*sizeof(mon));
346  //on vient d'agrandir les tableaux
347  for(int k=sizeplace-1;k>poscurrent;k--)
348  mon2intmon[k]=mon2intmon[k-1];
349 
350  //memmove((mon2intmon+poscurrent+1),(mon2intmon+poscurrent),
351  // (size-1-poscurrent)*sizeof(mon));
352  memmove((mon2intint+poscurrent+1),(mon2intint+poscurrent),
353  (sizeplace-1-poscurrent)*sizeof(int));
354  //on cherche s'il y a un indice dans int2mon libre
355  for(i=0;i<sizeplace-1;i++)
356  // if (int2mon_[i]==mon(-1)) break;
357  if (int2mon_[i]==mon(0)) break;
358  if (i==sizeplace-1)
359  {
360  int2mon_=(mon*)MAC_REV_REALLOC<mon>(int2mon_,(sizeplace-1)*sizeof(mon)
361  ,sizeplace*sizeof(mon));
362 #ifdef unimul
363  for(int k=0;k<nbvars;k++)
364  {
365  //cout<<"j'ai fait un realloc "<<endl;
366  multiple[k]=(int*)realloc(multiple[k],sizeplace*sizeof(int));
367  multiple[k][sizeplace-1]=-2;
368  }
369 #endif
370 #ifdef uninf
371  for(int k=0;k<nbvars;k++)
372  {
373  //cout<<"j'ai fait un realloc "<<endl;
374  *((pol**)nfmul+k)=(pol*)
375  MAC_REV_REALLOC<pol >
376  ((void*)*((pol**)nfmul+k)
377  ,(sizeplace-1)*sizeof(pol)
378  ,sizeplace*sizeof(pol));
379  ((pol**)nfmul)[k][sizeplace-1].size=-1;
380  }
381 #endif
382 
383  }
384  int2mon_[i]=m;
385  //cout<<"int2mon_["<<i<<"] vaut "<<m<<endl;
386  mon2intint[poscurrent]=i;
387  mon2intmon[poscurrent]=m;
388  //cout<<"mon2intmon["<<poscurrent<<"] vaut"<<mon2intmon[poscurrent]
389  // <<" et est sense valoir "<<m<<endl;
390  }
391 
392  }
393  servmutex.unlock();
394  return;
395 }
396 
397 #endif
398 void putmon2(const mon & m,const int poscurrent)
399 {
400  int i;
401 #ifdef REENTRANT_DEBUG
402  servmutex.lock();
403 #endif
404 
405  //si le monome est deja introduit on y touche pas
406  //cout<<"putmon2 atteint"<<endl;
407  //cout<<"poscurrent "<<poscurrent<<endl;
408  //cout<<"mon2intmon==NULL?? "<<(mon2intmon==NULL)<<" m "<<m<<endl;
409  //if (poscurrent<size)
410  // cout<<((mon2intmon==NULL)||(mon2intmon[poscurrent]==m))<<endl;
411  if((mon2intmon==NULL)||(poscurrent==sizeplace)||
412  (mon2intmon[poscurrent].rep!=m.rep))
413  {
414  if((mon2intmon==NULL)||(poscurrent==sizeplace)||
415  (mon2intmon[poscurrent].rep!=m.rep))
416  {
417  // cout<<"moncurent etc passe etc vaut "<<endl;
418  sizeplace++;
419 
420 
421  mon2intmon=(mon*)MAC_REV_REALLOC<mon>(mon2intmon,(sizeplace-1)*sizeof(mon)
422  ,(sizeplace)*sizeof(mon));
423  mon2intint=(int*)realloc(mon2intint,sizeplace*sizeof(int));
424 
425  //int2mon=(mon*)realloc(int2mon,size*sizeof(mon));
426  //on vient d'agrandir les tableaux
427  for(int k=sizeplace-1;k>poscurrent;k--)
428  mon2intmon[k]=mon2intmon[k-1];
429 
430  //memmove((mon2intmon+poscurrent+1),(mon2intmon+poscurrent),
431  // (size-1-poscurrent)*sizeof(mon));
432  memmove((mon2intint+poscurrent+1),(mon2intint+poscurrent),
433  (sizeplace-1-poscurrent)*sizeof(int));
434  //on cherche s'il y a un indice dans int2mon libre
435  for(i=0;i<sizeplace-1;i++)
436  // if (int2mon_[i]==mon(-1)) break;
437  if (int2mon_[i]==mon(0)) break;
438  if (i==sizeplace-1)
439  {
440  int2mon_=(mon*)MAC_REV_REALLOC<mon>(int2mon_,(sizeplace-1)*sizeof(mon)
441  ,sizeplace*sizeof(mon));
442 #ifdef unimul
443  for(int k=0;k<nbvars;k++)
444  {
445  //cout<<"j'ai fait un realloc "<<endl;
446  multiple[k]=(int*)realloc(multiple[k],sizeplace*sizeof(int));
447  multiple[k][sizeplace-1]=-2;
448  }
449 #endif
450 #ifdef uninf
451  for(int k=0;k<nbvars;k++)
452  {
453  //cout<<"j'ai fait un realloc "<<endl;
454  *((pol**)nfmul+k)=(pol*)
455  MAC_REV_REALLOC<pol >
456  ((void*)*((pol**)nfmul+k)
457  ,(sizeplace-1)*sizeof(pol)
458  ,sizeplace*sizeof(pol));
459  ((pol**)nfmul)[k][sizeplace-1].size=-1;
460  }
461 #endif
462 
463  }
464  int2mon_[i]=m;
465  //cout<<"int2mon_["<<i<<"] vaut "<<m<<endl;
466  mon2intint[poscurrent]=i;
467  mon2intmon[poscurrent]=m;
468  //cout<<"mon2intmon["<<poscurrent<<"] vaut"<<mon2intmon[poscurrent]
469  // <<" et est sense valoir "<<m<<endl;
470  }
471  }
472 #ifdef REENTRANT_DEBUG
473  servmutex.unlock();
474 #endif
475 
476  return;
477 }
478 
479  //template<typename mon>
480 
481 void putmon(const mon & m)
482 {
483  int inf=0,sup=sizeplace,poscurrent=0;
484  //on commence par localiser l'endroit dans mon2int*
485  //ou on va rajouter le monom
486 #ifdef REENTRANT_DEBUG
487  servmutex.lock();
488 #endif
489 
490  if(sizeplace!=0)
491  for(poscurrent=sizeplace/2;ord(mon2intmon[poscurrent+1],
492  m)&&
493  ord(m,mon2intmon[poscurrent-1]);)
494  {
495  if(ord(mon2intmon[poscurrent],m)>0)
496  {
497  sup=poscurrent;
498  poscurrent=(inf+sup)/2;
499  }
500  else
501  {
502  inf=poscurrent;
503  poscurrent=(inf+sup)/2;
504  }
505  }
506  putmon2(m,poscurrent);
507 #ifdef REENTRANT_DEBUG
508  servmutex.unlock();
509 #endif
510 
511  return ;
512 }
513 #ifdef REENTRANT
514 void putmon_th(const mon & m)
515 {
516  int inf=0,sup=sizeplace,poscurrent=0;
517  //on commence par localiser l'endroit dans mon2int*
518  //ou on va rajouter le monom
519  servmutex.lock();
520  if(sizeplace!=0)
521  for(poscurrent=sizeplace/2;ord(mon2intmon[poscurrent+1],
522  m)&&
523  ord(m,mon2intmon[poscurrent-1]);)
524  {
525  if(ord(mon2intmon[poscurrent],m)>0)
526  {
527  sup=poscurrent;
528  poscurrent=(inf+sup)/2;
529  }
530  else
531  {
532  inf=poscurrent;
533  poscurrent=(inf+sup)/2;
534  }
535  }
536 
537  putmon2_th(m,poscurrent);
538  servmutex.unlock();
539  return ;
540 }
541 #endif
542 #ifdef REENTRANT
543 void removemon_th(const mon &m)
544 {
545  int inf=0,sup,poscurrent,i;
546  //on commence par localiser l'endroit dans mon2int*
547  //ou on va rajouter le monom
548  servmutex.lock();
549  for(poscurrent=sizeplace/2;ord(mon2intmon[poscurrent+1],
550  m)&&
551  ord(m,
552  mon2intmon[poscurrent-1]);)
553  {
554  if(ord(mon2intmon[poscurrent],m)>0)
555  {
556  sup=poscurrent;
557  poscurrent=(inf+sup)/2;
558  }
559  else
560  {
561  inf=poscurrent;
562  poscurrent=(inf+sup)/2;
563  }
564  }
565  //si le monome n'est PAS deja introduit on touche a rien
566  if(mon2intmon[poscurrent]!=m)
567  {
568 
569 
570 
571  if(mon2intmon[poscurrent]!=m)
572  {
573 
574  //on libere l'endroit ou se trouve ce monome
575  // int2mon_[poscurrent]=mon(-1);
576  int2mon_[poscurrent]=mon(0);
577  //on recopier apres dans les mon2int pour enlever le monome
578  memmove((mon2intmon+poscurrent),(mon2intmon+poscurrent+1),
579  (sizeplace-poscurrent-2)*sizeof(mon));
580  memmove((mon2intint+poscurrent),(mon2intint+poscurrent+1),
581  (sizeplace-poscurrent-2)*sizeof(int));
582  //on retrecit les mon2int*
583  // cout<<"la"<<endl;
584  sizeplace--;
585  mon2intmon=(mon*)realloc(mon2intmon,sizeplace*sizeof(mon));
586  mon2intint=(int*)realloc(mon2intint,sizeplace*sizeof(int));
587  }
588 
589 
590 
591  }
592  servmutex.unlock();
593  return;
594 }
595 #endif
596 void removemon(const mon &m)
597 {
598  int inf=0,sup,poscurrent,i;
599 #ifdef REENTRANT_DEBUG
600  servmutex.lock();
601 #endif
602 
603  //on commence par localiser l'endroit dans mon2int*
604  //ou on va rajouter le monom
605  for(poscurrent=sizeplace/2;ord(mon2intmon[poscurrent+1],
606  m)&&
607  ord(m,
608  mon2intmon[poscurrent-1]);)
609  {
610  if(ord(mon2intmon[poscurrent],m)>0)
611  {
612  sup=poscurrent;
613  poscurrent=(inf+sup)/2;
614  }
615  else
616  {
617  inf=poscurrent;
618  poscurrent=(inf+sup)/2;
619  }
620  }
621  //si le monome n'est PAS deja introduit on touche a rien
622  if(mon2intmon[poscurrent]!=m)
623  {
624  if(mon2intmon[poscurrent]!=m)
625  {
626 
627  //on libere l'endroit ou se trouve ce monome
628  // int2mon_[poscurrent]=mon(-1);
629  int2mon_[poscurrent]=mon(0);
630  //on recopier apres dans les mon2int pour enlever le monome
631  memmove((mon2intmon+poscurrent),(mon2intmon+poscurrent+1),
632  (sizeplace-poscurrent-2)*sizeof(mon));
633  memmove((mon2intint+poscurrent),(mon2intint+poscurrent+1),
634  (sizeplace-poscurrent-2)*sizeof(int));
635  //on retrecit les mon2int*
636  // cout<<"la"<<endl;
637  sizeplace--;
638  mon2intmon=(mon*)realloc(mon2intmon,sizeplace*sizeof(mon));
639  mon2intint=(int*)realloc(mon2intint,sizeplace*sizeof(int));
640  }
641  }
642 #ifdef REENTRANT_DEBUG
643  servmutex.unlock();
644 #endif
645 
646  return;
647 }
648 
649 
650  //template<typename mon>
651 void affplace(const mon &m,int p)
652 {
653  int2mon_[p]=m;
654 }
655 
656  //template<typename mon>
657 void freeplace(int p)
658 {
659  // int2mon_[p]=mon(-1);
660  int2mon_[p]=mon(0);
661 }
662 
663  //template<typename mon>
664 void inline int2mon(const int &i,mon &res)
665 {
666  // cout<<"sizeplace ici "<<sizeplace<<" et i "<<i<<endl;
667 #ifdef REENTRANT
668  servmutex.lock();
669 #endif
670 
671  res=mon(1,(int2mon_+i)->rep);
672 #ifdef REENTRANT
673  servmutex.unlock();
674 #endif
675 
676 }
677 
678  //template<typename mon>
679 int inline mon2int(const mon &mm)
680 {
681  typedef typename mon::coeff_t coeff;
682  //mqon2intmon et mon2intint doivent etre trie
683  //par ordre (ord) croissant
684  //
685 #ifdef REENTRANT_DEBUG
686  servmutex.lock();
687 #endif
688 
689  int inf=0,sup=sizeplace,poscurrent;
690  mon m=mm;
691  m.SetCoeff(1);
692  // cout<<"rentre mon2int"<<endl;
693  //cout<<"size "<<size<<endl;
694  if(sizeplace==0) {mon2intmon=NULL;mon2intint=NULL;
695  int2mon_=NULL;putmon(m);
696  //cout<<"transition mon2int"<<endl;
697  };
698  //cout<<"sup "<<sup<<" inf "<<inf<<endl;
699  for(poscurrent=sizeplace/2;(sup-inf>1)&&
700  (mon2intmon[poscurrent].rep!=m.rep);)
701  {
702  // cout<<"poscurrent "<<poscurrent<<endl;
703  if(ord(mon2intmon[poscurrent],m)>0)
704  {
705  sup=poscurrent;
706  poscurrent=(inf+sup)/2;
707  }
708  else
709  {
710  inf=poscurrent;
711  poscurrent=(inf+sup)/2;
712  }
713  }
714  //cout<<"sortie for mon2int "<<poscurrent<<endl;
715  //cout<<"les monome "<<mon2intmon[poscurrent]<<" "<<m<<endl;
716  if (mon2intmon[poscurrent].rep!=m.rep)
717  {
718  if (ord(mon2intmon[poscurrent],m)<0) poscurrent++;
719  //if(poscurrent<size)
720  //cout<<"ord(mon2intmon[poscurrent],m) "
721  // <<ord(mon2intmon[poscurrent],m)<<endl;
722  //cout<<"appel putmon2 "<<endl;
723  putmon2(m,poscurrent);
724  }
725  //cout<<"sorti mon2int"<<endl;
726 #ifdef REENTRANT_DEBUG
727  servmutex.unlock();
728 #endif
729 
730  return mon2intint[poscurrent];
731 }
732 
733 #ifdef REENTRANT
734 int inline mon2int_th(const mon &mm)
735 {
736  typedef typename mon::coeff_t coeff;
737  //mqon2intmon et mon2intint doivent etre trie
738  //par ordre (ord) croissant
739  //
740  int res;
741  int inf=0,sup=sizeplace,poscurrent;
742  mon m=mm;
743  m.SetCoeff(1);
744  servmutex.lock();
745  // cout<<"rentre mon2int"<<endl;
746  //cout<<"size "<<size<<endl;
747  if(sizeplace==0)
748  {
749  mon2intmon=NULL;
750  mon2intint=NULL;
751  int2mon_=NULL;
752  putmon_th(m);
753  //cout<<"transition mon2int"<<endl;
754  }
755  //cout<<"sup "<<sup<<" inf "<<inf<<endl;
756  for(poscurrent=sizeplace/2;(sup-inf>1)&&
757  (mon2intmon[poscurrent].rep!=m.rep);)
758  {
759  // cout<<"poscurrent "<<poscurrent<<endl;
760  if(ord(mon2intmon[poscurrent],m)>0)
761  {
762  sup=poscurrent;
763  poscurrent=(inf+sup)/2;
764  }
765  else
766  {
767  inf=poscurrent;
768  poscurrent=(inf+sup)/2;
769  }
770  }
771 
772  //cout<<"sortie for mon2int "<<poscurrent<<endl;
773  //cout<<"les monome "<<mon2intmon[poscurrent]<<" "<<m<<endl;
774  if (mon2intmon[poscurrent].rep!=m.rep)
775  {
776  if (ord(mon2intmon[poscurrent],m)<0) poscurrent++;
777  //if(poscurrent<size)
778  //cout<<"ord(mon2intmon[poscurrent],m) "
779  // <<ord(mon2intmon[poscurrent],m)<<endl;
780  //cout<<"appel putmon2 "<<endl;
781  putmon2_th(m,poscurrent);
782  }
783  //cout<<"sorti mon2int"<<endl;
784  res=mon2intint[poscurrent];
785  servmutex.unlock();
786  return res;
787 }
788 #endif
789 
790 template<typename typPk, typename typdump>
791 void swap_all(int i, int j, typPk & Pk ,typdump& dump)
792 {
793  //hypothese i<j
794  //
795  typedef typename typPk::value_type::coeff_t coeff;
796  // typedef typename typPk::value_type::monom_t mon;
797  typedef typename typdump::value_type dumpstruct;
798  mon tmpmon,tmpmon2;
799  int deg,pos1,pos2;
800  int2mon(j,tmpmon);
801  int2mon(i,tmpmon2);
802  deg=tmpmon.GetDegree();
803 #ifdef DEB
804  for(typename typPk::iterator iter=Pk.begin();iter!=Pk.end();iter++)
805  cout<<"swap "<<invconv<Poly>(*iter)<<endl;
806  cout<<"je swap "<<tmpmon<<" et "<<tmpmon2<<endl;
807 #endif
808  for(typename typPk::iterator iter=Pk.begin();iter!=Pk.end();iter++)
809  if(j/8<iter->sizenf && ((iter->nfind[j/8]>>(j%8))&1))
810  {
811 #ifdef DEB
812  cout<<"swapall "<<i<<" "<<j<<" iter->nf[j] "<<endl;
813  //cout<<"x1*x3 a pour indice "<<mon2int(mon(1,1)*mon(3,1))<<endl;
814 #endif
815  int nbentre=0;
816  int indicej=0,indicei=0;
817  coeff tmp;
818  for(int k=i/8+1;k<=j/8;k++)
819  nbentre+=nbbits[iter->nfind[k]];
820  nbentre+=nbbits[iter->nfind[i/8]>>(i%8)];
821  nbentre-=nbbits[iter->nfind[j/8]>>(j%8)];
822  //nbentre--;
823  //nbentre-=2;//on compt i et j dedans dans les formules precedentes
824 
825  for(int k=iter->sizenf-1;k>j/8;k--)
826  indicej+=nbbits[iter->nfind[k]];
827  indicej+=nbbits[iter->nfind[j/8]>>(j%8)];
828  // indicej--;
829  for(int k=iter->sizenf-1;k>i/8;k--)
830  indicei+=nbbits[iter->nfind[k]];
831  indicei+=nbbits[iter->nfind[i/8]>>(i%8)];
832 #ifdef DEB
833  cout<<iter->size<<endl<<indicej<<endl<<nbentre<<endl;
834  cout<<"iter->size-indicej-nbentre+1 "<<iter->size-indicej-nbentre+1<<" et indice i "<<indicei<<" indicej "<<indicej<<endl;
835 
836  cout<<"iter->nf[iter-szie-indicej] "
837  <<iter->nf[iter->size-indicej]<<endl;
838  cout<<"iter->nf[iter-size-indicej-nbentre] "
839  <<iter->nf[iter->size-indicej-nbentre]<<endl;
840 #endif
841  tmp=iter->nf[iter->size-indicej];
842  if((iter->nfind[i/8]>>(i%8))&1)
843  {
844  iter->nf=(coeff*)MAC_REV_REALLOC<coeff>(iter->nf
845  ,iter->size*sizeof(coeff)
846  ,(iter->size-1)*sizeof(coeff));
847  iter->nf[iter->size-indicej-nbentre]=tmp;
848  iter->nfind[i/8]|=1<<(i%8);
849  iter->nfind[j/8]&=~(1<<(j%8));
850  iter->size--;
851  }
852  else
853  {
854  for(int k=0;k<nbentre;k++)
855  iter->nf[iter->size-indicej-k]=iter->nf[iter->size-indicej-k-1];
856  iter->nf[iter->size-indicej-nbentre]=tmp;
857  iter->nfind[i/8]|=1<<(i%8);
858  iter->nfind[j/8]&=~(1<<(j%8));
859 
860  }
861  // iter->nf[i]=iter->nf[j];
862  // iter->nf[j]=0;
863 #ifdef DEB
864  if ((iter->sizenf*8>sizeplace) && ((iter->nfind[iter->sizenf-1]
865  >>(sizeplace%8))&1))
866  {cout<<"swapall "<<iter->sizenf<<" "<<sizeplace<<endl;exit(10);}
867 #endif
868  }
869  for(typename typdump::iterator iter=dump.begin();iter!=dump.end();iter++)
870  {
871 
872  //if(iter->k<=deg)
873  {
874  for(typename dumpstruct::pol_t *iterdump=iter->nf;
875  iterdump!=iter->nf+iter->size;iterdump++)
876  {
877 
878  if(j/8<iterdump->sizenf && (iterdump->nfind[j/8]>>(j%8))&1)
879  {
880  //cout<<"swapall "<<i<<" "<<j<<
881  //" iter->nf[j] "<<iter->nf[j]<<endl;
882  int nbentre=0;
883  int indicej=0;
884  coeff tmp;
885  for(int k=i/8+1;k<=j/8;k++)
886  nbentre+=nbbits[iterdump->nfind[k]];
887  nbentre+=nbbits[iterdump->nfind[i/8]>>(i%8)];
888  nbentre-=nbbits[iterdump->nfind[j/8]>>(j%8)];
889 
890  for(int k=iterdump->sizenf-1;k>j/8;k--)
891  indicej+=nbbits[iterdump->nfind[k]];
892  indicej+=nbbits[iterdump->nfind[j/8]>>(j%8)];
893 
894  tmp=iterdump->nf[iterdump->size-indicej];
895  if((iterdump->nfind[i/8]>>(i%8))&1)
896  {
897  iterdump->nf=(coeff*)
898  MAC_REV_REALLOC<coeff>(iterdump->nf
899  ,iterdump->size*sizeof(coeff)
900  ,(iterdump->size-1)*sizeof(coeff));
901  iterdump->nf[iterdump->size-indicej-nbentre]=tmp;
902  iterdump->nfind[i/8]|=1<<(i%8);
903  iterdump->nfind[j/8]&=~(1<<(j%8));//^=1<<(j%8);
904  iterdump->size--;
905 
906  }
907  else
908  {
909  for(int k=0;k<nbentre;k++)
910  iterdump->nf[iterdump->size-indicej-k]
911  =iterdump->nf[iterdump->size-indicej-k-1];
912  iterdump->nf[iterdump->size-indicej-nbentre]=tmp;
913  iterdump->nfind[i/8]|=1<<(i%8);
914  iterdump->nfind[j/8]&=~(1<<(j%8));//^=1<<(j%8);
915  }
916  // iter->nf[i]=iter->nf[j];
917  // iter->nf[j]=0;
918 #ifdef DEB
919  if ((iterdump->sizenf*8>sizeplace) && ((iterdump->nfind[iterdump->sizenf-1]
920  >>(sizeplace%8))&1))
921  {cout<<"swapall "<<iterdump->sizenf<<" "<<sizeplace<<endl;exit(10);}
922 #endif
923  }
924 
925  }
926  }
927  }
928  tmpmon=int2mon_[i];
929  int2mon_[i]=int2mon_[j];
930  int2mon_[j]=tmpmon;
931  for(pos1=0;mon2intint[pos1]!=j;pos1++);
932  for(pos2=0;mon2intint[pos2]!=i;pos2++);
933  mon2intint[pos1]=i;
934  mon2intint[pos2]=j;
935 
936 #ifdef unimul
937  for(int k=0;k<nbvars;k++)
938  {
939  for(int l=0;l<sizeplace;l++)
940  {
941  if(multiple[k][l]==i)
942  multiple[k][l]=j;
943  else if(multiple[k][l]==j)
944  multiple[k][l]=i;
945  }
946  int stock=multiple[k][i];
947  multiple[k][i]=multiple[k][j];
948  multiple[k][j]=stock;
949  }
950 #endif
951 #ifdef uninf
952  for(int k=0;k<nbvars;k++)
953  {
954  pol stock=(*((pol**)nfmul+k))[i];
955  (*((pol**)nfmul+k))[i]=(*((pol**)nfmul+k))[j];
956  (*((pol**)nfmul+k))[j]=stock;
957  }
958 #endif
959 
960 }
961 
962 void freeint2mon(int k)
963 {
964  //memmove(int2mon_+k,int2mon_+j+1,(size-j-1)*sizeof(mon));
965  int2mon_=(mon*)MAC_REV_REALLOC<mon>(int2mon_,sizeplace*sizeof(mon)
966  ,(k)*sizeof(mon));
967 #ifdef unimul
968  for(int i=0;i<nbvars;i++)
969  multiple[i]=(int *)realloc(multiple[i],k*sizeof(int));
970 #endif
971 #ifdef uninf
972  for(int i=0;i<nbvars;i++)
973  ((pol**)nfmul)[i]=(pol*)
974  MAC_REV_REALLOC<pol >(
975  ((pol**)nfmul)[i],sizeplace*sizeof(pol),k*sizeof(pol));
976 
977 
978 #endif
979 }
980 void freemon(int j)
981 {
982  int k;
983  //memmove(int2mon_+j,int2mon_+j+1,(size-j-1)*sizeof(mon));
984  //int2mon_=(mon*)MAC_REV_REALLOC<mon>(int2mon_,size*sizeof(mon)
985  // ,(size-1)*sizeof(mon));
986  for(k=0;mon2intint[k]!=j;k++);
987  //cout<<"k "<<k<<" et size "<<size<<endl;
988  memmove(mon2intint+k,mon2intint+k+1,(sizeplace-k-1)*sizeof(int));
989  for(int i=k;i<sizeplace-1;i++)
990  mon2intmon[i]=mon2intmon[i+1];
991  mon2intmon[sizeplace-1]=mon(0);
992  //memmove(mon2intmon+k,mon2intmon+k+1,(size-k-1)*sizeof(mon));
993  mon2intint=(int*)MAC_REV_REALLOC<int>(mon2intint,sizeplace*sizeof(int)
994  ,(sizeplace-1)*sizeof(int));
995  mon2intmon=(mon*)MAC_REV_REALLOC<mon>(mon2intmon,sizeplace*sizeof(mon)
996  ,(sizeplace-1)*sizeof(mon));
997  //cout<<"ici "<<endl;
998  sizeplace--;
999 }
1000 
1001 void serveurcompress(int i)
1002 {
1003  //I est le der nier indice ou il reste un element de B.
1004 #ifdef REENTRANT
1005  servmutex.lock();
1006 #endif
1007 
1008  int tmpsize=sizeplace;
1009  // freeint2mon(i+2);????? PQ +2???
1010  freeint2mon(i);
1011  // for(int k=i+2;k<tmpsize;k++) ????? PQ +2 ??????
1012  for(int k=i;k<tmpsize;k++)
1013  freemon(k);
1014  //for(int j=0;j<size;j++)
1015  // cout<<j<<" les pos possibles "<<mon2intint[j]<<" "<<mon2intmon[j]<<" int2mon "<<int2mon_[mon2intint[j]]<<endl;
1016  //size=i+2;
1017 #ifdef REENTRANT
1018  servmutex.unlock();
1019 #endif
1020 
1021 }
1022 
1023 template<typename typPk, typename typdump>
1024 void Docompress(int i, typPk & Pk, typdump& dump)
1025 {
1026  //i est l'indice du premier monome ou IsinB vaut 0
1027  // typedef typename typPk::value_type::monom_t mon;
1028  typedef typename typPk::value_type::coeff_t coeff;
1029  typedef typename typdump::value_type dumpstruct;
1030  mon tmpmon;
1031 #ifdef REENTRANT
1032  servmutex.lock();
1033 #endif
1034 
1035  for(typename typPk::iterator iter=Pk.begin();iter!=Pk.end();iter++)
1036  if(i<iter->sizenf*8)
1037  {
1038  int k;
1039  // cout<<"iiiiiiiiiiiii "<<i<<" "<<iter->sizenf<<endl;
1040  for(k=i/8;(k>=0) && !(iter->nfind[k]);k--);
1041  // cout<<" do compress K "<<k<<" "<<iter->nf[k]<<endl;
1042  iter->nfind=(unsigned char*)MAC_REV_REALLOC<unsigned char>(iter->nfind
1043  ,iter->sizenf
1044  ,(k+1));
1045 #ifdef DEB
1046  cout<<"I "<<i<<" et iter->sizenf "<<iter->sizenf<<endl;
1047 #endif
1048  iter->sizenf=k+1;
1049 
1050  }
1051 
1052  for(typename typdump::iterator iter=dump.begin();
1053  iter!=dump.end();iter++)
1054  //if(iter!=dump.rend())
1055  {
1056  for(typename dumpstruct::pol_t *iterdump=iter->nf;
1057  iterdump!=iter->nf+iter->size;iterdump++)
1058  if(i<iterdump->sizenf*8)
1059  {
1060  int k;
1061  for(k=i/8;k>=0 && !(iterdump->nfind[k]);k--);
1062  iterdump->nfind=(unsigned char*)
1063  MAC_REV_REALLOC<unsigned char>(iterdump->nfind
1064  ,iterdump->sizenf
1065  ,(k+1));
1066  iterdump->sizenf=k+1;
1067  }
1068  }
1069 #ifdef REENTRANT
1070  servmutex.unlock();
1071 #endif
1072 
1073 }
1074 
1075 template<typename typdump, typename Base, typename typPk>
1076 void compress(typPk & Pk, typdump & dump, const Base &b, int k)
1077 {
1078  // return;
1079  // typedef typename typPk::value_type pol;
1080  //typedef typename pol::monom_t mon;
1081  mon tmpmon;
1082  //Normalement les compress ne sont pas thread
1083  //on sait jamais
1084 #ifdef REENTRANT
1085  servmutex.lock();
1086 #endif
1087 
1088  int i=0;int j=sizeplacemon()-1;
1089 #if DEB
1090  displaymon();
1091  //cout<<"sizeplacemon "<<sizeplacemon()<<endl;
1092  //cout<<"Docompress"<<endl;
1093 
1094  cout<<"poly avantcompress "<<Pk.size()<<endl;
1095  for(typename typPk::iterator iter=Pk.begin();iter!=Pk.end();iter++)
1096  cout<<invconv<Poly>(*iter,*this)<<endl;
1097 #endif
1098  for(i=0;i<j;i++)
1099  {
1100  int2mon(i,tmpmon);
1101  if(!IsinB(tmpmon,b))
1102  //On peut le virer
1103  {
1104  for(;j>i;j--)
1105  {
1106  int2mon(j,tmpmon);
1107  if(IsinB(tmpmon,b))
1108  break;
1109  // cout<<tmpmon<<" n'est pas dans B"<<endl;
1110  }
1111  if(i==j) break; //c fini on a plus rien a faire ici
1112 
1113  //cout<<" swap "<<i<<" "<<int2mon_[i]<<" et "<<j<<" "<<int2mon_[j]<<endl;
1114  swap_all(i,j,Pk,dump);
1115  }
1116 
1117  }
1118  int2mon(i,tmpmon);
1119  for(;!IsinB(tmpmon,b);i--)
1120  {
1121  int2mon(i,tmpmon);
1122  // cout<<"tmp mon "<<tmpmon<<" Isinb? "<<IsinB(tmpmon,b)<<endl;
1123  }
1124  // cout<<"compress je coupe a "<<i+1<<endl;
1125  //en i+1 Isinb vaut 1
1126  Docompress(i+2,Pk,dump);//Docompress fait deja un +1
1127  serveurcompress(i+2);
1128 #if DEB
1129  displaymon();
1130  //cout<<"sizeplacemon "<<sizeplacemon()<<endl;
1131  //cout<<"Docompress"<<endl;
1132 
1133  cout<<"poly aprescompress "<<Pk.size()<<endl;
1134  for(typename typPk::iterator iter=Pk.begin();iter!=Pk.end();iter++)
1135  cout<<invconv<Poly>(*iter,*this)<<endl;
1136 #endif
1137 
1138 #ifdef REENTRANT
1139  servmutex.unlock();
1140 #endif
1141 
1142 }
1143 
1144 template<typename typPk, typename typdump>
1145 void swap_all(int i, int j, typPk & Pk , typPk &res,typdump& dump)
1146 {
1147  //hypothese i<j
1148  //
1149  typedef typename typPk::value_type::coeff_t coeff;
1150  // typedef typename typPk::value_type::monom_t mon;
1151  typedef typename typdump::value_type dumpstruct;
1152  mon tmpmon,tmpmon2;
1153  int deg,pos1,pos2;
1154  int2mon(j,tmpmon);
1155  int2mon(i,tmpmon2);
1156  deg=tmpmon.GetDegree();
1157 #ifdef DEB
1158  for(typename typPk::iterator iter=Pk.begin();iter!=Pk.end();iter++)
1159  cout<<"swap "<<invconv<Poly>(*iter)<<endl;
1160  cout<<"je swap "<<tmpmon<<" et "<<tmpmon2<<endl;
1161 #endif
1162  for(typename typPk::iterator iter=Pk.begin();iter!=Pk.end();iter++)
1163  if(j/8<iter->sizenf && ((iter->nfind[j/8]>>(j%8))&1))
1164  {
1165 #ifdef DEB
1166  cout<<"swapall "<<i<<" "<<j<<" iter->nf[j] "<<endl;
1167  //cout<<"x1*x3 a pour indice "<<mon2int(mon(1,1)*mon(3,1))<<endl;
1168 #endif
1169  int nbentre=0;
1170  int indicej=0,indicei=0;
1171  coeff tmp;
1172  for(int k=i/8+1;k<=j/8;k++)
1173  nbentre+=nbbits[iter->nfind[k]];
1174  nbentre+=nbbits[iter->nfind[i/8]>>(i%8)];
1175  nbentre-=nbbits[iter->nfind[j/8]>>(j%8)];
1176  //nbentre--;
1177  //nbentre-=2;//on compt i et j dedans dans les formules precedentes
1178 
1179  for(int k=iter->sizenf-1;k>j/8;k--)
1180  indicej+=nbbits[iter->nfind[k]];
1181  indicej+=nbbits[iter->nfind[j/8]>>(j%8)];
1182  // indicej--;
1183  for(int k=iter->sizenf-1;k>i/8;k--)
1184  indicei+=nbbits[iter->nfind[k]];
1185  indicei+=nbbits[iter->nfind[i/8]>>(i%8)];
1186 #ifdef DEB
1187  cout<<iter->size<<endl<<indicej<<endl<<nbentre<<endl;
1188  cout<<"iter->size-indicej-nbentre+1 "<<iter->size-indicej-nbentre+1<<" et indice i "<<indicei<<" indicej "<<indicej<<endl;
1189 
1190  cout<<"iter->nf[iter-szie-indicej] "
1191  <<iter->nf[iter->size-indicej]<<endl;
1192  cout<<"iter->nf[iter-size-indicej-nbentre] "
1193  <<iter->nf[iter->size-indicej-nbentre]<<endl;
1194 #endif
1195  tmp=iter->nf[iter->size-indicej];
1196  if((iter->nfind[i/8]>>(i%8))&1)
1197  {
1198  iter->nf=(coeff*)MAC_REV_REALLOC<coeff>(iter->nf
1199  ,iter->size*sizeof(coeff)
1200  ,(iter->size-1)*sizeof(coeff));
1201  iter->nf[iter->size-indicej-nbentre]=tmp;
1202  iter->nfind[i/8]|=1<<(i%8);
1203  iter->nfind[j/8]&= ~(1<<(j%8));
1204  iter->size--;
1205  }
1206  else
1207  {
1208  for(int k=0;k<nbentre;k++)
1209  iter->nf[iter->size-indicej-k]=iter->nf[iter->size-indicej-k-1];
1210  iter->nf[iter->size-indicej-nbentre]=tmp;
1211  iter->nfind[i/8]|=1<<(i%8);
1212  iter->nfind[j/8]&= ~(1<<(j%8));
1213 
1214  }
1215  // iter->nf[i]=iter->nf[j];
1216  // iter->nf[j]=0;
1217 #ifdef DEB
1218  if ((iter->sizenf*8>sizeplace) && ((iter->nfind[iter->sizenf-1]
1219  >>(sizeplace%8))&1))
1220  {cout<<"swapall "<<iter->sizenf<<" "<<sizeplace<<endl;exit(10);}
1221 #endif
1222  }
1223  //RES
1224  for(typename typPk::iterator iter=res.begin();iter!=res.end();iter++)
1225  if(j/8<iter->sizenf && ((iter->nfind[j/8]>>(j%8))&1))
1226  {
1227 #ifdef DEB
1228  cout<<"swapall "<<i<<" "<<j<<" iter->nf[j] "<<endl;
1229  //cout<<"x1*x3 a pour indice "<<mon2int(mon(1,1)*mon(3,1))<<endl;
1230 #endif
1231  int nbentre=0;
1232  int indicej=0,indicei=0;
1233  coeff tmp;
1234  for(int k=i/8+1;k<=j/8;k++)
1235  nbentre+=nbbits[iter->nfind[k]];
1236  nbentre+=nbbits[iter->nfind[i/8]>>(i%8)];
1237  nbentre-=nbbits[iter->nfind[j/8]>>(j%8)];
1238  //nbentre--;
1239  //nbentre-=2;//on compt i et j dedans dans les formules precedentes
1240 
1241  for(int k=iter->sizenf-1;k>j/8;k--)
1242  indicej+=nbbits[iter->nfind[k]];
1243  indicej+=nbbits[iter->nfind[j/8]>>(j%8)];
1244  // indicej--;
1245  for(int k=iter->sizenf-1;k>i/8;k--)
1246  indicei+=nbbits[iter->nfind[k]];
1247  indicei+=nbbits[iter->nfind[i/8]>>(i%8)];
1248 #ifdef DEB
1249  cout<<iter->size<<endl<<indicej<<endl<<nbentre<<endl;
1250  cout<<"iter->size-indicej-nbentre+1 "<<iter->size-indicej-nbentre+1<<" et indice i "<<indicei<<" indicej "<<indicej<<endl;
1251 
1252  cout<<"iter->nf[iter-szie-indicej] "
1253  <<iter->nf[iter->size-indicej]<<endl;
1254  cout<<"iter->nf[iter-size-indicej-nbentre] "
1255  <<iter->nf[iter->size-indicej-nbentre]<<endl;
1256 #endif
1257  tmp=iter->nf[iter->size-indicej];
1258  if((iter->nfind[i/8]>>(i%8))&1)
1259  {
1260  iter->nf=(coeff*)MAC_REV_REALLOC<coeff>(iter->nf
1261  ,iter->size*sizeof(coeff)
1262  ,(iter->size-1)*sizeof(coeff));
1263  iter->nf[iter->size-indicej-nbentre]=tmp;
1264  iter->nfind[i/8]|=1<<(i%8);
1265  iter->nfind[j/8]&= ~(1<<(j%8));
1266  iter->size--;
1267  }
1268  else
1269  {
1270  for(int k=0;k<nbentre;k++)
1271  iter->nf[iter->size-indicej-k]=iter->nf[iter->size-indicej-k-1];
1272  iter->nf[iter->size-indicej-nbentre]=tmp;
1273  iter->nfind[i/8]|=1<<(i%8);
1274  iter->nfind[j/8]&= ~(1<<(j%8));
1275 
1276  }
1277  // iter->nf[i]=iter->nf[j];
1278  // iter->nf[j]=0;
1279 #ifdef DEB
1280  if ((iter->sizenf*8>sizeplace) && ((iter->nfind[iter->sizenf-1]
1281  >>(sizeplace%8))&1))
1282  {cout<<"swapall "<<iter->sizenf<<" "<<sizeplace<<endl;exit(10);}
1283 #endif
1284  }
1285  for(typename typdump::iterator iter=dump.begin();iter!=dump.end();iter++)
1286  {
1287 
1288  //if(iter->k<=deg)
1289  {
1290  for(typename dumpstruct::pol_t *iterdump=iter->nf;
1291  iterdump!=iter->nf+iter->size;iterdump++)
1292  {
1293 
1294  if(j/8<iterdump->sizenf && (iterdump->nfind[j/8]>>(j%8))&1)
1295  {
1296  //cout<<"swapall "<<i<<" "<<j<<
1297  //" iter->nf[j] "<<iter->nf[j]<<endl;
1298  int nbentre=0;
1299  int indicej=0;
1300  coeff tmp;
1301  for(int k=i/8+1;k<=j/8;k++)
1302  nbentre+=nbbits[iterdump->nfind[k]];
1303  nbentre+=nbbits[iterdump->nfind[i/8]>>(i%8)];
1304  nbentre-=nbbits[iterdump->nfind[j/8]>>(j%8)];
1305 
1306  for(int k=iterdump->sizenf-1;k>j/8;k--)
1307  indicej+=nbbits[iterdump->nfind[k]];
1308  indicej+=nbbits[iterdump->nfind[j/8]>>(j%8)];
1309 
1310  tmp=iterdump->nf[iterdump->size-indicej];
1311  if((iterdump->nfind[i/8]>>(i%8))&1)
1312  {
1313  iterdump->nf=(coeff*)
1314  MAC_REV_REALLOC<coeff>(iterdump->nf
1315  ,iterdump->size*sizeof(coeff)
1316  ,(iterdump->size-1)*sizeof(coeff));
1317  iterdump->nf[iterdump->size-indicej-nbentre]=tmp;
1318  iterdump->nfind[i/8]|=1<<(i%8);
1319  iterdump->nfind[j/8]&= ~(1<<(j%8));//^=1<<(j%8);
1320  iterdump->size--;
1321 
1322  }
1323  else
1324  {
1325  for(int k=0;k<nbentre;k++)
1326  iterdump->nf[iterdump->size-indicej-k]
1327  =iterdump->nf[iterdump->size-indicej-k-1];
1328  iterdump->nf[iterdump->size-indicej-nbentre]=tmp;
1329  iterdump->nfind[i/8]|=1<<(i%8);
1330  iterdump->nfind[j/8]&= ~(1<<(j%8));//^=1<<(j%8);
1331  }
1332  // iter->nf[i]=iter->nf[j];
1333  // iter->nf[j]=0;
1334 #ifdef DEB
1335  if ((iterdump->sizenf*8>sizeplace) && ((iterdump->nfind[iterdump->sizenf-1]
1336  >>(sizeplace%8))&1))
1337  {cout<<"swapall "<<iterdump->sizenf<<" "<<sizeplace<<endl;exit(10);}
1338 #endif
1339  }
1340 
1341  }
1342  }
1343  }
1344  tmpmon=int2mon_[i];
1345  int2mon_[i]=int2mon_[j];
1346  int2mon_[j]=tmpmon;
1347  for(pos1=0;mon2intint[pos1]!=j;pos1++);
1348  for(pos2=0;mon2intint[pos2]!=i;pos2++);
1349  mon2intint[pos1]=i;
1350  mon2intint[pos2]=j;
1351 
1352 #ifdef unimul
1353  for(int k=0;k<nbvars;k++)
1354  {
1355  for(int l=0;l<sizeplace;l++)
1356  {
1357  if(multiple[k][l]==i)
1358  multiple[k][l]=j;
1359  else if(multiple[k][l]==j)
1360  multiple[k][l]=i;
1361  }
1362  int stock=multiple[k][i];
1363  multiple[k][i]=multiple[k][j];
1364  multiple[k][j]=stock;
1365  }
1366 #endif
1367 #ifdef uninf
1368  for(int k=0;k<nbvars;k++)
1369  {
1370  pol stock=(*((pol**)nfmul+k))[i];
1371  (*((pol**)nfmul+k))[i]=(*((pol**)nfmul+k))[j];
1372  (*((pol**)nfmul+k))[j]=stock;
1373  }
1374 #endif
1375 
1376 }
1377 
1378 template<typename typPk, typename typdump>
1379 void Docompress(int i, typPk & Pk, typPk &res,typdump& dump)
1380 {
1381  // typedef typename typPk::value_type::monom_t mon;
1382  typedef typename typPk::value_type::coeff_t coeff;
1383  typedef typename typdump::value_type dumpstruct;
1384  mon tmpmon;
1385 #ifdef REENTRANT
1386  servmutex.lock();
1387 #endif
1388 
1389  for(typename typPk::iterator iter=Pk.begin();iter!=Pk.end();iter++)
1390  if(i<iter->size)
1391  {
1392  int k;
1393  for(k=i/8;(k>=0) && !(iter->nfind[k]);k--);
1394  // cout<<" do compress K "<<k<<" "<<iter->nf[k]<<endl;
1395  iter->nfind=(unsigned char*)MAC_REV_REALLOC<unsigned char>(iter->nfind
1396  ,iter->sizenf
1397  ,(k+1));
1398  //cout<<"I "<<i<<" et iter->size "<<iter->size<<endl;
1399  iter->sizenf=k+1;
1400 
1401  }
1402 
1403  for(typename typPk::iterator iter=res.begin();iter!=res.end();iter++)
1404  if(i<iter->size)
1405  {
1406  int k;
1407  for(k=i/8;(k>=0) && !(iter->nfind[k]);k--);
1408  // cout<<" do compress K "<<k<<" "<<iter->nf[k]<<endl;
1409  iter->nfind=(unsigned char*)MAC_REV_REALLOC<unsigned char>(iter->nfind
1410  ,iter->sizenf
1411  ,(k+1));
1412  //cout<<"I "<<i<<" et iter->size "<<iter->size<<endl;
1413  iter->sizenf=k+1;
1414 
1415  }
1416 
1417  for(typename typdump::iterator iter=dump.begin();
1418  iter!=dump.end();iter++)
1419  //if(iter!=dump.rend())
1420  {
1421  for(typename dumpstruct::pol_t *iterdump=iter->nf;
1422  iterdump!=iter->nf+iter->size;iterdump++)
1423  if(i<iterdump->size)
1424  {
1425  int k;
1426  for(k=i/8;k>=0 && !(iterdump->nfind[k]);k--);
1427  iterdump->nfind=(unsigned char*)
1428  MAC_REV_REALLOC<unsigned char>(iterdump->nfind
1429  ,iterdump->sizenf
1430  ,(k+1));
1431  iterdump->sizenf=k+1;
1432  }
1433  }
1434 #ifdef REENTRANT
1435  servmutex.unlock();
1436 #endif
1437 
1438 }
1439 
1440 template<typename typdump, typename Base, typename typPk>
1441 void compress(typPk & Pk, typPk &res, typdump & dump, const Base &b, int k)
1442 {
1443  // return;
1444  //typedef typename typPk::value_type pol;
1445  // typedef typename pol::monom_t mon;
1446  mon tmpmon;
1447  int i=0;int j=sizeplacemon()-1;
1448 #ifdef REENTRANT
1449  servmutex.lock();
1450 #endif
1451 
1452  //cout<<"sizeplacemon "<<sizeplacemon()<<endl;
1453  //cout<<"Docompress"<<endl;
1454  for(i=0;i<j;i++)
1455  {
1456  int2mon(i,tmpmon);
1457  if(!IsinB(tmpmon,b))
1458  //On peut le virer
1459  {
1460  for(;j>i;j--)
1461  {
1462  int2mon(j,tmpmon);
1463  if(IsinB(tmpmon,b))
1464  break;
1465  }
1466  if(i==j) break; //c fini on a plus rien a faire ici
1467  // cout<<" swap "<<i<<" "<<int2mon_[i]<<" et "<<j<<" "<<int2mon_[j]<<endl;
1468  swap_all(i,j,Pk,res,dump);
1469  }
1470 
1471  }
1472  int2mon(i,tmpmon);
1473  for(;!IsinB(tmpmon,b);i--)
1474  {
1475  int2mon(i,tmpmon);
1476  //cout<<"tmp mon "<<tmpmon<<endl;
1477  }
1478  Docompress(i+1,Pk,res,dump);
1479  serveurcompress(i);
1480 #ifdef REENTRANT
1481  servmutex.unlock();
1482 #endif
1483 
1484 }
1485 
1486 void freeplacemon()
1487 {
1488  MAC_REV_FREE<mon>(int2mon_,sizeplace*sizeof(mon));
1489  MAC_REV_FREE<mon>(mon2intmon,sizeplace*sizeof(mon));
1490  free(mon2intint);
1491  sizeplace=0;
1492 
1493 }
1494 };//struct monomial_server
1495 #endif
monomial_server::int2mon
void int2mon(const int &i, mon &res)
Definition: placemon3.hpp:664
monomial_server::freeplace
void freeplace(int p)
Definition: placemon3.hpp:657
monomial_server::multiple
int ** multiple
Definition: placemon3.hpp:26
dumpstruct
Definition: dump.hpp:2
monomial_server::nfmul
void ** nfmul
Definition: placemon3.hpp:27
monomial_server::removemon
void removemon(const mon &m)
Definition: placemon3.hpp:596
monomial_server::mon2int
int mon2int(const mon &mm)
Definition: placemon3.hpp:679
free
void free(void *)
monomial_server::setorder
void setorder(ptrfun tmpord)
Definition: placemon3.hpp:301
monomial_server::int2mon_
mon * int2mon_
Definition: placemon3.hpp:21
monomial_server::~monomial_server
~monomial_server()
Definition: placemon3.hpp:35
pol
Definition: pol.hpp:6
monomial_server::Docompress
void Docompress(int i, typPk &Pk, typPk &res, typdump &dump)
Definition: placemon3.hpp:1379
monomial_server::putmon2
void putmon2(const mon &m, const int poscurrent)
Definition: placemon3.hpp:398
monomial_server::sizeplace
int sizeplace
Definition: placemon3.hpp:20
monomial_server::init_multiple
void init_multiple(int n)
Definition: placemon3.hpp:59
monomial_server::mon2intint
int * mon2intint
Definition: placemon3.hpp:23
monomial_server::serveurcompress
void serveurcompress(int i)
Definition: placemon3.hpp:1001
nf
typpol nf(int var, int indmon, const typdump &dump, const Base &b)
Definition: corealgo.hpp:1001
monomial_server::displaymon
void displaymon()
Definition: placemon3.hpp:28
monomial_server::nbvars
int nbvars
Definition: placemon3.hpp:25
monomial_server::freemon
void freemon(int j)
Definition: placemon3.hpp:980
malloc
void * malloc(YYSIZE_T)
monomial_server::reinit_multiple
void reinit_multiple()
Definition: placemon3.hpp:85
j
MSKconetypee MSKrealt MSKint32t MSKint32t j
Definition: mosek.h:2421
k
MSKint32t k
Definition: mosek.h:2713
Monom::rep
R rep
Definition: Monom.hpp:30
Monom::coeff_t
C coeff_t
Definition: Monom.hpp:26
nbbits
int nbbits[256]
Definition: pol2ter.hpp:4
monomial_server
Definition: placemon3.hpp:14
IsinB
int IsinB(const mon &m, const Base &b)
Definition: IsinB3.hpp:68
mon
Mon mon
Definition: solver_bb_floating.cpp:136
monomial_server::sizeplacemon
int sizeplacemon()
Definition: placemon3.hpp:313
Base
Definition: types.hpp:14
Monom::GetDegree
exponent_t GetDegree() const
Definition: Monom.hpp:70
monomial_server::affplace
void affplace(const mon &m, int p)
Definition: placemon3.hpp:651
monomial_server::Docompress
void Docompress(int i, typPk &Pk, typdump &dump)
Definition: placemon3.hpp:1024
i
MSKint32t MSKint32t MSKint32t i
Definition: mosek.h:2278
monomial_server::monom_t
mon monom_t
Definition: placemon3.hpp:15
monomial_server::freeplacemon
void freeplacemon()
Definition: placemon3.hpp:1486
monomial_server::swap_all
void swap_all(int i, int j, typPk &Pk, typdump &dump)
Definition: placemon3.hpp:791
pol::size
int size
Definition: pol.hpp:10
monomial_server::freeint2mon
void freeint2mon(int k)
Definition: placemon3.hpp:962
monomial_server::compress
void compress(typPk &Pk, typPk &res, typdump &dump, const Base &b, int k)
Definition: placemon3.hpp:1441
monomial_server::mulind
int mulind(int indexbase, int var, const typBase &b)
Definition: placemon3.hpp:126
monomial_server::putmon
void putmon(const mon &m)
Definition: placemon3.hpp:481
monomial_server::swap_all
void swap_all(int i, int j, typPk &Pk, typPk &res, typdump &dump)
Definition: placemon3.hpp:1145
pol
#define pol
Definition: pol2ter.hpp:3
Monom::SetCoeff
void SetCoeff(const C &c)
Definition: Monom.hpp:68
monomial_server::ord
int(* ord)(const mon &m1, const mon &m2)
Definition: placemon3.hpp:24
monomial_server::compress
void compress(typPk &Pk, typdump &dump, const Base &b, int k)
Definition: placemon3.hpp:1076
monomial_server::monomial_server
monomial_server()
Definition: placemon3.hpp:48
Monom
Multivariate monomials.
Definition: Monom.hpp:21
pol::nf
T * nf
Definition: pol.hpp:12
monomial_server::mon2intmon
mon * mon2intmon
Definition: placemon3.hpp:22
monomial_server::pol_t
pol pol_t
Definition: placemon3.hpp:16
Home  |  Download & Install |  Contributions
Generated on Tue Sep 29 2015 11:43:20 for Borderbasix by 1.8.9.1