pol2terspecial-async.hpp

Go to the documentation of this file.

#ifdef ASYNC
template<typename typlistplus, typename Base>
void compute_ancestors(typlistplus &listplus, Base & b)
{
 //
  //
  //cet algo repose sur le fait que les composantes sont placées dans l'ordre d'inclusion
  // on a pas de petite composante avant une plus grosse
  //a changer par la suite
  //
  //
  typedef typename typlistplus::value_type::monom_t mon;
  for (auto &tmpresmul : listplus)
    {
      //      typename typlistplus::value_type tmpresmul=iter.get();
      mon tmp=tmpresmul.poly.ind;
      
      //Pour etre ancetre il faut diviser 
      //et etre dans la meme composante de B
      mon *candidate_ancestor=NULL;
      tmp.SetCoeff(1);
      for(auto &iterbase : b)
    {
      mon *compancestor=NULL;
      int isincomponent=0;
      for(int i=0;i<iterbase.taille1;i++)
        if(isdivisible(iterbase.accept[i],tmp,b))
          {
        isincomponent=1; 
#ifdef DEBUG
        cout<<"je break ici"<<endl;
#endif
        break;//pas la peine d'aller plus loin on est dans la composante
          }
      if(isincomponent)//sinon ca sert a rien
        {
          for(int i=0;i<iterbase.taille2;i++)
        if(isdivisible(iterbase.refuse[i],tmp,b))
          {
            if(compancestor)//on a deux monomomes qui divisent
              {
            candidate_ancestor=NULL;
#ifdef DEBUG
            cout<<"je break ici"<<endl;
#endif
            break;//pas la peine d'aller plus loin
              }
            else
              {
#ifdef DEBUG
            cout<<"g trouvé ici un gus "<<iterbase.refuse[i]<<endl;
#endif
            compancestor=&iterbase.refuse[i];
              }
          }
        }
      if(compancestor)
        {
#ifdef DEBUG
          cout<<"je passe ici compancestor non null"<<endl;
#endif
          candidate_ancestor=compancestor;
        }
    }
      tmpresmul.poly.ancestor=candidate_ancestor;
      //      listplus.push_back(tmpresmul);
    }
#ifdef DEBUG
  for(auto &&iter : listplus)
    {
      cout<<"ancestor ---- "<<iter->poly.ind<<endl;
      if (iter.ancestor)
    cout<<"\t\t -> "<<*(iter->poly.ancestor)<<endl;
      else
    cout<<"\e[31mcaca\e(B\e[m"<<endl;
    }
#endif
}

template<typename typgraph, typename typlistplus, 
     typename typmon2face, typename Base>
void makegraph(typgraph & G, const typlistplus & list_plus, 
           typmon2face &mon2face,
           Base &b)
{
  //on commence par numeroter les faces
  //Et on associe les ind et leur face
  //->>>>>>>>>>>>>on utilise une map
  typedef typename typlistplus::value_type::monom_t mon;
  //  typedef typename typPk::value_type::order_t ord;
  typedef my_Dlex<mon> ord;
  int numface=0;
  map<typename mon::rep_t,int> root2face;//associee le monome ancetre à sa face
  //map<typename mon::rep_t,int> mon2face;//associe l'ind a sa face
  //le root c'est un monome pres de l'ancetre
  //qui represente l'ind sur la face
  for(auto iterlist=list_plus.begin();iterlist!=list_plus.end();iterlist++)
    {
      typename typlistplus::value_type::pol poly=iterlist->poly;
      mon root=*(poly.ancestor);
      int count=0;
      for(int i=0;i<b.nbvars;i++)
    if(poly.ind.GetDegree(i)>root.GetDegree(i))
      {
        root*=mon(i,1);
        count++;
      }
      //ICI il faut repasser pour s'assurer que le root a bien exactement
      // nvars-1 position augmentées par rapport a l'ancetre
      //en cas de multiappartenance on choisi celle qui est la plus petite
      //dans l'ordre lexico (la multiappartenance c qd l'ind  est sur une 
      //intersefction de deux faces
      for(int i=0;(count<(b.nbvars-1)) && (i<b.nbvars);i++)
    if(poly.ancestor->GetDegree(i)==root.GetDegree(i))
      {
        root*=mon(i,1);
        count++;
      }
      if(root2face.count(root.rep)==0) 
    root2face[root.rep]=numface++;
      mon2face[poly.ind.rep]=root2face[root.rep];
    }
#ifdef DEBUG
  cout<<"roottoface"<<endl;
  for(auto &i :root2face)
    cout<<i.first<<" --- "<<i.second<<endl;
  cout<<"mon2face"<<endl;
  for(auto &i :mon2face)
    cout<<i.first<<" --- "<<i.second<<endl;
#endif
  //on allour le graph
  G.resize(numface);
  for(auto &i : G)
    {
      i.resize(numface);
      for(auto &j :i)
    j=0;
    }
  //Ensuite on construit le graph
 
  for(auto iterlist=list_plus.begin();iterlist!=list_plus.end();iterlist++)
    {
//     cout<<"ici on traite "<<iterpk->ind<<endl;
      for(int i=0;i<iterlist->sizeexceed;i++)
    G[mon2face[iterlist->poly.ind.rep]][mon2face[iterlist->exceed[i].rep]]=1;
      // On considere le graph dense
    }
  
}
namespace pol2terasync{
mutex synchromutex;
int flag=1;
mutex tmpmutex;
}

template <typename typdump,typename Base,typename mon, typename monomial_server>
void wrap_mult(resmul<pol<mon,COEFF> > &res, int i,const pol<mon, COEFF> &p,
           const typdump &dump, const Base &b, monomial_server &serv)
{
  pol2terasync::synchromutex.lock();
  // cout<<"je suis parti"<<endl;
 res=mult(i,p,dump,b,serv);
 //cout<<"g fini"<<endl;
  pol2terasync::synchromutex.unlock();
}

template<typename typdump,typename Base,typename mon, typename monomial_server> 
resmul<pol<mon,COEFF> >
 mult(int i,const pol<mon, COEFF> &p,const typdump &dump,
        const Base &b, monomial_server &serv)
{
  static const mon monzero=mon(0);
  typedef typename mon::coeff_t coeff;
  static const COEFF zero=0;
  //  static int flag=1;
  workspace<COEFF> w;
  resmul<pol<mon,COEFF> > res;//ICI IL FAUT METTRE LES CHAMPS ET RETOURNER RET
  res.exceed=(mon*)MAC_REV_MALLOC<mon>((p.size+1)*sizeof(mon));
  int *stockindicetab=(int*)malloc(p.size*sizeof(int));
  int noquo=0,maxind=0,pp=0,q=0,compt_coeff=0;
  int comptsize=0;
  COEFF *tmpspace;
  w.sizenf=0;
  pol2terasync::tmpmutex.lock();
  if(pol2terasync::flag)
    {
      pol2terasync::flag=0;
      init_pointer<COEFF>();
      //flag=0;cout<<"pouet pouet"<<endl;
    }
  pol2terasync::tmpmutex.unlock();
  //ici on determine l'espace de travail necessaire pour la suite;
  //tmpmutex.lock();
  for(int j=0;j<p.sizenf;++j)
    if (p.nfind[j])
     {
  
       for(int k=0;k<8;k++)
     if(((p.nfind[j]>>k)&1))
       {
#ifdef REENTRANT
         int stockindice2=serv.mulind_th(8*j+k,i,b);
#else
         int stockindice2=serv.mulind(8*j+k,i,b);
#endif  
         //pour affichage

         cout<<"stockindice2 "<<8*j+k<<" "<<i<<" "<<stockindice2<<endl;
         cout<<"i "<<i<<" j "<<j<<" k "<<k<<endl;
         //pour affichage
         if(stockindice2<0)
           stockindice2=-1*(8*j+k)-1;
         stockindicetab[pp++]=stockindice2;
         if (stockindice2>=maxind)
           maxind=stockindice2;
       }
     }

  //for(;maxind/8+1>=w.sizenf;increase_space(&w));
  w.sizenf=maxind/8+1;
  w.tabnf=(unsigned char*)malloc(maxind/8+1);
  w.size=8*w.sizenf;
  //  cout<<"w.size() "<<w.size<<endl;
  w.tabcoeff=(coeff*)MAC_REV_MALLOC<coeff>(w.size*sizeof(coeff));
  for(int i=0;i<w.sizenf;i++)
    w.tabnf[i]=0;
  for(int i=0;i<w.size;i++)
    w.tabcoeff[i]=0;
 
 for(int j=0;j<pp;j++)
    if(stockindicetab[j]>=0)
      {
    w.tabcoeff[stockindicetab[j]]+=p.nf[j];
    if(!Iszero(w.tabcoeff[stockindicetab[j]]))
      w.tabnf[stockindicetab[j]/8]|=1<<(stockindicetab[j]%8);
      }
    else  
      {
    pol<mon,COEFF>  tmp;
#ifdef REENTRANT
    tmp=serv.nf_th(i,-1*(stockindicetab[j]+1),dump,b);
#else
    tmp=serv.nf(i,-1*(stockindicetab[j]+1),dump,b);
#endif  
    if (tmp.size!=-1)
        {
          int compteurtmp=0;
          //On fait un plus dense dans tmpspace
          int k,l;
          unsigned long *tmpptr=(unsigned long*)tmp.nfind;
          unsigned long mask=1;
          for(;tmp.sizenf>=w.sizenf;increase_space(&w));

          for(k=0;k<tmp.sizenf/sizeof(unsigned long);k++)
            if(tmpptr[k])
              {
            mask=tmpptr[k];
            ((unsigned long*)w.tabnf)[k]|=mask;
            for(l=0;l<8*sizeof(unsigned long);l+=8,mask>>=8)
              {
                if(mask&255)
                  {
                tabfun2[mask&255](
                          w.tabcoeff+(8*sizeof(unsigned long)*k+l)
                          ,&(p.nf[j]),tmp.nf+compteurtmp);
                compteurtmp+=nbbits[mask&255];
                  }
              }
              }

          for(k=tmp.sizenf-(tmp.sizenf%sizeof(unsigned long))
            ;k<tmp.sizenf;k++)
            if(tmp.nfind[k])
              {
            w.tabnf[k]|=tmp.nfind[k];
            mask=1;
            for(l=0;l<8;l++,mask<<=1)
              {
                if(tmp.nfind[k]&mask)
                  w.tabcoeff[8*k+l]-=p.nf[j]*tmp.nf[compteurtmp++];
                if(Iszero(w.tabcoeff[8*k+l]))
                  w.tabnf[k]&=~mask;

              }
              }
        }
          else  
        {
          //On est tombé sur un monome du degre courant
          //qui est sur le bord
          mon tmpmon;
          res.exceed[noquo]=mon(i,1);
    
          serv.int2mon(-1*(stockindicetab[j]+1),tmpmon);
          
          res.exceed[noquo]*=tmpmon;//int2mon<mon>(j);
          res.exceed[noquo]*=p.nf[j];
          ++noquo;
        };
      }

  res.poly.ind=p.ind;
  res.poly.ind*=mon(i,1);
  res.exceed[noquo++]=res.poly.ind;
  res.sizeexceed=noquo;
  res.exceed=(mon*)MAC_REV_REALLOC<mon>(res.exceed,(p.size+1)*sizeof(mon)
                   ,(noquo)*sizeof(mon));
  res.poly.ind.SetCoeff(noquo+1);
  res.poly.size=0;
  pp=0;
  for(int j=0;j<w.sizenf;j++)
    if(w.tabnf[j])
      {
    for(int m=0;m<8;m++)
      if(Iszero(w.tabcoeff[8*j+m]))
        w.tabnf[j]&=~(1<<m);
    if(w.tabnf[j])
      {
        res.poly.size+=nbbits[w.tabnf[j]];
        pp=j;
      }
      }
  res.poly.nf=(COEFF*)MAC_REV_MALLOC<COEFF>(res.poly.size*sizeof(COEFF));
  res.poly.sizenf=pp+1;
  res.poly.nfind=(unsigned char *)malloc(res.poly.sizenf);
  pp=0;
  for(int j=0;j<res.poly.sizenf;j++)
    {
      if(w.tabnf[j])
    for(int k=0;k<8;k++)
      if((w.tabnf[j]>>k)&1)
        {
          res.poly.nf[pp++]=w.tabcoeff[8*j+k];
          w.tabcoeff[8*j+k]=zero;
        }
      res.poly.nfind[j]=w.tabnf[j];
      w.tabnf[j]=0;
    }
  free(stockindicetab);
  destroy_space(&w);

  return res;
}

template<typename typPk, typename typMk, typename typdump, typename Base, 
     typename typplus, typename typwork, typename typserv>
void compute_newpol(typplus &listplus, typPk &Pk, typMk &tmpMk, typdump &dump, 
            Base &b, int &k, typwork &w, typserv &serv)
{
  typedef typename typdump::value_type dumpstruct;
  typedef typename typPk::value_type pol;
  typedef typename typMk::value_type mon;
  //  list<std::future<typename typplus::value_type> >listfuture;
  list<std::thread >listfuture;
  map<mon,int,my_Dlex<typename typMk::value_type> > mapint;
  int nbface=0;
  int nbthreadrunning=0;
  resmul<typename typPk::value_type> tabmul[NBFUTURE];
#ifdef unimul
serv.reinit_multiple();
#endif
#ifdef uninf
  serv.reinit_nf();
#endif

  cout<<"debut compute newpol"<<endl;
  //construction des pol ord sup
  for(int i=0;i<b.nbvar();i++)
    {
      for(typename typPk::iterator iter=Pk.begin();iter!=Pk.end();iter++)
    {
      //      cout<<"avant gooddir l'ind "<<iter->ind<<" "<<i<<endl;
      // cout<<"GoodDir((*iter).ind,i,b)) "<<GoodDir((*iter).ind,i,b)<<endl;
      pol2terasync::synchromutex.lock();
      if(GoodDir((*iter).ind,i,b))
        {
          mon tmpmon=iter->ind*mon(i,1);
          tmpmon.SetCoeff(1);
          if(mapint.count(tmpmon)==0)
        {

          resmul<typename typPk::value_type> tmp;
          mapint[tmpmon]=nbface++;
          tmpMk.push_back(tmpmon);
          //          listplus.push_back(tmp);
          std::thread t=std::thread(
                           wrap_mult<typdump, Base, mon, typserv>
                           ,std::ref(tabmul[nbthreadrunning++]),i
                           ,std::ref(*iter),std::ref(dump),
                           std::ref(b),
                           std::ref(serv));
          //t.join();
          listfuture.push_back(std::move(t));
        
#if 0
          listfuture.push_back(
                       std::async(std::launch::async,
                        mult<typdump, Base, mon, typserv>
                        ,i,std::ref(*iter),std::ref(dump),
                        std::ref(b),
                          std::ref(serv)));
#endif
          //on a deja fait le push_back avant l'appel à mult
          //
          if(listfuture.size()==NBFUTURE)
            {
              pol2terasync::synchromutex.unlock();
              int compt_th=0;
     //           cout<<"------------------------------------------"<<endl;
              //              for(auto iterfuture=listfuture.begin();
              //  iterfuture!=listfuture.end();iterfuture++)
              for(auto &iterfuture : listfuture)
              {//iterfuture->wait();
              //listplus.push_back(iterfuture->get());
            iterfuture.join();
            listplus.push_back(std::move(tabmul[compt_th++]));
              }
              listfuture.erase(listfuture.begin(),listfuture.end());
              nbthreadrunning=0;
              pol2terasync::synchromutex.lock();
            }
        }
        }
      pol2terasync::synchromutex.unlock();

    }
    }
  int compt_th=0;
  for(auto &iterfuture : listfuture)
    //  for(auto iterfuture=listfuture.begin();
    //  iterfuture!=listfuture.end();iterfuture++)
    {
      iterfuture.join();
      //      listplus.push_back(iterfuture->get());
      listplus.push_back(std::move(tabmul[compt_th++]));
     }
  listfuture.erase(listfuture.begin(),listfuture.end());
    
  cout<<"fin compute newpol"<<endl;
  
}

template<typename typMat,typename typPk,typename typP,
         typename typMk,typename Base,typename typdump,typename typexceed,
         typename typsizeexceed, typename workspace, typename monomial_server>
int newpkmkMatrixofSolve(typMat &mat,typMat & L,typPk &Pk, typP &P,typMk &Mk,
                    int &k,Base &b, typdump &dump,typexceed &exceed_ret, 
             typsizeexceed & sizeexceed_ret, workspace &w, monomial_server &serv)
{
  
typedef typename typMk::value_type mon;
  typedef typename typP::value_type::order_t ord;
  typedef typename typPk::value_type pol;
  typedef typename pol::coeff_t coeff;
  typedef typename typP::value_type polyalp; 
  typedef component<vector<pol>,mon> compo;
  typPk recall;//to be erased as soon as treat_crochet et compute_... 
  //have been patched
  map<typename mon::rep_t,int> mon2face, mon2col; 
  vector<vector<int> > G;
  vector<int> vec;
  typPk tmpPk,workvect,convcrochet;
  typMk tmpMk;
  //list<mon *> exceed,exceedcrochet;
  vector<mon *> exceed,exceedcrochet;
  list<int> sizeexceed,sizeexceedcrochet;
  int nbproj=0,flagdoplus=1;
  int nbcompo=0,*pr,*pc;
  list<compo>listcomp;
  compo crochet;//ceci est le regroupement des crochet
  //  list<list<mon *> > listexceed;
  // list<list<int> > listsizeexceed;
  int indexinside=0;
  list<resmul<pol> > list_plus;
  list<std::future<resmul<pol> > >list_future;
  list<resmul<pol> > list_conv;
 //
  struct timeval t1,t2;
  gettimeofday(&t1,NULL);
  mat.destroystore();mat.ncol=0;mat.nrow=0;mat.nnz=0;
  exceed_ret.erase(exceed_ret.begin(),exceed_ret.end());
  sizeexceed_ret.erase(sizeexceed_ret.begin(),sizeexceed_ret.end());
 //prise en compte des pol pas encore introduits
  cerr<<"k on entering newpkmkmatrixof "<<k<<endl;
  typP ttmpP=Crochet(P,k+1);//
    if (!ttmpP.empty())
    {
      for(auto & p : ttmpP)
    cout<<"crochet ici"<<p<<endl;
//flagdo plus est positinne dans cett fonction au cas ou il ait chute de degre  
    treat_noempty_crochet(P, ttmpP, tmpPk, tmpMk, Pk,
                            Mk, dump, b, flagdoplus, k, recall, exceed, sizeexceed, serv);
    cout<<"en sortie tmpPk.size "<<tmpPk.size()<<endl;
    //tmpPk est non vide que si on chute de degre
    //on fait alors comme si on venait de les calculer 
    for(auto &i :tmpPk)
      {
    resmul<pol> tmp;
    tmp.poly=i;
    tmp.exceed=(mon*)MAC_REV_MALLOC<mon>(sizeof(mon));
    tmp.sizeexceed=1;
    *tmp.exceed=i.ind;
    list_plus.push_back(tmp);
      }
    
    }
    if(flagdoplus)
      {
    cout<<"newpol"<<endl;
    compute_newpol(list_plus,Pk,tmpMk,dump, b, k, w,serv);
    cout<<"fin newpol "<<list_plus.size()<<endl;
      }      
 //Ces polynomes la n'ont pas d'ind à proprement parler 
 //Il ne faut pas les prendre en compte pour faire le graph 
 //
    //
    //Il faut effacer tmpMk et le reconstruire apres coup en
    //fonction des composantes fortement connexes decouvertes
    //
    for(auto & p : ttmpP)
      cout<<"crochet ici"<<p<<endl;
  conv_merge(convcrochet,ttmpP,exceedcrochet,sizeexceedcrochet,b,serv);
  crochet.poly.resize(convcrochet.size());
  crochet.sizeexceed.resize(convcrochet.size());
  copy(convcrochet.begin(),convcrochet.end(),crochet.poly.begin());
  crochet.exceed=exceedcrochet;
  copy(sizeexceedcrochet.begin(),sizeexceedcrochet.end(),crochet.sizeexceed.begin());
#if 1 //def DEBUG1 
 cout<<"crochet "<<endl;
  for(int i=0;i<crochet.poly.size();i++)
    {
      cout<<"ind "<<crochet.poly[i].ind<<endl;
      copy(crochet.exceed[i],crochet.exceed[i]+crochet.sizeexceed[i],ostream_iterator<mon>(cout," + "));
      cout<<invconv<Poly>(crochet.poly[i],serv)<<endl;
    }
#endif
 // 
 // cout<<"icccccccccccccccccccccccccccccccccccccccccccccccccccccci"<<endl;
  auto itersizeexceed=sizeexceed.begin();
 // for(auto &p : exceed)
  //  copy(p,p+*(itersizeexceed++),ostream_iterator<mon>(cout," "));
  //crochet.sizeexceed=sizeexceedcrochet;
  //relire ce suit pour verifier les matrices pas carres

  //On constuit le graphe
  //Revoir l'alloc de G 
  //treat_nonmaximal_degree_elem(P, ttmpP, tmpPk, tmpMk, Pk,
  //                           Mk, dump, b, flagdoplus, k, recall, exceed, sizeexceed, serv);

  compute_ancestors(list_plus,b);
  makegraph(G, list_plus, mon2face,b);
  //On construit le grpahe et
  //on conserve l'appairage entre les ind et le faces
  vec.resize(G.size(),-1);
#ifdef DEBUG1
  cout<<"le graph"<<endl;
  for(auto &v : G)
    {
      for(auto i: v)
    cout<<i<<", ";
      cout<<endl;
    }
#endif
  cout<<"je rentre ds tarjan "<<G.size()<<" "<<tmpMk.size()<<endl;
 tarjan( G, vec);
 cout<<"alloc pr  "<<tmpPk.size()<<" "<<tmpMk.size()<<endl;
  pr=(int *)malloc(list_plus.size()*sizeof(int));
  pc=(int *)malloc(tmpMk.size()*sizeof(int));
   tmpMk.erase(tmpMk.begin(),tmpMk.end());
 //
  //On construit les listes de pol a partir des Comp Connexes
  for_each(vec.begin(),vec.end(),[&nbcompo](int i){nbcompo=(nbcompo<i?i:nbcompo);});
  //nbcompo est l'index de la derniere composante
  for(int i=0;i<=nbcompo;i++)
   {
    typPk tmp;
    list<mon*> tmpexceed;
    list<int> tmpsizeexceed;
    compo tmpcomp;
    int j=0;
    for_each(list_plus.begin(),list_plus.end(),
        [&]
         (resmul<typename typPk::value_type> &iter)
    {
      if(vec[mon2face[iter.poly.ind.rep]]==i) 
        {
          tmpcomp.poly.push_back(iter.poly);
          tmpcomp.sizeexceed.push_back(iter.sizeexceed);
          tmpcomp.exceed.push_back(iter.exceed);
        }
    });//fin de la lambda et du foreach
    listcomp.push_back(tmpcomp);
   }  
  gettimeofday(&t2,NULL);
  cout<<"\e[31m Temps poly+graph "<<t2.tv_sec-t1.tv_sec+1e-6*(t2.tv_usec-t1.tv_usec);
  cout<<"\e(B\e[m"<<endl;
  
//Pour chaque liste matrice + solve
//  itersizeexceed=sizeexceed.begin();
//  iterexceed=exceed!.begin();
  int prout=0;
  int numcompo=0;
  cout<<"nb total de compo dans la loiste "<<listcomp.size()<<endl;
  for(auto iter=listcomp.begin();iter!=listcomp.end();iter++,numcompo++)
   {
    //il faut construit tmpMK pour la composante
     int *tmppr,*tmppc;
     typMk verytmpMk;
     typMat tmpmat;
#ifdef DEBUG1
     cout<<"pour la composante "<<prout++<<endl;
     {
     auto toto=iter->sizeexceed.begin();
     typename vector<pol>::iterator tutu=iter->poly.begin();
    for(auto m : iter->exceed)
      {
    cout<<"sizeexceed ici "<<*toto<<endl;
    copy(m,m+*(toto++),ostream_iterator<mon>(cout," + ")),cout<<endl;;
    cout<<tutu->ind<<endl;
    if(tutu->size)
      copy(tutu->nf,tutu->nf+tutu->size,ostream_iterator<coeff>(cout," ")),cout<<endl;
    cout<<invconv<Poly>(*(tutu++),serv)<<endl;
    cout<<"------------------------------------ "<<endl;
      }
     } 
#endif
     for(auto &&iterind : iter->poly)
     {
       verytmpMk.push_back(iterind.ind);
       //   cout<<"je push "<<iterind.ind<<endl;
     }
     gettimeofday(&t1,NULL);
     construct_matrix_from_newpol_nofree(tmpmat, iter->poly, verytmpMk, 
                     iter->exceed, iter->sizeexceed, P);

#ifdef DEBUG
     cout<<"matrix of comp"<<endl;
     affdebug(tmpmat);
     cout<<"\e[32mpour la composante \e[37m"<<prout<<endl;
     {
       auto toto=iter->sizeexceed.begin();
       typename vector<pol>::iterator tutu=iter->poly.begin();
       for(auto m : iter->exceed)
     {
       copy(m,m+*(toto++),ostream_iterator<mon>(cout," - ")),cout<<endl;;
       cout<<tutu->ind<<endl;
       cout<<"size tutu "<<tutu->size<<endl;
        if(tutu->size)
         copy(tutu->nf,tutu->nf+tutu->size,ostream_iterator<coeff>(cout," "));
       cout<<invconv<Poly>(*(tutu++),serv)<<endl;
       cout<<"------------------------------------ "<<endl;
     }
     }
#endif 
#ifdef DEBUG
     cout<<"la petite matrice"<<endl;
     affdebug(tmpmat);
#endif
        /*
     modifier constructmatrix pour ressortir les exceed a cote de la composante
     //FAIT
    */


    //P est la pour forwareder les types ord et pol 
    //On resoud 
    //            pr et pc sont alloués avec malloc
    //            dans la fonction solve
    //            il faut les desallouer
    // 
    //Ceci est une fonction solve a ecrire pour reporter
    //les operations sur les poly aussi sur les exceed
    //
  gettimeofday(&t2,NULL);
  cout<<"\e[31m Temps contrustmatrix "<<t2.tv_sec-t1.tv_sec+1e-6*(t2.tv_usec-t1.tv_usec);
  cout<<"\e(B\e[m"<<endl;
  t1=t2;
     Solve(tmpmat,L,*iter,&tmppr,&tmppc,verytmpMk,w,serv);
#ifdef DEBUG11
    cout<<"\e[31mApres SOLVE \e[37m"<<prout<<endl;
    {
      auto toto=iter->sizeexceed.begin();
      typename vector<pol>::iterator tutu=iter->poly.begin();
      for(auto m : iter->exceed)
        {
          copy(m,m+*(toto++),ostream_iterator<mon>(cout," - ")),cout<<endl;;
          cout<<tutu->ind<<endl;
          cout<<invconv<Poly>(*(tutu++),serv)<<endl;
        }
    } 
#endif
    gettimeofday(&t2,NULL);
    cout<<"\e[31m Temps Solve "<<t2.tv_sec-t1.tv_sec+1e-6*(t2.tv_usec-t1.tv_usec);
    cout<<"\e(B\e[m"<<endl;
    t1=t2;
//  copy(tmppc,tmppc+verytmpMk.size(),ostream_iterator<int>(cout," "));
//  cout<<endl;
    // inverse(tmppc,verytmpMk.size());
    // Dopermu(verytmpMk,tmppc);
     for(auto &m :verytmpMk)
       {
         m.SetCoeff(1);
         tmpMk.push_back(m);
       } 
#if 0
     // ces operations sont faites dans reorder ind entre solveL et solveU
    {
    //ici on remet les ind a la bonne valeur 
    //a inclure dans une petite fonction inline apres
    int j=0;
    typename typMk::iterator itermon=verytmpMk.begin();

    for(auto iter_in_poly=iter->poly.begin();
        itermon!=verytmpMk.end();iter_in_poly++,itermon++,j++)
     {
       cout<<" dans verytmp "<<*itermon<<
         invconv<typename typP::value_type>(*iter_in_poly,serv)<<endl;
     
       if(!Iszero(tmpmat(j,j)))
         {
           //cout<<"ligne "<<j<<" je mets le monome "<<*itermon<<" "<<iter->ind.GetCoeff()<<endl:
           iter_in_poly->ind=*itermon;//*(iter_in_poly->ind.GetCoeff());
           iter_in_poly->ind.SetCoeff(1);
         }
       else
         {
           //On rajoute aux exceed des autre polyn\çomes de la composante les
           //les monomes correspondant a cette colonne 
           for(int i=tmpmat.colptr[j];i<tmpmat.colptr[j+1];i++)
         if(!(((coeff*)tmpmat.nzval)[i]==0))
           {
             //il y a eu permiutation des colonnes il
             // faut donc se fier a itermon plutot qu'aux ind
             mon tmpmon=*itermon;//iter_in_poly->ind;
             coeff tmpcoeff=((coeff*)tmpmat.nzval)[i];
             //Bon maintenant on regarde si le coefficient diagonal de U de la 
             //ligne tmpmat.rowind[i] est non nul et si c'est le cas
             //il fautr diviser par lui 
             if(!Iszero(tmpmat(tmpmat.rowind[i],tmpmat.rowind[i])))
               tmpcoeff/=tmpmat(tmpmat.rowind[i],tmpmat.rowind[i]);
             //Apres on peut affecter
             tmpmon.SetCoeff(tmpcoeff);
             iter->exceed[tmpmat.rowind[i]]=(mon*)
               MAC_REV_REALLOC<mon>(iter->exceed[tmpmat.rowind[i]],
                        iter->sizeexceed[tmpmat.rowind[i]]*sizeof(mon),
                        (iter->sizeexceed[tmpmat.rowind[i]]+1)*sizeof(mon));
             
             iter->exceed[tmpmat.rowind[i]][iter->sizeexceed[tmpmat.rowind[i]]]=tmpmon;
             iter->sizeexceed[tmpmat.rowind[i]]++;
           }
           iter_in_poly->ind=mon(0);
           
         }
     }
    }
#endif

#ifdef CACABOUDIN// 1//ICICICICI
    cout<<"apres solve les poly de la compo"<<endl;
    for(int i=0;i<iter->poly.size();i++)
      {
        cout<<"ind "<<iter->poly[i].ind<<endl;
        copy(iter->exceed[i],iter->exceed[i]+iter->sizeexceed[i],
         ostream_iterator<mon>(cout," + "));cout<<endl;
        cout<<invconv<typename typP::value_type>(iter->poly[i],serv)<<endl;
        cout<<"--------------------********************"<<endl;
      }
    for(auto i : iter->poly)
      cout<<"ind "<<i.ind<<endl;
    copy(iter->sizeexceed.begin(),iter->sizeexceed.end(),ostream_iterator<int>(cout," "));
    cout<<"iciiiiiiiiiiiiiiiiiiiiiiiiiiiiiii"<<endl;


#endif
    cout<<"update "<<endl;
    //mise a jour des autres polynomes et recnstruction de la matrice complete
    cout<<"la map"<<endl;
#if 1
    map<typename mon::rep_t,resmul<typename compo::typPk::value_type> > mon2pol;
    {
      auto iterexceed=iter->exceed.begin();
          auto itersizeexceed=iter->sizeexceed.begin();
      auto iterpoly=iter->poly.begin();
      int i=0;
      for(auto iterpoly=iter->poly.begin();iterpoly!=iter->poly.end();
          iterpoly++,iterexceed++,itersizeexceed++,i++)
        {
          resmul<typename compo::typPk::value_type> tmp;
          tmp.poly=*iterpoly;
          tmp.exceed=*iterexceed;
          tmp.sizeexceed=*itersizeexceed;
          if(!(tmpmat(i,i)==0)) mon2pol[iterpoly->ind.rep]=tmp;
          //on augmente le workspace pour update apres
          for(;w.sizenf<iterpoly->sizenf;increase_space(&w));
          }
    }
#endif
    cout<<"le graph"<<endl;
    //on regarde pour chaque sommet de la composante les arcs sortant
    //ceux qui aboutissent a des sommets qui ne sont pas dans la compo
    //indiquent un update a faire
    vector<char> toupdate(nbcompo+1,0);
    int indexcompo=0;
#if 1
    for(int i_vec=0;i_vec<G.size();i_vec++)
    {
        if(vec[i_vec]==numcompo)
        {
          //on a trouvé un sommet dans la composante
          //en cours de traitement
          for(int j=0;j<G.size();j++)
          {
            //          cout<<"G["<<j<<"]["<<i_vec<<"] "<<G[j][i_vec]<<endl;
            // cout<<"<<<<<<"<<vec[j]<<" "<<numcompo<<endl;
//          if(G[i_vec][j] && vec[j]!=numcompo)
            if(G[j][i_vec] && vec[j]!=numcompo)
              {
            toupdate[vec[j]]=1;
            //On rajoute les composantes qui vont m'updater
            //a celle trouvee
            for(int j_graph=0;j_graph<G.size();j_graph++)
              G[j][j_graph]|=G[i_vec][j_graph];
            //on a plus besoin re parser cet update
            G[j][i_vec]=0;

              }
          }
        }
    }
#endif
#ifdef ASYNCUPDATE
    list<std::thread> list_up;
#endif

    cout<<"les poly"<<endl;
    for(auto itercomp=listcomp.begin();itercomp!=listcomp.end();
        itercomp++,indexcompo++)
      //le test est fait dans update pol
       if(toupdate[indexcompo])
         {
#ifdef CACABOUDIN// 1//ICICICICICICI    
           cout<<"la compo a updater avant"<<endl;
           for(int i=0;i<itercomp->poly.size();i++)
         {
           cout<<"ind "<<itercomp->poly[i].ind<<endl;
           copy(itercomp->exceed[i],itercomp->exceed[i]+itercomp->sizeexceed[i],
            ostream_iterator<mon>(cout," + "));cout<<endl;
           cout<<invconv<typename typP::value_type>(itercomp->poly[i],serv)<<endl;
           cout<<"--------------------********************"<<endl;
         }  
#endif 
#ifndef ASYNCUPDATE
           update_pol(*itercomp,*iter,mon2pol,w,serv);
#else
           list_up.push_back(std::thread(wrap_update_pol<compo,
           map<typename mon::rep_t,resmul<typename compo::typPk::value_type> 
                         >,monomial_server>,
                    std::ref(*itercomp),
                 std::ref(*iter),std::ref(mon2pol),std::ref(serv)));
           if(list_up.size()>=NBFUTURE)
         {
           for(auto &i : list_up)
             i.join();
           list_up.erase(list_up.begin(),list_up.end());
         }
#endif

#if 0//ICVICICICICI 
           cout<<"la compo apres update"<<endl;
           for(int i=0;i<itercomp->poly.size();i++)
         {
           cout<<"ind "<<itercomp->poly[i].ind<<endl;
           copy(itercomp->exceed[i],itercomp->exceed[i]+itercomp->sizeexceed[i],
            ostream_iterator<mon>(cout," + "));cout<<endl;
           cout<<invconv<typename typP::value_type>(itercomp->poly[i],serv)<<endl;
           cout<<"--------------------********************"<<endl;
         }
#endif
         }
#ifdef ASYNCUPDATE
    for(auto &i : list_up)
      i.join();
    list_up.erase(list_up.begin(),list_up.end());
#endif

      //update_pol(*itercomp,*iter,w,serv);
    //   cout<<"fin update "<<endl;
    cout<<"avant update du crochet "<<endl;
    for(int i=0;i<crochet.poly.size();i++)
      {
        cout<<"ind "<<crochet.poly[i].ind<<endl;
        copy(crochet.exceed[i],crochet.exceed[i]+crochet.sizeexceed[i],ostream_iterator<mon>(cout," + "));
        cout<<invconv<Poly>(crochet.poly[i],serv)<<endl;
       }

     update_pol(crochet,*iter,mon2pol,w,serv);//on fait uassi agir sur les polynomes du crochet
     cout<<"fin des updates "<<endl;
#if 1
     cout<<"apres update du crochet "<<endl;
     for(int i=0;i<crochet.poly.size();i++)
       {
         cout<<"ind "<<crochet.poly[i].ind<<endl;
         copy(crochet.exceed[i],crochet.exceed[i]+crochet.sizeexceed[i],ostream_iterator<mon>(cout," + "));
         cout<<invconv<Poly>(crochet.poly[i],serv)<<endl;
       }
#endif
     reconstruct_mat(mat,tmpmat);
#ifdef DEBUG1
    affdebug(mat);
    //il faut reconstruire les pr et pc globaux
    cout<<"indexinside "<<indexinside<<endl;
#endif
    reconstruct_pr_pc(pr,pc,tmppr,tmppc,tmpmat.ncol,indexinside);
        indexinside+=verytmpMk.size();
    free(tmppr);
    free(tmppc);
   }
  //Reconstruction des tmpPk tmpMk classiques
  // Pour la matrice
  // On gere aussi ici le cas des coefficient des colonnes de pivot nul 
  //comme ca on connait les indices de ligne et colonne
  //
  typPk verytmpPk;

  for(auto c : listcomp)
    {
      for(auto &p: c.poly)
    verytmpPk.push_back(p);
      for(auto &p: c.exceed)
    exceed_ret.push_back(p);
      for(auto &p: c.sizeexceed)
    {
      //  cout<<"sizeexceed "<<p<<endl;
      sizeexceed_ret.push_back(p);
    }
     
    }
  cout<<"apres reconstruction des Pk "<<endl;
#ifdef DEBUG
  copy(sizeexceed_ret.begin(),sizeexceed_ret.end(),ostream_iterator<int>(cout," **--** "));cout<<endl;
#endif
  //On rajoute les poly de crochet dans Pk
  //ET (c'est important pour addB on incrmente nrow ce mat en fonction
   for(auto &p : crochet.poly)
     {
       p.ind=mon(0);
       verytmpPk.push_back(p);
     }
   for(auto &p : crochet.exceed)
     exceed_ret.push_back(p);
   for(auto &p : crochet.sizeexceed)
     sizeexceed_ret.push_back(p);
   
#if 1
  int indexmat=0;
  for(auto m : tmpMk)
    {
      //      cout<<"mon2col "<<m.rep<<" "<<indexmat<<endl;
      mon2col[m.rep]=indexmat++;
    }
  indexmat=0;
  cout<<"avant updatematrix "<<endl;
#ifdef DEBUG 
  copy(sizeexceed_ret.begin(),sizeexceed_ret.end(),ostream_iterator<int>(cout," **--** "));cout<<endl;
#endif
#ifdef GLOBALUPDATE
        global_update_matrix(mat,listcomp,mon2col);
#else
  for(auto c : listcomp)
    {
      update_matrix(mat,c,mon2col,indexmat);
      indexmat+=c.poly.size();
    }
#endif
  cout<<"apres updatematrix"<<endl;
  //affdebug(mat);
  //copy(sizeexceed_ret.begin(),sizeexceed_ret.end(),ostream_iterator<int>(cout," **--** "));cout<<endl;
#endif 


   mat.nrow+=crochet.poly.size();
#ifdef DEBUG
 cout<<"verytmp"<<endl;
  for(auto &p :verytmpPk)
    cout<<invconv<typename typP::value_type>(p,serv)<<endl;
#endif
  Pk=verytmpPk;
  Mk=tmpMk;
  return flagdoplus;
}


template<typename typP,typename typdump,typename Base,
     template<typename mon, typename pol> class monomial_server, typename mon>
void algo_borderbases(typP P,typdump &dump,Base &b, 
      monomial_server<mon,pol2ter<mon,typename mon::coeff_t> > &serv)
{
  typedef typename typP::value_type polyalp;
  typedef list<pol2ter<mon,typename mon::coeff_t> > typPk;
  typedef list<typename typPk::value_type::monom_t> typMk;
  //  typedef typename typMk::value_type mon;
  typedef typename typPk::value_type pol;

  typMk Mk;
  typMk Spoldejavu;
  typPk Pk,S;
  typPk recall;
  workspace<typename typP::value_type::coeff_t> w;
  typedef harewell<typename typP::value_type::coeff_t> typMat;
  typMat Mat,L;
  int nouveaumon,allpolused=0,maxdeg,k,*pr,*pc;
  vector<typename typMk::value_type*> exceed;
  list<int> sizeexceed;
  //cout<<"avant init"<<endl;
  
  init_algo<typMat>(P,nouveaumon,maxdeg,k,Pk,Mk,b,dump,w,serv);
  //cout<<"apres init"<<endl;
#ifdef GOTZMANN
  int nextdim=-1;
  initial_mon(k,b,dump,serv);
  while((!critere_got(b,dump,serv))||(k<=maxdeg))
#else  
    while(nouveaumon||(k<=maxdeg))
#endif
    {
    int killspol;
#ifdef VERBOSE
    cout<<"Spolordsup"<<endl;
#endif
    S=Spolordsup(Pk,b,Spoldejavu);
    for(typename typPk::iterator iter=S.begin();iter!=S.end();iter++)
      {
    //   cout<<"poly de taille "<<iter->size<<endl;
    cout<<invconv<typename typP::value_type>(*iter,serv)<<endl;       
      }
#ifdef DEBUG
cout<<"poly a la fin de la boulcle de l'algo "<<Pk.size()<<endl;
for(typename typPk::iterator iter=Pk.begin();iter!=Pk.end();iter++)
 {
   //   cout<<"poly de taille "<<iter->size<<endl;
   cout<<invconv<typename typP::value_type>(*iter,serv)<<endl;       
}
    cout<<endl<<"newpkmkmatrixof"<<endl;
#endif

    killspol=!newpkmkMatrixofSolve(Mat,L,Pk,P,Mk,k,b,dump,exceed,sizeexceed
                   ,w,serv);
#ifdef DEBUG
    cout<<"poly apres solve (attention exceed)"<<endl;
    copy(sizeexceed.begin(),sizeexceed.end(),ostream_iterator<int>(cout," *** "));cout<<endl;
    for(typename typPk::iterator iter=Pk.begin();iter!=Pk.end();iter++)
      {
    
    cout<<invconv<typename typP::value_type>(*iter,serv)<<endl;       
      }
#endif
    if(killspol) S.erase(S.begin(),S.end());
    if (k+1>=maxdeg) allpolused=1;
    if(Mk.size()==0) nouveaumon=0;
    //    cout<<"le rang "<<my_rank(Mat)<<endl;
    // cout<<"Mk.size() "<<Mk.size()<<endl;
   // copy(Mk.begin(),Mk.end(),ostream_iterator<mon>(cout," "));
   // cout<<endl;
    if ((unsigned)my_rank(Mat)==Mk.size())
      //matrice de rang plein
      //donc tous les exceed sont vides
      {
    typMk tmpSpoldejavu;
    typPk redspol,secd=secondmembre(Mat,Pk);;
    //secondmembre2(Mat,Pk,secd);
    //typename typPk::iterator iter=Pk.begin();
#ifdef VERBOSE
    cout<<"matrice de rang plein "<<endl;
#endif
    Dump(Pk,dump);
#ifdef GOTZMANN
    nextmon(k,b,dump,serv);
#endif
#ifdef VERBOSE
    cout<<"secd/size() "<<secd.size()<<endl;
#endif
    ReduceSpol(S,dump,redspol,b,w,serv);//tmpSpoldejavu);
    my_merge(redspol,secd);
#ifdef VERBOSE
    cout<<"redspol.size "<<redspol.size()<<endl;
#endif
    if(redspol.size()==0)
      {
        k++;
        my_merge(Spoldejavu,tmpSpoldejavu);
        L.destroystore();
        continue;
        //la matrice a rang plein 
        //ET les Spol\secondmembre de ce niveau se ,reduisent a 0
      }
    else
      {
        //on a des spol\secondmembre qui se reduisent pas a 0
        //cad un defaut de commuatation
        int tmpdeg=mindeg(redspol,serv);
        max_degppcm=k+2;
        nouveaumon=1;
#ifdef VERBOSE
    cout<<"redspol.size() "<<redspol.size()<<endl;
#endif

        if (tmpdeg==(k+1))
          my_merge(Spoldejavu,tmpSpoldejavu);
        k=tmpdeg;

        recover(Pk,Mk,dump,k);

        forget(b,dump,k,recall);
#ifdef VERBOSE
        cout<<"debut newcrochetchoix"<<endl;
#endif
        NewCrochetchoix(P,Pk,Mk,redspol,k,dump,b,recall,w,serv);
#ifdef VERBOSE
        cout<<"fin newcrochetchoix"<<endl;
#endif
        NewDestroyredspol(redspol,Pk);
        serv.compress(Pk,dump,b,k);
        Dump(Pk,dump);
#ifdef GOTZMANN
        nextmon(k,b,dump,serv);
#endif
        L.destroystore();
        //misa jour de B dans crochet choix!!
        continue;
      }
      }
    else
      //la matrice n'est pas de rang plein
      {
#ifdef VERBOSE  
    cout<<"matrice de rang pas plein "<<endl;
#endif
    typPk secd;
#ifdef VERBOSE  
    cout<<"addB"<<endl;
#endif
#ifdef DEBUG11  
    cout<<"avant addB "<<Pk.size()<<endl;
    auto iterexceed=exceed.begin();
    auto itersizeexceed=sizeexceed.begin();
    for(typename typPk::iterator iter=Pk.begin();iter!=Pk.end();iter++,iterexceed++,itersizeexceed++)
      {
        cout<<"ind "<<iter->ind<<" est sikzeexceed "<<*itersizeexceed<<endl;
        copy(*iterexceed,*iterexceed+*itersizeexceed,ostream_iterator<mon>(cout," + "));
        cout<<endl;
        cout<<invconv<typename typP::value_type>(*iter,serv)<<endl;       
      }
#endif
    AddB(Mat,Pk,Mk,exceed,sizeexceed,dump,b,serv);
#if 0
    cout<<"apres addB "<<Pk.size()<<endl;
    for(typename typPk::iterator iter=Pk.begin();iter!=Pk.end();iter++)
      {
        cout<<invconv<typename typP::value_type>(*iter,serv)<<endl;       
      }
#endif
    //
    //secondmembre supprime des trucs dans Pk!!
    //
    //  cout<<"second membre"<<endl;
    secd=secondmembre(Mat,Pk);
    //  cout<<"voisin"<<endl;
    rajoute_voisins(Pk,Mk,dump,b,w,serv);
    //  cout<<"fin voisin"<<endl;
    //ne selectionne que les non nuls
       if(secd.size()==0)
     {
       typPk redspol;
       Dump(Pk,dump);
#ifdef GOTZMANN
       nextmon(k,b,dump,serv);
#endif
      
       ReduceSpol(S,dump,redspol,b,w,serv);//,Spoldejavu);
#ifdef NO_TWICE    
for(typename typPk::iterator iter=redspol.begin();iter!=redspol.end();iter++)
      P.push_back(invconv<polyalp>(*iter));
#endif
       if(redspol.size()==0)
         {
           k++;
           L.destroystore();
           continue;
           //la matrice a pas rang plein second membre =0 
           //ET les Spol de ce niveau se ,reduisent a 0
         }
       else
         {
           //on a des spol qui se reduisent pas a 0
           //cad un defaut de commutation 
           k=mindeg(redspol,serv);
           recover(Pk,Mk,dump,k);
           forget(b,dump,k,recall);
#ifdef VERBOSE
           cout<<"il ya un passage par mat rang pas"
               <<"plein et pol non zero"<<endl;
#endif        
           NewCrochetchoix(P,Pk,Mk,redspol,k,dump,b,recall,w,serv);
           NewDestroyredspol(redspol,Pk);
           serv.compress(Pk,dump,b,k);
           Dump(Pk,dump);
#ifdef GOTZMANN
           nextmon(k,b,dump,serv);
#endif
 
           L.destroystore();
           continue;
         }
     }
       else
     {
       //on a des pol qui se reduisent pas a 0
       //cad un defaut de commuatation dans les coins
       typPk redspol;
       Dump(Pk,dump);
#ifdef GOTZMANN
       nextmon(k,b,dump,serv);
#endif
       ReduceSpol(S,dump,redspol,b,w,serv);//,Spoldejavu);
       my_merge(secd,redspol);
#ifdef NO_TWICE    
for(typename typPk::iterator iter=redspol.begin();iter!=redspol.end();iter++)
         P.push_back(invconv<polyalp>(*iter));
#endif
           k=mindeg(secd,serv);
       recover(Pk,Mk,dump,k);
       forget(b,dump,k,recall);
#if 0
        cout<<"poly avant newcrochetchoix (attention exceed)"<<endl;
        copy(sizeexceed.begin(),sizeexceed.end(),ostream_iterator<int>(cout," *** "));cout<<endl;
        for(typename typPk::iterator iter=Pk.begin();iter!=Pk.end();iter++)
          {
        
        cout<<invconv<typename typP::value_type>(*iter,serv)<<endl;       
          }
#endif

       NewCrochetchoix(P,Pk,Mk,secd,k,dump,b,recall,w,serv);
#if 0
        cout<<"poly apres newcrochetchoix (attention exceed)"<<endl;
        copy(sizeexceed.begin(),sizeexceed.end(),ostream_iterator<int>(cout," *** "));cout<<endl;
        for(typename typPk::iterator iter=Pk.begin();iter!=Pk.end();iter++)
          {
        
        cout<<invconv<typename typP::value_type>(*iter,serv)<<endl;       
          }
#endif

       NewDestroyredspol(secd,Pk);
       serv.compress(Pk,dump,b,k);
       Dump(Pk,dump);
#ifdef GOTZMANN
       nextmon(k,b,dump,serv);
#endif

       L.destroystore();
       continue;
     }
      
      }
  }
  
  Mat.destroystore();
  //while nouveau mon etc...
  destroy_space(&w);
#ifdef VERBOSE
  cout<<"sortie d'algo flash et dimension "<<endl;
#endif
  return ;//dump;
  //comme ca on conserve le tri par degre des formes normales et 
  //donc la construction des operateurs de multiplication se 
  //fait plus vite.. :-)

}


#ifdef FUN
template<typename typcompo, typename typP, typename typwork, typename typserv>
void treatment_component(typcompo &iter,int numcompo, int nbcompo, typP &P, 
             typwork &w, typserv &serv)
{
  //il faut construit tmpMK pour la composante
  int *tmppr,*tmppc;
  typMk verytmpMk;
  typMat tmpmat;
     for(auto &&iterind : iter->poly)
     {
       verytmpMk.push_back(iterind.ind);
       //   cout<<"je push "<<iterind.ind<<endl;
     }
     gettimeofday(&t1,NULL);
     construct_matrix_from_newpol_nofree(tmpmat, iter->poly, verytmpMk, 
                     iter->exceed, iter->sizeexceed, P);

    //P est la pour forwareder les types ord et pol 
    //On resoud 
    //            pr et pc sont alloués avec malloc
    //            dans la fonction solve
    //            il faut les desallouer
    // 
    //Ceci est une fonction solve a ecrire pour reporter
    //les operations sur les poly aussi sur les exceed
    //
     gettimeofday(&t2,NULL);
#ifdef VERBOSE
     cout<<"\e[31m Temps contrustmatrix "<<t2.tv_sec-t1.tv_sec+1e-6*(t2.tv_usec-t1.tv_usec);
     cout<<"\e(B\e[m"<<endl;
#endif
     t1=t2;
     Solve(tmpmat,L,*iter,&tmppr,&tmppc,verytmpMk,w,serv);

     gettimeofday(&t2,NULL);
#ifdef VERBOSE
     cout<<"\e[31m Temps Solve "<<t2.tv_sec-t1.tv_sec+1e-6*(t2.tv_usec-t1.tv_usec);
     cout<<"\e(B\e[m"<<endl;
#endif
     t1=t2;
     for(auto &m :verytmpMk)
       {
     m.SetCoeff(1);
     tmpMk.push_back(m);
       } 
#ifdef VERBOSE
     cout<<"update "<<endl;
     //mise a jour des autres polynomes et recnstruction de la matrice complete
     cout<<"la map"<<endl;
#endif
     map<typename mon::rep_t,resmul<typename compo::typPk::value_type> > mon2pol;
     {
       auto iterexceed=iter->exceed.begin();
       auto itersizeexceed=iter->sizeexceed.begin();
       auto iterpoly=iter->poly.begin();
       int i=0;
       for(auto iterpoly=iter->poly.begin();iterpoly!=iter->poly.end();
       iterpoly++,iterexceed++,itersizeexceed++,i++)
     {
       resmul<typename compo::typPk::value_type> tmp;
       tmp.poly=*iterpoly;
       tmp.exceed=*iterexceed;
       tmp.sizeexceed=*itersizeexceed;
       if(!(tmpmat(i,i)==0)) mon2pol[iterpoly->ind.rep]=tmp;
       //on augmente le workspace pour update apres
       for(;w.sizenf<iterpoly->sizenf;increase_space(&w));
     }
     }
#ifdef VERBOSE
     cout<<"le graph"<<endl;
#endif
     //on regarde pour chaque sommet de la composante les arcs sortant
     //ceux qui aboutissent a des sommets qui ne sont pas dans la compo
     //indiquent un update a faire
     vector<char> toupdate(nbcompo+1,0);
     int indexcompo=0;
     for(int i_vec=0;i_vec<G.size();i_vec++)
       {
     if(vec[i_vec]==numcompo)
       {
         //on a trouvé un sommet dans la composante
         //en cours de traitement
         for(int j=0;j<G.size();j++)
           {
         if(G[j][i_vec] && vec[j]!=numcompo)
           {
             toupdate[vec[j]]=1;
             //On rajoute les composantes qui vont m'updater
             //a celle trouvee
             for(int j_graph=0;j_graph<G.size();j_graph++)
               G[j][j_graph]|=G[i_vec][j_graph];
             //on a plus besoin re parser cet update
             G[j][i_vec]=0;
           }
           }
       }
       }
#ifdef ASYNCUPDATE
    list<std::thread> list_up;
#endif
#ifdef VERBOSE
    cout<<"les poly"<<endl;
#endif
    for(auto itercomp=listcomp.begin();itercomp!=listcomp.end();
        itercomp++,indexcompo++)
      //le test est fait dans update pol
       if(toupdate[indexcompo])
         {
#ifndef ASYNCUPDATE
           update_pol(*itercomp,*iter,mon2pol,w,serv);
#else
           list_up.push_back(std::thread(wrap_update_pol<compo,
           map<typename mon::rep_t,resmul<typename compo::typPk::value_type> 
                         >,monomial_server>,
                    std::ref(*itercomp),
                 std::ref(*iter),std::ref(mon2pol),std::ref(serv)));
           if(list_up.size()>=NBFUTURE)
         {
           for(auto &i : list_up)
             i.join();
           list_up.erase(list_up.begin(),list_up.end());
         }
#endif
         }
#ifdef ASYNCUPDATE
    for(auto &i : list_up)
      i.join();
    list_up.erase(list_up.begin(),list_up.end());
#endif
#ifdef VERBOSE
    cout<<"avant update du crochet "<<endl;
    for(int i=0;i<crochet.poly.size();i++)
      {    cout<<"ind "<<crochet.poly[i].ind<<endl;
        copy(crochet.exceed[i],crochet.exceed[i]+crochet.sizeexceed[i],ostream_iterator<mon>(cout," + "));
        cout<<invconv<Poly>(crochet.poly[i],serv)<<endl;
       }
#endif
     update_pol(crochet,*iter,mon2pol,w,serv);
     //on fait uassi agir sur les polynomes du crochet
#ifdef VERBOSE
     cout<<"fin des updates "<<endl;
     cout<<"apres update du crochet "<<endl;
     for(int i=0;i<crochet.poly.size();i++)
       {
         cout<<"ind "<<crochet.poly[i].ind<<endl;
         copy(crochet.exceed[i],crochet.exceed[i]+crochet.sizeexceed[i],ostream_iterator<mon>(cout," + "));
         cout<<invconv<Poly>(crochet.poly[i],serv)<<endl;
       }
#endif
     reconstruct_mat(mat,tmpmat);
     reconstruct_pr_pc(pr,pc,tmppr,tmppc,tmpmat.ncol,indexinside);
     indexinside+=verytmpMk.size();
     free(tmppr);
     free(tmppc);
}
#endif

#endif