corealgo3sdp.hpp

Go to the documentation of this file.

#ifndef ALREADY_corealgo3
#define ALREADY_corealgo3
#include<algorithm>
#include<iostream>
#include<string>
#include<fstream>
#include<iomanip>
#include<iterator>


#include "linalg/clapack.h"

namespace coinor {
//  extern "C" {
#define NOSHORTS
using namespace std;
#include "sdpinclude.hpp"
//#include "declarations.hpp"
//}
}

template<typename typP,typename typPk,typename Base>
void Crochetchoix(const typP & P,typPk & Pk, typPk & redspol,int k,
            Base &b);

template<typename typPk>
void stab(typPk & Pk)
{
  typedef typename typPk::value_type pol;
  for(typename typPk::iterator iter=Pk.begin();iter!=Pk.end();iter++)
    {
      pol tmpres=mon(0);
      for(typename pol::iterator iterpol=iter->begin();iterpol!=iter->end();
      iterpol++)
    {
      if(!Iszero(iterpol->GetCoeff()))
        tmpres+=*iterpol;
    }
      *iter=tmpres;
    }
}

template<typename T>
void  my_merge(T &l1,const T &l2)
{
  typename T::const_iterator iter=l2.begin();
  for(;iter!=l2.end();iter++)
     l1.push_back(*iter);
}
template<typename mon>
mon lcm(const mon &m1,const mon &m2)
{
  mon m(1);
  int maxi=max(lvar(m1.rep),lvar(m2.rep));
  for(int i=0;i<=maxi;i++)
    m*=mon(i,max(m1.GetDegree(i),m2.GetDegree(i)));
  return m;
}

static int max_degppcm;

template<typename typppcm,typename Base>
int compute_ppcm(typppcm &ppcm,const Base & b)
{
  typedef typename Base::mon mon;
  //typppcm tmpppcm;
  max_degppcm=0;
  int maxdeg=-1;
  list<mon> list1,list2,tmplist2;
 

 for(typename Base::const_reverse_iterator iter=b.rbegin()
    ;iter==b.rbegin();iter++)
    {
#ifndef oldppcm
      for(int i=0;i<iter->taille2;i++)
    for(int j=i+1;j<iter->taille2;j++)
      {
        mon tmpmon=lcm(iter->refuse[i],iter->refuse[j]);
        
        if((!ppcm.count(tmpmon))&& 
           (tmpmon.GetDegree()!=
        (iter->refuse[i].GetDegree()+iter->refuse[j].GetDegree())))
          {
        ppcm[tmpmon]=1;
        if(tmpmon.GetDegree()>max_degppcm)
          max_degppcm=tmpmon.GetDegree();
          }
        
        //      cout<<"ppcm rajoute "<<tmpmon<<" "<<iter->refuse[i]<<" "<<iter->refuse[j]<<endl;
      }
#else      
      for(int i=0;i<iter->taille2;i++)
    for(int j=i+1;j<iter->taille2;j++)
      {
        mon tmpmon=lcm(iter->refuse[i],iter->refuse[j]);
    
             if((tmpmon.GetDegree()!=
        (iter->refuse[i].GetDegree()+iter->refuse[j].GetDegree())))
          {
        int ok=1;
        for(int k=0;k<iter->taille2;k++)
          {
            if((k!=i) && (k!=j) 
               && (isdivisible(iter->refuse[k],tmpmon,b)))
              {
            mon lc_i=lcm(iter->refuse[k],iter->refuse[i]);
            mon lc_j=lcm(iter->refuse[k],iter->refuse[j]);
            if((lc_i.rep!=tmpmon.rep) 
               && (isdivisible(lc_i,tmpmon,b)) &&
               (lc_j.rep!=tmpmon.rep)
               &&(isdivisible(lc_j,tmpmon,b)))
              ok=0;
              }
          }
        if(ok)
          list2.push_back(tmpmon);
          }
      }
#endif
    }
#ifdef oldppcm  
  maxdeg=0;
  //  cout<<"liste2.size "<<list2.size()<<endl;
  for(typename list<mon>::iterator iter2=list2.begin();
      iter2!=list2.end();iter2++)
    {
      // cout<<"je passe ici "<<*iter2<<endl;
      ppcm[*iter2]=1;
      if(iter2->GetDegree()>maxdeg)
    maxdeg=iter2->GetDegree();
    }
  max_degppcm=maxdeg;
#endif
  return maxdeg;
}

int GB_stop(int k)
{
  int res=0;
  if(k>max_degppcm) res=1;
  return res;
}

template<typename mon,typename Base,typename typppcm,typename typMk>
int goodspol(const mon &m1,const mon &m2, typppcm & ppcm,const Base &b
         ,const typMk &Spoldejavu)
{
  //list<mon> ppcm;
  int res=0,comp=0;//,nobplus=1;
  mon m=m1;
  for(int i=0;i<b.nbvar();i++)
    if(m1.GetDegree(i)!=m2.GetDegree(i))
      {
    comp++;
    if (m1.GetDegree(i)-m2.GetDegree(i)==1)
      res+=1;
    if (m1.GetDegree(i)-m2.GetDegree(i)==-1)
      {
        res+=1;
        m*=mon(i,1);
      }
      };
  //compute_ppcm(ppcm,b);
  //if((res==2)&&(comp==2)) 
  //  for(int i=0;i<b.nbvar();i++)
  //    if(m.GetDegree(i)>0)
  //    nobplus=nobplus && !IsinB(my_divmon(m,i,b),b);
   //cout<<"m1 "<<m1<<" m2 "<<m2<<" resultat "<<((res==2)&&(comp==2))<<endl;
   //return ((res==2)&&(comp==2)&&nobplus);
  //cout<<m1<<" < "<<m2<<" res "<<(member(ppcm,m)&&(res==2)&&(comp==2))<<endl;
  
  //  cout<<"m "<<m<<endl;
  //il y a un pbm a ne pas refaire les spol deja vu je ne comprends 
  //pas pourquoi voir example caprass
  #ifdef NO_TWICE
  return (res==2)&&(comp==2)&&ppcm[m]&&!member(Spoldejavu,m);
  #else
  return (res==2)&&(comp==2)&&ppcm.count(m);
  #endif
}

template<typename typPk,typename Base,typename typMk>
typPk Spolordsup(const typPk &Pk,const Base & b, const typMk & Spoldejavu)
{
  typedef typename typPk::value_type::monom_t mon;
  //typedef typename typ::order_t O;
  map<mon,int> ppcm;
  typPk res;
  int maxdeg;
  maxdeg=compute_ppcm(ppcm,b);
  cout<<"maxdeg"<<maxdeg<<endl;
  //cout<<"test goodspol"<<endl;
  for(typename typPk::const_iterator iter1=Pk.begin();iter1!=Pk.end();iter1++)
  
    for(typename typPk::const_iterator iter2=iter1;iter2!=Pk.end();iter2++)
    { cout<<"iter1->ind"<<iter1->ind<<endl;
      cout<<"iter2->ind"<<iter2->ind<<endl;
      cout<<"goodspol"<<goodspol(iter1->ind,iter2->ind,ppcm,b,Spoldejavu)<<endl;
      if (goodspol(iter1->ind,iter2->ind,ppcm,b,Spoldejavu))
    {
//    cout<<"iter1"<<*iter1<<endl;
//    cout<<"iter2"<<*iter2<<endl;
      res.push_back(*iter1);
      res.push_back(*iter2);
    }
    }
  return res;
}
template<typename typP>
int minmaxdegP(typP P,int &maxdeg)
{
  int res=Degree(P.front());
  maxdeg=res;
  for(typename typP::iterator iter=P.begin();iter!=P.end();iter++)
    {
      res=(res>Degree(*iter))?Degree(*iter):res;
      maxdeg=(maxdeg<Degree(*iter))?Degree(*iter):maxdeg;
    }
  return res;
}
template<typename typP>
typP Crochet(const typP &P, int k)
{
  typP res;
  for(typename typP::const_iterator iter=P.begin();iter!=P.end();iter++)
    {
      if(Degree(*iter)==k) res.push_back(*iter);
    }
  return res;
}

template<typename mon, typename T, typename monomial_server>
std::list<pol<mon,T> > Crochet(const std::list<pol<mon,T> > &P, int k, 
                   monomial_server &serv)
{
  std::list<pol<mon,T> > res;
  for(typename std::list<pol<mon,T> >::const_iterator iter=P.begin()
    ;iter!=P.end();iter++)
    {
      if(Degree(*iter,serv)==k) res.push_back(*iter);
    }
  return res;
}

template<typename typP, typename Base>
void Setnbvars(const typP &tmpPk,Base& b)
{
  int tmpvar=0;
  for(typename typP::const_iterator iter=tmpPk.begin();iter!=tmpPk.end();iter++)
    for(typename typP::value_type::const_iterator iterpol=iter->begin();
    iterpol!=iter->end();iterpol++)
    {
       cout<<"iterpol->rep"<<iterpol->rep<<endl;
       cout<<"lvar(iterpol->rep)"<<lvar(iterpol->rep)<<endl;
      if(tmpvar<lvar(iterpol->rep)) tmpvar=lvar(iterpol->rep);
    }
  b.nbvars=tmpvar+1;
}

template<typename typP>
int Setnvars(const typP &tmpPk)
{
  int tmpvar=0;
  for(typename typP::const_iterator iter=tmpPk.begin();iter!=tmpPk.end();iter++)
    for(typename typP::value_type::const_iterator iterpol=iter->begin();
    iterpol!=iter->end();iterpol++)
    {
       cout<<"iterpol->rep"<<iterpol->rep<<endl;
       cout<<"lvar(iterpol->rep)"<<lvar(iterpol->rep)<<endl;
      if(tmpvar<lvar(iterpol->rep)) tmpvar=lvar(iterpol->rep);
    }
  return tmpvar+1;
  
}

template<typename typP, typename typMk, typename Base, 
     typename monomial_server>
void DoBaseMk(const typP &tmpPk, typMk &Mk, Base &b, monomial_server &serv)
{
  typedef typename typMk::value_type mon;
  typename Base::predicat_t tmp;
  int i=0;
  //int tmpvar=0;
   
  for(typename typP::const_iterator iter=tmpPk.begin();iter!=tmpPk.end();iter++)
    {
      mon tmp(choice(*iter,b,serv));
      int yes=1;
      //  cout<<"pol dans DoBaseMk "<<endl<<*iter<<endl<<"g choisi "<<tmp<<endl;
      tmp.SetCoeff(1);//*=mon(1/tmp.GetCoeff());
      for(typename typMk::iterator iter=Mk.begin();iter!=Mk.end();iter++)
    if(*iter==tmp) {yes=0;break;};
      if(yes) Mk.push_back(tmp);
    }
  //cout<<"Mk.size()"<<Mk.size()<<endl;
  tmp.taille2=Mk.size();
  tmp.refuse=(mon*)MAC_REV_MALLOC<mon>(tmp.taille2*sizeof(mon));
  tmp.taille1=1;
  tmp.accept=(mon*)MAC_REV_MALLOC<mon>(sizeof(mon));
  // cout<<"mon(1) "<<mon(1)<<endl;
  tmp.accept[0]=mon(1);
  //cout<<"tmp.accept "<<tmp.accept[0]<<endl;
  i=0;//pour en etre bien sur
  for(typename typMk::iterator iter=Mk.begin();iter!=Mk.end();iter++,i++)
    {
      tmp.refuse[i]=*iter;
    };
  if(!b.def.empty())
    {
      typename Base::predicat_t verytmp;
      for(typename Base::iterator iter=b.begin();iter!=b.end();iter++)
    {
      verytmp=*iter;
      MAC_REV_FREE<mon>(verytmp.refuse,verytmp.taille2*sizeof(mon));
      MAC_REV_FREE<mon>(verytmp.accept,verytmp.taille1*sizeof(mon));
    }
      b.erase(b.begin(),b.end());
    }
  b.def.push_back(tmp);
  return;
}

template <typename typPk,typename typMk,typename typmat >
typmat*
MatrixOf(const typPk & L, 
     const typMk & lm,const typmat &mat) 
{
  typedef typename typPk::value_type POL;
  typedef typename typMk::value_type monom_t;  
  typmat *res=NULL;
  map<monom_t,int> index;
  int l=1;
  if (res!=NULL) {delete res;};
  for(typename typMk::const_iterator m = lm.begin(); m!=lm.end(); m++){
    //    cout<<"*m "<<*m<<endl;
    index[*m]=l;
    l++;
  }
  int c;
  res=new typmat(L.size(),lm.size());
  l=0;

  cout<<"L.size() "<<L.size()<<" lm.size() "<<lm.size()<<endl;
  for(typename typPk::const_iterator pi = L.begin(); pi != L.end(); ++pi){
    for(typename POL::const_iterator m = pi->begin(); m!=pi->end(); m++)
      {
    
    if((index.count(*m))) 
      {
        c=index[*m];
        (*res)(l,c-1,m->GetCoeff());
      }
      }
    l++;
  }
  cout<<"fin"<<endl;
  return res;   
}

template<typename typMat,typename typP,typename typPk,typename typMk, typename Base,typename typdump, class monomial_server, typename workspace>
void init_algo(typP &P,int &nouveaumon, int &maxdeg, int & k,
           typPk &Pk, typMk & Mk, Base & b, typdump & dump, workspace &w,
           monomial_server &serv)
{
  typedef typename typPk::value_type pol;
  typedef typename pol::coeff_t coeff;
  typedef typename pol::monom_t mon;
  const typename typP::value_type::order_t (tmpord)(const mon,const mon);
  typP tmpPk=P;
  pol debugpol;
  typMat *Mat;
  int *pr,*pc,flag=1;
  serv.setorder(my_ord);
  nouveaumon=1;
  Setnbvars(P,b);
  cout<<"Init Space"<<endl;
  init_space(&w);
  cout<<"Init Space fini"<<endl;
#ifdef unimul
  serv.init_multiple(b.nbvars);
#endif
#ifdef uninf
  serv.init_nf(b.nbvars);
#endif 
  flag=1;
while(flag)
    {
      cout<<"Dans While"<<endl;
      Mk.erase(Mk.begin(),Mk.end());
      cout<<"Dans While 1"<<endl;
      k=minmaxdegP(tmpPk,maxdeg);
      cout<<"Dans While 2"<<endl;
      tmpPk=Crochet(tmpPk,k);
      cout<<"Dans While 3"<<endl;
      DoBaseMk(tmpPk,Mk,b,serv);
      cout<<"Dans While 4"<<endl;
      Mat=MatrixOf(tmpPk,Mk,typMat());
      cout<<"Dans While 5"<<endl;
      tmpPk=Solve(*Mat,tmpPk,&pr,&pc);
      cout<<"Dans While 6"<<endl;
      selectnozero(tmpPk);
      stab(tmpPk);
      cout<<"my_rank(*Mat)"<<my_rank(*Mat)<<endl;
      cout<<"tmpPk.size()"<<tmpPk.size()<<endl;
      if(my_rank(*Mat)==(int)tmpPk.size()) flag=0;
      Mat->destroystore();
      delete(Mat);
      free(pr);
      free(pc);
    }
 cout<<"While fini"<<endl;
      for(typename typP::iterator iter=tmpPk.begin();iter!=tmpPk.end();iter++)
      {
    Pk.push_back(convert<pol>(*iter,b,serv));
    cout<<"tmpPk"<<*iter<<endl;
      }
      
      Dump(Pk,dump);
     
      
  return ;
}

template<typename pol,typename coeff, typename workspace>
void inline my_plus(pol &res,const pol & nf,const coeff toto,workspace *w)
{
  typedef typename pol::monom_t mon;
  typedef typename mon::coeff_t mcoeff_t;
  //symbolic size
  int i=0,j=0,k=0,p=0,q=0;
  int tmpsize=0,tmp;
  mcoeff_t *tmpnf,*tmpspace,zero=0;
  unsigned char *tmpnfind;
#ifdef DEB
  cout<<"dans myplus je calcul"<<endl<<invconv<Poly>(res)<<endl<<
    "toto "<<toto<<endl<<"nf"<<endl<<invconv<Poly>(nf)<<endl;
#endif
  if(res.sizenf<nf.sizenf)
    {
      //      cout<<"res.sizenf<nf.sizenf "<<endl;
      if(w->sizenf<nf.sizenf)
    increase_space(w);

//#pragma omp parallel for shared(w,toto)
      for(i=0;i<res.sizenf;i++)
      {
        if(res.nfind[i]|nf.nfind[i])
          {
        w->tabnf[i]=res.nfind[i]|nf.nfind[i];
        for(int j=0;j<8;j++)
          {
            if ((res.nfind[i]>>j)&1)
              w->tabcoeff[8*i+j]=res.nf[p++];
            if((nf.nfind[i]>>j)&1)
              w->tabcoeff[8*i+j]-=toto*nf.nf[q++];
            if(Iszero(w->tabcoeff[8*i+j]))
              w->tabnf[i]&=~(1<<j);
          }
          }
      }
//#pragma omp parallel for shared(w,toto)
      for(i=res.sizenf;i<nf.sizenf;i++)
      {
        if(nf.nfind[i])
          for(int j=0;j<8;j++)
        if ((nf.nfind[i]>>j)&1)
          if (!Iszero(nf.nf[q++]))
            w->tabcoeff[8*i+j]=((mcoeff_t)-1)*toto*(nf.nf[q-1]);
          else
            w->tabnf[i]&=~(1<<j);
        w->tabnf[i]=nf.nfind[i];
      }
      for(int i=0;i<nf.sizenf;i++)
    tmpsize+=nbbits[w->tabnf[i]];
      res.nf=(COEFF*)MAC_REV_REALLOC<COEFF>(res.nf,res.size*sizeof(COEFF)
                        ,tmpsize*sizeof(COEFF));
      res.size=tmpsize;
      res.nfind=(unsigned char*)realloc(res.nfind,nf.sizenf);
      res.sizenf=nf.sizenf;

      for(int i=0;i<nf.sizenf;i++)
    {
      if(w->tabnf[i])
        for(int j=0;j<8;j++)
          if ((w->tabnf[i]>>j)&1)
        //if (!Iszero(w->tabcoeff[8*i+j]))
        {
          res.nf[k++]=w->tabcoeff[8*i+j];
          w->tabcoeff[8*i+j]=zero;
        }
      //else
      //  w->tabnf[i]&=~(1<<j);
      res.nfind[i]=w->tabnf[i];
      w->tabnf[i]=0;
    }
    }
  else
    {
      if(w->sizenf<res.sizenf)
    increase_space(w);
//#pragma omp parallel for shared(w,toto)
      for(i=0;i<nf.sizenf;i++)
#if 1
    {
        if(res.nfind[i])
          {
        unsigned char mask=1;
        w->tabnf[i]=res.nfind[i];
        if(res.nfind[i]==255)
          for(int j=0;j<8;j++)
            w->tabcoeff[8*i+j]=res.nf[p++];
        else
          for(int j=0;j<8;j++,mask<<=1)
            {
              //if ((res.nfind[i]>>j)&1) 
              if (res.nfind[i]&mask)
            w->tabcoeff[8*i+j]=res.nf[p++];
            }
          }
        if(nf.nfind[i])
        {
          unsigned char mask=1;
          w->tabnf[i]|=nf.nfind[i];
          if(nf.nfind[i]==255)
            for(int j=0;j<8;j++,mask<<=1)
              {
            w->tabcoeff[8*i+j]-=toto*nf.nf[q++];
            if(Iszero(w->tabcoeff[8*i+j]))
              w->tabnf[i]&=~mask;
              }
          else
            for(int j=0;j<8;j++,mask<<=1)
              {
            if(nf.nfind[i]&mask)
              w->tabcoeff[8*i+j]-=toto*nf.nf[q++];
            if(Iszero(w->tabcoeff[8*i+j]))
              w->tabnf[i]&=~mask;
              }
        }
      }
#endif
#if 0
        if(res.nfind[i]|nf.nfind[i])
          {
        w->tabnf[i]=res.nfind[i]|nf.nfind[i];
        for(int j=0;j<8;j++)
          {
            if ((res.nfind[i]>>j)&1)
              {
            w->tabcoeff[8*i+j]=res.nf[p++];
              }
            if((nf.nfind[i]>>j)&1)
              w->tabcoeff[8*i+j]-=toto*nf.nf[q++];
            if(Iszero(w->tabcoeff[8*i+j]))
              w->tabnf[i]&=~(1<<j);
          }
          }
#endif
//#pragma omp parallel for shared(w,toto)
      for(i=nf.sizenf;i<res.sizenf;i++)
      {
        if(res.nfind[i])
          for(int j=0;j<8;j++)
        if ((res.nfind[i]>>j)&1) 
          if (!Iszero(res.nf[p++]))
            w->tabcoeff[8*i+j]=res.nf[p-1];
          else
            w->tabnf[i]&=~(1<<j);
        w->tabnf[i]=res.nfind[i];
      }
      for(int i=0;i<res.sizenf;i++)
    tmpsize+=nbbits[w->tabnf[i]];
      res.nf=(COEFF*)MAC_REV_REALLOC<COEFF>(res.nf,res.size*sizeof(COEFF)
                        ,tmpsize*sizeof(COEFF));
      res.size=tmpsize;
      //  res.nfind=(unsigned char*)realloc(res.nfind,nf.sizenf);
      //res.sizenf=nf.sizenf;
      for(int i=0;i<res.sizenf;i++)
    {
      if(w->tabnf[i])
        for(int j=0;j<8;j++)
          if ((w->tabnf[i]>>j)&1)
        //if (!Iszero(w->tabcoeff[8*i+j]))
        {
            res.nf[k++]=w->tabcoeff[8*i+j];
            w->tabcoeff[8*i+j]=zero;
        }
          //else
          //  w->tabnf[i]&=~(1<<j);
    
      res.nfind[i]=w->tabnf[i];
      w->tabnf[i]=0;
    }
    }

#ifdef DEB
  cout<<"k "<<k<<" tmpsize "<<tmpsize<<endl;
  int cpt=0;
  for(int i=0;i<res.sizenf;i++)
    if(res.nfind[i])
      for(int j=0;j<8;j++)
    if ((res.nfind[i]>>j)&1) 
      if (Iszero(res.nf[cpt++]))
        cout<<"j'ai fait n'importe quoi ici"<<endl;
  cout<<"les resultat "<<endl<<invconv<Poly>(res)<<endl;
#endif
  return;
}
template<typename pol,typename coeff>
void inline my_plus(pol &res,const pol & nf,const coeff toto,int removeme)
{
  typedef typename pol::monom_t mon;
  typedef typename mon::coeff_t mcoeff_t;
  //symbolic size
  int i=0,j=0,k=0,p=0,q=0;
  int tmpsize=0,tmp;
  mcoeff_t *tmpnf,*tmpspace;
  unsigned char *tmpnfind;
#ifdef DEB
  cout<<"dans myplus je calcul"<<endl<<invconv<Poly>(res)<<endl<<
    "toto "<<toto<<endl<<"nf"<<endl<<invconv<Poly>(nf)<<endl;
#endif
  if(res.sizenf<nf.sizenf)
    {
      tmpspace=(mcoeff_t*)
    MAC_REV_MALLOC<mcoeff_t>(sizeof(mcoeff_t)*nf.sizenf*8);
      for(int i=0;i<nf.sizenf*8;i++)
    tmpspace[i]=0;
      for(int i=0;i<res.sizenf;i++)
    tmpsize+=nbbits[res.nfind[i]|nf.nfind[i]];
      for(int i=0;i<nf.sizenf;i++)
    tmpsize+=nbbits[nf.nfind[i]];
      tmpnf=(mcoeff_t*)
    MAC_REV_MALLOC<mcoeff_t>(sizeof(mcoeff_t)*tmpsize);
      tmpnfind=(unsigned char*)
    MAC_REV_MALLOC<unsigned char>(nf.sizenf);
      //      memset(tmpnfind,0,nf.sizenf);

      for(int i=0;i<res.sizenf;i++)
      {
        if(res.nfind[i]|nf.nfind[i])
          for(int j=0;j<8;j++)
          {
        if ((res.nfind[i]>>j)&1)
          tmpspace[8*i+j]=res.nf[p++];
        if((nf.nfind[i]>>j)&1)
          tmpspace[8*i+j]-=toto*nf.nf[q++];
          }
        tmpnfind[i]=res.nfind[i]|nf.nfind[i];
      }

      for(int i=res.sizenf;i<nf.sizenf;i++)
      {
        if(nf.nfind[i])
          for(int j=0;j<8;j++)
        if ((nf.nfind[i]>>j)&1)
          tmpspace[8*i+j]=((mcoeff_t)-1)*toto*(nf.nf[q++]);
        tmpnfind[i]=nf.nfind[i];
      }
      for(int i=0;i<nf.sizenf;i++)
    if(tmpnfind[i])
      for(int j=0;j<8;j++)
        if ((tmpnfind[i]>>j)&1)
          if (!Iszero(tmpspace[8*i+j]))
        tmpnf[k++]=tmpspace[8*i+j];
          else
        tmpnfind[i]&=~(1<<j);
      MAC_REV_FREE<mcoeff_t>(tmpspace,nf.sizenf*8*sizeof(mcoeff_t));
      res.sizenf=nf.sizenf;
    }
  else
    {
      tmpspace=(mcoeff_t*)
    MAC_REV_MALLOC<mcoeff_t>(sizeof(mcoeff_t)*res.sizenf*8);
      for(int i=0;i<res.sizenf*8;i++)
    tmpspace[i]=0;
      for(int i=0;i<nf.sizenf;i++)
    tmpsize+=nbbits[res.nfind[i]|nf.nfind[i]];
      for(int i=0;i<res.sizenf;i++)
    tmpsize+=nbbits[res.nfind[i]];
      tmpnf=(mcoeff_t*)
    MAC_REV_MALLOC<mcoeff_t>(sizeof(mcoeff_t)*tmpsize);
      tmpnfind=(unsigned char*)
    MAC_REV_MALLOC<unsigned char>(res.sizenf);

      for(int i=0;i<nf.sizenf;i++)
    {
      if(res.nfind[i]|nf.nfind[i])
        for(int j=0;j<8;j++)
          {
        if((res.nfind[i]>>j)&1)
          tmpspace[8*i+j]=res.nf[p++];
        if((nf.nfind[i]>>j)&1)
          tmpspace[8*i+j]-=toto*nf.nf[q++];
          }
        tmpnfind[i]=res.nfind[i]|nf.nfind[i];
      }

      for(int i=nf.sizenf;i<res.sizenf;i++)
      {
        if(res.nfind[i])
          for(int j=0;j<8;j++)
          if((res.nfind[i]>>j)&1)
        tmpspace[8*i+j]=res.nf[p++];
        tmpnfind[i]=res.nfind[i];
      }

      for(int i=0;i<res.sizenf;i++)
    if(tmpnfind[i])
      for(int j=0;j<8;j++)
        if  ((tmpnfind[i]>>j)&1) 
          if (!Iszero(tmpspace[8*i+j]))
        tmpnf[k++]=tmpspace[8*i+j];
          else
        tmpnfind[i]&=~(1<<j);
        
      MAC_REV_FREE<mcoeff_t>(tmpspace,res.sizenf*8*sizeof(mcoeff_t));
    }
#ifdef DEB
  cout<<"k "<<k<<" tmpsize "<<tmpsize<<endl;
#endif
  MAC_REV_FREE<mcoeff_t>(res.nf,res.size*sizeof(mcoeff_t));
  //res.nf=tmpnf;
  MAC_REV_FREE<unsigned char>(res.nfind,res.sizenf);
  //res.nfind=tmpnfind;
  
  res.nf=tmpnf;
  res.nf=(mcoeff_t*)MAC_REV_REALLOC<mcoeff_t>(res.nf,res.size*sizeof(mcoeff_t)
                    ,k*sizeof(mcoeff_t));
                               
  //cout<<"tmpnfind "<<tmpnfind<<endl;
  res.nfind=tmpnfind;
  //  cout<<"res.nfind "<<res.nfind<<endl;
  res.size=k;
#ifdef DEB
  int cpt=0;
  for(int i=0;i<res.sizenf;i++)
    if(tmpnfind[i])
      for(int j=0;j<8;j++)
    if  ((tmpnfind[i]>>j)&1) 
      if (Iszero(res.nf[cpt++]))
        cout<<"j'ai fait n'importe quoi ici"<<endl;
  cout<<"les resultat "<<endl<<invconv<Poly>(res)<<endl;
#endif
  return;
}

//#undef DEB
//renvoit l'indice du monome x_i*m_j
template<typename mon,typename Base>
int indice2(int i,int j,const Base & b)
{
 int res=-1;
 mon tmp;
 int2mon(j,tmp);
 tmp*=mon(i,1);//on suppose qd meme que j correspond a qqchose
 //cout<<"indice2 IsinB("<<mon(i,1)*tmp<<",b) "<<IsinB(mon(i,1)*tmp,b)<<endl;
 if(IsinB(tmp,b))
   {
     res=mon2int(tmp);
     //  cout<<"le monome "<<mon(i,1)*tmp<<" l'indice "<<res<<endl;
   }
 return res;
}

//on lui donne l'ensemble des formes normales, dump, l'indice de b(cf ci dessus)
// le numero de la variable par laquelle on multiplie
//et elle renvoie un pol(cf def du type) sur la forme normale de var*m_{indmon}
#ifndef uninf 
template<typename typpol,typename typdump,typename Base>
typpol nf(int var ,int indmon,const typdump &dump,const Base & b)
{
  //on cherche dans dump...
  //a optimiser plus tard
  typedef typename typdump::value_type dumpstruct;
  typedef typpol pol;
  typedef typename pol::monom_t mon;
  pol res;
  res.nf=NULL;
  res.size=-1;
  mon tmpmon;//=mon(1,var)*int2mon<mon>(indmon);
  int deg=0;//=tmpmon.GetDegree()+1;
  typename typdump::const_iterator iter;
  int2mon(indmon,tmpmon);
  deg=tmpmon.GetDegree()+1;
  //cout<<"mon("<<var<<",1) "<<mon(var,1)<<" et deg "<<deg<<endl;
  tmpmon*=mon(var,1);
   for(iter=dump.begin();
       (iter!=dump.end()) && (iter->k!=deg);iter++);
   //    cout<<"iter-k "<<iter->k<<endl;
   // if(iter!=dump.end()) cout<<"iter->k en sortie "<<iter->k<<" et deg "<<deg<<endl;
  //cout<<"valuer a la sortie "<<(--iter)++->k<<endl;
   // cout<<"iter!=dump.end() "<<(iter!=dump.end())
   //   <<" dump.empty() "<<dump.empty()<<endl;
  if(iter!=dump.end())//on cherche pas n'importe quoi qd meme
    {
      int i;
      for(i=0;i<iter->size;i++)
    {
      //  cout<<"dans nf iter->nf[i].ind "<<iter->nf[i].ind<<endl;
      if(iter->nf[i].ind.rep==tmpmon.rep)
        break;
    }
      if(i!=iter->size)
    //Tue Dec  4 16:39:25 MET 2001
    //  densify(iter->nf[i],res);

    res=(iter->nf[i]);
    }
  //cout<<"la gueule de res "<<res<<endl;
  //if (res!=NULL) cout<<"suite de res "<<res->ind<<" "<<res->nf<<endl;
  return res;
}
#endif

void getperm(int *perm, int sizeperm, int *indextab)
{
  int median=indextab[sizeperm/2],i,j=sizeperm-1;
  if(1)
  for(i=0;i<=j;i++)
    if(indextab[i]>median)
      {
    int tmp=indextab[j];
    indextab[j]=indextab[i];
    indextab[i]=tmp;
    j--;i--;
      }
  perm[sizeperm/2]=sizeperm-i;
  getperm(perm,sizeperm-i-1,indextab);
  getperm(perm+sizeperm-i,i,indextab+sizeperm-i);
} 

//effectue la multiplication du pol T par la variable x_i
template<typename typpol,typename typdump,typename Base,typename mon,
     typename workspace, typename monomial_server> 
typpol inline mult(int i,const typpol &pol,const typdump &dump,
           const Base &b,mon **exce,int &exsize,workspace &w,
           monomial_server &serv)
{
  typedef typename typpol::coeff_t coeff;
  static const mon monzero=mon(0);
  static COEFF zero=0;
  typpol ret;
  (*exce)=(mon*)MAC_REV_MALLOC<mon>((pol.size+1)*sizeof(mon));
  int *stockindicetab=(int*)malloc(pol.size*sizeof(int));
  int noquo=0,maxind=0,p=0,q=0;
  coeff *tmpspace;
  //  for(int i=0;i<w.sizenf;i++)
  //  p+=nbbits[w.tabnf[i]];
  for(int j=0;j<pol.sizenf;++j)
    if (pol.nfind[j])
     {
       for(int k=0;k<8;k++)
     if((pol.nfind[j]>>k)&1)
       {
         int stockindice2=mulind(8*j+k,i,b);
         if(stockindice2<0)
           stockindice2=-1*(8*j+k)-1;
         stockindicetab[p++]=stockindice2;
               
         //   cout<<"stockindice2 "<<stockindice2<<" pol.size "<<
         //pol.size<<" J "<<j<<endl;
         if (stockindice2>=maxind)
           maxind=stockindice2;
       }
     }
  //cout<<"p "<<p<<" pol.size "<<pol.size<<endl;
  for(;maxind/8+1>=w.sizenf;increase_space(&w));
  //tmpspace=(coeff*)MAC_REV_MALLOC<coeff>((maxind/8+1)*8*sizeof(coeff));
  //ret.sizenf=(maxind/8+1);
  //ret.nfind=(unsigned char*)MAC_REV_MALLOC<unsigned char>(ret.sizenf);
  //memset(ret.nfind,0,ret.sizenf);
    


  //for(int j=0;j<ret.sizenf*8;j++)
  //  tmpspace[j]=0;
#ifdef DEB 
  q=0;
  for(int j=0;j<p;j++)
    q+=nbbits[pol.nfind[j]];
  cout<<" a '"<<q<<endl;
#endif
  int j;
//#pragma omp parallel for shared(stockindicetab,w,serv)
  for(j=0;j<p;j++)
    if(stockindicetab[j]>=0)
      {
    
#ifdef DEB
    mon tmpmm;
    int2mon(stockindicetab[j],tmpmm);
    cout<<"le monome la "<<tmpmm<<" "<<pol.nf[j]<<endl;
#endif
    w.tabcoeff[stockindicetab[j]]+=pol.nf[j];
    if(!Iszero(w.tabcoeff[stockindicetab[j]]))
      w.tabnf[stockindicetab[j]/8]|=1<<(stockindicetab[j]%8);
      }
    else  
      {
    //  cout<<"ici aussi"<<endl;
    typpol tmp;
    tmp=serv.nf(i,-1*(stockindicetab[j]+1),dump,b);
          if (tmp.size!=-1)
        {
          int compteurtmp=0;
          //On fait un plus dense dans tmpspace
          for(;tmp.sizenf>=w.sizenf;increase_space(&w));
//                  if(tmp.sizenf>res.sizenf)
//                   {
//            ret.nfind=(unsigned char*)realloc(ret.nfind,tmp.sizenf);
//            for(int k=ret.sizenf;k<tmp.sizenf;k++)
//          ret.nfind[k]=0;
//            tmpspace=(coeff*)MAC_REV_REALLOC<coeff>(tmpspace,
//                   ret.sizenf*8*sizeof(coeff),
//                   tmp.sizenf*8*sizeof(coeff));
//            for(int k=ret.sizenf*8;k<tmp.sizenf*8;k++)
//          tmpspace[k]=0;
//            ret.sizenf=tmp.sizenf;
              
//            //normalement on ne devrait JAMAIS passer par la
//          }
#if 1
          int k,l;
          unsigned *tmpptr=(unsigned*)tmp.nfind;
          unsigned mask=1;
          for(k=0;k<tmp.sizenf/sizeof(unsigned);k++)
            if(tmpptr[k])
              {
            ((unsigned*)w.tabnf)[k]|=tmpptr[k];
            mask=1;
            for(l=0;l<8*sizeof(unsigned);l++,mask<<=1)
              {
                if(tmpptr[k]&mask)
                  w.tabcoeff[8*sizeof(unsigned)*k+l]
                -=pol.nf[j]*tmp.nf[compteurtmp++];
                //    if(Iszero(w.tabcoeff[8*k*sizeof(unsigned)+l]))
                //  ((unsigned*)w.tabnf)[k]&=~mask;
              }
              }
          for(k=tmp.sizenf-(tmp.sizenf%sizeof(unsigned))
            ;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]-=pol.nf[j]*tmp.nf[compteurtmp++];
                //if(Iszero(w.tabcoeff[8*k+l]))
                //  w.tabnf[k]&=~mask;
              }
              }
#endif
#if 0
          for(int k=0;k<tmp.sizenf;k++)
            {
              if(tmp.nfind[k])
            {
              if(tmp.nfind[k]==255)
                {
                  unsigned char mask=1;
                  w.tabnf[k]|=tmp.nfind[k];
                  for(int l=0;l<8;l++,mask<<=1)
                {
                  w.tabcoeff[8*k+l]-=
                    pol.nf[j]*tmp.nf[compteurtmp++];
                  if(Iszero(w.tabcoeff[8*k+l]))
                    w.tabnf[k]&=~mask;
                }
                }
              else
                {
                  unsigned char mask=1;
                  w.tabnf[k]|=tmp.nfind[k];
                  for(int l=0;l<8;l++,mask<<=1)
                if(tmp.nfind[k]&mask)
                  {
                    w.tabcoeff[8*k+l]-=
                      pol.nf[j]*tmp.nf[compteurtmp++];
                    if(Iszero(w.tabcoeff[8*k+l]))
                      w.tabnf[k]&=~mask;
                  }
                }
            }
              
            }
#endif
        }
          else  
        {
          mon tmpmon;
          (*exce)[noquo]=mon(i,1);
          int2mon(-1*(stockindicetab[j]+1),tmpmon);
          (*exce)[noquo]*=tmpmon;//int2mon<mon>(j);
          (*exce)[noquo]*=pol.nf[j];
          ++noquo;
        };
      }
  ret.ind=pol.ind;
  ret.ind*=mon(i,1);
  (*exce)[noquo++]=ret.ind;
  exsize=noquo;
  (*exce)=(mon*)MAC_REV_REALLOC<mon>((*exce),(pol.size+1)*sizeof(mon)
                   ,(noquo)*sizeof(mon));
#ifdef DEB  
  for(int j=0;j<exsize;j++)
    cout<<" "<<(*exce)[j];
  cout<<endl;
#endif
  ret.ind.SetCoeff(noquo+1);
  ret.size=0;
  p=0;
  for(int j=0;j<w.sizenf;j++)
    if(w.tabnf[j])
      {
    ret.size+=nbbits[w.tabnf[j]];
    p=j;
      }
#ifdef DEB
  cout<<" val p "<<p<<" et pol.size "<<pol.size<<endl;
#endif
  ret.nf=(coeff*)MAC_REV_MALLOC<coeff>(ret.size*sizeof(coeff));
  ret.sizenf=p+1;
  ret.nfind=(unsigned char *)malloc(ret.sizenf);
  p=0;
  for(int j=0;j<ret.sizenf;j++)
    {
      ret.nfind[j]=w.tabnf[j];
      if(w.tabnf[j])
    for(int k=0;k<8;k++)
      if((w.tabnf[j]>>k)&1)
        {
          if(!Iszero(w.tabcoeff[8*j+k]))
        {
          ret.nf[p++]=w.tabcoeff[8*j+k];
          w.tabcoeff[8*j+k]=zero;
        }
          else
        {
          ret.nfind[j]&=~(1<<k);
        }
        }
      w.tabnf[j]=0;
    }
  ret.nf=(coeff*)MAC_REV_REALLOC<coeff>(ret.nf,ret.size*sizeof(coeff),
                    p*sizeof(coeff));
  ret.size=p;
  //MAC_REV_FREE<coeff>(tmpspace,ret.sizenf*8*sizeof(coeff));
  free(stockindicetab);
#ifdef DEB
  cout<<"ret.size "<<ret.size<<endl;
  cout<<invconv<Poly>(ret)<<endl;
  cout<<"-----------------------------------"<<endl;
  int cpt=0;
  for(int i=0;i<ret.sizenf;i++)
    if(ret.nfind[i])
      for(int j=0;j<8;j++)
    if  ((ret.nfind[i]>>j)&1) 
      if (Iszero(ret.nf[cpt++]))
        cout<<"nimpici"<<endl;
#endif  
  return ret;
}

// renvoit mon/x_i .... mais suppose qu'on ne fait pas n'importe quoi
 template <typename Mon,typename Base>
Mon my_divmon(const Mon &mon,int i,const Base& b)
{
  Mon res(1);
  for(int j=0;j<b.nbvar();j++)
    if(i==j)
      {
    res*=Mon(j,mon.GetDegree(j)-1);
      }
     else 
       {
     res*=Mon(j,mon.GetDegree(j));
       }
  return res;
}

template<typename typmon,typename Base>
int GoodDir(const typmon &m,int i, const Base & b)
{
  int j,res=0;
  mon tmpm=m*mon(i,1);
  //cout<<"dans GoodDir les monomes "<<m<<"********"<<typmon(i,1)<<endl;
  //cout<<"b.nbvar() "<<b.nbvar()<<endl;
  //#pragma omp parallel for shared(tmpm,res)
  for(j=0;j<b.nbvar();j++)
    {
      if(tmpm.GetDegree(j)>=1)
    if(IsinB(my_divmon(tmpm,j,b),b)) {res|=1;};
    }
  //cout<<" le verdict de GoodDir "<<res<<endl;
  return res;
}

//fonction adhoc qui merge une liste de polyalp avec une liste de pol
//en cours de calcul cad liste de pol + liste excedentaire 
template<typename typPk,typename typP,typename typexceed,
     typename typsize ,typename Base,typename monomial_server>
void conv_merge(typPk &Pk,typP &P,typexceed &ex,typsize &sizeex,
        const Base &b, monomial_server &serv)
{
  typedef typename typP::value_type polalp;
  typedef typename polalp::order_t ord;
  typedef typename polalp::monom_t mon;
  typedef typename typPk::value_type pol;
  typedef typename pol::coeff_t coeff;
  coeff * tabcoeff=NULL;
  unsigned char *tabindices=NULL;
  int tabsize=0,tabnfsize=0;
  
  for(typename typP::iterator iter=P.begin();iter!=P.end();iter++)
    {
      //cout<<"dans for"<<endl;
      int comp=0;int i=0;
      pol tmp;
      int maxind=0;
      tmp.ind=mon(1);
      for(typename polalp::iterator iterpol=iter->begin();
      iterpol!=iter->end();iterpol++)
      {  
//    cout<<"iterpol"<<*iterpol<<endl;
//    cout<<"IsinB(*iterpol,b)"<<IsinB(*iterpol,b)<<endl;
//          cout<<"serv.mon2int(*iterpol)"<<serv.mon2int(*iterpol)<<endl;
    if (IsinB(*iterpol,b) && (serv.mon2int(*iterpol)>maxind))
      maxind=serv.mon2int(*iterpol);
      }
//    cout<<"maxind"<<maxind<<endl;
      tabcoeff=(coeff*)MAC_REV_MALLOC<coeff>((maxind+1)*sizeof(coeff));
      tabindices=(unsigned char*)malloc(maxind/8+1);
      
      tabsize=maxind+1;
      tabnfsize=maxind/8+1;
      memset((void*)tabindices,0,tabnfsize);
      maxind=0;
      //ici il faudrait un type template
      for(i=0;i<tabsize;i++)
    {
      tabcoeff[i]=0;
    }
      //memset((void*)tabcoeff,0,tabsize*sizeof(coeff));
      //ici aussi
      i=0;
      mon * tmpex=NULL;
      tmpex=(mon*)MAC_REV_REALLOC<mon>((void*)tmpex,0,iter->size()
                       *sizeof(mon));
        
    for(typename polalp::iterator iterpol=iter->begin();
        iterpol!=iter->end();iterpol++)
      {
#if 1
    cout<<"IsinB("<<*iterpol<<","<<"b)"<<IsinB(*iterpol,b)<<endl;
#endif     
           if (IsinB(*iterpol,b))
          {
#ifdef BONRAJOUT        
        cout<<"dedans"<<endl;
#endif
        int tmp=serv.mon2int(*iterpol);
        tabcoeff[tmp]=iterpol->GetCoeff();
        tabindices[tmp/8]|=1<<(tmp%8);
        i++;
        maxind++;
          }
        else
          { 
#if 1   
        cout<<"y en a un qu'est pas dans B "<<*iterpol<<endl;
#endif
        if(!Iszero(iterpol->GetCoeff()))
           tmpex[comp++]=*iterpol;
          }
      }
    tmpex=(mon*)MAC_REV_REALLOC<mon>((void*)tmpex,iter->size()*sizeof(mon)
                     ,(comp+1)*sizeof(mon));
    tmp.size=maxind;
    tmp.nf=(coeff*)MAC_REV_MALLOC<coeff>(tmp.size*sizeof(coeff));
    tmp.nfind=tabindices;
    tmp.sizenf=tabnfsize;
    tmp.ind=mon(comp+1);
    maxind=0;
    for(int i=0;i<tabnfsize;i++)
      if(tabindices[i])
        {
          for(int j=0;j<8;j++)
        if (((tabindices[i]>>j)&1) && !Iszero(tabcoeff[8*i+j]))
            tmp.nf[maxind++]=tabcoeff[8*i+j];
        else
          tmp.nfind[i]&=~(1<<j);
        }
    tmp.nf=(coeff*)MAC_REV_REALLOC<coeff>(tmp.nf,tmp.size*sizeof(coeff)
                          ,maxind*sizeof(coeff));
    tmp.size=maxind;
    MAC_REV_FREE<coeff>(tabcoeff,tabsize*sizeof(coeff));
    cout<<"tmp"<<tmp.nf<<endl;
    cout<<"tmpex"<<*tmpex<<endl;
    cout<<"comp"<<comp<<endl;
    Pk.push_back(tmp);
    ex.push_back(tmpex);
    sizeex.push_back(comp);
#ifdef BONRAJOUT
    cout<<"ici dans conv merge"<<endl;
    for(int i=0;i<comp;i++)
      cout<<tmpex[i]<<" ";
    cout<<endl;
#endif
    }
}
//member ne test que les exposants pas les coefficients
template<typename typMk>
int member(const typMk & tmpMk,const typename typMk::value_type mon)
{
  int res=0;
  for(typename typMk::const_iterator iter=tmpMk.begin();
      iter!=tmpMk.end();iter++)
    if(iter->rep==mon.rep) {res=1;break;}
  return res;
}

template<typename typMat,typename typPk,typename typP,
     typename typMk,typename Base,typename typdump,typename typrecall,
     typename workspace, typename monomial_server>
int newPkMkMatrixof(typMat &mat,typPk &Pk, typP &P,typMk &Mk,
            int &k,Base &b, typdump &dump,typrecall &recall
            ,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;
  typPk tmpPk,workvect;
  typMk tmpMk;
  list<mon *> exceed;
  list<int> sizeexceed;
  int nbproj=0,flagdoplus=1,*ncol;
  //prise en compte des pol pas encore introduits
  cerr<<"k on entering newpkmkmatrixof "<<k<<endl;
  typP ttmpP=Crochet(P,k+1);//
  typrecall verytmp=Crochet(recall,k+1,serv);
  recall.erase(recall.begin(),recall.end());
  if (!ttmpP.empty()) 
    {
      int tmpdeg;
      proj(ttmpP,dump,b,serv);
      selectnozero(ttmpP);
#if 1 
     cout<<"---------"<<endl;
      for(typename typP::iterator iter=ttmpP.begin();iter!=ttmpP.end();iter++)
    cout<<*iter<<endl;
#endif
#ifdef NO_TWICE_FALL
      for(typename typP::iterator iter=P.begin();iter!=P.end();iter++)
    if(Degree(*iter)==k+1) P.erase(iter--);
      for(typename typP::iterator iter=ttmpP.begin()
        ;iter!=ttmpP.end();iter++)
    P.push_back(*iter);
#endif     
 // cout<<"pol mal red "<<*iter<<endl;
      //cout<<"passage par ici"<<endl;
      nbproj=ttmpP.size();
      if (!ttmpP.empty())
    {
      //  cout<<"apres select non zero "<<ttmpP.size()<<endl;
      tmpdeg=minmaxdegP(ttmpP,tmpdeg);
      //      cout<<"apres minmax deg "<<tmpdeg<<" "<<k<<endl;
      if(tmpdeg<k+1)
        {
          flagdoplus=0;
          cout<<"un des pol de pretendu degre le bon se reduit mal"<<endl;
    
          //en fait a un polynome de degre inferieur
          typPk tmpconv;
          //cout<<"recover"<<endl;
          recover(tmpPk,Mk,dump,tmpdeg);
          //Listedejafait(Mk,Spoldejavu);
          for (typename typP::iterator iter=ttmpP.begin();iter!=ttmpP.end();iter++)
        cout<<"pol ICI "<<*iter<<endl;      
        //      cout<<"pol ICI "<<invconv<Poly>(*iter,serv)<<endl;
//        cout<<"forget "<<tmpdeg<<endl;
          recall=verytmp;
          forget(b,dump,tmpdeg,recall);
          serv.compress(tmpPk,dump,b,tmpdeg);
          verytmp.erase(verytmp.begin(),verytmp.end());


          
          //forget(b,dump,tmpdeg);
          
          ttmpP=Crochet(ttmpP,tmpdeg);
#ifdef NO_TWICE    
   for(typename typP::iterator iter=P.begin()
            ;iter!=P.end();iter++)
        if(Degree(*iter)==tmpdeg)
          P.erase(iter--);
#endif  
      nbproj=ttmpP.size();
          //for(typename typP::iterator iter=ttmpP.begin();iter!=ttmpP.end();iter++)
          //    tmpconv.push_back(convert<pol>(*iter,b));
          //ttmpP.erase(ttmpP.begin(),ttmpP.end());//samedi 24 aout
          //nbproj=1;//                              samedi 24 aout
          //Crochetchoix(P,Pk,tmpconv,tmpdeg,b);
          //ttmpP.push_back(invconv<typename typP::value_type>(Pk.back()));
          //Pk.pop_back();//on elimine de Pk le pol de proj choisi
          //pour se ramner au cas ou proj != 0 et P ok
          Mk.erase(Mk.begin(),Mk.end());
          for (typename typPk::iterator iterpk=tmpPk.begin();
           iterpk!=tmpPk.end();iterpk++)
        {
          // cout<<"iterpk->ind "<<iterpk->ind
          //    <<"et Isinb(iterpk-ind,b) "<<IsinB(iterpk->ind,b)<<endl;
          if (IsinB(iterpk->ind,b))
            {
              for(typename Base::iterator iterb=b.begin()
                ;iterb!=b.end();iterb++)
            {
              iterb->refuse=(mon*)MAC_REV_REALLOC<mon>
                (iterb->refuse,(iterb->taille2)*sizeof(mon),
                 (iterb->taille2+1)*sizeof(mon));
              iterb->refuse[iterb->taille2]=iterpk->ind;
              iterb->refuse[iterb->taille2].SetCoeff(1);
              iterb->taille2++;
            }
            }
        }
          for(typename typPk::iterator iter=tmpPk.begin()
            ;iter!=tmpPk.end();iter++)
        {
          mon *tmp=(mon*)MAC_REV_MALLOC<mon>(sizeof(mon));
          *tmp=iter->ind;
          tmpMk.push_back(*tmp);
          exceed.push_back(tmp);
          sizeexceed.push_back(1);
          //      cout<<"pour Mk iter->ind "<<iter->ind<<endl;
        }
          //on vient de chuter de 
          //degre et on a reconstitue les bons mk et pk
          k=tmpdeg-1;
          //Dump(Pk,dump);
        }
    }
    }
  if(flagdoplus)
    {
#ifdef unimul
        serv.reinit_multiple();
#endif      
#ifdef uninf
    serv.reinit_nf();
#endif 

      //list<mon> dejavu;
      //construction des pol ord sup
//
// Problewme de gestion des accumulateurs ici   
int i;
//#pragma omp parallel for shared(tmpPk,tmpMk,exceed,sizeexceed) private(i)
for(i=0;i<b.nbvar();i++)
    {

      for(typename typPk::iterator iter=Pk.begin();iter!=Pk.end();iter++)
        {
          //cout<<"avant gooddir l'ind "<<iter->ind<<" et i "<<i<<endl;
          if(GoodDir((*iter).ind,i,b))
        {
          mon tmpmon=iter->ind*mon(i,1);
          tmpmon.SetCoeff(1);
          //cout<<"tmpmon ici "<<tmpmon<<endl;
          if(!member(tmpMk,tmpmon))
            {
              //
              //ici aussi rendre les op atomic ne suffit pas 
              //il faut aussi faire l'ajout.
                      //#pragma omp atomic
              typename typrecall::iterator iterrec;
              
              mon * tmp=NULL;
              int tmpsize;
              //cout<<"avant mult"<<endl;
              pol stockmult=mult(i,*iter,dump,b,&tmp,tmpsize,w
                     ,serv);


                       
            //attention le coefficient de ind est la taille de 
            // l'exceed correspondant
#ifdef DEB           
            cout<<"apres mult "<<tmpsize<<endl;
#endif
//#pragma omp critical
            {
              tmpMk.push_back(tmpmon);
              tmpPk.push_back(stockmult);
              exceed.push_back(tmp);
              sizeexceed.push_back(tmpsize);
            }
            }
        }
        }
    }
      //      recall=verytmp;
    }
  //  cout<<"tmpPK.size "<<tmpPk.size()<<endl;
  //Constructyion de pol terminee
  //cout<<"ttmpP.size "<<ttmpP.size()<<endl;
  //cout<<"avant conv merge"<<endl;
  conv_merge(tmpPk,ttmpP,exceed,sizeexceed,b,serv);
  //cout<<"apres conv merge"<<endl;
  //cout<<"tmpMK==empty?? "<<tmpMk.empty()<<endl;
#ifdef DEB
     for(typename typPk::iterator iter=tmpPk.begin();iter!=tmpPk.end();iter++)
       cout<<"invocn"<<invconv<Poly>(*iter,serv)<<endl;
#endif
       //   {
  //    cout<<"iter->ind.GetCoeff() "<<iter->ind.GetCoeff()-1
  //        <<" et ind "<<iter->ind<<endl;
  //   }
    //cout<<"tmpPK.size "<<tmpPk.size()<<endl;

  //Tue Nov 27 15:57:25 MET 2001
  /*
   for(typename typPk::iterator iter=tmpPk.begin();iter!=tmpPk.end();iter++)
    
   {
   mon tmp=iter->ind;
   tmp.SetCoeff(1);
   if((iter->ind.GetDegree()!=0)&&(!member(tmpMk,tmp)))
   {
   //cout<<"iter->ind.GetCoeff()"<<iter->ind.GetCoeff()-(coeff)1<<" "
   //    <<tmp<<endl;
   tmpMk.push_back(tmp);
   //tmpMk.back().SetCoeff(1);
   }
   }
  */
  //construction de la matrice maintenant
  //positionnement des pointeurs de matrices pour gagner en tps
   {
     int nnz=0;
     //-----------------
     //for(typename typMk::iterator iter=tmpMk.begin();iter!=tmpMk.end();iter++)
     // cout<<"mon "<<*iter<<endl;
     //-----------------
     //     cout<<"nb proj "<<nbproj<<endl;
     //for(list<int>::iterator iter=sizeexceed.begin();iter!=sizeexceed.end()
     //    ;iter++)
     // {
     // nnz+=*iter;
     //  cout<<"on a donc de monme pour celui la "<<
     //  (int)((iter->ind).GetCoeff()-1)<<" d'ou nnz "<<nnz<<endl;
     //       }
     //for(typename typPk::iterator iter=tmpPk.begin();iter!=tmpPk.end();iter++)
     //  {
     //  int tmp=0;
     //  for(;(iter->ind).GetCoeff()>(coeff)tmp;tmp++);
     //  nnz+=tmp-1;
     //  cout<<"on a donc de monme pour celui la "<<
     //  (int)((iter->ind).GetCoeff()-1)<<" d'ou nnz "<<nnz<<endl;
     //       }
     // nnz+=tmpPk.size()-nbproj;//le 10/05/2001 avant: nnz+=tmpMk.size()-nbproj;
     //le -nbproj rajoute le 23/01/2001!!
     //     #define DEBUG
#ifdef DEBUG
     typename typPk::iterator tmpiter=tmpPk.begin();
     list<int>::iterator itersize=sizeexceed.begin();
     for(typename list<mon*>::iterator iter=exceed.begin();iter!=exceed.end()
      ;tmpiter++,iter++,itersize++)
      {
    cout<<"pour un exceeed la taille attendue est "
        <<*itersize<<endl;
    for(int i=0;*itersize>i;i++)//;tmpiter->ind.GetCoeff()>i+1;i++)
       {
         cout<<"le gus que je regarde "<<(*iter)[i]<<endl;
         if(!member(tmpMk,(*iter)[i]))
         {
           cout<<(*iter)[i]<<endl;
           cout<<"dans ce pol "<<invconv<Poly>(*tmpiter)<<endl;
           cout<<"l'ind "<<tmpiter->ind<<endl;
           exit(-10);
         }
       }
     }
#endif
     // #undef DEBUG
     mat.nrow=tmpPk.size();
     mat.ncol=tmpMk.size();
     ncol=(int*)calloc(mat.ncol,sizeof(int));
     //memset((void*)ncol,0,(*mat)->ncol*sizeof(int));
     map<mon,int,ord> mapint;
     typename typMk::iterator itermk=tmpMk.begin();
     typename typPk::iterator iterpk=tmpPk.begin();
     typename list<mon*>::iterator iterex=exceed.begin();
     list<int>::iterator itersize=sizeexceed.begin();
     int line_num=0;
     for(int i=0;itermk!=tmpMk.end();i++,itermk++)
       {
     mapint[*itermk]=i;
    cout<<"mapint "<<*itermk<<" "<<i<<endl;
       } 
     iterpk=tmpPk.begin();
     nnz=0;
     for(;iterpk!=tmpPk.end();iterpk++,iterex++,itersize++,line_num++)
       {
     nnz+=*itersize;
#ifdef DEB
     cout<<"itesize "<<*itersize<<endl;
#endif   
     // if(iterpk->ind.GetDegree()>0) 
     //  {
     //    mon tmpmon=iterpk->ind;
     //    tmpmon.SetCoeff(1);
     //   ncol[mapint[tmpmon]]++;
         //      cout<<"on est a la ligne "<<line_num<<" ai augmente "<<mapint[(iterpk->ind*(1/iterpk->ind.GetCoeff()))]<<" a cause de son monome dom "<<endl;
         // cout<<"le voila "<<(iterpk->ind*(1/iterpk->ind.GetCoeff()))<<endl;
     //}
     
    {
      // coeff tmpcoeff=(iterpk->ind).GetCoeff()-(coeff)1;
     for(int i=0;*itersize>i;i++)
       {
         //cout<<"iterpk icici ->GetCoeff()"<<iterpk->ind.GetCoeff()<<endl;
         if (mapint.count((*iterex)[i]))
           {
#ifdef DEB
         cout<<"iterex ici "<<(*iterex)[i]<<endl;
#endif      
         ++ncol[mapint[(*iterex)[i]]];
         // cout<<" ai augmente "<<mapint[(*iterex)[i]]<<"a cause de iterex "<<endl;
           }
#ifdef FAST
         else
           {
         int j,tmpsize;
         cout<<"OUILLE OUILLE OUILLE "<<(*iterex)[i]<<endl;
         mat.ncol++;
         mat.nrow++;
         mapint[(*iterex)[i]]=mat.ncol-1;
         ncol=(int*)realloc(ncol,mat.ncol*sizeof(int));
         ncol[mapint[(*iterex)[i]]]=1;
         //reste a calculer un proj de ce monome et le tour sera joue
         Poly tmppolyalp;
         mon tmpmon=(*iterex)[i];
         pol tmppol;
         mon *tmp;
         tmpMk.push_back(tmpmon);
         for(j=0;j<b.nbvar()&&(!tmpmon.GetDegree(j))
               &&IsinB(my_divmon(tmpmon,j,b),b);j++); 
         tmppolyalp=Poly(my_divmon(tmpmon,j,b));
         //proj(tmppolyalp,dump,b);
         tmppol=convert<pol>(tmppolyalp,b);
         tmpPk.push_back(mult(j,tmppol,dump,b,&tmp,tmpsize,w));
         exceed.push_back(tmp);
         sizeexceed.push_back(tmpsize);
         mat.nnz+=tmpsize;
           }
#endif
       }
    }
       }
     //rajoute le 23/01/2001
     //enleve le 17.05/2001
     //     for(int i=mat.nrow-nbproj;i<mat.nrow;i++)
     // ncol[i]--;
     //fin rajout c pour prendre en compte que lors de 
     //de la proj le monome de tete se trouve dans exceed
     //fin enlevement
     cout<<"nnz of matrix "<<nnz<<endl;
     //en general la matrice est rectangulaire
     void * toto=MAC_REV_MALLOC<coeff>(nnz*sizeof(typename typMat::coeff_t));
     //+nnz*sizeof(int)+((*mat)->ncol+1)*sizeof(int));
     if (mat.nzval!=NULL) MAC_REV_FREE<typename typMat::coeff_t>
                (mat.nzval,mat.nnz
                 *sizeof(typename typMat::coeff_t));
     mat.nnz=nnz;
     mat.nzval=toto;
     
     
     //for(int i=0;i<nnz;i++)
     //  ((typename typMat::coeff_t*)mat.nzval)[i]=(coeff)1000000000000.0;
     
     
     // mstore->rowind=(int*)((double*)toto+nnz);
     if(mat.rowind!=NULL) free(mat.rowind);
     mat.rowind=(int*)malloc(nnz*sizeof(int));
     //mstore->colptr=(int*)(mstore->rowind+nnz);//
     if(mat.colptr!=NULL) free(mat.colptr);
     mat.colptr=(int*)malloc((mat.ncol+1)*sizeof(int));
     cout<<"matrix of size "<<mat.nrow<<"x"<<mat.ncol<<endl;
   //matrice cree rest plus qu'a ecrire dedans ca
     typename typMat::coeff_t* nzval=(typename typMat::coeff_t*)mat.nzval;
     int *rowind=mat.rowind;
     int *colptr=mat.colptr;
    //mise  en place des colptr
    *colptr=0;
    for(int i=0;i<mat.ncol-1;i++)
      {
    colptr[i+1]=colptr[i]+ncol[i];
    //cout<<"nb element colonne "<<i<<" "<<ncol[i]<<endl;
    //cout<<"les valeurs de debut de colonne "<<8*colptr[i+1]<<endl;
      }
    colptr[mat.ncol]=mat.nnz;
    
    //cout<<"mat.nnz "<<mat.nnz<<" "<<mat.nnz*8<<endl;
    //fin mise en place
    //la on fait des manip symboliques pour savoir ou ecrire 
    //les coeffs de chaques colonnes ca evite d'avoir a les
    //recopier 50000 fois pour construire la matrice 
    //c bcp plus rapide
    itermk=tmpMk.begin();
    iterpk=tmpPk.begin();
    iterex=exceed.begin();
    itersize=sizeexceed.begin();
    line_num=0;
    //cout<<"nbproj "<<nbproj<<endl;
    for(;0&&(line_num < (int)(tmpPk.size()-nbproj));
    iterpk++,iterex++,itersize++,line_num++)
      //les polynomes projetes sont foutut au bout de la liste!!
      //d'ou le tmpPk.size()-nbproj
      {
    mon tmpmon=iterpk->ind;
    tmpmon.SetCoeff(1);
    //const unsigned int tmpplus=line_num+1,tmp=line_num;
    const unsigned int tmpplus
      =mapint[tmpmon]+1,tmp=tmpplus-1;
    //  cout<<"ici line_num"<<line_num<<" le mon dom est col "<<tmp<<endl;
    //ici couille car le ind n'est pas forcement le mon diag
    nzval[colptr[tmpplus]-ncol[tmp]]=1;
    //fin couille changer un truc
    //  cout<<"mat.nnz "<<mat.nnz<<endl;
    //cout<<"colptr[...]"<<colptr[tmpplus]<<endl;
    //cout<<"ncol[....]"<<ncol[tmp]<<endl;
    //cout<<"1 a la pos "<<colptr[tmpplus]-ncol[tmp]<<endl;
    rowind[colptr[tmpplus]-ncol[tmp]]=line_num;
    //cout<<"1 a la ligne "<<rowind[colptr[tmpplus]-ncol[tmp]]<<endl;
    ncol[tmp]--;
    {
      //coeff tmpcoeff=iterpk->ind.GetCoeff()-(coeff)1;
      for(int i=0;*itersize>i;i++)
      {
        const coeff stock=(*iterex)[i].GetCoeff();
        (*iterex)[i].SetCoeff(1);
        const unsigned int tmpplusex=mapint[(*iterex)[i]]+1;
        const unsigned int tmpex=mapint[(*iterex)[i]];
        nzval[colptr[tmpplusex]-ncol[tmpex]]
          =stock;
        rowind[colptr[tmpplusex]-ncol[tmpex]]=line_num; 
        ncol[tmpex]--;
           cout<<(*iterex)[i]<<" valeur de ncol["<<tmpex<<"] "<<ncol[tmpex]<<endl;
      }
    }
    MAC_REV_FREE<mon>(*iterex,*itersize*sizeof(mon));
      }
    for(;(iterpk!=tmpPk.end());iterpk++,iterex++,itersize++,line_num++)
      {
    //La c le traitement des projetes
    //const unsigned int tmpplus=line_num+1,tmp=line_num;
    {
    cout<<"=================================================="<<endl;
      //coeff tmpcoeff=iterpk->ind.GetCoeff()-(coeff)1;
      for(int i=0;*itersize>i;i++)
      {
        cout<<" le monome "<<(*iterex)[i]<<endl;
        const coeff stock=(*iterex)[i].GetCoeff();
        (*iterex)[i].SetCoeff(1);
        const unsigned int tmpplusex=mapint[(*iterex)[i]]+1;
        const unsigned int tmpex=mapint[(*iterex)[i]];
        nzval[colptr[tmpplusex]-ncol[tmpex]]
          =stock;
        rowind[colptr[tmpplusex]-ncol[tmpex]]=line_num; 
        ncol[tmpex]--;
        cout<<"tmpex "<<tmpex<<endl;
        cout<<"tmpplusex "<<tmpplusex<<endl;
        cout<<"colptr[tmpplusex] "<<colptr[tmpplusex]<<endl;
        cout<<"ncol[tmpex] "<<ncol[tmpex]<<endl;
        cout<<"linenum "<<line_num<<endl;
        cout<<"nzval "<<stock<<endl;
        cout<<"rowind "<<line_num<<endl;
        cout<<"colptr[tmpplusex]-ncol[tmpex] "<<colptr[tmpplusex]-ncol[tmpex]+1<<endl;
      }
    }
    MAC_REV_FREE<mon>(*iterex,*itersize*sizeof(mon));
    //free(*iterex);
      }
    free(ncol);
   for(typename typPk::iterator iterpk=tmpPk.begin()
     ;iterpk!=tmpPk.end();iterpk++)
     iterpk->ind.SetCoeff(1);
     //iterpk->ind*=1/iterpk->ind.GetCoeff();
   //  cout<<"la matrice dans newpkmkmatrixof"<<endl;
   //cout<<" nombre de non zero "<<mat.nnz<<endl;
#ifdef DEB
   affdebug(mat);
#endif
   //cout<<"le colptr "<<endl;
   //for(int i=0;i<mat.ncol;i++)
   // cout<<mat.colptr[i]<<" "<<endl;
   cout<<"les indices de lignes et le nnz"<<endl;
   for(int i=0;i<mat.nnz;i++)
     cout<<mat.rowind[i]<<" "<<((typename typMat::coeff_t*)mat.nzval)[i]<<endl;
   cout<<"fin matrice"<<endl;
   Pk.swap(tmpPk);
   Mk.swap(tmpMk);
   }
   //  for(int i=0;i<mat.nnz;i++)
   // cout<<"coeff mat "<<((typename typMat::coeff_t*)mat.nzval)[i]<<" et i "<<i<<endl; 
   return flagdoplus;
}
//newpkmkmatrixof termine reste plus qu'a tester .... ;-(

template<typename typdump,typename mon,typename pol>
void findcorresppol(const mon & m,const typdump &dump,pol &res)
{
  int i,d=m.GetDegree();
  typename typdump::const_iterator iter=dump.begin();
  for(;(iter!=dump.end())&&(iter->k!=d);iter++);
  {
    cout<<"dump"<<iter->k<<endl;
    cout<<"nf"<<iter->nf[i].ind.rep<<endl;
    cout<<"m.rep"<<m.rep<<endl;
  //localise la dump struct de bon degre
  if(iter!=dump.end())
    {
      for(i=0;(i<iter->size)&&(iter->nf[i].ind.rep!=m.rep);i++);
      cout<<"monomes passe en revue pour chercher "<<m<<" : "<<iter->nf[i].ind<<endl;;
      //trouve dans la dump struct le pol qui marche
      if (i<iter->size)//estce que je connais?
    //oui super
    {
      //cout<<"g trouve un gus qui convient"<<endl;
      //for(int j=0;j<iter->nf[i].size;j++)
      // cout<<"et ses coeff sont "<<iter->nf[i].nf[j]<<endl;
      //Tue Dec  4 16:12:10 MET 2001
      //densify(iter->nf[i],res);}
      //Tue Dec  4 16:12:10 MET 2001
      res=iter->nf[i];}
      else {
    //non ben alors il se reecrit en lui meme
    res.ind=mon(0);//m*(1/m.GetCoeff());
    res.size=-1;//pour proj avant ct -1
    res.nf=NULL;
    res.nfind=NULL;
    res.sizenf=0;
      }
    }
  }
  return;
}
template<typename iterator, typename mon,typename Base>
void varmult(iterator iter1,iterator iter2,mon &var1, mon &var2,const Base &b)
{
  for(int i=0;i<b.nbvar();i++)
    {
      if(iter1->ind.GetDegree(i)>iter2->ind.GetDegree(i))
    var2=mon(i,1);
      if(iter2->ind.GetDegree(i)>iter1->ind.GetDegree(i))
    var1=mon(i,1);
    }
}

template <typename mon,typename pol, typename typdump,typename Base, 
      typename monomial_server>
pol halfred(const mon &targetind, const pol & p, const typdump & dump
        , const Base & b, monomial_server & serv)
{
  typedef typename pol::coeff_t coeff;
  static const mon monzero=mon(0);
  static const typename pol::coeff_t zero(0);
  int *place=(int*)MAC_REV_MALLOC<int>(p.size*sizeof(int)),comp=0;
  pol res;
#ifdef uninf
  int varref;
#else
  mon varref;
#endif 
  int i,maxref=0,ppp=0,nbbitsun=0;
  for(int j=0;j<p.size;j++)
    place[j]=0;
//  coeff *tmpspace;
  for(i=0;i<b.nbvar();i++)
    {
      cout<<"targetind.GetDegree(i)"<<targetind.GetDegree(i)<<endl;
      cout<<"p.ind.GetDegree(i)"<<p.ind.GetDegree(i)<<endl;
      if(targetind.GetDegree(i)>p.ind.GetDegree(i))
    break;
    }
#ifdef uninf
  varref=i;
#else
  varref=mon(i,1);
#endif
  
  //  for(i=0;i<p.size;i++)
  // cout<<p.nf[i]<<" ";
  //cout<<endl;
  //cout<<"ppp "<<ppp<<" p.size "<<p.size<<endl;
  //cout<<"p en entree"<<invconv<Poly>(p)<<endl;
  //cout<<"mulind(0,1,b) "<<mulind(0,1,b)<<endl;
  //cout<<"target "<<targetind<<" et ind "<<p.ind<<" et var "<<varref<<endl;
  cout<<"p.size"<<endl;
  for(i=0;i<p.sizenf;i++)
    {
      if(p.nfind[i])
    {
#ifdef DEB  
      cout<<nbbitsun<<" p.nfind[i] "<<(int)p.nfind[i]<<endl;
#endif
      nbbitsun+=nbbits[p.nfind[i]];
      for(int j=0;j<8;j++)
        {
          if((p.nfind[i]>>j)&1)
        {
#ifdef unimul   
              cout<<"8*i+j"<<8*i+j<<endl;
          cout<<"varref"<<varref<<endl;
          cout<<"comp"<<comp<<endl;
          cout<<"place[comp]"<<place[comp]<<endl;
          place[comp]=serv.mulind(8*i+j,varref,b);
          cout<<"place[comp]"<<place[comp]<<endl;
          if(place[comp]<0)
            place[comp]=-1*(8*i+j+1);
          if (place[comp]>maxref)
            maxref=place[comp];
          cout<<"maxref"<<maxref<<endl;
          
#else
          //ATTENTION UNIQUEMENT UNIMUL SINON PAS DEBUGGE 
          int indtmpmon;
          mon tmpmon;
          int2mon(8*i+j,tmpmon);
          tmpmon*=varref;
          if(IsinB(tmpmon,b))
            {
              //int j;
              indtmpmon=mon2int(tmpmon);
              //for(j=0;j<p.size&&p.nfind[j]!=indtmpmon;j++);
              //if(j<p.size) 
              maxref++;
              place[comp]=indtmpmon;
            }
          else
            {
              place[comp]=-1*(8*i+j);
            }
#endif
          comp++;
        }
        }
    }
    }
   cout<<"despues del for"<<endl; 
  coeff *tmpspace=(coeff*)MAC_REV_MALLOC<coeff>((maxref/8+1)*8*sizeof(coeff));
#ifdef DEB
  cout<<"comp "<<comp<<" et p.size "<<p.size<<endl;
#endif 
  res.sizenf=(maxref/8+1);
  for(int j=0;j<8*res.sizenf;j++)
    tmpspace[j]=0;
  res.nfind=(unsigned char*)MAC_REV_MALLOC<unsigned char>(res.sizenf);
  memset(res.nfind,0,res.sizenf);
  cout<<"por aqui"<<endl;
  for(int j=0;j<nbbitsun;j++)
    if(place[j]>=0)
      {
#ifdef DEB
    mon tmpmm;
    int2mon(place[j],tmpmm);
    cout<<"le monome la "<<tmpmm<<" "<<p.nf[j]<<endl;
#endif
    tmpspace[place[j]]+=p.nf[j];
    res.nfind[place[j]/8]|=1<<(place[j]%8);
      }
    else  
      {
    pol tmp;
#ifdef unimul      
    tmp=serv.nf(varref,-1*place[j]-1,dump,b);
#else
          mon tmpmon;
          int2mon(-1*place[j],tmpmon);
          tmpmon*=mon(i,1);
          tmp=nf<typpol>(tmpmon,dump,b);
#endif   

          if (tmp.size>=0)
        {
          int compteurtmp=0;
          //cout<<" je reduit prr lui"<<endl<<invconv<Poly>(tmp)<<endl;
          //On fait un plus dense dans tmpspace
          if(tmp.sizenf>res.sizenf)
            {
              res.nfind=(unsigned char*)realloc(res.nfind,tmp.sizenf);
              for(int k=res.sizenf;k<tmp.sizenf;k++)
            res.nfind[k]=0;
              tmpspace=(coeff*)MAC_REV_REALLOC<coeff>(tmpspace,
                     res.sizenf*8*sizeof(coeff),
                     tmp.sizenf*8*sizeof(coeff));
              for(int k=res.sizenf*8;k<tmp.sizenf*8;k++)
            tmpspace[k]=0;
              res.sizenf=tmp.sizenf;
              
            }
          for(int k=0;k<tmp.sizenf;k++)
            {
              if(tmp.nfind[k])
            {
              for(int l=0;l<8;l++)
              if((tmp.nfind[k]>>l)&1)
                tmpspace[8*k+l]-=p.nf[j]*tmp.nf[compteurtmp++];
            }
              res.nfind[k]|=tmp.nfind[k];
            }
        }
          else
        {
          mon tmpmon;
          serv.int2mon(-1*place[j]-1,tmpmon);
          tmpmon*=mon(varref,1);
          for(int i=0;i<serv.sizeplacemon();i++)
            cout<<i<<" "<<serv.int2mon_[i]<<endl;
          cout<<"monom "<<tmpmon<<" "<<-1*place[j]
              <<" "<<p.nf[j]<<endl;
          cerr<<"Je n'aurrai pas du passer par la "<<endl;
          exit(10);
        };
      } 
   cout<<"despues del segundo for"<<endl;   
 res.ind=mon(0);
 comp=0;
  for(int j=0;j<res.sizenf;j++)
    if(res.nfind[j])
      comp+=nbbits[res.nfind[j]];
  res.nf=(coeff*)MAC_REV_MALLOC<coeff>(comp*sizeof(coeff));
  res.size=comp;
  comp=0;
  cout<<"antes del ultimo for"<<endl;
  for(int j=0;j<res.sizenf;j++)
    if(res.nfind[j])
      for(int k=0;k<8;k++)
    if((res.nfind[j]>>k)&1)
      if(tmpspace[8*j+k]!=0)
        {res.nf[comp++]=tmpspace[8*j+k];
          
        }
      else
        res.nfind[j]&=~(1<<k);
      cout<<"despues del ultimo for"<<endl;
  res.nf=(coeff*)MAC_REV_REALLOC<coeff>(res.nf,res.size*sizeof(coeff)
                    ,comp*sizeof(coeff));
  cout<<"res.nf"<<endl;
  res.size=comp;
  cout<<"res.size"<<endl;
//  for(int j=0;j<8*res.sizenf;j++)
//    tmpspace[j]=0;
  cout<<"tmpspace.size"<<res.sizenf*8*sizeof(coeff)<<res.sizenf*8<<endl;
  MAC_REV_FREE<coeff>(tmpspace,res.sizenf*8*sizeof(coeff));
  cout<<"antes de free"<<endl;
  free(place);
  //cout<<" apres reduction "<<invconv<Poly>(res)<<endl;
 return res;
}

template <typename typPk, typename typdump,typename Base,
      typename workspace ,typename monomial_server>//,typename typMk>
void ReduceSpol(typPk &S,const typdump & dump,typPk &redspol,const Base &b
        ,workspace &w, monomial_server &serv)
        //, typMk & Spoldejavu)
{
  typedef typename typPk::value_type pol;
  typedef typename pol::monom_t mon;
  typedef typename pol::coeff_t coeff;
  list<mon> leadmon;
  list<typPk> membermon;
  cout<<"en entree de RedSpol S.size "<<S.size()/2<<endl;

  for(typename typPk::iterator iterS=S.begin();iterS!=S.end();iterS++,iterS++)
    {
      typename typPk::iterator iterS2=iterS;
      typename list<mon>::iterator itermon=leadmon.begin();
      typename list<typPk>::iterator itermemb=membermon.begin();
      mon var1,var2,tmpleadmon;
      iterS2++;
      varmult(iterS,iterS2,var1,var2,b);
      tmpleadmon=iterS->ind*var1;
      cout<<"tmpleadmon"<<tmpleadmon<<endl;
      // Spoldejavu.push_back(tmpleadmon);
      for(;itermon!=leadmon.end()&&itermon->rep!=tmpleadmon.rep;
      itermon++,itermemb++);
      if(itermon!=leadmon.end())
    {
      int yes1=1,yes2=1;
      for(typename typPk::iterator tmpiter=itermemb->begin();
          tmpiter!=itermemb->end();tmpiter++)
        {
          if(tmpiter->ind.rep==iterS->ind.rep) yes1=0;
          if(tmpiter->ind.rep==iterS2->ind.rep) yes2=0;
        }
      if(yes1) itermemb->push_back(*iterS);
      if(yes2) itermemb->push_back(*iterS2);
    }
      else
    {
      cout<<"iterS"<<iterS->ind<<endl;
      cout<<"iterS2"<<iterS2->ind<<endl;
      typPk verytmp;
      leadmon.push_back(tmpleadmon);
      //cout<<"le tmpleadmon "<<tmpleadmon<<endl;
      membermon.push_back(verytmp);
      membermon.back().push_back(*iterS); 
      membermon.back().push_back(*iterS2);
    }
    }
     cout<<"sale del primer for"<<endl;
  //maintenant on a mis en place la structure de Redspol
  //reste plus qu'a calculer les bons et a reduire tout ca!!
  { 
    typename list<mon>::iterator itermon=leadmon.begin();
    typename list<typPk>::iterator itermemb=membermon.begin();
    cout<<"antes del otro for"<<endl;
    for(;itermon!=leadmon.end();itermon++,itermemb++)
      {
    typename typPk::value_type ref;
    typename typPk::iterator tmpiter=itermemb->begin();
    cout<<"antes halfred"<<endl;
//  cout<<"itermon"<<*itermon<<endl;
        cout<<"tmpiter"<<tmpiter->ind<<endl;
    ref=halfred(*itermon,*tmpiter,dump,b,serv);
    cout<<"ref.size "<<ref.size<<" "<<ref.ind<<endl;
    //cout<<"ref en entier"<<endl<<invconv<Poly>(ref)<<endl;
    tmpiter++;
    for(;tmpiter!=itermemb->end();tmpiter++)
      {
        typename typPk::value_type redcur;
        redcur=halfred(*itermon,*tmpiter,dump,b,serv);
        my_plus(redcur,ref,(coeff)1,&w);
        if(!Ispolzero(redcur))
          {
        redspol.push_back(redcur);
        //cout<<"redcur "<<endl<<invconv<Poly>(redcur)<<endl;
        //cout<<"le leadmon qui donne un non zero "<<*itermon<<endl;
          }
        else
          {
        MAC_REV_FREE<coeff>(redcur.nf,redcur.size*sizeof(coeff));
        MAC_REV_FREE<unsigned char>(redcur.nfind,redcur.sizenf);
          }
      }
    MAC_REV_FREE<coeff>(ref.nf,ref.size*sizeof(coeff));
    MAC_REV_FREE<unsigned char>(ref.nfind,ref.sizenf);
      }
  }
}

template<typename typPk,typename monomial_server>
int mindeg(const typPk &l,monomial_server &serv)
{
  typedef typename typPk::value_type::monom_t mon;
  typedef typename mon::coeff_t coeff;
  int res=-1;
  //  cout<<"dans mindeg res au debut"<<res<<endl;
  for(typename typPk::const_iterator iter=l.begin() ;iter!=l.end();iter++)
   {
     int mmax=-1;
     // cout<<"tour de boucle de mindeg "<<endl;
     for(int i=0;i<iter->sizenf;i++)
       if(iter->nfind[i])
     for(int j=0;j<8;j++)
       if((iter->nfind[i]>>j)&1)
       {
         mon tmpmon;
         serv.int2mon(8*i+j,tmpmon);
         mmax=(mmax<tmpmon.GetDegree())?tmpmon.GetDegree():mmax;
       }
     // cout<<"mmax ici "<<mmax<<endl;
     if (iter->ind.GetCoeff()==(coeff)1)
       mmax=(mmax<iter->ind.GetDegree())?iter->ind.GetDegree():mmax;
     //cout<<"les gens que je regarde "<<iter->ind<<endl;
     if(mmax!=-1)
     {
       if(res==-1) res=mmax;
       res=(mmax>res)?res:mmax;
     }
   }
  //cout<<"resultat de mindeg "<<res<<endl;
  return res;
}

template<typename coeff,typename typiterpk, typename workspace>
void inline update_crochetchoix(typiterpk &iterPk, typiterpk &iter,int tmpind
                ,workspace &w)
{
 
  if((iterPk->sizenf>tmpind/8)&&(((iterPk->nfind[tmpind/8])>>(tmpind%8))&1))
    {
      //      cout<<"g trouve un gus qui a un coeff du mon choisi "<<endl;
      //cout<<"le voila "<<invconv<Poly>(*iterPk)<<endl;
        int i=0;
        coeff tmp;
        for(int j=0;8*j<=tmpind;j++)
          i+=nbbits[iterPk->nfind[j]];
        for(int j=7;j>=(tmpind % 8);j--)
          if((iterPk->nfind[tmpind/8]>>j)&1)
            i--;
        
#ifdef DEB
        cout<<"i ici "<<i<<" et iterPk->size "<<iterPk->size<<endl;
#endif
        tmp=iterPk->nf[i];
        //  cout<<"le coeff "<<tmp<<" tmpind "<<tmpind<<endl;
        //cout<<"les voisins "<<iterPk->nf[i-1]<<" "<<iterPk->nf[i+1]<<endl;
        
        //cout<<"les voisins plus loin"<<iterPk->nf[i-2]<<" "<<iterPk->nf[i+2]<<endl;
        for(int j=i;j<iterPk->size-1;j++){
          iterPk->nf[j]=iterPk->nf[j+1];
        }
        iterPk->nfind[tmpind/8]&=~(1<< (tmpind%8));
        iterPk->nf=(coeff*)MAC_REV_REALLOC<coeff>(iterPk->nf,
            iterPk->size*sizeof(coeff),(iterPk->size-1)*sizeof(coeff));
        iterPk->size--;
        //iterPk->nf[i]=0;
        my_plus(*iterPk,*iter,tmp,&w);
        
        //cout<<"apres plus le coeff vaut "
        //    <<iterPk->nf[mon2int(iter->ind)]<<endl; 
          }
  //cout<<"apres mise a jour"<<endl<<invconv<Poly>(*iterPk)<<endl;
}
template<typename typP,typename typPk,typename typMk
         ,typename Base,typename typdump, typename typrecall,
     typename workspace ,typename monomial_server>
void NewCrochetchoix(typP & P,typPk & Pk,typMk & Mk, typPk & redspol
             ,int &k,typdump &dump, Base &b, typrecall & recall
             ,workspace &w, monomial_server &serv)
             //,typMk &Spoldejavu)
  //template<typename typP,typename typPk,typename typMk,typename Base,typename typdump>
//void NewCrochetchoix(const typP & P,typPk & Pk,typMk & Mk, typPk & redspol
//           ,int &k,typdump &dump, Base &b)
  {
  typedef typename typP::value_type polyalp;
  typedef typename polyalp::monom_t mon;
  typedef typename polyalp::coeff_t coeff;
  //for(typename typPk::iterator iter=redspol.begin();iter!=redspol.end();iter++)
  //  P.push_back(invconv<Poly>(*iter));
  //cout<<"dans newcrochetchoix"<<endl;
  /*
    
    //cout<<"les sizes "<<iter->size<<endl;
    {
    int cpt=0;
    cout<<invconv<typename typP::value_type>(*iter)<<endl;       
      for(int i=0;i<iter->sizenf;i++)
    for(int j=0;j<8;j++)
      if (((iter->nfind[i]>>j)&1) && (iter->nf[cpt++]==0))
        {
          cout<<"ici ca couille a la place "<<8*i+j<<endl;
          exit(1);
        }
    }
  */
  typPk res=Crochet(redspol,k,serv),tmpres;
  //cout<<"redspol.size "<<redspol.size()<<endl;
  //cout<<"res.size "<<res.size()<<endl;
  for(typename typPk::iterator iter=res.begin();iter!=res.end();iter++)
    {
      for(typename typPk::iterator iterredspol=redspol.begin();
          iterredspol!=redspol.end();iterredspol++)
        if(iter->nf==iterredspol->nf)
          {
        redspol.erase(iterredspol);
        break;
          }
    }
  NewDestroyredspol(redspol,Pk);
  redspol.erase(redspol.begin(),redspol.end());
  //for(typename typPk::iterator iter=res.begin();iter!=res.end();iter++)
  //   cout<<"res->sizenf<< "<<iter->sizenf<<endl;
  for(typename typPk::iterator iter=res.begin();iter!=res.end();iter++)
    {
      //cout<<"un nouveau tour de boucle "<<endl;
      if (!Ispolzero(*iter))
    {
      int tmpind,i;
      iter->ind=choice(*iter,b,serv);
      //cout<<"le pol pas zero "<<(invconv<polyalp>(*iter))<<endl;
      //cout<<"iter -> size "<<iter->size<<" "<<iter->ind<<endl;
      //for (int i=0;i<iter->size;i++)
      // cout<<iter->nf[i]<<" "<<iter->nfind[i]<<endl;
      if(iter->ind.GetDegree()<k)
        {
         //cout<<"le pol qui fait chuter"<<(invconv<polyalp>(*iter))<<endl;
          k=iter->ind.GetDegree();
          iter->ind=mon(0);
          //cout<<"passage par bout de code en plus "<<endl;
          my_merge(res,tmpres);
          my_merge(redspol,res);
          tmpres.erase(tmpres.begin(),tmpres.end());
          res.erase(res.begin(),res.end());
          res=Crochet(redspol,k,serv);
          //cout<<"newres.size "<<res.size()<<endl;
          for(typename typPk::iterator iterres=res.begin()
            ;iterres!=res.end();iterres++)
        {
          for(typename typPk::iterator iterredspol=redspol.begin();
              iterredspol!=redspol.end();iterredspol++)
            if(iterres->nf==iterredspol->nf)
              {
            redspol.erase(iterredspol);
            break;
              }
        }
          for(typename typPk::iterator iterredspol=redspol.begin();
              iterredspol!=redspol.end();iterredspol++)
        if(Degree(*iterredspol,serv)<=k)
          {
            tmpres.push_back(*iterredspol);
            redspol.erase(iterredspol--);
          }
          NewDestroyredspol(redspol,Pk);
          redspol.erase(redspol.begin(),redspol.end());
          my_merge(redspol,tmpres);
          tmpres.erase(tmpres.begin(),tmpres.end());
          iter=res.begin();
          iter->ind=choice(*iter,b,serv);
          
          Dump(Pk,dump);//c pour detruire Pk dans forget
                  //ca ne respecte pas la structure du dump!!!
          recover(Pk,Mk,dump,k);
          // Listedejafait(Mk,Spoldejavu);
          forget(b,dump,k,recall);
          //forget(b,dump,k);
          //          cout<<"un coup de compress"<<endl;
          //ce compresss la vire le 06 10 2006
          serv.compress(Pk,redspol,dump,b,k);
          //pose un probleme de oherence pour le int2mon 
          //si on le laisse 
          //swap(*iter,*res.rbegin());//on veut ne plus 


          //iter=--res.end();//refaire d'autre tours
        }
      //cout<<"g choisi dans Crochetchoix "<<iter->ind<<endl;
      //cout<<"a t'il un mon2int ?"<<IsinB(iter->ind,b)<<endl;
      //mon tmp10,tmp11;
      //      int2mon(10,tmp10);int2mon(11,tmp11);
      //cout<<"qu'en est il de int2mon(10) et 11 "<<tmp10<<" "<<tmp11<<endl;
      //      
      //
      //
      //UGLY HACK
      remiseenforme(*iter);
      //SALE HACK
      //
      //
      //
      //
      //
      *iter/=iter->ind.GetCoeff();//pour la "nf"
      //cout<<"le coeff "<<iter->ind<<endl;
      iter->ind*=(coeff)1/iter->ind.GetCoeff();//pour l'ind
      tmpind=serv.mon2int(iter->ind);
      i=0;
      for(int j=0;8*j<=tmpind;j++)
        i+=nbbits[iter->nfind[j]];
      for(int j=7;j>=(tmpind % 8);j--)
        if((iter->nfind[tmpind/8]>>j)&1)
          i--;
      for(int j=i;j<iter->size-1;j++)
        iter->nf[j]=iter->nf[j+1];
      iter->nf=(coeff*)MAC_REV_REALLOC<coeff>(iter->nf,
                         iter->size*sizeof(coeff),
                         (iter->size-1)*sizeof(coeff));
      iter->nfind[tmpind/8]&=~(1<<(tmpind%8));
      iter->size--;
#ifdef DEB
      cout<<"apres tambouille"<<endl<<invconv<Poly>(*iter)<<endl;
#endif

      //      
      //
          //
      //UGLY HACK
      remiseenforme(*iter);
      //SALE HACK
          //
      //
          //
      //
      //
      
      tmpres.push_back(*iter);
      //on met a 0 le coeff du mon passe en ind
      //maintenant on a une regle en forme comme il faut reste a:
      //-reduire les regles deja existantes par rapport a celle ci
      //-reduire les autres redspol par rapport a celle ci
      for(typename typPk::iterator iterPk=Pk.begin();iterPk!=Pk.end();iterPk++)
        update_crochetchoix<coeff>(iterPk,iter,tmpind,w);
      typename typPk::iterator iterredspol=iter;
      iterredspol++;
      for(;iterredspol!=res.end();iterredspol++)
        {
          //cout<<"redspol.size() "<<redspol.size()<<endl;
          //cout<<"iterredspol-ind "<<iterredspol->ind<<" "<<iterredspol->nf<<endl;
          update_crochetchoix<coeff>(iterredspol,iter,tmpind,w);
        }
      //au tour de tmpres...
      typename typPk::iterator iterend=tmpres.end();
      iterend--;
      for(iterredspol=tmpres.begin();iterredspol!=iterend;iterredspol++)
        {
          //cout<<"redspol.size() "<<redspol.size()<<endl;
          //cout<<"iterredspol-ind "<<iterredspol->ind<<" "<<iterredspol->nf<<endl;
          update_crochetchoix<coeff>(iterredspol,iter,tmpind,w);
        }
          
      //voila c fait 
      //maintenant on met a jour la Base b.
      for(typename Base::iterator iterb=b.begin();iterb!=b.end();iterb++)
        {
          int tmptaille1=0;
          mon *tmp=(mon*)MAC_REV_MALLOC<mon>(iterb->taille1*sizeof(mon));
          for(int i=0;i<iterb->taille1;i++)
        if(!isdivisible(iter->ind,iterb->accept[i],b))
          tmp[tmptaille1++]=iterb->accept[i];
          tmp=(mon*)MAC_REV_REALLOC<mon>(tmp,iterb->taille1*sizeof(mon)
                         ,tmptaille1*sizeof(mon));
          MAC_REV_FREE<mon>(iterb->accept,iterb->taille1*sizeof(mon));
          iterb->accept=tmp;
          iterb->taille1=tmptaille1;
          if(iterb->taille1==0)
        {
          MAC_REV_FREE<mon>(iterb->refuse,iterb->taille2*sizeof(mon));
          b.erase(iterb--);
          continue;
        }
          iterb->refuse=(mon*)MAC_REV_REALLOC<mon>
        (iterb->refuse,(iterb->taille2)*sizeof(mon),
         (iterb->taille2+1)*sizeof(mon));
          iterb->refuse[iterb->taille2]=iter->ind;
          // cout<<"reffuse rajoute "<<iter->ind<<endl;
          iterb->refuse[iterb->taille2].SetCoeff(1);
          iterb->taille2++;
        }
      res.erase(iter--);
    }
      //break;//comme ca on fait pas 50 tours.
    }
  for (typename typPk::iterator iterpk=Pk.begin();iterpk!=Pk.end();iterpk++)
    {
      //cout<<"iterpk->ind "<<iterpk->ind<<"et Isinb(iterpk-ind,b) "<<IsinB(iterpk->ind,b)<<endl;
      //cout<<"le pol "<<invconv<Poly>(*iterpk)<<endl;
      if (IsinB(iterpk->ind,b))
    {
      for(typename Base::iterator iterb=b.begin();iterb!=b.end();iterb++)
        {
          iterb->refuse=(mon*)MAC_REV_REALLOC<mon>
        (iterb->refuse,(iterb->taille2)*sizeof(mon),
         (iterb->taille2+1)*sizeof(mon));
          iterb->refuse[iterb->taille2]=iterpk->ind;
          iterb->refuse[iterb->taille2].SetCoeff(1);
          iterb->taille2++;
        }
    }
    }
#ifdef NO_TWICE_FALL
  for(typename typPk::iterator iter=tmpres.begin();iter!=tmpres.end();iter++)
    P.push_back(invconv<polyalp>(*iter));
#endif
#ifdef BONRAJOUT
  for(typename typPk::iterator iter=tmpres.begin();iter!=tmpres.end();iter++)
    P.push_back(invconv<polyalp>(*iter));
  cout<<"a la fin de §New"<<endl;
#endif
#ifdef DEB
  for(typename typPk::iterator iter=tmpres.begin();iter!=tmpres.end();iter++)
    cout<<"tmpres"<<endl<<invconv<polyalp>(*iter)<<endl;
  cout<<"tmpres.size "<<tmpres.size()<<endl;
#endif 
 my_merge(Pk,tmpres);//les gens dans res\tmpres ne sont pas detruits ici!!
  my_merge(redspol,res);
  
  
  /*  for(typename typPk::iterator iter=Pk.begin();iter!=Pk.end();iter++)
       //cout<<"les sizes "<<iter->size<<endl;
      {
    int cpt=0;
    cout<<invconv<typename typP::value_type>(*iter)<<endl;       
    for(int i=0;i<iter->sizenf;i++)
      for(int j=0;j<8;j++)
        if (((iter->nfind[i]>>j)&1) && (iter->nf[cpt++]==0))
          {
        cout<<"ici ca couille a la place "<<8*i+j<<endl;
        exit(1);
          }
      }
  */
  return;
}
//#undef DEB
template<typename typPk>
void NewDestroyredspol(typPk &redspol,const typPk &Pk)
{
//  typename typPk::const_iterator iterpk=--Pk.end(); 
   for(typename typPk::iterator iter=redspol.begin();
      iter!=redspol.end();iter++)
    {
      //    if(iter->nf!=iterpk->nf)
      MAC_REV_FREE<typename typPk::value_type::coeff_t>(iter->nf,iter->size*sizeof(typename typPk::value_type::coeff_t));
      MAC_REV_FREE<unsigned char>(iter->nfind,iter->sizenf);
    }
}

template<typename typMk>
void Listedejafait(const typMk &Mk,typMk &Spoldejavu)
{
  Spoldejavu.erase(Spoldejavu.begin(),Spoldejavu.end());
  for(typename typMk::const_iterator iter1=Mk.begin();iter1!=Mk.end();
      iter1++)
    for(typename typMk::const_iterator iter2=iter1;iter2!=Mk.end();
      iter2++)
      {
    typename typMk::value_type tmp=lcm(*iter1,*iter2);
    if (tmp.GetDegree()==iter1->GetDegree()+1)
      Spoldejavu.push_back(tmp);
      }
}

//on suppose stockmon vide
template<typename Base, typename typstock, typename typdump>
void enumeratemon(typstock &stockmon, int k, 
          const Base &b,  const typdump &dump)
{
  typedef typename typstock::value_type mon;
  int maxdeg=0;
  typstock current;
  current.push_back(mon(1));
  stockmon.push_back(mon(1));
  //
  //
  //on a le degre max : k
  // on part de 1 et on decrit le reste en multipliant par les variables
  //
  //
  for(int i=0;i<k;i++)
    {
      typstock tmpcurrent=current;
      current.erase(current.begin(),current.end());
      for(int i=0;i<b.nbvar();i++)
    {
      for(typename list<mon>::iterator iter=tmpcurrent.begin();
          iter!=tmpcurrent.end();iter++)
        {
          mon tmpmon=(*iter)*mon(i,1);
          tmpmon.SetCoeff(1);
          current.push_back(tmpmon);
        }
    }
      //maintenant on tri;
      for(typename list<mon>::iterator iter=current.begin();iter!=current.end();iter++)
    if(!member(stockmon,*iter))
      {
        stockmon.push_back(*iter);
      }
    else
      {
        current.erase(iter--);
      }
    }
 // cout<<"ttttttttt "<<stockmon.size()<<endl;
  return;
} 
template <class M> struct Dlexpolprod 
{
  static bool less (const M &, const M &);
  bool operator() (const M &, const M &) const;
};
template <class M>
bool Dlexpolprod<M>::operator()(const M & m1, const M & m2) const {
    return less(m1,m2);
}

template <class M>
inline bool Dlexpolprod<M>::less(const M & p1, const M & p2){
  typedef typename M::monom_t mon;
  mon m1=*(p1.begin());
  mon m2=*(p2.begin());
  int dm1=0,dm2=0,firstdiff=0,tmpdeg1,tmpdeg2;
  //int dm1=Degree(m1),dm2=Degree(m2);
  int n1 = lvar(m1.rep), n2 =lvar(m2.rep);
  int n = max(n1,n2);
  if(n1 <0 && n2>0) return false;
  if(n2 <0 && n1>0) return true;
  for(int i=0;i<=n;i++)
    {
      tmpdeg1=m1.GetDegree(i);
      tmpdeg2=m2.GetDegree(i);
      if(tmpdeg1>tmpdeg2 && firstdiff==0) firstdiff=1;
      if(tmpdeg2>tmpdeg1 && firstdiff==0) firstdiff=-1;
      dm1+=tmpdeg1;
      dm2+=tmpdeg2;
    } 
  if (dm1 < dm2) return false;
  else if (dm1 > dm2) return true;
  return (firstdiff==1);
}

template<typename typprod,typename Base, typename typstock, typename typdump>
void computeprod(typprod &prod,typstock &stockmon, Base & b, 
         typdump & dump)
{
  //
  for(typename typstock::iterator i=stockmon.begin();
      i!=stockmon.end();i++)
    {
      for(typename typstock::iterator j=i;j!=stockmon.end();j++)
    prod.push_back(*i * *j);
    }
  //Maintenant on tri et on ne selectionne que ceux qui sont en dehors de B
  //
  //Aie ici il faut define DLEX sur des polynomes!
  prod.sort(Dlexpolprod<typename typprod::value_type>());
  prod.unique();
  //  for(typename typprod::iterator i=prod.begin();i!=prod.end();i++)
  //  if (IsinB(*(i->begin()),b)) prod.erase(i--);
}

template<typename T>
int dgesvd_(char *jobu, char *jobvt, long *m, long *n, 
        T *a, long *lda, T *s, T *u, long *
        ldu, T *vt, long *ldvt, T *work, long *lwork, 
        long *info);

template<typename typP, typename typdump,typename Base, typename typserv>
void generickernel(typP &newpol, int k, 
           const typdump &dump, Base &b, typserv &serv)
{
  using namespace coinor;
  typedef typename typP::value_type::order_t ord;
  //
  //Allocation du problem et des
  //contraintes
  struct blockmatrix<COEFF> C;
  struct sparseblock<COEFF> *blockptr;
  COEFF *bb;
  int i;
  struct constraintmatrix<COEFF> *constraints;
  
  //
  //On introduit un variable par monome de degre d en dehors de B
  //On va contruire l'operateur de de Hankel associé  //
  
  //
  //On commence par enumerer les monomes de degre plus petit que k
  //
  //
  typP stockprod,stockproj;//dans stockprod on a des polynomes
  //
  //
  //
  int nbconstraint=0;
  list<typename typserv::monom_t> stockmon,stockksur2;
  map<mon,int,ord> mapintligne,mapintcolonne,maphankel;
  enumeratemon(stockmon,k,b,dump);
  //
  //ICI on cree un index pour le monomes de degre k
  //il n'a a priori rien a voir avec int2mon/mon2int du reste du code 
  //sic.....
  enumeratemon(stockksur2,k/2,b,dump);
  //
  //pour le suite il nous faut les monomes de B de degre <=k/2
  //

  for(typename list<typename typserv::monom_t>::iterator 
    iter=stockksur2.begin(); iter!=stockksur2.end();iter++)
    if(!IsinB(*iter,b)) stockksur2.erase(iter--);
#ifdef DEBUGSDP  
cout<<"monome en degre k/2 "<<endl;
   for(typename list<typename typserv::monom_t>::iterator 
    iter=stockksur2.begin(); iter!=stockksur2.end();iter++)
     cout<<*iter<<" ";
   cout<<endl;
#endif
  i=1;
  for(typename list<typename typserv::monom_t>::iterator 
    iter=stockksur2.begin();iter!=stockksur2.end();iter++,i++)
    { 
      int j=1;
      for(typename list<typename typserv::monom_t>::iterator 
    iter2=stockksur2.begin();iter2!=stockksur2.end();iter2++,j++)
    {
      typename typserv::monom_t mono=*iter * (*iter2);
//    cout<<"monome "<<mono<<" "<<i<<" "<<j<<endl;
      if (!mapintligne.count(mono))
        {
          mapintligne[mono]=i;
          mapintcolonne[mono]=j;
        }
    }
    }
  //cout<<"passé"<<endl;

  // 
  //  On  genere les formes normales des produits de monomes de
  // de tous les monomes de   degre <=k/2 dez B.
  //
  
  computeprod(stockprod,stockksur2,b,dump);
  stockproj=stockprod;
  proj(stockproj,dump,b,serv);

#ifdef DEBUGSDP
 cout<<"produits "<<endl;
  for(typename typP::iterator iter=stockprod.begin();iter!=stockprod.end();
      iter++)
   cout<<*iter<<" ";
   cout<<endl;  
   cout<<"proj "<<endl;
  for(typename typP::iterator iter=stockproj.begin();iter!=stockproj.end();
      iter++)
   cout<<*iter<<" ";
   cout<<endl;
#endif  
  //
  //
  //computerelations();//
  //
  //
  //
  //
  // §Ici on va avoir besoin d'une structure contenant un monome de tete
  // hors de B et sa forme normal

   for(typename typP::iterator iter=stockprod.begin();
       iter!=stockprod.end();iter++)
     if(!IsinB(*(iter->begin()),b))
       nbconstraint++;
#ifndef NONEW
  constraints=new constraintmatrix<COEFF>[nbconstraint+1];
#else
  constraints=(struct constraintmatrix<COEFF> *)
    malloc((nbconstraint+1)*sizeof(struct constraintmatrix<COEFF>));
 #endif
 /*
   *
   * Les indices partent de 1 pas de 0!
   *
   */
  //
  //On construit la liste des contraintes de la fin vers le debut
  //
  //Ca c la fin
  constraints[0].blocks=NULL;//not used dixit the manual
  //
  i=1;
  typename typP::iterator iterstockprod=stockprod.begin();
  for(typename typP::iterator iter=stockproj.begin();
      iter!=stockproj.end();iter++,iterstockprod++)
    {
      if(!IsinB(*(iterstockprod->begin()),b))
    {
      int k;
      int decal;
      //
      //On construit la liste des contraintes de la fin vers le debut
      //
      //Ca c la fin
      constraints[i].blocks=NULL;
      //
#ifndef NONEW
      blockptr=new sparseblock<COEFF>[1];
#else
      blockptr=(struct sparseblock<COEFF> *)malloc(sizeof(struct sparseblock<COEFF>));
#endif
      blockptr->blocknum=1;//
      // ?????? relations.size()-i;
#if 0
      blockptr->blocksize=stockksur2.size();
      blockptr->numentries=2*iter->size()+2;//pour l'ind
      decal=iter->size()+1;//pour l'ind
#else
      blockptr->blocksize=stockksur2.size();
      blockptr->numentries=iter->size()+1;//pour l'ind
      decal=0;
#endif
      blockptr->constraintnum=i;
      blockptr->next=NULL;
      blockptr->nextbyblock=NULL;
#ifndef NONEW
      blockptr->entries=new COEFF[(blockptr->numentries+1)];
#else    
    blockptr->entries=(COEFF *) 
        malloc((blockptr->numentries+1)*sizeof(COEFF));
#endif
#ifndef NOSHORTS
      blockptr->iindices=(short unsigned int *) 
        malloc((blockptr->numentries+1)*sizeof(short unsigned int));
      blockptr->jindices=(short unsigned int *) malloc((blockptr->numentries+1)*sizeof(short unsigned int));
#else  
      blockptr->iindices=( int *) 
        malloc((blockptr->numentries+1)*sizeof( int));
      blockptr->jindices=(int *) malloc((blockptr->numentries+1)*sizeof( int));
#endif 

      k=1;
//    cout<<" matrix contrainte "<<endl<<*iter<<endl;
      for(typename typP::value_type::iterator iterpol=iter->begin();
          iterpol!=iter->end();k++,iterpol++)
        {
          if(mapintligne[*iterpol]<mapintcolonne[*iterpol])
        {
          blockptr->iindices[k]=mapintligne[*iterpol];
          blockptr->jindices[k]=mapintcolonne[*iterpol];
          blockptr->entries[k]=((COEFF)-1)*iterpol->GetCoeff();
//        cout<<blockptr->iindices[k]<<" "<<blockptr->jindices[k]
//            <<" "<<blockptr->entries[k]<<endl;
          //
        }
          else
        {
          //blockptr->numentries--;
          //decal--;
          if (mapintligne[*iterpol]!=mapintcolonne[*iterpol] )
            {
              blockptr->jindices[k]=mapintligne[*iterpol];
              blockptr->iindices[k]=mapintcolonne[*iterpol];
              blockptr->entries[k]=((COEFF)-1)*iterpol->GetCoeff();
            }
          else
            {
              blockptr->jindices[k]=mapintligne[*iterpol];
              blockptr->iindices[k]=mapintcolonne[*iterpol];
              blockptr->entries[k]=((COEFF)-2)*iterpol->GetCoeff();
            }
        }

        }
    
//    cout<<"index en plus"<<endl;
     if(mapintligne[*(iterstockprod->begin())]<
        mapintcolonne[*(iterstockprod->begin())]  ) 
       {
         blockptr->iindices[k]=mapintligne[*(iterstockprod->begin())];
         blockptr->jindices[k]=mapintcolonne[*(iterstockprod->begin())];
         blockptr->entries[k]=1;
//       cout<<blockptr->iindices[k]<<" "<<blockptr->jindices[k]
//        <<" "<<blockptr->entries[k]<<endl;
       }
     else
       {
         if (mapintligne[*(iterstockprod->begin())]!=
         mapintcolonne[*(iterstockprod->begin())]) 
           {
         blockptr->iindices[k]
           =mapintcolonne[*(iterstockprod->begin())];
         
         blockptr->jindices[k]
           =mapintligne[*(iterstockprod->begin())];
         blockptr->entries[k]=1;
//       cout<<"indices ici "<<mapintligne[*(iterstockprod->begin())]<<" "<<
//         mapintcolonne[*(iterstockprod->begin())]<<endl;
           }
         else
           {
         blockptr->iindices[k]=mapintligne[*(iterstockprod->begin())];
               blockptr->jindices[k]=mapintcolonne[*(iterstockprod->begin())];
           blockptr->entries[k]=2;
           }
       }
      /*
       * Insert block into the linked list of A1 blocks.  
       */
      //      blockptr->blocksize--;
      blockptr->next=NULL;
        //=constraints[i].blocks;
      constraints[i].blocks=blockptr;
//    cout<<"i "<<i<<" "<<stockprod.size()<<endl;
      i++;
      
    }
    }
  //
  // On donne les relations Hankel
  //
  //
  //
  // 
  //
  //
  int nbhankelrel=0,i_counter=1,j_counter;
  for(typename list<typename typserv::monom_t>::iterator i=stockksur2.begin();
      i!=stockksur2.end();i++,i_counter++)
    {
      j_counter=1;
     for(typename list<typename typserv::monom_t>::iterator j=stockksur2.begin();
      j!=stockksur2.end();j++,j_counter++)
    if(!maphankel.count(*i * *j))
      {
        maphankel[*i * *j]=j_counter*stockksur2.size()+i_counter;
      }
    else
      if((maphankel[*i * *j]%stockksur2.size()!=j_counter)
         ||(maphankel[*i * *j]/stockksur2.size()!=i_counter))
        {
          int decal=0;
          nbhankelrel++;
#ifndef NONEW
         constraintmatrix<COEFF> *tmpconstraints=new constraintmatrix<COEFF>[nbhankelrel+nbconstraint+1];
         for(int ii=0;ii<nbhankelrel+nbconstraint;ii++) 
        tmpconstraints[ii]=constraints[ii]; 
         delete[] constraints;
             constraints=tmpconstraints;
          blockptr=new sparseblock<COEFF>[1];
#else        
        constraints=(struct constraintmatrix<COEFF> *)
          realloc(constraints,
              (nbhankelrel+nbconstraint+1)
              *sizeof(struct constraintmatrix<COEFF>));
        
        blockptr=(struct sparseblock<COEFF> *)malloc(sizeof(struct sparseblock<COEFF>));
#endif
        blockptr->blocknum=1;//
        blockptr->blocksize=stockksur2.size();
#if 0
        blockptr->numentries=4;
#else 
        blockptr->numentries=2;
#endif
        blockptr->constraintnum=nbconstraint+nbhankelrel;
        blockptr->next=NULL;
        blockptr->nextbyblock=NULL;
#ifndef NONEW
        blockptr->entries=new COEFF[(blockptr->numentries+1)];
#else
        blockptr->entries=(COEFF *) 
          malloc((blockptr->numentries+1)*sizeof(COEFF));
#endif
#ifndef NOSHORTS
        blockptr->iindices=(short unsigned int *) malloc((blockptr->numentries+1)*sizeof(short unsigned int));
        blockptr->jindices=(short unsigned int *) malloc((blockptr->numentries+1)*sizeof(short unsigned int));
#else
        blockptr->iindices=(int *) malloc((blockptr->numentries+1)*sizeof(int));
        blockptr->jindices=(int *) malloc((blockptr->numentries+1)*sizeof(int));
#endif  
        //blockptr->numentries=blockptr->blocksize-1; //On a rajoute un avant
        if((maphankel[*i * *j]%stockksur2.size())<
           (maphankel[*i * *j]/stockksur2.size()))
          {
        blockptr->iindices[1]=maphankel[*i * *j]%stockksur2.size();
        blockptr->jindices[1]=maphankel[*i * *j]/stockksur2.size();
        blockptr->entries[1]=1;
          }
        else
          {
        if((maphankel[*i * *j]/stockksur2.size())!=
           (maphankel[*i * *j]%stockksur2.size()))
          {
            blockptr->jindices[1]=maphankel[*i * *j]%stockksur2.size();
            blockptr->iindices[1]=maphankel[*i * *j]/stockksur2.size();
            blockptr->entries[1]=1;
          }
        else
          {
            blockptr->jindices[1]=maphankel[*i * *j]%stockksur2.size();
            blockptr->iindices[1]=maphankel[*i * *j]/stockksur2.size();
            blockptr->entries[1]=2;
          } 

          }
        if(i_counter<j_counter)
          {
        blockptr->iindices[2]=i_counter;
        blockptr->jindices[2]=j_counter;
        blockptr->entries[2]=-1;
          }
        else
          {
        if(i_counter!=j_counter)
          {
            blockptr->iindices[2]=j_counter;
            blockptr->jindices[2]=i_counter;
            blockptr->entries[2]=-1;
          }
        else
          {
            blockptr->iindices[2]=j_counter;
            blockptr->jindices[2]=i_counter;
            blockptr->entries[2]=-2;
          }
          }
#if 0       
        if((maphankel[*i * *j]/stockksur2.size())!=
           (maphankel[*i * *j]%stockksur2.size()))
          {
        blockptr->iindices[3]=maphankel[*i * *j]/stockksur2.size();
        blockptr->jindices[3]=maphankel[*i * *j]%stockksur2.size();;
        blockptr->entries[3]=1;
          }
        else
          {
        decal++;
        blockptr->numentries--;
        blockptr->entries[1]=2;
          } 

        if(i_counter!=j_counter)
          {
        blockptr->iindices[4-decal]=j_counter;
        blockptr->jindices[4-decal]=i_counter;
        blockptr->entries[4-decal]=-1;
          }
        else
          {
        blockptr->numentries--;
        blockptr->entries[2]=-2;
     
          }
#endif
//      cout<<"indice "<<maphankel[*i * *j]%stockksur2.size()
//      <<" "<<maphankel[*i * *j]/stockksur2.size()<<endl;
//      cout<<"indice "<<i_counter<<" "<<j_counter<<endl;
//      cout<<endl;
        //      cout<<"indice "<<l<<" "<<1<<endl;
        //cout<<"indice "<<l-k<<" "<<k+1<<endl;
    /*
     * Insert block  into the linked list of A1 blocks.  
     */
    
        blockptr->next=NULL;//constraints[i].blocks;
        constraints[nbconstraint+nbhankelrel].blocks=blockptr;
        
        
      }
    }
  //
  //
  //
  // les relations de symetrie sont implicites X est recherche SDP
  // ONrajoute la contrainte sur le coeff en haut a gauche
  //
  //
  nbhankelrel++;
#ifndef NONEW
  constraintmatrix<COEFF> *tmpconstraints=
    new constraintmatrix<COEFF>[(nbhankelrel+nbconstraint+1)];
  for(int ii=0;ii<nbhankelrel+nbconstraint;ii++)
    tmpconstraints[ii]=constraints[ii];
  delete [] constraints;
  constraints=tmpconstraints;
#else
  constraints=(struct constraintmatrix<COEFF> *)
          realloc(constraints,
              (nbhankelrel+nbconstraint+1)
              *sizeof(struct constraintmatrix<COEFF>));
#endif
        
 #ifndef NONEW
  blockptr=new sparseblock<COEFF>[1];
#else 
 blockptr=(struct sparseblock<COEFF> *)malloc(sizeof(struct sparseblock<COEFF>));
#endif 
 blockptr->blocknum=1;//
  blockptr->blocksize=stockksur2.size();
  blockptr->numentries=1;
  blockptr->constraintnum=nbconstraint+nbhankelrel;
  blockptr->next=NULL;
  blockptr->nextbyblock=NULL;
#ifndef NONEW
  blockptr->entries=new COEFF[blockptr->numentries+1];
#else
  blockptr->entries=(COEFF *) 
    malloc((blockptr->numentries+1)*sizeof(COEFF));
#endif
#ifndef NOSHORTS
  blockptr->iindices=(short unsigned int *) malloc((blockptr->numentries+1)*sizeof(short unsigned int));
  blockptr->jindices=(short unsigned int *) malloc((blockptr->numentries+1)*sizeof(short unsigned int));
#else
  blockptr->iindices=(int *) malloc((blockptr->numentries+1)*sizeof(int));
  blockptr->jindices=(int *) malloc((blockptr->numentries+1)*sizeof(int));
#endif  
  //blockptr->numentries=blockptr->blocksize-1; //On a rajoute un avant
  
  blockptr->iindices[1]=1;
  blockptr->jindices[1]=1;
  blockptr->entries[1]=1;
  blockptr->next=NULL;//constraints[i].blocks;
  constraints[nbconstraint+nbhankelrel].blocks=blockptr;
  //
  //On optimise la fonction "0" sous l es contraintes lineaires precedents
  //
  struct blockmatrix<COEFF> X,Z;
  COEFF *y;
  COEFF pobj,dobj;
  int tmpsize=(int)stockksur2.size();
#ifndef NONEW
  bb=new COEFF[nbhankelrel+nbconstraint+1];
#else
  bb=(COEFF *)malloc((nbhankelrel+nbconstraint+1)*sizeof(COEFF));
#endif  //oon a un block de 0
  C.nblocks=1;
#ifndef NONEW
  C.blocks=new blockrec<COEFF>[2];
 #else
 C.blocks=(struct blockrec<COEFF> *)malloc(2*sizeof(struct blockrec<COEFF>));
#endif
#ifndef CCCCC
  C.blocks[1].blockcategory=MATRIX;
  C.blocks[1].blocksize=stockksur2.size();
#ifndef NONEW
  C.blocks[1].data.mat=new COEFF[stockksur2.size()*stockksur2.size()+1];
#else
  C.blocks[1].data.mat=(COEFF *)malloc(
          (stockksur2.size()*stockksur2.size()+1)*sizeof(COEFF));
#endif 
 for(int k=0;k<=(stockksur2.size()*stockksur2.size());k++)
    C.blocks[1].data.mat[k]=0;
  //
  C.blocks[1].data.mat[1]=0;
#else
  C.blocks[1].blockcategory=DIAG;
  C.blocks[1].blocksize=stockksur2.size();
  C.blocks[1].data.vec=(COEFF *)malloc(
          (stockksur2.size()+1)*sizeof(COEFF));
  for(int k=0;k<=(stockksur2.size());k++)
    C.blocks[1].data.vec[k]=0;

#endif
  for(i=0;i<=nbhankelrel+nbconstraint;i++)
    bb[i]=0;
  bb[nbconstraint+nbhankelrel]=(COEFF)1.;//on double qd on est sur la diagonale
  //cout<<"stockprod.size() "<<stockprod.size()<<endl;
 // cout<<"nbconstraint "<<nbconstraint<<endl;
 // cout<<"tmpsize "<<tmpsize<<endl;
 // cout<<"Affichage contraintes"<<endl;
  for(i=1;i<nbconstraint+nbhankelrel+1;i++)
    {
   //   cout<<"le b associe "<<bb[i]<<endl;
      int tsize=constraints[i].blocks->blocksize;
      COEFF* tmp= new COEFF[tsize*tsize];
     // cout<<"taille "<<tsize<<endl;
      for(int j;j<tsize*tsize;j++)
    tmp[j]=0;
      for(int j=1;j<=constraints[i].blocks->numentries;j++)
    tmp[constraints[i].blocks->iindices[j]-tsize-1+
        constraints[i].blocks->jindices[j]*tsize]=
      constraints[i].blocks->entries[j];
#ifdef DEBUGSDP 
     for(int j=0;j<tsize;j++)
    {
      for(int jj=0;jj<tsize;jj++)
        cout<<tmp[tsize*(jj)+j]<<" ";
      cout<<endl;
    }
      cout<<endl;
#endif
    }
  char nom[50];
  static int d=0;
  sprintf(nom,"ficprob_%d",d++);
  write_prob(nom,tmpsize,
         nbhankelrel+nbconstraint,C,bb,constraints);
  //Precision(53);      
  cout<<"SDP of size : "<<stockksur2.size()<<"x"<<nbhankelrel+
    nbconstraint<<endl; 
  initsoln(tmpsize,nbhankelrel+nbconstraint,
       C,bb,constraints,&X,&y,&Z);
  struct timeval tvini, tvfin;
  gettimeofday(&tvini,NULL);
  int return_code=easy_sdp((int)stockksur2.size(),nbhankelrel+
               nbconstraint,
       C,bb,constraints,(COEFF)(0.0),&X,&y,&Z,&pobj,&dobj);
  //Precision(350);
  gettimeofday(&tvfin,NULL);
  tempsCDSP+=tvfin.tv_sec-tvini.tv_sec+1e-6*(tvfin.tv_usec-tvini.tv_usec);
  // write_sol("prob.sol",tmpsize,nbhankelrel+nbconstraint,X,y,Z);
  //
  //
  //
  // A ce niveau la il faut verifier le rang
  // Le cas echeant recuperer le kernel
  //
  cout<<"pobj "<<pobj<<" dobj "<<dobj<<" diff "<<pobj-dobj<<endl;
//  cout<<"return code "<<return_code<<endl;
  if (1||return_code==8)//c le code de retour indiquant une singularite
    {
      long n=stockksur2.size();
      COEFF *matdense=new COEFF[n*n];
      COEFF *V=new COEFF[n*n];
      COEFF *S=new COEFF[n];
      COEFF *work=new COEFF[16*n];
      long lwork=16*n,info;
      long k=0;//servira pour le rang0
      for(int j=0;j<n*n;j++)
    matdense[j]=0;
      /*
    Warning !!!
    je ne traite pas les differetn cas des blocks de X
    il peuvent etre soit DIAG soit MATRIX
    soit PACKEDMATRIX (on peut s'en passez il y a invalid dasn writesol
      */

      //
      //on est pas de rang plein
      //
      //il faut calculer le noyau
      //
      //
#ifdef DEBUGSDP
      for(int i=1;i<=nbconstraint+nbhankelrel;i++)
    cout<<"y "<<i<<" "<<y[i]<<endl;
      cout<<"nombre de blocks de X "<<X.nblocks<<endl;
#endif
      for(int i=1;i<=X.nblocks;i++)
    {
      //Pour chque block il faut regarder son noyau
      struct blockrec<COEFF> tmp=X.blocks[i]; 
      //
      //On recopie le bloc en dense
      //    
#ifdef DEBUGSDP
      cout<<"n _________________________________ "<<n<<endl;
      cout<<"blockcat "<<tmp.blockcategory<<" "<<k<<endl;
#endif
      switch(tmp.blockcategory)
        {
        case DIAG:
          for(int j=1;j<=tmp.blocksize;j++)
        matdense[n*(k+j-1)+(k+j-1)]=tmp.data.vec[j];
#ifdef DEBUGSDP
          for(int j=1;j<=tmp.blocksize;j++)
        {
          for(int jj=1;jj<=tmp.blocksize;jj++)
            cout<<matdense[n*(k+jj-1)+j-1]<<" ";
          cout<<endl;
        }
          cout<<endl;
#endif
          break;
        case MATRIX:
          for(int j=1;j<=tmp.blocksize;j++)
        for(int jj=1;jj<=tmp.blocksize;jj++)
          matdense[n*(k+jj-1)+j-1]=
            tmp.data.mat[tmp.blocksize*(jj-1)+j-1];
#ifdef DEBUGSDP
          for(int j=1;j<=tmp.blocksize;j++)
        {
          for(int jj=1;jj<=tmp.blocksize;jj++)
            cout<<matdense[n*(k+jj-1)+j-1]<<" ";
          cout<<endl;
        }
#endif     
      }
      k+=tmp.blocksize;
  
    }
      //
      //On calcul le noyau
      //
      dgesvd_((char*)"N",(char*)"A",&n,&n,matdense,
          &n,S,(COEFF*)NULL,&n,V,&n,work,&lwork,&info);
#if 1
      cout<<"info svd "<<info<<endl;
      cout<<"val singulieres "<<endl;
      for(k=0;k<n;k++)
    cout<<S[k]<<" ";
      cout<<endl;
#endif
      for(k=1;k<n;k++)
    //if(S[0]>S[k]*1e6) break;//MAGIC
    if((abs(S[k-1])==0) || (abs(S[k-1])>abs(S[k])*1e6)) break;//MAGIC
      //#ifdef DEBUGSDP     
 cout<<"----k ici "<<k<<" et n "<<n<<endl;
 //#endif
      for(int j=1;j<=n;j++)
    {
      for(int jj=1;jj<=n;jj++)
        cout<<V[n*(jj-1)+j-1]<<" ";
      cout<<endl;
    }
      //
      //On construit les nouvelles equations 
      //
      for(;k<n;k++)
    {
#ifdef DEBUGSDP
      cout<<"equation dans le noyau"<<endl;
#endif
      typedef typename typP::value_type polyalp;
      polyalp tmp(0); 
      for(typename list<typename typserv::monom_t>::iterator 
        iter=stockksur2.begin();
          iter!=stockksur2.end();iter++)
        {
          
          //cout<<"dans construct eq "<<k<<" map "<<mapintcolonne[*iter]<<endl;
      //cout<<V[k+n*(mapintcolonne[*iter]-1)]<<" "<<*iter<<" ";
          if(!Iszero(abs(V[k+n*(mapintcolonne[*iter]-1)])))
        
        {
          //      cout<<"tmp avant"<<endl<<tmp<<endl;
          //cout<<"ajout "<<endl<<polyalp(*iter*V[k+n*(mapintcolonne[*iter]-1)])<<endl;
          tmp+=polyalp(*iter*(COEFF)V[k+n*(mapintcolonne[*iter]-1)]);
          //cout<<"tmp aapre"<<endl<<tmp<<endl;
        }
          //iter->first;// est le monome
          //iter->second;//est l'entier associé
     }
//    cout<<endl;
//    cout<<"g trouve ca comme nvlle eq "<<endl<<tmp<<endl;
      newpol.push_back(tmp); 
         
    }
      delete[] S;
      delete[] V;
      delete[] work;
      delete[] matdense;
    }
  for(int i=1;i<nbconstraint;i++)
    {
      free(constraints[i].blocks->iindices);
      free(constraints[i].blocks->jindices);
      delete [] constraints[i].blocks->entries;
      delete [] constraints[i].blocks;
    }
  delete [] constraints;
  delete [] bb;
  delete [] C.blocks[1].data.mat;
  delete [] C.blocks;
  // il faut desallouer les contraintes mieux (les matrices pointees
  //il faut desalluer C
  //Precision(53);
  //cout<<"en sortie "<<newpol.empty()<<endl;
}

#include"genekersdpa.hpp"

template<typename typmatmap, typename typserv>
void  write_to_sdpa_fic(typmatmap &matrixmap,  int &dim, typserv &serv, 
            int d)
{
  ofstream tmpfic;
  typename typserv::monom_t m(1);
  COEFF *tmpval=matrixmap[m];
  char nomdufic[50];
  sprintf(nomdufic,"tmpfile_%d",d);
  tmpfic.open(nomdufic);
  tmpfic<<setprecision(80);
  tmpfic<<"\" Ceci est un message \""<<endl;
  tmpfic<<matrixmap.size()-1<<" =  mDIM"<<endl;
  tmpfic<<1<<" =  nBLOCK"<<endl;
  tmpfic<<dim<<" =  bLOCKsTRUCT"<<endl;
  tmpfic<<"{";
  for(int i=0;i<((long)matrixmap.size())-2;i++)
    tmpfic<<"0,";
  tmpfic<<"0}"<<endl;
  tmpfic<<"{";
  for(int i=0;i<dim-1;i++)
    {
      tmpfic<<"{";
      for(int j=0;j<dim-1;j++)
    {
      //cout<<(-1*matrixmap[m][i*dim+j])<<" ";
      tmpfic<<(COEFF)(-1*matrixmap[m][i*dim+j])<<",";
    }
      cout<<endl;
      tmpfic<<(COEFF)(-1*matrixmap[m][i*dim+dim-1])<<"},";
    }
  tmpfic<<"{";

  for(int j=0;j<dim-1;j++)
    tmpfic<<-1*matrixmap[m][(dim-1)*dim+j]<<",";
  tmpfic<<-1*matrixmap[m][dim*dim-1]<<"}}"<<endl;
 
  matrixmap.erase(matrixmap.find(m));
  for(typename typmatmap::iterator itermat=matrixmap.begin();
      itermat!=matrixmap.end();itermat++)
    {
      //cout<<"matrice de "<<itermat->first<<endl;
      COEFF *tt=itermat->second;
      tmpfic<<"{";
      for(int i=0;i<dim-1;i++)
    {
      tmpfic<<"{";
      for(int j=0;j<dim-1;j++)
        tmpfic<<tt[i*dim+j]<<",";
      tmpfic<<tt[i*dim+dim-1]<<"},";
    }
      tmpfic<<"{";
      
      for(int j=0;j<dim-1;j++)
    tmpfic<<tt[(dim-1)*dim+j]<<",";
      tmpfic<<tt[dim*dim-1]<<"}}"<<endl;
      
    }
  matrixmap[m]=tmpval;
  tmpfic.close();
}

template<typename typmatmap, typename coeff, typename typserv>
void read_sol_from_sdpa(coeff *&sol, typmatmap &matmap,int dim, typserv &serv)
{
  typedef typename typserv::monom_t mon;
  ifstream tmpfic;
  string ligne,ligne2;
  typename string::iterator debut;
  int i;
  coeff *xVec,*xMat;
  stringstream tmpstr;
  system(
     "perl -i.bak -0777 -ne 'if (/^xMat *= *(.*)(?=yMat)/ms) {$toto=$1; $toto=~s/[[:blank:]{}]\\+?//g; $toto=~s/,\\+?/ /g; print $toto}' lenom"      // "perl -0777 -i.bak -ne '/^xMat *= *(.*)(?=yMat)/ms and $toto=$1 and $toto=~s/[[:blank:]{}]\\+?//g and $toto=~s/,\\+?/ /g and print $toto' lenom"
     );
  tmpfic.open("lenom");
#if 0
  tmpfic>>ligne;//chaine Xvec
  cout<<"ligne xVec :"<<ligne<<endl;
  tmpfic>>ligne;// les coordonnées interessantes
  cout<<"ligne coordq :"<<ligne<<endl;
  dim=count(ligne.begin(),ligne.end(),'i')+1;
  xVec=new coeff[dim];
  sol=new coeff[dim*dim];
  i=0;
  int tmpindex;
  for(string::iterator iter=ligne.begin()+1;iter!=ligne.end();
      iter=ligne.begin()+tmpindex+1)
    {
      stringstream tmpstr;
      cout<<"iter "<<iter-ligne.begin()<<endl;
      tmpindex=ligne.find(",",iter-ligne.begin());
      if (tmpindex==string::npos) tmpindex=ligne.size()-1;
      cout<<"tmpindex "<<tmpindex<<endl;
      copy(iter,ligne.begin()+tmpindex,ostream_iterator<char>(tmpstr,""));
      tmpstr>>ligne2;
      cout<<"eeeee "<<ligne2<<" "<<ligne.find(",",iter-ligne.begin())<<endl;
      tmpstr<<ligne2;
      tmpstr>>xVec[i++];
      cout<<"i "<<i<<endl;
    }
#endif
  //en theorie maintenant on a xVec
#if 0  
  tmpfic>>ligne;//chaine xMat
  cout<<"ligne xmat :"<<ligne<<endl;
  tmpfic>>ligne;//chaine '{'
  for(i=0;i<dim;i++)
    {
      tmpfic>>ligne;// les coordonnées interessantes
      int j=0;
      for(string::iterator iter=ligne.begin()+ligne.find_last_of('{');
      iter!=ligne.end();
      iter=ligne.begin()+ligne.find(",",iter-ligne.begin()))
    {
      stringstream tmpstr;
      //      copy(iter,ligne.begin()+ligne.find(',',iter-ligne.begin())
      //     ,ostream_iterator<char>(tmpstr,""));
      int toto=ligne.find(",",iter-ligne.begin());
      cout<<"ligne "<<ligne<<endl;
      cout<<"toto "<<toto<<" "<<string::npos<<endl;
      if(toto==string::npos) toto=ligne.size()-2;
      cout<<"toto "<<toto<<" "<<string::npos<<endl;
      tmpstr<<ligne.substr(iter-ligne.begin(),toto);
        tmpstr>>xMat[dim*j++ + i];
    }
    }
#endif
  //maintenant on a relu le xVec et le Xmat
  //Reconstruction de la solution
  sol=new coeff[dim*dim];
  for(int i=0;i<dim*dim;i++)
    {
      tmpfic>>sol[i];
    } 
  tmpfic.close();
  cout<<"Solution "<<endl;
  for(int i=0;i<dim*dim;i++)
    cout<<sol[i]<<" ";
  cout<<endl;
  // copy(sol,sol+dim*dim,ostream_iterator<string>(cout," "));
#if 0
for(int i=0;i<dim*dim;i++)
    sol[i]+=matmap[mon(1)][i];
  matmap.erase(matmap.find(mon(1)));
  int j=0;
  for(typename typmatmap::iterator itermat=matmap.begin();
      itermat!=matmap.end();itermat++)
    {
      for(int i=0;i<dim*dim;i++)
    sol[i]-=xVec[j]*itermat->second[i];
      j++;
    }
#endif
}

template<typename typP, typename typdump,typename Base, typename typserv>
void generickernelsdpa(typP &newpol, int k, 
           const typdump &dump, Base &b, typserv &serv)
{
  typedef typename typP::value_type::order_t ord;
  typedef typename typserv::monom_t Monomial;
  //
  //Allocation du problem et des
  //contraintes
  COEFF * C;
  map<Monomial,COEFF*,ord> matrixmap;
  int i;
  
  //
  //On introduit un variable par monome de degre d en dehors de B
  //On va contruire l'operateur de de Hankel associé
  //
  
  //
  //On commence par enumerer les monomes de degre plus petit que k
  //
  //
  typP stockprod,stockproj;//dans stockprod on a des polynomes
  //
  //
  //
  int nbconstraint=0;
  typedef  list<typename typserv::monom_t> typstock;  
  list<typename typserv::monom_t> stockmon,stockksur2;
  map<mon,int,ord> mapintligne,mapintcolonne,maphankel;
  enumeratemon(stockmon,k,b,dump);
  //
  //ICI on cree un index pour le monomes de degre k
  //il n'a a priori rien a voir avec int2mon/mon2int du reste du code 
  //sic.....
  enumeratemon(stockksur2,k/2,b,dump);
  //
  //pour le suite il nous faut les monomes de B de degre <=k/2
  //

  for(typename list<typename typserv::monom_t>::iterator 
    iter=stockksur2.begin(); iter!=stockksur2.end();iter++)
    if(!IsinB(*iter,b)) stockksur2.erase(iter--);
  i=1;
  for(typename list<typename typserv::monom_t>::iterator 
    iter=stockksur2.begin();iter!=stockksur2.end();iter++,i++)
    { 
      int j=1;
      for(typename list<typename typserv::monom_t>::iterator 
    iter2=stockksur2.begin();iter2!=stockksur2.end();iter2++,j++)
    {
      typename typserv::monom_t mono=*iter * (*iter2);
//    cout<<"monome "<<mono<<" "<<i<<" "<<j<<endl;
      if (!mapintligne.count(mono))
        {
          mapintligne[mono]=i;
          mapintcolonne[mono]=j;
        }
    }
    }
  //cout<<"passé"<<endl;

  // 
  //  On  genere les formes normales des produits de monomes de
  // de tous les monomes de   degre <=k/2 dez B.
  //
  int dim=stockksur2.size();
  for(typename typstock::iterator i=stockmon.begin();
      i!=stockmon.end();i++)
    if(IsinB(*i,b))
       {
     cout<<"ici "<<*i<<" dim "<<dim<<endl;
     matrixmap[*i]=new COEFF [dim*dim];
     for(int ii=0;ii<dim*dim;ii++)
       matrixmap[*i][ii]=0;
       }
  

 int ii=0;
 cout<<"coiucou"<<endl;
  for(typename typstock::iterator i=stockksur2.begin();
      i!=stockksur2.end();i++,ii++)
    {
      int jj=ii;
      cout<<"coiucou"<<endl;
      for(typename typstock::iterator j=i;j!=stockksur2.end();jj++,j++)
    {
       
      typename typserv::monom_t tmpmon=(*j)*(*i);
      //cout<<"coiucoufffffff "<<tmpmon<<endl;
      if (IsinB(tmpmon,b))
        {
          matrixmap[tmpmon][ii*dim+jj]+=1;
          if(ii!=jj)
        matrixmap[tmpmon][jj*dim+ii]+=1;
        }
      else
        {
          typP tmplist;
          tmplist.push_back(tmpmon);
          proj(tmplist,dump,b,serv);
          // cout<<"ici tmpmon "<<tmpmon<<endl;
          //cout<<"tmplist.front "<<tmplist.front()<<endl;
          for(typename typP::value_type::iterator iter=tmplist.front().begin();
          iter!=tmplist.front().end();iter++)
        {
          Monomial verytmpmon=*iter;
          verytmpmon.SetCoeff(1);
          //cout<<"tmpmon "<<verytmpmon<<" "<<*iter<<endl;
          matrixmap[verytmpmon][ii*dim+jj]+=iter->GetCoeff();
          if(ii!=jj)
            matrixmap[verytmpmon][jj*dim+ii]+=iter->GetCoeff();

        }
        }
    }
    }
 
  if(dim>1)
    {
      struct timeval tvini, tvfin;
      COEFF *sol;
      static int d=0;
      static char nom[1024];
      gettimeofday(&tvini,NULL);
      cout<<"coucou dim "<<dim<<endl;
      write_to_sdpa_fic(matrixmap,dim,serv,d);
      sprintf(nom,"sdpa_gmp -dd tmpfile_%d -o lenom",d++);
      system(nom);
      read_sol_from_sdpa(sol,matrixmap,dim,serv);
      
      
      gettimeofday(&tvfin,NULL);
      tempsCDSP+=tvfin.tv_sec-tvini.tv_sec+1e-6*(tvfin.tv_usec-tvini.tv_usec);
    
      //
      //cout<<"coiucou"<<endl;
      // A ce niveau la il faut verifier le rang
      // Le cas echeant recuperer le kernel
      //
      //  cout<<"return code "<<return_code<<endl;
      long n=stockksur2.size();
      COEFF *V=new COEFF[n*n];
      COEFF *S=new COEFF[n];
      COEFF *work=new COEFF[16*n];
      long lwork=16*n,info;
      long kk=0;//servira pour le rang 0
      dgesvd_((char*)"N",(char*)"A",&n,&n,sol,
          &n,S,(COEFF*)NULL,&n,V,&n,work,&lwork,&info);
#if 1
      cout<<"info svd "<<info<<endl;
      cout<<"val sing"<<endl;
      for(kk=0;kk<n;kk++)
    cout<<S[kk]<<" ";
      cout<<endl;
#endif
      cout<<"coiucou"<<endl;
      for(kk=1;kk<n;kk++)
    //if(S[0]>S[k]*1e6) break;//MAGIC
    if((abs(S[kk-1])==0) ||(abs(S[kk-1])>abs(S[kk])*1e6)) break;//MAGIC
#if 1     
      cout<<"kk ici "<<kk<<" et n "<<n<<endl;
#endif
      for(int j=0;j<n;j++)
    {
      for(int jj=0;jj<n;jj++)
        cout<<V[n*(jj)+j]<<" ";
      cout<<endl;
    }
      //
      //On construit les nouvelles equations 
      //
      for(;kk<(int)n;kk++)
    {
#if 1
      cout<<"equation dans le noyau"<<endl;
#endif
      typedef typename typP::value_type polyalp;
      polyalp tmp(0); 
      for(typename list<typename typserv::monom_t>::iterator 
        iter=stockksur2.begin();
          iter!=stockksur2.end();iter++)
        {
          
          //cout<<"dans construct eq "<<k<<" map "<<mapintcolonne[*iter]<<endl;
          //cout<<V[k+n*(mapintcolonne[*iter]-1)]<<" "<<*iter<<" ";
          if(!Iszero(abs(V[kk+n*(mapintcolonne[*iter]-1)])))
        
        {
          //      cout<<"tmp avant"<<endl<<tmp<<endl;
          //cout<<"ajout "<<endl<<polyalp(*iter*V[k+n*(mapintcolonne[*iter]-1)])<<endl;
          tmp+=polyalp(*iter*(COEFF)V[kk+n*(mapintcolonne[*iter]-1)]);
          //cout<<"tmp aapre"<<endl<<tmp<<endl;
        }
          //iter->first;// est le monome
          //iter->second;//est l'entier associé
     }
      //      cout<<endl;
      cout<<"g trouve ca comme nvlle eq "<<endl<<tmp<<endl;
      newpol.push_back(tmp); 
      
    }

      delete[] S;
      delete[] V;
      delete[] work;
      delete[] sol;
    }
}

template<typename typdump,typename Base, typename typserv>
int testsdp(int k, const typdump &dump,const Base &b,const typserv &serv)
{
  return !(k%2);
}
template<typename typP,typename typPk,typename typdump,typename Base
     , template<typename  T> class tmptypmat ,typename monomial_server>
void algo(typP P,typdump &dump,Base &b, monomial_server &serv)
{
#ifdef PEQUAN
  int toto=0;
  FILE *fic;
  char name[8];
#endif
  typedef typename typP::value_type polyalp;
  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;
  //typP recall 
  typPk recall;
  //Base b;
  workspace<typename typP::value_type::coeff_t> w;
  typedef tmptypmat<typename typP::value_type::coeff_t> typMat;
  typMat Mat,L;
  int onemoretime=1,nouveaumon,allpolused=0,maxdeg,k,*pr,*pc;
  cout<<"avant init"<<endl;
  
  init_algo<typMat>(P,nouveaumon,maxdeg,k,Pk,Mk,b,dump,w,serv);
  cout<<"apres init"<<endl;
  cout<<"onemoretime "<<onemoretime<<endl;
  cout<<"nouveaumon "<<nouveaumon<<endl;
  cout<<"k "<<k<<endl;
  cout<<"maxdeg "<<maxdeg<<endl;
#ifndef GROEBNER

  
  //  while((critere(b,k)==-1)||(k<=maxdeg))
#ifdef ONEMORETIME
  cout<<"one"<<endl;
  while(nouveaumon||(k<=maxdeg)||onemoretime)
#else
    while(nouveaumon||(k<=maxdeg))
#endif
#else
    while(!GB_stop(k)||(k<=maxdeg))
#endif
 
    {
#ifdef ONEMORETIME
       cout<<"two"<<endl;
       cout<<"nouveaumon"<<endl;
      if(!nouveaumon)
    cout<<"si"<<endl;
    onemoretime=0;
#endif
    //if (toto>=5) {exit(0);}
    //toto++;
        
    int killspol;
    //test si on est dans les conditions d'application
   gettimeofday(&initclock,NULL); 
   cout<<"onemoretime "<<onemoretime<<endl;
   cout<<"nouveaumon"<<nouveaumon<< endl;
   cout<<"k "<<k<<endl;
   cout<<"maxdeg "<<maxdeg<<endl;
   cout<<"testsdp(k,dump,b,serv) "<<testsdp(k,dump,b,serv)<<endl;
   if(testsdp(k,dump,b,serv)||(!onemoretime))
      //envoie la routine de calcul de sdp
      {
    int mindeg_newpol;
    typP newpol;
    cout<<"un nouveau tour de boucle et k vaut "<<k<<endl;
    if(!onemoretime)//sdpa!!!!!!!!
      //  generickernel(newpol,2*k,dump,b,serv);
     generickernel_testT(newpol,2*k,dump,b,serv);
      //  generickernelsdpa(newpol,2*k,dump,b,serv);
    else
      //  generickernel(newpol,k,dump,b,serv);
      generickernel_testT(newpol,k,dump,b,serv);
    //generickernelsdpa(newpol,k,dump,b,serv);
      gettimeofday(&tmpclock,NULL);
      tempsdssdp+=tmpclock.tv_sec-initclock.tv_sec+1e-6*(tmpclock.tv_usec-initclock.tv_usec);      

    //sdprealrad(newpol,dump,b,serv);
    //penser a decroitre k le cas echeant avec un coup de recover
    cout<<"newpol "<<newpol.empty()<<endl;
    if(!newpol.empty())
      {
        mindeg_newpol=Degree(newpol.front());
//      cout<<"mindeg "<<mindeg_newpol<<" k "<<k<<endl;
        for(typename typP::iterator iter=newpol.begin();
        iter!=newpol.end();iter++)
          mindeg_newpol=(mindeg_newpol<Degree(*iter)
                  ?mindeg_newpol:Degree(*iter));
        for(typename typP::iterator iter=newpol.begin();
        iter!=newpol.end();iter++)
          if(Degree(*iter)==mindeg_newpol)
        P.push_back(*iter);
        if(k>=mindeg_newpol)
          {
        list<mon *> exceed;
            list<int> sizeexceed;
        typPk tmpPk;
        conv_merge(tmpPk,newpol,exceed,sizeexceed,b,serv);
//      cout<<"merde merde k "<<k<<" mindeg_newpol "<<mindeg_newpol<<endl;
        k=mindeg_newpol;
        //      forget(b,dump,k,recall);
        //              recover(Pk,Mk,dump,k);
        recover(Pk,Mk,dump,k);

        //Listedejafait(Mk,Spoldejavu);
//      cout<<"Pk.size() apres recover "<<Pk.size()<<endl;
        if((k>0)||(k==-1))
          forget(b,dump,k,recall);
        else
          forget0(b,dump,k,recall);
//      cout<<"forget fait"<<endl;
        //forget(b,dump,k);
        NewCrochetchoix(P,Pk,Mk,tmpPk,k,dump,b,recall,w,serv);
        serv.compress(Pk,dump,b,k);
        cout<<"compress"<<endl;
        Dump(Pk,dump);
        continue;
          }
      }
      }
#ifdef BONRAJOUT
      for(typename Base::const_iterator p=b.begin();p!=b.end();p++)
        {
    for(int i=0;i<p->taille1;i++)
      {
        cout<<"p.accept[i] "<<p->accept[i]<<endl;
      }
    for(int i=0;i<p->taille2;i++)
      {
        cout<<"p.refuse[i] "<<p->refuse[i]<<endl;
      }
        }
#endif
#if 1//def DEB

    //cout<<"mon a la fin de la boulcle de l'algo "<<Mk.size()<<endl;
      //for(typename typMk::iterator iter=Mk.begin();iter!=Mk.end();iter++)
      // cout<<*iter<<endl;  
  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<<"les sizes "<<iter->size<<endl;
      {
    int cpt=0;
    cout<<invconv<typename typP::value_type>(*iter,serv)<<endl;       
    for(int i=0;i<iter->sizenf;i++)
      for(int j=0;j<8;j++)
        if (((iter->nfind[i]>>j)&1) && (iter->nf[cpt++]==0))
          {
        cout<<"ici ca couille a la place"<<8*i+j<<endl;
        cout<<iter->sizenf<<" "<<iter->size<<endl;
        exit(1);
          }
      }
#endif   

  //  cout<<"Spolordsup"<<endl;
    S=Spolordsup(Pk,b,Spoldejavu);
    //S.erase(S.begin(),S.end());
    //S=Spolordsup(Pk,b);
    cout<<endl;
    cout<<endl<<"newpkmkmatrixof"<<endl;
    //cout<<"Pk.size() "<<Pk.size()<<endl;
    //killspol=!newPkMkMatrixof(Mat,Pk,P,Mk,k,b,dump,recall,Spoldejavu);
    killspol=!newPkMkMatrixof(Mat,Pk,P,Mk,k,b,dump,recall,w,serv);
#ifdef PEQUAN
    sprintf(name,"mat%d",toto);
    fic=fopen(name,"w");
    printmatfile_pequan(Mat,fic);
    fclose(fic);
    toto++;
#endif
    //    if (toto>=5) {cout<<"killredspol "<<killspol<<endl; exit(0);}
    // killspol=!newPkMkMatrixof(Mat,Pk,P,Mk,k,b,dump);
    if(killspol) S.erase(S.begin(),S.end());
    if (k+1>=maxdeg) allpolused=1;
    if(Mk.size()==0) nouveaumon=0;
    //cout<<"j'en suis a k="<<k<<endl;
    //cout<<"Ici dans algo Mat"<<endl;
    //#ifdef BONRAJOUT
    //affdebug(Mat);
    //#endif
    //Solve affecte a Mat la valeur U
    //cout<<"solve"<<endl;
    //for(typename typPk::iterator iter=Pk.begin();iter!=Pk.end();iter++)
    //  cout<<"avant solve les ind "<<iter->ind<<endl;
    //for(typename typPk::iterator iter=Pk.begin();iter!=Pk.end();iter++)
    //  cout<<"avant solve les pol "<<invconv<Poly>(*iter)<<endl;
    //if(k==3) exit(-10);
    //for(typename typMk::iterator iter=Mk.begin();iter!=Mk.end();iter++)
    //  cout<<"monomes dans Mk "<<*iter<<endl;
    
    if (Mat.ncol!=0)
      {
    //cout<<"debut du solve"<<endl;
    Solve(Mat,L,Pk,&pr,&pc,w);
//  cout<<"fin du solve"<<endl;
    //for(int kk=0;kk<Mk.size();kk++)
    //  cout<<"permc "<<kk<<" "<<pc[kk]<<endl;
    inverse(pc,Mk.size());
    Dopermu(Mk,pc);
    {
      //ici on remet les ind a la bonne valuer 
      //a inclure dans une petite fonction inline apres
      int j=0;
      typename typMk::iterator itermon=Mk.begin();
      typename typPk::iterator iter;
      for(iter=Pk.begin();
          itermon!=Mk.end();iter++,itermon++,j++)
        {
          if(!Iszero(Mat(j,j)))
        {
          //          cout<<"ligne "<<j<<" je mets le monome "<<*itermon<<endl;
          iter->ind=*itermon*(iter->ind.GetCoeff());
        }
          else
        {
          iter->ind=mon(0);
        }
        }
      //for(;itermon!=Mk.end();iter++,itermon++)
      //  iter->ind=mon(0);
    }

    free(pr);
    free(pc);
      }

 //appliquer les permutation a MK!!!!!!!!
    // for(typename typPk::iterator iter=Pk.begin();iter!=Pk.end();iter++)
      //  cout<<"apres solve les ind "<<iter->ind<<endl;
    //for(typename typPk::iterator iter=Pk.begin();iter!=Pk.end();iter++)
    // cout<<"apres solve les pol "<<invconv<Poly>(*iter)<<endl;
    //
    //
    //APPLIQUER LES PERMUTYATIONS A MK!!
    //
    //
    //
    //
    if ((unsigned)my_rank(Mat)==Mk.size())
      //matrice de rang plein
      {
    typMk tmpSpoldejavu;
    typPk redspol,secd=secondmembre(Mat,Pk);;
    //secondmembre2(Mat,Pk,secd);
    //typename typPk::iterator iter=Pk.begin();
    cout<<"matrice de rang plein "<<endl;
    //for(unsigned int i=0;i<Mk.size();i++,iter++);
    //Pk.erase(iter,Pk.end());
    //cout<<"Dump "<<endl;
    Dump(Pk,dump);
    //cout<<"Reduce Spol "<<endl;
    
    ReduceSpol(S,dump,redspol,b,w,serv);//tmpSpoldejavu);
    //cout<<"secd.size() "<<secd.size()<<endl;
    my_merge(redspol,secd);
    if(redspol.size()==0)
      {
        //a voir....    Dump(Pk,dump);
        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;
        cout<<"redspol.size() "<<redspol.size()<<endl;
        //cout<<invconv<typename typP::value_type>(redspol.front())<<endl;
        if (tmpdeg==(k+1))
          my_merge(Spoldejavu,tmpSpoldejavu);
        k=tmpdeg;
        //cout<<"le mindeg ici vaut "<<k<<endl;
        //cout<<"Pk.size() avant recover "<<Pk.size()<<endl;
        recover(Pk,Mk,dump,k);

        //Listedejafait(Mk,Spoldejavu);
        //cout<<"Pk.size() apres recover "<<Pk.size()<<endl;
        forget(b,dump,k,recall);
        //forget(b,dump,k);
#ifdef DEB     
        cout<<"Pk.size() avant Crochetchoix "<<Pk.size()<<endl;
#endif     
        //NewCrochetchoix(P,Pk,Mk,redspol,k,dump,b,recall,Spoldejavu);
        NewCrochetchoix(P,Pk,Mk,redspol,k,dump,b,recall,w,serv);
        //NewCrochetchoix(P,Pk,Mk,redspol,k,dump,b);
#ifdef DEB     
        cout<<"Pk.size apres Crochetchoix "<<Pk.size()<<" et k "<<k<<endl;
#endif     
        NewDestroyredspol(redspol,Pk);
        serv.compress(Pk,dump,b,k);
        Dump(Pk,dump);
        L.destroystore();
        //misa jour de B dans crochet choix!!
        continue;
      }
      }
    else
      //la matrice n'est pas de rang plein
      {
    cout<<"matrice de rang pas plein "<<endl;
    typPk secd;
#ifdef BONRAJOUT
    AddB_dim(Mat,L,P,Pk,Mk,dump,b);
#else
    AddB(Mat,Pk,Mk,dump,b,serv);
#endif
    //
    //secondmembre supprime des trucs dans Pk!!
    //
    secd=secondmembre(Mat,Pk);
    rajoute_voisins(Pk,Mk,dump,b,w,serv);
    //ne selectionne que les non nuls
       if(secd.size()==0)
     {
       typPk redspol;
       //for(int i=Pk.size();i>rank(Mat);i--)
       //{
       //  if(Pk.back().size!=0)
       // MAC_REV_FREE<typename typMat::coeff_t>(Pk.rbegin()->nf
       //    ,Pk.rbegin()->size*sizeof(typename typMat::coeff_t));
       //  Pk.pop_back();
       //}//on vire les 0 avant de dumper
       //      AddB(Mat,Pk,Mk,dump,b);
       Dump(Pk,dump);
       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)
         {
           // forget(b,dump,k);
           //AddB(Mat,Pk,Mk,b);
           //Dump(Pk,dump);
           //ici on modifie Pk dans AddB 
           //<=> forget(b,dump,k) AddB(..) Dump(Pk,dump);
           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);
           //Listedejafait(Mk,Spoldejavu);
           forget(b,dump,k,recall);
           //forget(b,dump,k);
           cout<<"il ya un passage par mat rang pas"
               <<"plein et pol non zero"<<endl;
           //NewCrochetchoix(P,Pk,Mk,redspol,k,dump,b,recall,Spoldejavu);
           NewCrochetchoix(P,Pk,Mk,redspol,k,dump,b,recall,w,serv);
           //NewCrochetchoix(P,Pk,Mk,redspol,k,dump,b);
           NewDestroyredspol(redspol,Pk);
           serv.compress(Pk,dump,b,k);
           Dump(Pk,dump); 
           L.destroystore();
           continue;
         }
     }
       else
     {
       //on a des pol qui se reduisent pas a 0
       //cad un defaut de commuatation dans les coins
       typPk redspol;
       //for(int i=Pk.size();i>rank(Mat);i--)
       //  Pk.pop_back();
       //cout<<"PK. size "<<Pk.size()<<" Mat.nbcol "<<Mat.ncol<<endl;
       //cout<<"rank(Mat) "<<rank(Mat)<<endl;
       //int j=0;
       //cout<<"avant recover et meme avant le dump "<<endl;
       //for(typename typPk::iterator iter = secd.begin();iter!=secd.end()
       //    ;iter++,j++)
       // cout<<"pol de secd num "<<j<<endl<<invconv<Poly>(*iter)<<endl;
       //      AddB(Mat,Pk,Mk,b);
       //cout<<"apres ADDB le dump "<<endl;
       //for(typename typPk::iterator iter = Pk.begin();iter!=Pk.end()
       //    ;iter++)
       // cout<<invconv<Poly>(*iter)<<endl;
       Dump(Pk,dump);
       //cout<<"secd.size()" <<secd.size()<<endl;
       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);
       //cout<<"k "<<k<<endl;
       //Listedejafait(Mk,Spoldejavu);
       //cout<<"apres recover"<<endl;
       //      for(typename typPk::iterator iter = Pk.begin();iter!=Pk.end()
       //    ;iter++)
       //  cout<<invconv<Poly>(*iter)<<endl;
       //cout<<"les Spol non reduits"<<endl;
       //for(typename typPk::iterator iter = secd.begin();iter!=secd.end()
       //    ;iter++)
       //  cout<<invconv<Poly>(*iter)<<endl;
       forget(b,dump,k,recall);
       
       //forget(b,dump,k);
       //cout<<"il ya un passage par mat pas rang plein et Spol non zero"<<endl;
       //for(typename typPk::iterator iter = secd.begin();iter!=secd.end()
       //    ;iter++)
       // cout<<invconv<Poly>(*iter)<<endl;
       //NewCrochetchoix(P,Pk,Mk,redspol,k,dump,b,recall,Spoldejavu);
       NewCrochetchoix(P,Pk,Mk,secd,k,dump,b,recall,w,serv);
       //NewCrochetchoix(P,Pk,Mk,secd,k,dump,b);
       NewDestroyredspol(secd,Pk);
#ifdef BONRAJOUT
       cout<<"Apres NewCrochetchoix"<<endl;

       for(typename Base::const_iterator p=b.begin();p!=b.end();p++)
         {
           for(int i=0;i<p->taille1;i++)
         {
           cout<<"p.accept[i] "<<p->accept[i]<<endl;
         }
           for(int i=0;i<p->taille2;i++)
         {
           cout<<"p.refuse[i] "<<p->refuse[i]<<endl;
         }
         }
#endif
       //for(typename typPk::iterator iter = Pk.begin();iter!=Pk.end()
       //    ;iter++)
       // cout<<invconv<Poly>(*iter)<<endl;
       serv.compress(Pk,dump,b,k);
       Dump(Pk,dump);
       L.destroystore();
       continue;
     }
      
      }
  }
  
  Mat.destroystore();
  //while nouveau mon etc...
  // Pk=recomposePk(dump);
  //return Pk;
  //  return;
#ifdef DEBUG
  for(typename Base::const_iterator p=b.begin();p!=b.end();p++)
    {
      for(int i=0;i<p->taille1;i++)
    {
      cout<<"p.accept[i] "<<p->accept[i]<<endl;
    }
      for(int i=0;i<p->taille2;i++)
    {
      cout<<"p.refuse[i] "<<p->refuse[i]<<endl;
    }
    }
#endif
  destroy_space(&w);
  cout<<"sortie d'algo flash et dimension "<<endl;//<<critere(b,k)<<endl;
  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.. :-)

    }

template<typename typP,typename typPk,typename typdump,typename Base
     , template<typename  T> class tmptypmat ,typename monomial_server>
void algo(typP P,typdump &dump,Base &b, monomial_server &serv,typP F)
{
#ifdef PEQUAN
  int toto=0;
  FILE *fic;
  char name[8];
#endif
  typedef typename typP::value_type polyalp;
  typedef list<typename typPk::value_type::monom_t> typMk;
  typedef typename typMk::value_type mon;
  typedef typename typPk::value_type pol;
  cout<<"entra aqui "<<endl; 
  typMk Mk;
  typMk Spoldejavu;
  typPk Pk,S;
  typPk recall;
  typP Pini;
  workspace<typename typP::value_type::coeff_t> w;
  typedef tmptypmat<typename typP::value_type::coeff_t> typMat;
  typMat Mat,L;
  int onemoretime=1,nouveaumon,allpolused=0,maxdeg,k,maxdegb,kb,*pr,*pc,optimo=0,k1;
  int nogap=0,deg=0,nok=1, noreduced=0, kbon,kini;
 
  typP newpol,newpol1;
  COEFF *sol2,*sol3;
  cout<<"avant init"<<endl;
  
  init_algo<typMat>(P,nouveaumon,maxdeg,k,Pk,Mk,b,dump,w,serv);
  Pini=P;
  kini=k;
  cout<<"apres init"<<endl;
  cout<<"onemoretime "<<onemoretime<<endl;
  cout<<"nouveaumon "<<nouveaumon<<endl;
  cout<<"k "<<k<<endl;
  cout<<"maxdeg "<<maxdeg<<endl;
#ifndef GROEBNER
 
#ifdef ONEMORETIME
  cout<<"one"<<endl;
  while(nouveaumon||(k<=maxdeg)||onemoretime)
#else
    while(nouveaumon||(k<=maxdeg)|| (!optimo) || nok )//|| (k!=deg))

#endif
#else
    while(!GB_stop(k)||(k<=maxdeg))
#endif
 
    {
#ifdef ONEMORETIME
       cout<<"two"<<endl;
       cout<<"nouveaumon"<<endl;
      if(!nouveaumon)
    cout<<"si"<<endl;
    onemoretime=0;
#endif
    
        
    int killspol;
    //test si on est dans les conditions d'application
   gettimeofday(&initclock,NULL); 
   cout<<"onemoretime "<<onemoretime<<endl;
   cout<<"nouveaumon"<<nouveaumon<< endl;
   cout<<"k "<<k<<endl;
   cout<<"maxdeg "<<maxdeg<<endl;
   cout<<"testsdp(k,dump,b,serv) "<<testsdp(k,dump,b,serv)<<endl;
   for(typename Base::const_iterator p=b.begin();p!=b.end();p++)
        {
    for(int i=0;i<p->taille1;i++)
      {
        cout<<"p.accept[i] "<<p->accept[i]<<endl;
      }
    for(int i=0;i<p->taille2;i++)
      {
        cout<<"p.refuse[i] "<<p->refuse[i]<<endl;
      }
        }
//todo este if es por ver si el noyau de k+1 se reduce con la base que hemos calculado o no   
//hay un problema en la reinicializacion de las variables cuando el noyau no se reduce
     cout<<"k"<<k<<endl;
     cout<<"maxdeg"<<maxdeg<<endl;
     cout<<"optimo"<<optimo<<endl;
     cout<<"nok"<<nok<<endl;
 

//   if(testsdp(k,dump,b,serv)||(!onemoretime))
     if((testsdp(k,dump,b,serv) && (!optimo)) || (k==deg))
      //envoie la routine de calcul de sdp
      {
    int mindeg_newpol;
    
    
    
    
    cout<<"un nouveau tour de boucle et k vaut "<<k<<endl;
//  if(!onemoretime)//sdpa!!!!!!!!  
//   generickernel_testF(newpol,2*k,dump,b,serv,F,*&sol2);
//  else
    
    cout<<"deg"<<deg<<endl;
    
      if (nogap)
      {
      cout<<"sol3"<<k<<endl;
      cout<<"kbon"<<kbon<<endl;
      if (k==deg)
      { cout<<"pasas por aqui"<<endl;
        newpol1.erase(newpol1.begin(),newpol1.end());
//      newpol=newpol1;
        
        for(typename typP::iterator iter=newpol.begin();iter!=newpol.end();
            iter++)
           {
             cout<<*iter<<" ";
             cout<<endl;
           }
      } 
     
      
      newpol1.erase(newpol1.begin(),newpol1.end());
//#ifdef CSDP
//    generickernel_testTT(newpol1,k,dump,b,serv,F,*&sol3);
//#else
      generickernel_testF(newpol1,k,dump,b,serv,F,*&sol3);
//#endif
      cout<<"solucionprimal k"<< sol2[2] << endl;
        cout<<"solucionprimal k+1"<< sol3[2] << endl;
        cout<<"diferenciasprimales"<<abs(sol2[2]-sol3[2])*1e+1<<endl;
        cout<<"k1"<<k1<<endl;
        cout<<"k"<<k<<endl;
        cout<<"gap"<<abs(sol3[2]-sol3[3])*1e+4<<endl;
        cout<<"deg"<<deg<<endl;
        cout<<"!newpol.empty()"<<!newpol.empty()<<endl;
        cout<<"newpol1.empty()"<<newpol1.empty()<<endl;
        
     
        if (((abs(sol2[2]-sol3[2])*1e+1<1) && (!newpol.empty()) && (k1!=k))
          || ((k==deg)) )
//      if ((abs(sol3[0])*1e+5<1) && (abs(sol2[2]-sol3[2])*1e+5<1) && (!newpol.empty()) && (k1!=k))
         
        {  
         if (k==deg && newpol1.empty())  
          {
        
        nok=0;
        continue;
        
          }
          else
          {
        if (k!=deg)
        {  
          optimo=1;  
          deg=k+2;
          cout<<"deg dentro"<<deg<<endl;
          int numkerf=0;
             cout<<"noyau bon"<<endl;
             for(typename typP::iterator iter=newpol.begin();iter!=newpol.end();
             iter++,numkerf++)
           {
             cout<<*iter<<" ";
             cout<<endl;
           }
         mindeg_newpol=Degree(newpol.front());
         cout<<"mindeg "<<mindeg_newpol<<" k1 "<<k1<<endl;
         for(typename typP::iterator iter=newpol.begin();
        iter!=newpol.end();iter++)
          mindeg_newpol=(mindeg_newpol<Degree(*iter)
                  ?mindeg_newpol:Degree(*iter));
         cout<<"mindeg "<<mindeg_newpol<<" k1 "<<k1<<endl; 
        }
        if (k==deg && (!newpol.empty()))
        { 
//       for(typename typP::iterator iter=newpol1.begin();
//      iter!=newpol1.end();iter++)
//       newpol.push_back(*iter);
//       for(typename typP::iterator iter=newpol.begin();iter!=newpol.end();
//             iter++)
//         {
//             cout<<*iter<<"newpol2fois ";
//             cout<<endl;
//         }
                 newpol.erase(newpol.begin(),newpol.end());
         newpol=newpol1;
         mindeg_newpol=Degree(newpol.front());
         cout<<"mindeg2fois"<<mindeg_newpol<<endl;
        }
//      nok=0;
        
//       for(typename typP::iterator iterP=P.begin();
//      iterP!=P.end();iterP++)
//       newpol.push_back(*iterP);
         P.erase(P.begin(),P.end());
        for(typename typP::iterator iter=newpol.begin();
        iter!=newpol.end();iter++)
          if(Degree(*iter)==mindeg_newpol)
        P.push_back(*iter);
        if(k-2>=mindeg_newpol)
          {
        list<mon *> exceed;
            list<int> sizeexceed;
        typPk tmpPk;
        conv_merge(tmpPk,newpol,exceed,sizeexceed,b,serv);
        k=mindeg_newpol;
                
//      if (!nok) deg=0;
//      else deg=k*2;
        cout<<"k noyau bon"<< k<<endl;
        
        
        recover(Pk,Mk,dump,k);


//      cout<<"Pk.size() apres recover "<<Pk.size()<<endl;
        if (k!=deg)
        {
        if((k>0)||(k==-1))
          forget(b,dump,k,recall);
        else
          forget0(b,dump,k,recall);
        }

        NewCrochetchoix(P,Pk,Mk,tmpPk,k,dump,b,recall,w,serv);
        for(typename typP::iterator iter=P.begin();iter!=P.end();
                 iter++)
                 cout<<*iter<<" ";
                 cout<<endl;
        serv.compress(Pk,dump,b,k);
        cout<<"compress"<<endl;
        Dump(Pk,dump);

        continue;
          }
          }
        }
        else
        {
          
          cout<<"pasa por aqui cambiamos"<<endl;
          sol2=sol3;
          newpol=newpol1;
          
          
       } 
      }
      else
      {
      cout<<"sol2"<<k<<endl;  
      k1=k;
      newpol.erase(newpol.begin(),newpol.end());
//#ifdef CSDP
//    generickernel_testTT(newpol,k,dump,b,serv,F,*&sol2);
//#else
      generickernel_testF(newpol,k,dump,b,serv,F,*&sol2);
//#endif
      int numker=0;
          
           for(typename typP::iterator iter=newpol.begin();iter!=newpol.end();
            iter++,numker++)
          cout<<*iter<<" ";
          cout<<endl;
      cout<<"newpol "<<newpol.empty()<<endl;
      cout<<"numker"<<numker<<endl;
      //pour le case de polynome dans degree 2
      if (k==2 && maxdeg==1)
      {
        nogap=1;
        optimo=1;
        nok=0;
        
      }
      else{
        
      cout<<"gap"<<sol2[0]<<endl;
      cout<<"gapx"<<abs(sol2[0])*1e+4<<endl;
      if (abs(sol2[0])*1e+4<1){
        nogap=1;
        for(typename typP::iterator iter=newpol.begin();iter!=newpol.end();
        iter++,numker++)
          cout<<*iter<<" ";
        cout<<endl;
        cout<<"newpol "<<newpol.empty()<<endl;
        cout<<"numker"<<numker<<endl;
        
       }
      }
      
     }

      } 


      
 

#ifdef BONRAJOUT
      for(typename Base::const_iterator p=b.begin();p!=b.end();p++)
        {
    for(int i=0;i<p->taille1;i++)
      {
        cout<<"p.accept[i] "<<p->accept[i]<<endl;
      }
    for(int i=0;i<p->taille2;i++)
      {
        cout<<"p.refuse[i] "<<p->refuse[i]<<endl;
      }
        }
#endif
#ifdef DEB

    //cout<<"mon a la fin de la boulcle de l'algo "<<Mk.size()<<endl;
      //for(typename typMk::iterator iter=Mk.begin();iter!=Mk.end();iter++)
      // cout<<*iter<<endl;  
  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<<"les sizes "<<iter->size<<endl;
      {
    int cpt=0;
    cout<<invconv<typename typP::value_type>(*iter)<<endl;       
    for(int i=0;i<iter->sizenf;i++)
      for(int j=0;j<8;j++)
        if (((iter->nfind[i]>>j)&1) && (iter->nf[cpt++]==0))
          {
        cout<<"ici ca couille a la place"<<8*i+j<<endl;
        cout<<iter->sizenf<<" "<<iter->size<<endl;
        exit(1);
          }
      }
#endif   
   
    S=Spolordsup(Pk,b,Spoldejavu);
    
  
    cout<<"newpkmkmatrixof"<<endl;
    cout<<"k"<<k<<endl;
  
    killspol=!newPkMkMatrixof(Mat,Pk,P,Mk,k,b,dump,recall,w,serv);
#ifdef PEQUAN
    sprintf(name,"mat%d",toto);
    fic=fopen(name,"w");
    printmatfile_pequan(Mat,fic);
    fclose(fic);
    toto++;
#endif
    
    if(killspol) S.erase(S.begin(),S.end());
    if (k+1>=maxdeg) allpolused=1;
    cout<<"Mk.size()"<<Mk.size()<<endl;
    if(Mk.size()==0) nouveaumon=0;
    //Solve affecte a Mat la valeur U
    //cout<<"solve"<<endl;
    for(typename typPk::iterator iter=Pk.begin();iter!=Pk.end();iter++)
      cout<<"avant solve les ind "<<iter->ind<<endl;
    for(typename typMk::iterator iter=Mk.begin();iter!=Mk.end();iter++)
      cout<<"monomes dans Mk "<<*iter<<endl;
    cout<<"Mat.ncol"<<Mat.ncol<<endl;
    if (Mat.ncol!=0)
      {
    //cout<<"debut du solve"<<endl;
    Solve(Mat,L,Pk,&pr,&pc,w);
//  cout<<"fin du solve"<<endl;
    //for(int kk=0;kk<Mk.size();kk++)
    //  cout<<"permc "<<kk<<" "<<pc[kk]<<endl;
    inverse(pc,Mk.size());
    Dopermu(Mk,pc);
    {
      //ici on remet les ind a la bonne valuer 
      //a inclure dans une petite fonction inline apres
      int j=0;
      typename typMk::iterator itermon=Mk.begin();
      typename typPk::iterator iter;
      for(iter=Pk.begin();
          itermon!=Mk.end();iter++,itermon++,j++)
        {
          if(!Iszero(Mat(j,j)))
        {
          //          cout<<"ligne "<<j<<" je mets le monome "<<*itermon<<endl;
          iter->ind=*itermon*(iter->ind.GetCoeff());
        }
          else
        {
          iter->ind=mon(0);
        }
        }
      //for(;itermon!=Mk.end();iter++,itermon++)
      //  iter->ind=mon(0);
    }

    free(pr);
    free(pc);
      }

 //appliquer les permutation a MK!!!!!!!!
    // for(typename typPk::iterator iter=Pk.begin();iter!=Pk.end();iter++)
      //  cout<<"apres solve les ind "<<iter->ind<<endl;
    //for(typename typPk::iterator iter=Pk.begin();iter!=Pk.end();iter++)
    // cout<<"apres solve les pol "<<invconv<Poly>(*iter)<<endl;
    //
    //
    //APPLIQUER LES PERMUTYATIONS A MK!!
    //
    //
    //
    //
    if ((unsigned)my_rank(Mat)==Mk.size())
      //matrice de rang plein
      {
    typMk tmpSpoldejavu;
    typPk redspol,secd=secondmembre(Mat,Pk);;
    cout<<"matrice de rang plein "<<endl;
    Dump(Pk,dump);
    cout<<"Reduce Spol "<<endl;

    ReduceSpol(S,dump,redspol,b,w,serv);//tmpSpoldejavu);
    
    cout<<"secd.size() "<<secd.size()<<endl;
    my_merge(redspol,secd);
    if(redspol.size()==0)
      {
        //a voir....    Dump(Pk,dump);
        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;
        cout<<"redspol.size() "<<redspol.size()<<endl;
        if (tmpdeg==(k+1))
          my_merge(Spoldejavu,tmpSpoldejavu);
        k=tmpdeg;
        //cout<<"le mindeg ici vaut "<<k<<endl;
        //cout<<"Pk.size() avant recover "<<Pk.size()<<endl;
        recover(Pk,Mk,dump,k);


        //cout<<"Pk.size() apres recover "<<Pk.size()<<endl;
        forget(b,dump,k,recall);
        //forget(b,dump,k);
#ifdef DEB     
        cout<<"Pk.size() avant Crochetchoix "<<Pk.size()<<endl;
#endif     
        //NewCrochetchoix(P,Pk,Mk,redspol,k,dump,b,recall,Spoldejavu);
        NewCrochetchoix(P,Pk,Mk,redspol,k,dump,b,recall,w,serv);
        //NewCrochetchoix(P,Pk,Mk,redspol,k,dump,b);
#ifdef DEB     
        cout<<"Pk.size apres Crochetchoix "<<Pk.size()<<" et k "<<k<<endl;
#endif     
        NewDestroyredspol(redspol,Pk);
        serv.compress(Pk,dump,b,k);
        Dump(Pk,dump);

        L.destroystore();
        cout<<"kaquiPini"<<k<<endl;
        //misa jour de B dans crochet choix!!
        continue;
      }
      }
    else
      //la matrice n'est pas de rang plein
      {
    cout<<"matrice de rang pas plein "<<endl;
    typPk secd;
#ifdef BONRAJOUT
    AddB_dim(Mat,L,P,Pk,Mk,dump,b);
#else
    AddB(Mat,Pk,Mk,dump,b,serv);
#endif
    //
    //secondmembre supprime des trucs dans Pk!!
    //
    secd=secondmembre(Mat,Pk);
    rajoute_voisins(Pk,Mk,dump,b,w,serv);
    //ne selectionne que les non nuls
       if(secd.size()==0)
     {
       typPk redspol;
       Dump(Pk,dump);

       ReduceSpol(S,dump,redspol,b,w,serv);
#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)
         {
           //ici on modifie Pk dans AddB 
           //<=> forget(b,dump,k) AddB(..) Dump(Pk,dump);
           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);
           //Listedejafait(Mk,Spoldejavu);
           forget(b,dump,k,recall);
           //forget(b,dump,k);
           cout<<"il ya un passage par mat rang pas"
               <<"plein et pol non zero"<<endl;
           //NewCrochetchoix(P,Pk,Mk,redspol,k,dump,b,recall,Spoldejavu);
           NewCrochetchoix(P,Pk,Mk,redspol,k,dump,b,recall,w,serv);
           //NewCrochetchoix(P,Pk,Mk,redspol,k,dump,b);
           NewDestroyredspol(redspol,Pk);
           serv.compress(Pk,dump,b,k);
           Dump(Pk,dump); 

           L.destroystore();
           continue;
         }
     }
       else
     {
       //on a des pol qui se reduisent pas a 0
       //cad un defaut de commuatation dans les coins
       typPk redspol;
       //for(int i=Pk.size();i>rank(Mat);i--)
       //  Pk.pop_back();
       //cout<<"PK. size "<<Pk.size()<<" Mat.nbcol "<<Mat.ncol<<endl;
       //cout<<"rank(Mat) "<<rank(Mat)<<endl;
       //int j=0;
       //cout<<"avant recover et meme avant le dump "<<endl;
       //for(typename typPk::iterator iter = secd.begin();iter!=secd.end()
       //    ;iter++,j++)
       // cout<<"pol de secd num "<<j<<endl<<invconv<Poly>(*iter)<<endl;
       //      AddB(Mat,Pk,Mk,b);
       //cout<<"apres ADDB le dump "<<endl;
       //for(typename typPk::iterator iter = Pk.begin();iter!=Pk.end()
       //    ;iter++)
       // cout<<invconv<Poly>(*iter)<<endl;
       Dump(Pk,dump);
 
       //cout<<"secd.size()" <<secd.size()<<endl;
       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);
       //cout<<"k "<<k<<endl;
       //Listedejafait(Mk,Spoldejavu);
       //cout<<"apres recover"<<endl;
       //      for(typename typPk::iterator iter = Pk.begin();iter!=Pk.end()
       //    ;iter++)
       //  cout<<invconv<Poly>(*iter)<<endl;
       //cout<<"les Spol non reduits"<<endl;
       //for(typename typPk::iterator iter = secd.begin();iter!=secd.end()
       //    ;iter++)
       //  cout<<invconv<Poly>(*iter)<<endl;
       forget(b,dump,k,recall);
       
       //forget(b,dump,k);
       //cout<<"il ya un passage par mat pas rang plein et Spol non zero"<<endl;
       //for(typename typPk::iterator iter = secd.begin();iter!=secd.end()
       //    ;iter++)
       // cout<<invconv<Poly>(*iter)<<endl;
       //NewCrochetchoix(P,Pk,Mk,redspol,k,dump,b,recall,Spoldejavu);
       NewCrochetchoix(P,Pk,Mk,secd,k,dump,b,recall,w,serv);
       //NewCrochetchoix(P,Pk,Mk,secd,k,dump,b);
       NewDestroyredspol(secd,Pk);
#ifdef BONRAJOUT
       cout<<"Apres NewCrochetchoix"<<endl;

       for(typename Base::const_iterator p=b.begin();p!=b.end();p++)
         {
           for(int i=0;i<p->taille1;i++)
         {
           cout<<"p.accept[i] "<<p->accept[i]<<endl;
         }
           for(int i=0;i<p->taille2;i++)
         {
           cout<<"p.refuse[i] "<<p->refuse[i]<<endl;
         }
         }
#endif
       //for(typename typPk::iterator iter = Pk.begin();iter!=Pk.end()
       //    ;iter++)
       // cout<<invconv<Poly>(*iter)<<endl;
       serv.compress(Pk,dump,b,k);
       Dump(Pk,dump);

       L.destroystore();
       continue;
     }     
      }     
  }
    
    Mat.destroystore();
  
#ifdef DEBUG
  for(typename Base::const_iterator p=b.begin();p!=b.end();p++)
    {
      for(int i=0;i<p->taille1;i++)
    {
      cout<<"p.accept[i] "<<p->accept[i]<<endl;
    }
      for(int i=0;i<p->taille2;i++)
    {
      cout<<"p.refuse[i] "<<p->refuse[i]<<endl;
    }
    }
#endif
  
  destroy_space(&w);
//  delete[] &sol2;
//  delete[] &sol3;
 
  cout<<"sortie d'algo flash et dimension "<<endl;//<<critere(b,k)<<endl;
  cout<<"TPS SDP "<<tempsCDSP<<endl;
  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.. :-)

    }
#endif //ALREADY_corealgo3

  //
  
  //
  //On commence par enumerer les monomes de degre plus petit que k
  //
  //
  typP stockprod,stockproj;//dans stockprod on a des polynomes
  //
  //
  //
  int nbconstraint=0;
  list<typename typserv::monom_t> stockmon,stockksur2;
  map<mon,int,ord> mapintligne,mapintcolonne,maphankel;
  enumeratemon(stockmon,k,b,dump);
  //
  //ICI on cree un index pour le monomes de degre k
  //il n'a a priori rien a voir avec int2mon/mon2int du reste du code 
  //sic.....
  enumeratemon(stockksur2,k/2,b,dump);
  //
  //pour le suite il nous faut les monomes de B de degre <=k/2
  //

  for(typename list<typename typserv::monom_t>::iterator 
    iter=stockksur2.begin(); iter!=stockksur2.end();iter++)
    if(!IsinB(*iter,b)) stockksur2.erase(iter--);
#ifdef DEBUGSDP  
cout<<"monome en degre k/2 "<<endl;
   for(typename list<typename typserv::monom_t>::iterator 
    iter=stockksur2.begin(); iter!=stockksur2.end();iter++)
     cout<<*iter<<" ";
   cout<<endl;
#endif
  i=1;
  for(typename list<typename typserv::monom_t>::iterator 
    iter=stockksur2.begin();iter!=stockksur2.end();iter++,i++)
    { 
      int j=1;
      for(typename list<typename typserv::monom_t>::iterator 
    iter2=stockksur2.begin();iter2!=stockksur2.end();iter2++,j++)
    {
      typename typserv::monom_t mono=*iter * (*iter2);
//    cout<<"monome "<<mono<<" "<<i<<" "<<j<<endl;
      if (!mapintligne.count(mono))
        {
          mapintligne[mono]=i;
          mapintcolonne[mono]=j;
        }
    }
    }
  //cout<<"passé"<<endl;

  // 
  //  On  genere les formes normales des produits de monomes de
  // de tous les monomes de   degre <=k/2 dez B.
  //
  
  computeprod(stockprod,stockksur2,b,dump);
  stockproj=stockprod;
  proj(stockproj,dump,b,serv);

#ifdef DEBUGSDP
 cout<<"produits "<<endl;
  for(typename typP::iterator iter=stockprod.begin();iter!=stockprod.end();
      iter++)
   cout<<*iter<<" ";
   cout<<endl;  
   cout<<"proj "<<endl;
  for(typename typP::iterator iter=stockproj.begin();iter!=stockproj.end();
      iter++)
   cout<<*iter<<" ";
   cout<<endl;
#endif  
  //
  //
  //computerelations();//
  //
  //
  //
  //
  // §Ici on va avoir besoin d'une structure contenant un monome de tete
  // hors de B et sa forme normal

   for(typename typP::iterator iter=stockprod.begin();
       iter!=stockprod.end();iter++)
     if(!IsinB(*(iter->begin()),b))
       nbconstraint++;
#ifndef NONEW
  constraints=new constraintmatrix<COEFF>[nbconstraint+1];
#else
  constraints=(struct constraintmatrix<COEFF> *)
    malloc((nbconstraint+1)*sizeof(struct constraintmatrix<COEFF>));
 #endif
 /*
   *
   * Les indices partent de 1 pas de 0!
   *
   */
  //
  //On construit la liste des contraintes de la fin vers le debut
  //
  //Ca c la fin
  constraints[0].blocks=NULL;//not used dixit the manual
  //
  i=1;
  typename typP::iterator iterstockprod=stockprod.begin();
  for(typename typP::iterator iter=stockproj.begin();
      iter!=stockproj.end();iter++,iterstockprod++)
    {
      if(!IsinB(*(iterstockprod->begin()),b))
    {
      int k;
      int decal;
      //
      //On construit la liste des contraintes de la fin vers le debut
      //
      //Ca c la fin
      constraints[i].blocks=NULL;
      //
#ifndef NONEW
      blockptr=new sparseblock<COEFF>[1];
#else
      blockptr=(struct sparseblock<COEFF> *)malloc(sizeof(struct sparseblock<COEFF>));
#endif
      blockptr->blocknum=1;//
      // ?????? relations.size()-i;
#if 0
      blockptr->blocksize=stockksur2.size();
      blockptr->numentries=2*iter->size()+2;//pour l'ind
      decal=iter->size()+1;//pour l'ind
#else
      blockptr->blocksize=stockksur2.size();
      blockptr->numentries=iter->size()+1;//pour l'ind
      decal=0;
#endif
      blockptr->constraintnum=i;
      blockptr->next=NULL;
      blockptr->nextbyblock=NULL;
#ifndef NONEW
      blockptr->entries=new COEFF[(blockptr->numentries+1)];
#else    
    blockptr->entries=(COEFF *) 
        malloc((blockptr->numentries+1)*sizeof(COEFF));
#endif
#ifndef NOSHORTS
      blockptr->iindices=(short unsigned int *) 
        malloc((blockptr->numentries+1)*sizeof(short unsigned int));
      blockptr->jindices=(short unsigned int *) malloc((blockptr->numentries+1)*sizeof(short unsigned int));
#else  
      blockptr->iindices=( int *) 
        malloc((blockptr->numentries+1)*sizeof( int));
      blockptr->jindices=(int *) malloc((blockptr->numentries+1)*sizeof( int));
#endif 

      k=1;
//    cout<<" matrix contrainte "<<endl<<*iter<<endl;
      for(typename typP::value_type::iterator iterpol=iter->begin();
          iterpol!=iter->end();k++,iterpol++)
        {
          if(mapintligne[*iterpol]<mapintcolonne[*iterpol])
        {
          blockptr->iindices[k]=mapintligne[*iterpol];
          blockptr->jindices[k]=mapintcolonne[*iterpol];
          blockptr->entries[k]=((COEFF)-1)*iterpol->GetCoeff();
//        cout<<blockptr->iindices[k]<<" "<<blockptr->jindices[k]
//            <<" "<<blockptr->entries[k]<<endl;
          //
        }
          else
        {
          //blockptr->numentries--;
          //decal--;
          if (mapintligne[*iterpol]!=mapintcolonne[*iterpol] )
            {
              blockptr->jindices[k]=mapintligne[*iterpol];
              blockptr->iindices[k]=mapintcolonne[*iterpol];
              blockptr->entries[k]=((COEFF)-1)*iterpol->GetCoeff();
            }
          else
            {
              blockptr->jindices[k]=mapintligne[*iterpol];
              blockptr->iindices[k]=mapintcolonne[*iterpol];
              blockptr->entries[k]=((COEFF)-2)*iterpol->GetCoeff();
            }
        }

        }
    
//    cout<<"index en plus"<<endl;
     if(mapintligne[*(iterstockprod->begin())]<
        mapintcolonne[*(iterstockprod->begin())]  ) 
       {
         blockptr->iindices[k]=mapintligne[*(iterstockprod->begin())];
         blockptr->jindices[k]=mapintcolonne[*(iterstockprod->begin())];
         blockptr->entries[k]=1;
//       cout<<blockptr->iindices[k]<<" "<<blockptr->jindices[k]
//        <<" "<<blockptr->entries[k]<<endl;
       }
     else
       {
         if (mapintligne[*(iterstockprod->begin())]!=
         mapintcolonne[*(iterstockprod->begin())]) 
           {
         blockptr->iindices[k]
           =mapintcolonne[*(iterstockprod->begin())];
         
         blockptr->jindices[k]
           =mapintligne[*(iterstockprod->begin())];
         blockptr->entries[k]=1;
//       cout<<"indices ici "<<mapintligne[*(iterstockprod->begin())]<<" "<<
//         mapintcolonne[*(iterstockprod->begin())]<<endl;
           }
         else
           {
         blockptr->iindices[k]=mapintligne[*(iterstockprod->begin())];
               blockptr->jindices[k]=mapintcolonne[*(iterstockprod->begin())];
           blockptr->entries[k]=2;
           }
       }
      /*
       * Insert block into the linked list of A1 blocks.  
       */
      //      blockptr->blocksize--;
      blockptr->next=NULL;
        //=constraints[i].blocks;
      constraints[i].blocks=blockptr;
//    cout<<"i "<<i<<" "<<stockprod.size()<<endl;
      i++;
      
    }
    }
  //
  // On donne les relations Hankel
  //
  //
  //
  // 
  //
  //
  int nbhankelrel=0,i_counter=1,j_counter;
  for(typename list<typename typserv::monom_t>::iterator i=stockksur2.begin();
      i!=stockksur2.end();i++,i_counter++)
    {
      j_counter=1;
     for(typename list<typename typserv::monom_t>::iterator j=stockksur2.begin();
      j!=stockksur2.end();j++,j_counter++)
    if(!maphankel.count(*i * *j))
      {
        maphankel[*i * *j]=j_counter*stockksur2.size()+i_counter;
      }
    else
      if((maphankel[*i * *j]%stockksur2.size()!=j_counter)
         ||(maphankel[*i * *j]/stockksur2.size()!=i_counter))
        {
          int decal=0;
          nbhankelrel++;
#ifndef NONEW
         constraintmatrix<COEFF> *tmpconstraints=new constraintmatrix<COEFF>[nbhankelrel+nbconstraint+1];
         for(int ii=0;ii<nbhankelrel+nbconstraint;ii++) 
        tmpconstraints[ii]=constraints[ii]; 
         delete[] constraints;
             constraints=tmpconstraints;
          blockptr=new sparseblock<COEFF>[1];
#else        
        constraints=(struct constraintmatrix<COEFF> *)
          realloc(constraints,
              (nbhankelrel+nbconstraint+1)
              *sizeof(struct constraintmatrix<COEFF>));
        
        blockptr=(struct sparseblock<COEFF> *)malloc(sizeof(struct sparseblock<COEFF>));
#endif
        blockptr->blocknum=1;//
        blockptr->blocksize=stockksur2.size();
#if 0
        blockptr->numentries=4;
#else 
        blockptr->numentries=2;
#endif
        blockptr->constraintnum=nbconstraint+nbhankelrel;
        blockptr->next=NULL;
        blockptr->nextbyblock=NULL;
#ifndef NONEW
        blockptr->entries=new COEFF[(blockptr->numentries+1)];
#else
        blockptr->entries=(COEFF *) 
          malloc((blockptr->numentries+1)*sizeof(COEFF));
#endif
#ifndef NOSHORTS
        blockptr->iindices=(short unsigned int *) malloc((blockptr->numentries+1)*sizeof(short unsigned int));
        blockptr->jindices=(short unsigned int *) malloc((blockptr->numentries+1)*sizeof(short unsigned int));
#else
        blockptr->iindices=(int *) malloc((blockptr->numentries+1)*sizeof(int));
        blockptr->jindices=(int *) malloc((blockptr->numentries+1)*sizeof(int));
#endif  
        //blockptr->numentries=blockptr->blocksize-1; //On a rajoute un avant
        if((maphankel[*i * *j]%stockksur2.size())<
           (maphankel[*i * *j]/stockksur2.size()))
          {
        blockptr->iindices[1]=maphankel[*i * *j]%stockksur2.size();
        blockptr->jindices[1]=maphankel[*i * *j]/stockksur2.size();
        blockptr->entries[1]=1;
          }
        else
          {
        if((maphankel[*i * *j]/stockksur2.size())!=
           (maphankel[*i * *j]%stockksur2.size()))
          {
            blockptr->jindices[1]=maphankel[*i * *j]%stockksur2.size();
            blockptr->iindices[1]=maphankel[*i * *j]/stockksur2.size();
            blockptr->entries[1]=1;
          }
        else
          {
            blockptr->jindices[1]=maphankel[*i * *j]%stockksur2.size();
            blockptr->iindices[1]=maphankel[*i * *j]/stockksur2.size();
            blockptr->entries[1]=2;
          } 

          }
        if(i_counter<j_counter)
          {
        blockptr->iindices[2]=i_counter;
        blockptr->jindices[2]=j_counter;
        blockptr->entries[2]=-1;
          }
        else
          {
        if(i_counter!=j_counter)
          {
            blockptr->iindices[2]=j_counter;
            blockptr->jindices[2]=i_counter;
            blockptr->entries[2]=-1;
          }
        else
          {
            blockptr->iindices[2]=j_counter;
            blockptr->jindices[2]=i_counter;
            blockptr->entries[2]=-2;
          }
          }
#if 0       
        if((maphankel[*i * *j]/stockksur2.size())!=
           (maphankel[*i * *j]%stockksur2.size()))
          {
        blockptr->iindices[3]=maphankel[*i * *j]/stockksur2.size();
        blockptr->jindices[3]=maphankel[*i * *j]%stockksur2.size();;
        blockptr->entries[3]=1;
          }
        else
          {
        decal++;
        blockptr->numentries--;
        blockptr->entries[1]=2;
          } 

        if(i_counter!=j_counter)
          {
        blockptr->iindices[4-decal]=j_counter;
        blockptr->jindices[4-decal]=i_counter;
        blockptr->entries[4-decal]=-1;
          }
        else
          {
        blockptr->numentries--;
        blockptr->entries[2]=-2;
     
          }
#endif
//      cout<<"indice "<<maphankel[*i * *j]%stockksur2.size()
//      <<" "<<maphankel[*i * *j]/stockksur2.size()<<endl;
//      cout<<"indice "<<i_counter<<" "<<j_counter<<endl;
//      cout<<endl;
        //      cout<<"indice "<<l<<" "<<1<<endl;
        //cout<<"indice "<<l-k<<" "<<k+1<<endl;
    /*
     * Insert block  into the linked list of A1 blocks.  
     */
    
        blockptr->next=NULL;//constraints[i].blocks;
        constraints[nbconstraint+nbhankelrel].blocks=blockptr;
        
        
      }
    }
  //
  //
  //
  // les relations de symetrie sont implicites X est recherche SDP
  // ONrajoute la contrainte sur le coeff en haut a gauche
  //
  //
  nbhankelrel++;
#ifndef NONEW
  constraintmatrix<COEFF> *tmpconstraints=
    new constraintmatrix<COEFF>[(nbhankelrel+nbconstraint+1)];
  for(int ii=0;ii<nbhankelrel+nbconstraint;ii++)
    tmpconstraints[ii]=constraints[ii];
  delete [] constraints;
  constraints=tmpconstraints;
#else
  constraints=(struct constraintmatrix<COEFF> *)
          realloc(constraints,
              (nbhankelrel+nbconstraint+1)
              *sizeof(struct constraintmatrix<COEFF>));
#endif
        
 #ifndef NONEW
  blockptr=new sparseblock<COEFF>[1];
#else 
 blockptr=(struct sparseblock<COEFF> *)malloc(sizeof(struct sparseblock<COEFF>));
#endif 
 blockptr->blocknum=1;//
  blockptr->blocksize=stockksur2.size();
  blockptr->numentries=1;
  blockptr->constraintnum=nbconstraint+nbhankelrel;
  blockptr->next=NULL;
  blockptr->nextbyblock=NULL;
#ifndef NONEW
  blockptr->entries=new COEFF[blockptr->numentries+1];
#else
  blockptr->entries=(COEFF *) 
    malloc((blockptr->numentries+1)*sizeof(COEFF));
#endif
#ifndef NOSHORTS
  blockptr->iindices=(short unsigned int *) malloc((blockptr->numentries+1)*sizeof(short unsigned int));
  blockptr->jindices=(short unsigned int *) malloc((blockptr->numentries+1)*sizeof(short unsigned int));
#else
  blockptr->iindices=(int *) malloc((blockptr->numentries+1)*sizeof(int));
  blockptr->jindices=(int *) malloc((blockptr->numentries+1)*sizeof(int));
#endif  
  //blockptr->numentries=blockptr->blocksize-1; //On a rajoute un avant
  
  blockptr->iindices[1]=1;
  blockptr->jindices[1]=1;
  blockptr->entries[1]=1;
  blockptr->next=NULL;//constraints[i].blocks;
  constraints[nbconstraint+nbhankelrel].blocks=blockptr;
  //
  //On optimise la fonction "0" sous l es contraintes lineaires precedents
  //
  struct blockmatrix<COEFF> X,Z;
  COEFF *y;
  COEFF pobj,dobj;
  int tmpsize=(int)stockksur2.size();
#ifndef NONEW
  bb=new COEFF[nbhankelrel+nbconstraint+1];
#else
  bb=(COEFF *)malloc((nbhankelrel+nbconstraint+1)*sizeof(COEFF));
#endif  //oon a un block de 0
  C.nblocks=1;
#ifndef NONEW
  C.blocks=new blockrec<COEFF>[2];
 #else
 C.blocks=(struct blockrec<COEFF> *)malloc(2*sizeof(struct blockrec<COEFF>));
#endif
#ifndef CCCCC
  C.blocks[1].blockcategory=MATRIX;
  C.blocks[1].blocksize=stockksur2.size();
#ifndef NONEW
  C.blocks[1].data.mat=new COEFF[stockksur2.size()*stockksur2.size()+1];
#else
  C.blocks[1].data.mat=(COEFF *)malloc(
          (stockksur2.size()*stockksur2.size()+1)*sizeof(COEFF));
#endif 
 for(int k=0;k<=(stockksur2.size()*stockksur2.size());k++)
    C.blocks[1].data.mat[k]=0;
  //
  C.blocks[1].data.mat[1]=0;
#else
  C.blocks[1].blockcategory=DIAG;
  C.blocks[1].blocksize=stockksur2.size();
  C.blocks[1].data.vec=(COEFF *)malloc(
          (stockksur2.size()+1)*sizeof(COEFF));
  for(int k=0;k<=(stockksur2.size());k++)
    C.blocks[1].data.vec[k]=0;

#endif
  for(i=0;i<=nbhankelrel+nbconstraint;i++)
    bb[i]=0;
  bb[nbconstraint+nbhankelrel]=(COEFF)1.;//on double qd on est sur la diagonale
  //cout<<"stockprod.size() "<<stockprod.size()<<endl;
 // cout<<"nbconstraint "<<nbconstraint<<endl;
 // cout<<"tmpsize "<<tmpsize<<endl;
 // cout<<"Affichage contraintes"<<endl;
  for(i=1;i<nbconstraint+nbhankelrel+1;i++)
    {
   //   cout<<"le b associe "<<bb[i]<<endl;
      int tsize=constraints[i].blocks->blocksize;
      COEFF* tmp= new COEFF[tsize*tsize];
     // cout<<"taille "<<tsize<<endl;
      for(int j;j<tsize*tsize;j++)
    tmp[j]=0;
      for(int j=1;j<=constraints[i].blocks->numentries;j++)
    tmp[constraints[i].blocks->iindices[j]-tsize-1+
        constraints[i].blocks->jindices[j]*tsize]=
      constraints[i].blocks->entries[j];
#ifdef DEBUGSDP 
     for(int j=0;j<tsize;j++)
    {
      for(int jj=0;jj<tsize;jj++)
        cout<<tmp[tsize*(jj)+j]<<" ";
      cout<<endl;
    }
      cout<<endl;
#endif
    }
  char nom[50];
  static int d=0;
  sprintf(nom,"ficprob_%d",d++);
  write_prob(nom,tmpsize,
         nbhankelrel+nbconstraint,C,bb,constraints);
  //Precision(53);      
  cout<<"SDP of size : "<<stockksur2.size()<<"x"<<nbhankelrel+
    nbconstraint<<endl; 
  initsoln(tmpsize,nbhankelrel+nbconstraint,
       C,bb,constraints,&X,&y,&Z);
  struct timeval tvini, tvfin;
  gettimeofday(&tvini,NULL);
  int return_code=easy_sdp((int)stockksur2.size(),nbhankelrel+
               nbconstraint,
       C,bb,constraints,(COEFF)(0.0),&X,&y,&Z,&pobj,&dobj);
  //Precision(350);
  gettimeofday(&tvfin,NULL);
  tempsCDSP+=tvfin.tv_sec-tvini.tv_sec+1e-6*(tvfin.tv_usec-tvini.tv_usec);
  // write_sol("prob.sol",tmpsize,nbhankelrel+nbconstraint,X,y,Z);
  //
  //
  //
  // A ce niveau la il faut verifier le rang
  // Le cas echeant recuperer le kernel
  //
  cout<<"pobj "<<pobj<<" dobj "<<dobj<<" diff "<<pobj-dobj<<endl;
//  cout<<"return code "<<return_code<<endl;
  if (1||return_code==8)//c le code de retour indiquant une singularite
    {
      long n=stockksur2.size();
      COEFF *matdense=new COEFF[n*n];
      COEFF *V=new COEFF[n*n];
      COEFF *S=new COEFF[n];
      COEFF *work=new COEFF[16*n];
      long lwork=16*n,info;
      long k=0;//servira pour le rang0
      for(int j=0;j<n*n;j++)
    matdense[j]=0;
      /*
    Warning !!!
    je ne traite pas les differetn cas des blocks de X
    il peuvent etre soit DIAG soit MATRIX
    soit PACKEDMATRIX (on peut s'en passez il y a invalid dasn writesol
      */

      //
      //on est pas de rang plein
      //
      //il faut calculer le noyau
      //
      //
#ifdef DEBUGSDP
      for(int i=1;i<=nbconstraint+nbhankelrel;i++)
    cout<<"y "<<i<<" "<<y[i]<<endl;
      cout<<"nombre de blocks de X "<<X.nblocks<<endl;
#endif
      for(int i=1;i<=X.nblocks;i++)
    {
      //Pour chque block il faut regarder son noyau
      struct blockrec<COEFF> tmp=X.blocks[i]; 
      //
      //On recopie le bloc en dense
      //    
#ifdef DEBUGSDP
      cout<<"n _________________________________ "<<n<<endl;
      cout<<"blockcat "<<tmp.blockcategory<<" "<<k<<endl;
#endif
      switch(tmp.blockcategory)
        {
        case DIAG:
          for(int j=1;j<=tmp.blocksize;j++)
        matdense[n*(k+j-1)+(k+j-1)]=tmp.data.vec[j];
#ifdef DEBUGSDP
          for(int j=1;j<=tmp.blocksize;j++)
        {
          for(int jj=1;jj<=tmp.blocksize;jj++)
            cout<<matdense[n*(k+jj-1)+j-1]<<" ";
          cout<<endl;
        }
          cout<<endl;
#endif
          break;
        case MATRIX:
          for(int j=1;j<=tmp.blocksize;j++)
        for(int jj=1;jj<=tmp.blocksize;jj++)
          matdense[n*(k+jj-1)+j-1]=
            tmp.data.mat[tmp.blocksize*(jj-1)+j-1];
#ifdef DEBUGSDP
          for(int j=1;j<=tmp.blocksize;j++)
        {
          for(int jj=1;jj<=tmp.blocksize;jj++)
            cout<<matdense[n*(k+jj-1)+j-1]<<" ";
          cout<<endl;
        }
#endif     
      }
      k+=tmp.blocksize;
  
    }
      //
      //On calcul le noyau
      //
      dgesvd_((char*)"N",(char*)"A",&n,&n,matdense,
          &n,S,(COEFF*)NULL,&n,V,&n,work,&lwork,&info);
#if 1
      cout<<"info svd "<<info<<endl;
      cout<<"val singulieres "<<endl;
      for(k=0;k<n;k++)
    cout<<S[k]<<" ";
      cout<<endl;
#endif
      for(k=1;k<n;k++)
    //if(S[0]>S[k]*1e6) break;//MAGIC
    if((abs(S[k-1])==0) || (abs(S[k-1])>abs(S[k])*1e6)) break;//MAGIC
      //#ifdef DEBUGSDP     
 cout<<"----k ici "<<k<<" et n "<<n<<endl;
 //#endif
      for(int j=1;j<=n;j++)
    {
      for(int jj=1;jj<=n;jj++)
        cout<<V[n*(jj-1)+j-1]<<" ";
      cout<<endl;
    }
      //
      //On construit les nouvelles equations 
      //
      for(;k<n;k++)
    {
#ifdef DEBUGSDP
      cout<<"equation dans le noyau"<<endl;
#endif
      typedef typename typP::value_type polyalp;
      polyalp tmp(0); 
      for(typename list<typename typserv::monom_t>::iterator 
        iter=stockksur2.begin();
          iter!=stockksur2.end();iter++)
        {
          
          //cout<<"dans construct eq "<<k<<" map "<<mapintcolonne[*iter]<<endl;
      //cout<<V[k+n*(mapintcolonne[*iter]-1)]<<" "<<*iter<<" ";
          if(!Iszero(abs(V[k+n*(mapintcolonne[*iter]-1)])))
        
        {
          //      cout<<"tmp avant"<<endl<<tmp<<endl;
          //cout<<"ajout "<<endl<<polyalp(*iter*V[k+n*(mapintcolonne[*iter]-1)])<<endl;
          tmp+=polyalp(*iter*(COEFF)V[k+n*(mapintcolonne[*iter]-1)]);
          //cout<<"tmp aapre"<<endl<<tmp<<endl;
        }
          //iter->first;// est le monome
          //iter->second;//est l'entier associé     }
//    cout<<endl;
//    cout<<"g trouve ca comme nvlle eq "<<endl<<tmp<<endl;
      newpol.push_back(tmp); 
         
    }
      delete[] S;
      delete[] V;
      delete[] work;
      delete[] matdense;
    }
  for(int i=1;i<nbconstraint;i++)
    {
      free(constraints[i].blocks->iindices);
      free(constraints[i].blocks->jindices);
      delete [] constraints[i].blocks->entries;
      delete [] constraints[i].blocks;
    }
  delete [] constraints;
  delete [] bb;
  delete [] C.blocks[1].data.mat;
  delete [] C.blocks;
  // il faut desallouer les contraintes mieux (les matrices pointees
  //il faut desalluer C
  //Precision(53);
  //cout<<"en sortie "<<newpol.empty()<<endl;
}

#include"genekersdpa.hpp"

template<typename typmatmap, typename typserv>
void  write_to_sdpa_fic(typmatmap &matrixmap,  int &dim, typserv &serv, 
            int d)
{
  ofstream tmpfic;
  typename typserv::monom_t m(1);
  COEFF *tmpval=matrixmap[m];
  char nomdufic[50];
  sprintf(nomdufic,"tmpfile_%d",d);
  tmpfic.open(nomdufic);
  tmpfic<<setprecision(80);
  tmpfic<<"\" Ceci est un message \""<<endl;
  tmpfic<<matrixmap.size()-1<<" =  mDIM"<<endl;
  tmpfic<<1<<" =  nBLOCK"<<endl;
  tmpfic<<dim<<" =  bLOCKsTRUCT"<<endl;
  tmpfic<<"{";
  for(int i=0;i<((long)matrixmap.size())-2;i++)
    tmpfic<<"0,";
  tmpfic<<"0}"<<endl;
  tmpfic<<"{";
  for(int i=0;i<dim-1;i++)
    {
      tmpfic<<"{";
      for(int j=0;j<dim-1;j++)
    {
      //cout<<(-1*matrixmap[m][i*dim+j])<<" ";
      tmpfic<<(COEFF)(-1*matrixmap[m][i*dim+j])<<",";
    }
      cout<<endl;
      tmpfic<<(COEFF)(-1*matrixmap[m][i*dim+dim-1])<<"},";
    }
  tmpfic<<"{";

  for(int j=0;j<dim-1;j++)
    tmpfic<<-1*matrixmap[m][(dim-1)*dim+j]<<",";
  tmpfic<<-1*matrixmap[m][dim*dim-1]<<"}}"<<endl;
 
  matrixmap.erase(matrixmap.find(m));
  for(typename typmatmap::iterator itermat=matrixmap.begin();
      itermat!=matrixmap.end();itermat++)
    {
      //cout<<"matrice de "<<itermat->first<<endl;
      COEFF *tt=itermat->second;
      tmpfic<<"{";
      for(int i=0;i<dim-1;i++)
    {
      tmpfic<<"{";
      for(int j=0;j<dim-1;j++)
        tmpfic<<tt[i*dim+j]<<",";
      tmpfic<<tt[i*dim+dim-1]<<"},";
    }
      tmpfic<<"{";
      
      for(int j=0;j<dim-1;j++)
    tmpfic<<tt[(dim-1)*dim+j]<<",";
      tmpfic<<tt[dim*dim-1]<<"}}"<<endl;
      
    }
  matrixmap[m]=tmpval;
  tmpfic.close();
}

template<typename typmatmap, typename coeff, typename typserv>
void read_sol_from_sdpa(coeff *&sol, typmatmap &matmap,int dim, typserv &serv)
{
  typedef typename typserv::monom_t mon;
  ifstream tmpfic;
  string ligne,ligne2;
  typename string::iterator debut;
  int i;
  coeff *xVec,*xMat;
  stringstream tmpstr;
  system(
     "perl -i.bak -0777 -ne 'if (/^xMat *= *(.*)(?=yMat)/ms) {$toto=$1; $toto=~s/[[:blank:]{}]\\+?//g; $toto=~s/,\\+?/ /g; print $toto}' lenom"      // "perl -0777 -i.bak -ne '/^xMat *= *(.*)(?=yMat)/ms and $toto=$1 and $toto=~s/[[:blank:]{}]\\+?//g and $toto=~s/,\\+?/ /g and print $toto' lenom"
     );
  tmpfic.open("lenom");
#if 0
  tmpfic>>ligne;//chaine Xvec
  cout<<"ligne xVec :"<<ligne<<endl;
  tmpfic>>ligne;// les coordonnées interessantes
  cout<<"ligne coordq :"<<ligne<<endl;
  dim=count(ligne.begin(),ligne.end(),'i')+1;
  xVec=new coeff[dim];
  sol=new coeff[dim*dim];
  i=0;
  int tmpindex;
  for(string::iterator iter=ligne.begin()+1;iter!=ligne.end();
      iter=ligne.begin()+tmpindex+1)
    {
      stringstream tmpstr;
      cout<<"iter "<<iter-ligne.begin()<<endl;
      tmpindex=ligne.find(",",iter-ligne.begin());
      if (tmpindex==string::npos) tmpindex=ligne.size()-1;
      cout<<"tmpindex "<<tmpindex<<endl;
      copy(iter,ligne.begin()+tmpindex,ostream_iterator<char>(tmpstr,""));
      tmpstr>>ligne2;
      cout<<"eeeee "<<ligne2<<" "<<ligne.find(",",iter-ligne.begin())<<endl;
      tmpstr<<ligne2;
      tmpstr>>xVec[i++];
      cout<<"i "<<i<<endl;
    }
#endif
  //en theorie maintenant on a xVec
#if 0  
  tmpfic>>ligne;//chaine xMat
  cout<<"ligne xmat :"<<ligne<<endl;
  tmpfic>>ligne;//chaine '{'
  for(i=0;i<dim;i++)
    {
      tmpfic>>ligne;// les coordonnées interessantes
      int j=0;
      for(string::iterator iter=ligne.begin()+ligne.find_last_of('{');
      iter!=ligne.end();
      iter=ligne.begin()+ligne.find(",",iter-ligne.begin()))
    {
      stringstream tmpstr;
      //      copy(iter,ligne.begin()+ligne.find(',',iter-ligne.begin())
      //     ,ostream_iterator<char>(tmpstr,""));
      int toto=ligne.find(",",iter-ligne.begin());
      cout<<"ligne "<<ligne<<endl;
      cout<<"toto "<<toto<<" "<<string::npos<<endl;
      if(toto==string::npos) toto=ligne.size()-2;
      cout<<"toto "<<toto<<" "<<string::npos<<endl;
      tmpstr<<ligne.substr(iter-ligne.begin(),toto);
        tmpstr>>xMat[dim*j++ + i];
    }
    }
#endif
  //maintenant on a relu le xVec et le Xmat
  //Reconstruction de la solution
  sol=new coeff[dim*dim];
  for(int i=0;i<dim*dim;i++)
    {
      tmpfic>>sol[i];
    } 
  tmpfic.close();
  cout<<"Solution "<<endl;
  for(int i=0;i<dim*dim;i++)
    cout<<sol[i]<<" ";
  cout<<endl;
  // copy(sol,sol+dim*dim,ostream_iterator<string>(cout," "));
#if 0
for(int i=0;i<dim*dim;i++)
    sol[i]+=matmap[mon(1)][i];
  matmap.erase(matmap.find(mon(1)));
  int j=0;
  for(typename typmatmap::iterator itermat=matmap.begin();
      itermat!=matmap.end();itermat++)
    {
      for(int i=0;i<dim*dim;i++)
    sol[i]-=xVec[j]*itermat->second[i];
      j++;
    }
#endif
}

template<typename typP, typename typdump,typename Base, typename typserv>
void generickernelsdpa(typP &newpol, int k, 
           const typdump &dump, Base &b, typserv &serv)
{
  typedef typename typP::value_type::order_t ord;
  typedef typename typserv::monom_t Monomial;
  //
  //Allocation du problem et des
  //contraintes
  COEFF * C;
  map<Monomial,COEFF*,ord> matrixmap;
  int i;
  
  //
  //On introduit un variable par monome de degre d en dehors de B
  //On va contruire l'operateur de de Hankel associé
  //
  
  //
  //On commence par enumerer les monomes de degre plus petit que k
  //
  //
  typP stockprod,stockproj;//dans stockprod on a des polynomes
  //
  //
  //
  int nbconstraint=0;
  typedef  list<typename typserv::monom_t> typstock;  
  list<typename typserv::monom_t> stockmon,stockksur2;
  map<mon,int,ord> mapintligne,mapintcolonne,maphankel;
  enumeratemon(stockmon,k,b,dump);
  //
  //ICI on cree un index pour le monomes de degre k
  //il n'a a priori rien a voir avec int2mon/mon2int du reste du code 
  //sic.....
  enumeratemon(stockksur2,k/2,b,dump);
  //
  //pour le suite il nous faut les monomes de B de degre <=k/2
  //

  for(typename list<typename typserv::monom_t>::iterator 
    iter=stockksur2.begin(); iter!=stockksur2.end();iter++)
    if(!IsinB(*iter,b)) stockksur2.erase(iter--);
  i=1;
  for(typename list<typename typserv::monom_t>::iterator 
    iter=stockksur2.begin();iter!=stockksur2.end();iter++,i++)
    { 
      int j=1;
      for(typename list<typename typserv::monom_t>::iterator 
    iter2=stockksur2.begin();iter2!=stockksur2.end();iter2++,j++)
    {
      typename typserv::monom_t mono=*iter * (*iter2);
//    cout<<"monome "<<mono<<" "<<i<<" "<<j<<endl;
      if (!mapintligne.count(mono))
        {
          mapintligne[mono]=i;
          mapintcolonne[mono]=j;
        }
    }
    }
  //cout<<"passé"<<endl;

  // 
  //  On  genere les formes normales des produits de monomes de
  // de tous les monomes de   degre <=k/2 dez B.
  //
  int dim=stockksur2.size();
  for(typename typstock::iterator i=stockmon.begin();
      i!=stockmon.end();i++)
    if(IsinB(*i,b))
       {
     cout<<"ici "<<*i<<" dim "<<dim<<endl;
     matrixmap[*i]=new COEFF [dim*dim];
     for(int ii=0;ii<dim*dim;ii++)
       matrixmap[*i][ii]=0;
       }
  

 int ii=0;
 cout<<"coiucou"<<endl;
  for(typename typstock::iterator i=stockksur2.begin();
      i!=stockksur2.end();i++,ii++)
    {
      int jj=ii;
      cout<<"coiucou"<<endl;
      for(typename typstock::iterator j=i;j!=stockksur2.end();jj++,j++)
    {
       
      typename typserv::monom_t tmpmon=(*j)*(*i);
      //cout<<"coiucoufffffff "<<tmpmon<<endl;
      if (IsinB(tmpmon,b))
        {
          matrixmap[tmpmon][ii*dim+jj]+=1;
          if(ii!=jj)
        matrixmap[tmpmon][jj*dim+ii]+=1;
        }
      else
        {
          typP tmplist;
          tmplist.push_back(tmpmon);
          proj(tmplist,dump,b,serv);
          // cout<<"ici tmpmon "<<tmpmon<<endl;
          //cout<<"tmplist.front "<<tmplist.front()<<endl;
          for(typename typP::value_type::iterator iter=tmplist.front().begin();
          iter!=tmplist.front().end();iter++)
        {
          Monomial verytmpmon=*iter;
          verytmpmon.SetCoeff(1);
          //cout<<"tmpmon "<<verytmpmon<<" "<<*iter<<endl;
          matrixmap[verytmpmon][ii*dim+jj]+=iter->GetCoeff();
          if(ii!=jj)
            matrixmap[verytmpmon][jj*dim+ii]+=iter->GetCoeff();

        }
        }
    }
    }
 
  if(dim>1)
    {
      struct timeval tvini, tvfin;
      COEFF *sol;
      static int d=0;
      static char nom[1024];
      gettimeofday(&tvini,NULL);
      cout<<"coucou dim "<<dim<<endl;
      write_to_sdpa_fic(matrixmap,dim,serv,d);
      sprintf(nom,"sdpa_gmp -dd tmpfile_%d -o lenom",d++);
      system(nom);
      read_sol_from_sdpa(sol,matrixmap,dim,serv);
      
      
      gettimeofday(&tvfin,NULL);
      tempsCDSP+=tvfin.tv_sec-tvini.tv_sec+1e-6*(tvfin.tv_usec-tvini.tv_usec);
    
      //
      //cout<<"coiucou"<<endl;
      // A ce niveau la il faut verifier le rang
      // Le cas echeant recuperer le kernel
      //
      //  cout<<"return code "<<return_code<<endl;
      long n=stockksur2.size();
      COEFF *V=new COEFF[n*n];
      COEFF *S=new COEFF[n];
      COEFF *work=new COEFF[16*n];
      long lwork=16*n,info;
      long kk=0;//servira pour le rang 0
      dgesvd_((char*)"N",(char*)"A",&n,&n,sol,
          &n,S,(COEFF*)NULL,&n,V,&n,work,&lwork,&info);
#if 1
      cout<<"info svd "<<info<<endl;
      cout<<"val sing"<<endl;
      for(kk=0;kk<n;kk++)
    cout<<S[kk]<<" ";
      cout<<endl;
#endif
      cout<<"coiucou"<<endl;
      for(kk=1;kk<n;kk++)
    //if(S[0]>S[k]*1e6) break;//MAGIC
    if((abs(S[kk-1])==0) ||(abs(S[kk-1])>abs(S[kk])*1e6)) break;//MAGIC
#if 1     
      cout<<"kk ici "<<kk<<" et n "<<n<<endl;
#endif
      for(int j=0;j<n;j++)
    {
      for(int jj=0;jj<n;jj++)
        cout<<V[n*(jj)+j]<<" ";
      cout<<endl;
    }
      //
      //On construit les nouvelles equations 
      //
      for(;kk<(int)n;kk++)
    {
#if 1
      cout<<"equation dans le noyau"<<endl;
#endif
      typedef typename typP::value_type polyalp;
      polyalp tmp(0); 
      for(typename list<typename typserv::monom_t>::iterator 
        iter=stockksur2.begin();
          iter!=stockksur2.end();iter++)
        {
          
          //cout<<"dans construct eq "<<k<<" map "<<mapintcolonne[*iter]<<endl;
          //cout<<V[k+n*(mapintcolonne[*iter]-1)]<<" "<<*iter<<" ";
          if(!Iszero(abs(V[kk+n*(mapintcolonne[*iter]-1)])))
        
        {
          //      cout<<"tmp avant"<<endl<<tmp<<endl;
          //cout<<"ajout "<<endl<<polyalp(*iter*V[k+n*(mapintcolonne[*iter]-1)])<<endl;
          tmp+=polyalp(*iter*(COEFF)V[kk+n*(mapintcolonne[*iter]-1)]);
          //cout<<"tmp aapre"<<endl<<tmp<<endl;
        }
          //iter->first;// est le monome
          //iter->second;//est l'entier associé
     }
      //      cout<<endl;
      cout<<"g trouve ca comme nvlle eq "<<endl<<tmp<<endl;
      newpol.push_back(tmp); 
      
    }

      delete[] S;
      delete[] V;
      delete[] work;
      delete[] sol;
    }
}

template<typename typdump,typename Base, typename typserv>
int testsdp(int k, const typdump &dump,const Base &b,const typserv &serv)
{
  return !(k%2);
}
template<typename typP,typename typPk,typename typdump,typename Base
     , template<typename  T> class tmptypmat ,typename monomial_server>
void algo(typP P,typdump &dump,Base &b, monomial_server &serv)
{
#ifdef PEQUAN
  int toto=0;
  FILE *fic;
  char name[8];
#endif
  typedef typename typP::value_type polyalp;
  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;
  //typP recall 
  typPk recall;
  //Base b;
  workspace<typename typP::value_type::coeff_t> w;
  typedef tmptypmat<typename typP::value_type::coeff_t> typMat;
  typMat Mat,L;
  int onemoretime=1,nouveaumon,allpolused=0,maxdeg,k,*pr,*pc;
  cout<<"avant init"<<endl;
  
  init_algo<typMat>(P,nouveaumon,maxdeg,k,Pk,Mk,b,dump,w,serv);
  cout<<"apres init"<<endl;
  cout<<"onemoretime "<<onemoretime<<endl;
  cout<<"nouveaumon "<<nouveaumon<<endl;
  cout<<"k "<<k<<endl;
  cout<<"maxdeg "<<maxdeg<<endl;
#ifndef GROEBNER

  
  //  while((critere(b,k)==-1)||(k<=maxdeg))
#ifdef ONEMORETIME
  cout<<"one"<<endl;
  while(nouveaumon||(k<=maxdeg)||onemoretime)
#else
    while(nouveaumon||(k<=maxdeg))
#endif
#else
    while(!GB_stop(k)||(k<=maxdeg))
#endif
 
    {
#ifdef ONEMORETIME
       cout<<"two"<<endl;
       cout<<"nouveaumon"<<endl;
      if(!nouveaumon)
    cout<<"si"<<endl;
    onemoretime=0;
#endif
    //if (toto>=5) {exit(0);}
    //toto++;
        
    int killspol;
    //test si on est dans les conditions d'application
   gettimeofday(&initclock,NULL); 
   cout<<"onemoretime "<<onemoretime<<endl;
   cout<<"nouveaumon"<<nouveaumon<< endl;
   cout<<"k "<<k<<endl;
   cout<<"maxdeg "<<maxdeg<<endl;
   cout<<"testsdp(k,dump,b,serv) "<<testsdp(k,dump,b,serv)<<endl;
   if(testsdp(k,dump,b,serv)||(!onemoretime))
      //envoie la routine de calcul de sdp
      {
    int mindeg_newpol;
    typP newpol;
    cout<<"un nouveau tour de boucle et k vaut "<<k<<endl;
    if(!onemoretime)//sdpa!!!!!!!!
      //  generickernel(newpol,2*k,dump,b,serv);
     generickernel_testT(newpol,2*k,dump,b,serv);
      //  generickernelsdpa(newpol,2*k,dump,b,serv);
    else
      //  generickernel(newpol,k,dump,b,serv);
      generickernel_testT(newpol,k,dump,b,serv);
    //generickernelsdpa(newpol,k,dump,b,serv);
      gettimeofday(&tmpclock,NULL);
      tempsdssdp+=tmpclock.tv_sec-initclock.tv_sec+1e-6*(tmpclock.tv_usec-initclock.tv_usec);      

    //sdprealrad(newpol,dump,b,serv);
    //penser a decroitre k le cas echeant avec un coup de recover
    cout<<"newpol "<<newpol.empty()<<endl;
    if(!newpol.empty())
      {
        mindeg_newpol=Degree(newpol.front());
//      cout<<"mindeg "<<mindeg_newpol<<" k "<<k<<endl;
        for(typename typP::iterator iter=newpol.begin();
        iter!=newpol.end();iter++)
          mindeg_newpol=(mindeg_newpol<Degree(*iter)
                  ?mindeg_newpol:Degree(*iter));
        for(typename typP::iterator iter=newpol.begin();
        iter!=newpol.end();iter++)
          if(Degree(*iter)==mindeg_newpol)
        P.push_back(*iter);
        if(k>=mindeg_newpol)
          {
        list<mon *> exceed;
            list<int> sizeexceed;
        typPk tmpPk;
        conv_merge(tmpPk,newpol,exceed,sizeexceed,b,serv);
//      cout<<"merde merde k "<<k<<" mindeg_newpol "<<mindeg_newpol<<endl;
        k=mindeg_newpol;
        //      forget(b,dump,k,recall);
        //              recover(Pk,Mk,dump,k);
        recover(Pk,Mk,dump,k);

        //Listedejafait(Mk,Spoldejavu);
//      cout<<"Pk.size() apres recover "<<Pk.size()<<endl;
        if((k>0)||(k==-1))
          forget(b,dump,k,recall);
        else
          forget0(b,dump,k,recall);
//      cout<<"forget fait"<<endl;
        //forget(b,dump,k);
        NewCrochetchoix(P,Pk,Mk,tmpPk,k,dump,b,recall,w,serv);
        serv.compress(Pk,dump,b,k);
        cout<<"compress"<<endl;
        Dump(Pk,dump);
        continue;
          }
      }
      }
#ifdef BONRAJOUT
      for(typename Base::const_iterator p=b.begin();p!=b.end();p++)
        {
    for(int i=0;i<p->taille1;i++)
      {
        cout<<"p.accept[i] "<<p->accept[i]<<endl;
      }
    for(int i=0;i<p->taille2;i++)
      {
        cout<<"p.refuse[i] "<<p->refuse[i]<<endl;
      }
        }
#endif
#if 1//def DEB

    //cout<<"mon a la fin de la boulcle de l'algo "<<Mk.size()<<endl;
      //for(typename typMk::iterator iter=Mk.begin();iter!=Mk.end();iter++)
      // cout<<*iter<<endl;  
  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<<"les sizes "<<iter->size<<endl;
      {
    int cpt=0;
    cout<<invconv<typename typP::value_type>(*iter,serv)<<endl;       
    for(int i=0;i<iter->sizenf;i++)
      for(int j=0;j<8;j++)
        if (((iter->nfind[i]>>j)&1) && (iter->nf[cpt++]==0))
          {
        cout<<"ici ca couille a la place"<<8*i+j<<endl;
        cout<<iter->sizenf<<" "<<iter->size<<endl;
        exit(1);
          }
      }
#endif   

  //  cout<<"Spolordsup"<<endl;
    S=Spolordsup(Pk,b,Spoldejavu);
    //S.erase(S.begin(),S.end());
    //S=Spolordsup(Pk,b);
    cout<<endl;
    cout<<endl<<"newpkmkmatrixof"<<endl;
    //cout<<"Pk.size() "<<Pk.size()<<endl;
    //killspol=!newPkMkMatrixof(Mat,Pk,P,Mk,k,b,dump,recall,Spoldejavu);
    killspol=!newPkMkMatrixof(Mat,Pk,P,Mk,k,b,dump,recall,w,serv);
#ifdef PEQUAN
    sprintf(name,"mat%d",toto);
    fic=fopen(name,"w");
    printmatfile_pequan(Mat,fic);
    fclose(fic);
    toto++;
#endif
    //    if (toto>=5) {cout<<"killredspol "<<killspol<<endl; exit(0);}
    // killspol=!newPkMkMatrixof(Mat,Pk,P,Mk,k,b,dump);
    if(killspol) S.erase(S.begin(),S.end());
    if (k+1>=maxdeg) allpolused=1;
    if(Mk.size()==0) nouveaumon=0;
    //cout<<"j'en suis a k="<<k<<endl;
    //cout<<"Ici dans algo Mat"<<endl;
    //#ifdef BONRAJOUT
    //affdebug(Mat);
    //#endif
    //Solve affecte a Mat la valeur U
    //cout<<"solve"<<endl;
    //for(typename typPk::iterator iter=Pk.begin();iter!=Pk.end();iter++)
    //  cout<<"avant solve les ind "<<iter->ind<<endl;
    //for(typename typPk::iterator iter=Pk.begin();iter!=Pk.end();iter++)
    //  cout<<"avant solve les pol "<<invconv<Poly>(*iter)<<endl;
    //if(k==3) exit(-10);
    //for(typename typMk::iterator iter=Mk.begin();iter!=Mk.end();iter++)
    //  cout<<"monomes dans Mk "<<*iter<<endl;
    
    if (Mat.ncol!=0)
      {
    //cout<<"debut du solve"<<endl;
    Solve(Mat,L,Pk,&pr,&pc,w);
//  cout<<"fin du solve"<<endl;
    //for(int kk=0;kk<Mk.size();kk++)
    //  cout<<"permc "<<kk<<" "<<pc[kk]<<endl;
    inverse(pc,Mk.size());
    Dopermu(Mk,pc);
    {
      //ici on remet les ind a la bonne valuer 
      //a inclure dans une petite fonction inline apres
      int j=0;
      typename typMk::iterator itermon=Mk.begin();
      typename typPk::iterator iter;
      for(iter=Pk.begin();
          itermon!=Mk.end();iter++,itermon++,j++)
        {
          if(!Iszero(Mat(j,j)))
        {
          //          cout<<"ligne "<<j<<" je mets le monome "<<*itermon<<endl;
          iter->ind=*itermon*(iter->ind.GetCoeff());
        }
          else
        {
          iter->ind=mon(0);
        }
        }
      //for(;itermon!=Mk.end();iter++,itermon++)
      //  iter->ind=mon(0);
    }

    free(pr);
    free(pc);
      }

 //appliquer les permutation a MK!!!!!!!!
    // for(typename typPk::iterator iter=Pk.begin();iter!=Pk.end();iter++)
      //  cout<<"apres solve les ind "<<iter->ind<<endl;
    //for(typename typPk::iterator iter=Pk.begin();iter!=Pk.end();iter++)
    // cout<<"apres solve les pol "<<invconv<Poly>(*iter)<<endl;
    //
    //
    //APPLIQUER LES PERMUTYATIONS A MK!!
    //
    //
    //
    //
    if ((unsigned)my_rank(Mat)==Mk.size())
      //matrice de rang plein
      {
    typMk tmpSpoldejavu;
    typPk redspol,secd=secondmembre(Mat,Pk);;
    //secondmembre2(Mat,Pk,secd);
    //typename typPk::iterator iter=Pk.begin();
    cout<<"matrice de rang plein "<<endl;
    //for(unsigned int i=0;i<Mk.size();i++,iter++);
    //Pk.erase(iter,Pk.end());
    //cout<<"Dump "<<endl;
    Dump(Pk,dump);
    //cout<<"Reduce Spol "<<endl;
    
    ReduceSpol(S,dump,redspol,b,w,serv);//tmpSpoldejavu);
    //cout<<"secd.size() "<<secd.size()<<endl;
    my_merge(redspol,secd);
    if(redspol.size()==0)
      {
        //a voir....    Dump(Pk,dump);
        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;
        cout<<"redspol.size() "<<redspol.size()<<endl;
        //cout<<invconv<typename typP::value_type>(redspol.front())<<endl;
        if (tmpdeg==(k+1))
          my_merge(Spoldejavu,tmpSpoldejavu);
        k=tmpdeg;
        //cout<<"le mindeg ici vaut "<<k<<endl;
        //cout<<"Pk.size() avant recover "<<Pk.size()<<endl;
        recover(Pk,Mk,dump,k);

        //Listedejafait(Mk,Spoldejavu);
        //cout<<"Pk.size() apres recover "<<Pk.size()<<endl;
        forget(b,dump,k,recall);
        //forget(b,dump,k);
#ifdef DEB     
        cout<<"Pk.size() avant Crochetchoix "<<Pk.size()<<endl;
#endif     
        //NewCrochetchoix(P,Pk,Mk,redspol,k,dump,b,recall,Spoldejavu);
        NewCrochetchoix(P,Pk,Mk,redspol,k,dump,b,recall,w,serv);
        //NewCrochetchoix(P,Pk,Mk,redspol,k,dump,b);
#ifdef DEB     
        cout<<"Pk.size apres Crochetchoix "<<Pk.size()<<" et k "<<k<<endl;
#endif     
        NewDestroyredspol(redspol,Pk);
        serv.compress(Pk,dump,b,k);
        Dump(Pk,dump);
        L.destroystore();
        //misa jour de B dans crochet choix!!
        continue;
      }
      }
    else
      //la matrice n'est pas de rang plein
      {
    cout<<"matrice de rang pas plein "<<endl;
    typPk secd;
#ifdef BONRAJOUT
    AddB_dim(Mat,L,P,Pk,Mk,dump,b);
#else
    AddB(Mat,Pk,Mk,dump,b,serv);
#endif
    //
    //secondmembre supprime des trucs dans Pk!!
    //
    secd=secondmembre(Mat,Pk);
    rajoute_voisins(Pk,Mk,dump,b,w,serv);
    //ne selectionne que les non nuls
       if(secd.size()==0)
     {
       typPk redspol;
       //for(int i=Pk.size();i>rank(Mat);i--)
       //{
       //  if(Pk.back().size!=0)
       // MAC_REV_FREE<typename typMat::coeff_t>(Pk.rbegin()->nf
       //    ,Pk.rbegin()->size*sizeof(typename typMat::coeff_t));
       //  Pk.pop_back();
       //}//on vire les 0 avant de dumper
       //      AddB(Mat,Pk,Mk,dump,b);
       Dump(Pk,dump);
       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)
         {
           // forget(b,dump,k);
           //AddB(Mat,Pk,Mk,b);
           //Dump(Pk,dump);
           //ici on modifie Pk dans AddB 
           //<=> forget(b,dump,k) AddB(..) Dump(Pk,dump);
           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);
           //Listedejafait(Mk,Spoldejavu);
           forget(b,dump,k,recall);
           //forget(b,dump,k);
           cout<<"il ya un passage par mat rang pas"
               <<"plein et pol non zero"<<endl;
           //NewCrochetchoix(P,Pk,Mk,redspol,k,dump,b,recall,Spoldejavu);
           NewCrochetchoix(P,Pk,Mk,redspol,k,dump,b,recall,w,serv);
           //NewCrochetchoix(P,Pk,Mk,redspol,k,dump,b);
           NewDestroyredspol(redspol,Pk);
           serv.compress(Pk,dump,b,k);
           Dump(Pk,dump); 
           L.destroystore();
           continue;
         }
     }
       else
     {
       //on a des pol qui se reduisent pas a 0
       //cad un defaut de commuatation dans les coins
       typPk redspol;
       //for(int i=Pk.size();i>rank(Mat);i--)
       //  Pk.pop_back();
       //cout<<"PK. size "<<Pk.size()<<" Mat.nbcol "<<Mat.ncol<<endl;
       //cout<<"rank(Mat) "<<rank(Mat)<<endl;
       //int j=0;
       //cout<<"avant recover et meme avant le dump "<<endl;
       //for(typename typPk::iterator iter = secd.begin();iter!=secd.end()
       //    ;iter++,j++)
       // cout<<"pol de secd num "<<j<<endl<<invconv<Poly>(*iter)<<endl;
       //      AddB(Mat,Pk,Mk,b);
       //cout<<"apres ADDB le dump "<<endl;
       //for(typename typPk::iterator iter = Pk.begin();iter!=Pk.end()
       //    ;iter++)
       // cout<<invconv<Poly>(*iter)<<endl;
       Dump(Pk,dump);
       //cout<<"secd.size()" <<secd.size()<<endl;
       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);
       //cout<<"k "<<k<<endl;
       //Listedejafait(Mk,Spoldejavu);
       //cout<<"apres recover"<<endl;
       //      for(typename typPk::iterator iter = Pk.begin();iter!=Pk.end()
       //    ;iter++)
       //  cout<<invconv<Poly>(*iter)<<endl;
       //cout<<"les Spol non reduits"<<endl;
       //for(typename typPk::iterator iter = secd.begin();iter!=secd.end()
       //    ;iter++)
       //  cout<<invconv<Poly>(*iter)<<endl;
       forget(b,dump,k,recall);
       
       //forget(b,dump,k);
       //cout<<"il ya un passage par mat pas rang plein et Spol non zero"<<endl;
       //for(typename typPk::iterator iter = secd.begin();iter!=secd.end()
       //    ;iter++)
       // cout<<invconv<Poly>(*iter)<<endl;
       //NewCrochetchoix(P,Pk,Mk,redspol,k,dump,b,recall,Spoldejavu);
       NewCrochetchoix(P,Pk,Mk,secd,k,dump,b,recall,w,serv);
       //NewCrochetchoix(P,Pk,Mk,secd,k,dump,b);
       NewDestroyredspol(secd,Pk);
#ifdef BONRAJOUT
       cout<<"Apres NewCrochetchoix"<<endl;

       for(typename Base::const_iterator p=b.begin();p!=b.end();p++)
         {
           for(int i=0;i<p->taille1;i++)
         {
           cout<<"p.accept[i] "<<p->accept[i]<<endl;
         }
           for(int i=0;i<p->taille2;i++)
         {
           cout<<"p.refuse[i] "<<p->refuse[i]<<endl;
         }
         }
#endif
       //for(typename typPk::iterator iter = Pk.begin();iter!=Pk.end()
       //    ;iter++)
       // cout<<invconv<Poly>(*iter)<<endl;
       serv.compress(Pk,dump,b,k);
       Dump(Pk,dump);
       L.destroystore();
       continue;
     }
      
      }
  }
  
  Mat.destroystore();
  //while nouveau mon etc...
  // Pk=recomposePk(dump);
  //return Pk;
  //  return;
#ifdef DEBUG
  for(typename Base::const_iterator p=b.begin();p!=b.end();p++)
    {
      for(int i=0;i<p->taille1;i++)
    {
      cout<<"p.accept[i] "<<p->accept[i]<<endl;
    }
      for(int i=0;i<p->taille2;i++)
    {
      cout<<"p.refuse[i] "<<p->refuse[i]<<endl;
    }
    }
#endif
  destroy_space(&w);
  cout<<"sortie d'algo flash et dimension "<<endl;//<<critere(b,k)<<endl;
  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.. :-)

    }

template<typename typP,typename typPk,typename typdump,typename Base
     , template<typename  T> class tmptypmat ,typename monomial_server>
void algo(typP P,typdump &dump,Base &b, monomial_server &serv,typP F)
{
#ifdef PEQUAN
  int toto=0;
  FILE *fic;
  char name[8];
#endif
  typedef typename typP::value_type polyalp;
  typedef list<typename typPk::value_type::monom_t> typMk;
  typedef typename typMk::value_type mon;
  typedef typename typPk::value_type pol;
  cout<<"entra aqui "<<endl; 
  typMk Mk;
  typMk Spoldejavu;
  typPk Pk,S;
  typPk recall;
  typP Pini;
  workspace<typename typP::value_type::coeff_t> w;
  typedef tmptypmat<typename typP::value_type::coeff_t> typMat;
  typMat Mat,L;
  int onemoretime=1,nouveaumon,allpolused=0,maxdeg,k,maxdegb,kb,*pr,*pc,optimo=0,k1;
  int nogap=0,deg=0,nok=1, noreduced=0, kbon,kini;
 
  typP newpol,newpol1;
  COEFF *sol2,*sol3;
  cout<<"avant init"<<endl;
  
  init_algo<typMat>(P,nouveaumon,maxdeg,k,Pk,Mk,b,dump,w,serv);
  Pini=P;
  kini=k;
  cout<<"apres init"<<endl;
  cout<<"onemoretime "<<onemoretime<<endl;
  cout<<"nouveaumon "<<nouveaumon<<endl;
  cout<<"k "<<k<<endl;
  cout<<"maxdeg "<<maxdeg<<endl;
#ifndef GROEBNER
 
#ifdef ONEMORETIME
  cout<<"one"<<endl;
  while(nouveaumon||(k<=maxdeg)||onemoretime)
#else
    while(nouveaumon||(k<=maxdeg)|| (!optimo) || nok )//|| (k!=deg))

#endif
#else
    while(!GB_stop(k)||(k<=maxdeg))
#endif
 
    {
#ifdef ONEMORETIME
       cout<<"two"<<endl;
       cout<<"nouveaumon"<<endl;
      if(!nouveaumon)
    cout<<"si"<<endl;
    onemoretime=0;
#endif
    
        
    int killspol;
    //test si on est dans les conditions d'application
   gettimeofday(&initclock,NULL); 
   cout<<"onemoretime "<<onemoretime<<endl;
   cout<<"nouveaumon"<<nouveaumon<< endl;
   cout<<"k "<<k<<endl;
   cout<<"maxdeg "<<maxdeg<<endl;
   cout<<"testsdp(k,dump,b,serv) "<<testsdp(k,dump,b,serv)<<endl;
   for(typename Base::const_iterator p=b.begin();p!=b.end();p++)
        {
    for(int i=0;i<p->taille1;i++)
      {
        cout<<"p.accept[i] "<<p->accept[i]<<endl;
      }
    for(int i=0;i<p->taille2;i++)
      {
        cout<<"p.refuse[i] "<<p->refuse[i]<<endl;
      }
        }
//todo este if es por ver si el noyau de k+1 se reduce con la base que hemos calculado o no   
//hay un problema en la reinicializacion de las variables cuando el noyau no se reduce
     cout<<"k"<<k<<endl;
     cout<<"maxdeg"<<maxdeg<<endl;
     cout<<"optimo"<<optimo<<endl;
     cout<<"nok"<<nok<<endl;
 

//   if(testsdp(k,dump,b,serv)||(!onemoretime))
     if((testsdp(k,dump,b,serv) && (!optimo)) || (k==deg))
      //envoie la routine de calcul de sdp
      {
    int mindeg_newpol;
    
    
    
    
    cout<<"un nouveau tour de boucle et k vaut "<<k<<endl;
//  if(!onemoretime)//sdpa!!!!!!!!  
//   generickernel_testF(newpol,2*k,dump,b,serv,F,*&sol2);
//  else
    
    cout<<"deg"<<deg<<endl;
    
      if (nogap)
      {
      cout<<"sol3"<<k<<endl;
      cout<<"kbon"<<kbon<<endl;
      if (k==deg)
      { cout<<"pasas por aqui"<<endl;
        newpol1.erase(newpol1.begin(),newpol1.end());
//      newpol=newpol1;
        
        for(typename typP::iterator iter=newpol.begin();iter!=newpol.end();
            iter++)
           {
             cout<<*iter<<" ";
             cout<<endl;
           }
      } 
     
      
      newpol1.erase(newpol1.begin(),newpol1.end());
//#ifdef CSDP
//    generickernel_testTT(newpol1,k,dump,b,serv,F,*&sol3);
//#else
      generickernel_testF(newpol1,k,dump,b,serv,F,*&sol3);
//#endif
      cout<<"solucionprimal k"<< sol2[2] << endl;
        cout<<"solucionprimal k+1"<< sol3[2] << endl;
        cout<<"diferenciasprimales"<<abs(sol2[2]-sol3[2])*1e+1<<endl;
        cout<<"k1"<<k1<<endl;
        cout<<"k"<<k<<endl;
        cout<<"gap"<<abs(sol3[2]-sol3[3])*1e+4<<endl;
        cout<<"deg"<<deg<<endl;
        cout<<"!newpol.empty()"<<!newpol.empty()<<endl;
        cout<<"newpol1.empty()"<<newpol1.empty()<<endl;
        
     
        if (((abs(sol2[2]-sol3[2])*1e+1<1) && (!newpol.empty()) && (k1!=k))
          || ((k==deg)) )
//      if ((abs(sol3[0])*1e+5<1) && (abs(sol2[2]-sol3[2])*1e+5<1) && (!newpol.empty()) && (k1!=k))
         
        {  
         if (k==deg && newpol1.empty())  
          {
        
        nok=0;
        continue;
        
          }
          else
          {
        if (k!=deg)
        {  
          optimo=1;  
          deg=k+2;
          cout<<"deg dentro"<<deg<<endl;
          int numkerf=0;
             cout<<"noyau bon"<<endl;
             for(typename typP::iterator iter=newpol.begin();iter!=newpol.end();
             iter++,numkerf++)
           {
             cout<<*iter<<" ";
             cout<<endl;
           }
         mindeg_newpol=Degree(newpol.front());
         cout<<"mindeg "<<mindeg_newpol<<" k1 "<<k1<<endl;
         for(typename typP::iterator iter=newpol.begin();
        iter!=newpol.end();iter++)
          mindeg_newpol=(mindeg_newpol<Degree(*iter)
                  ?mindeg_newpol:Degree(*iter));
         cout<<"mindeg "<<mindeg_newpol<<" k1 "<<k1<<endl; 
        }
        if (k==deg && (!newpol.empty()))
        { 
//       for(typename typP::iterator iter=newpol1.begin();
//      iter!=newpol1.end();iter++)
//       newpol.push_back(*iter);
//       for(typename typP::iterator iter=newpol.begin();iter!=newpol.end();
//             iter++)
//         {
//             cout<<*iter<<"newpol2fois ";
//             cout<<endl;
//         }
                 newpol.erase(newpol.begin(),newpol.end());
         newpol=newpol1;
         mindeg_newpol=Degree(newpol.front());
         cout<<"mindeg2fois"<<mindeg_newpol<<endl;
        }
//      nok=0;
        
//       for(typename typP::iterator iterP=P.begin();
//      iterP!=P.end();iterP++)
//       newpol.push_back(*iterP);
         P.erase(P.begin(),P.end());
        for(typename typP::iterator iter=newpol.begin();
        iter!=newpol.end();iter++)
          if(Degree(*iter)==mindeg_newpol)
        P.push_back(*iter);
        if(k-2>=mindeg_newpol)
          {
        list<mon *> exceed;
            list<int> sizeexceed;
        typPk tmpPk;
        conv_merge(tmpPk,newpol,exceed,sizeexceed,b,serv);
        k=mindeg_newpol;
                
//      if (!nok) deg=0;
//      else deg=k*2;
        cout<<"k noyau bon"<< k<<endl;
        
        
        recover(Pk,Mk,dump,k);


//      cout<<"Pk.size() apres recover "<<Pk.size()<<endl;
        if (k!=deg)
        {
        if((k>0)||(k==-1))
          forget(b,dump,k,recall);
        else
          forget0(b,dump,k,recall);
        }

        NewCrochetchoix(P,Pk,Mk,tmpPk,k,dump,b,recall,w,serv);
        for(typename typP::iterator iter=P.begin();iter!=P.end();
                 iter++)
                 cout<<*iter<<" ";
                 cout<<endl;
        serv.compress(Pk,dump,b,k);
        cout<<"compress"<<endl;
        Dump(Pk,dump);

        continue;
          }
          }
        }
        else
        {
          
          cout<<"pasa por aqui cambiamos"<<endl;
          sol2=sol3;
          newpol=newpol1;
          
          
       } 
      }
      else
      {
      cout<<"sol2"<<k<<endl;  
      k1=k;
      newpol.erase(newpol.begin(),newpol.end());
//#ifdef CSDP
//    generickernel_testTT(newpol,k,dump,b,serv,F,*&sol2);
//#else
      generickernel_testF(newpol,k,dump,b,serv,F,*&sol2);
//#endif
      int numker=0;
          
           for(typename typP::iterator iter=newpol.begin();iter!=newpol.end();
            iter++,numker++)
          cout<<*iter<<" ";
          cout<<endl;
      cout<<"newpol "<<newpol.empty()<<endl;
      cout<<"numker"<<numker<<endl;
      //pour le case de polynome dans degree 2
      if (k==2 && maxdeg==1)
      {
        nogap=1;
        optimo=1;
        nok=0;
        
      }
      else{
        
      cout<<"gap"<<sol2[0]<<endl;
      cout<<"gapx"<<abs(sol2[0])*1e+4<<endl;
      if (abs(sol2[0])*1e+4<1){
        nogap=1;
        for(typename typP::iterator iter=newpol.begin();iter!=newpol.end();
        iter++,numker++)
          cout<<*iter<<" ";
        cout<<endl;
        cout<<"newpol "<<newpol.empty()<<endl;
        cout<<"numker"<<numker<<endl;
        
       }
      }
      
     }

      } 


      
 

#ifdef BONRAJOUT
      for(typename Base::const_iterator p=b.begin();p!=b.end();p++)
        {
    for(int i=0;i<p->taille1;i++)
      {
        cout<<"p.accept[i] "<<p->accept[i]<<endl;
      }
    for(int i=0;i<p->taille2;i++)
      {
        cout<<"p.refuse[i] "<<p->refuse[i]<<endl;
      }
        }
#endif
#ifdef DEB

    //cout<<"mon a la fin de la boulcle de l'algo "<<Mk.size()<<endl;
      //for(typename typMk::iterator iter=Mk.begin();iter!=Mk.end();iter++)
      // cout<<*iter<<endl;  
  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<<"les sizes "<<iter->size<<endl;
      {
    int cpt=0;
    cout<<invconv<typename typP::value_type>(*iter)<<endl;       
    for(int i=0;i<iter->sizenf;i++)
      for(int j=0;j<8;j++)
        if (((iter->nfind[i]>>j)&1) && (iter->nf[cpt++]==0))
          {
        cout<<"ici ca couille a la place"<<8*i+j<<endl;
        cout<<iter->sizenf<<" "<<iter->size<<endl;
        exit(1);
          }
      }
#endif   
   
    S=Spolordsup(Pk,b,Spoldejavu);
    
  
    cout<<"newpkmkmatrixof"<<endl;
    cout<<"k"<<k<<endl;
  
    killspol=!newPkMkMatrixof(Mat,Pk,P,Mk,k,b,dump,recall,w,serv);
#ifdef PEQUAN
    sprintf(name,"mat%d",toto);
    fic=fopen(name,"w");
    printmatfile_pequan(Mat,fic);
    fclose(fic);
    toto++;
#endif
    
    if(killspol) S.erase(S.begin(),S.end());
    if (k+1>=maxdeg) allpolused=1;
    cout<<"Mk.size()"<<Mk.size()<<endl;
    if(Mk.size()==0) nouveaumon=0;
    //Solve affecte a Mat la valeur U
    //cout<<"solve"<<endl;
    for(typename typPk::iterator iter=Pk.begin();iter!=Pk.end();iter++)
      cout<<"avant solve les ind "<<iter->ind<<endl;
    for(typename typMk::iterator iter=Mk.begin();iter!=Mk.end();iter++)
      cout<<"monomes dans Mk "<<*iter<<endl;
    cout<<"Mat.ncol"<<Mat.ncol<<endl;
    if (Mat.ncol!=0)
      {
    //cout<<"debut du solve"<<endl;
    Solve(Mat,L,Pk,&pr,&pc,w);
//  cout<<"fin du solve"<<endl;
    //for(int kk=0;kk<Mk.size();kk++)
    //  cout<<"permc "<<kk<<" "<<pc[kk]<<endl;
    inverse(pc,Mk.size());
    Dopermu(Mk,pc);
    {
      //ici on remet les ind a la bonne valuer 
      //a inclure dans une petite fonction inline apres
      int j=0;
      typename typMk::iterator itermon=Mk.begin();
      typename typPk::iterator iter;
      for(iter=Pk.begin();
          itermon!=Mk.end();iter++,itermon++,j++)
        {
          if(!Iszero(Mat(j,j)))
        {
          //          cout<<"ligne "<<j<<" je mets le monome "<<*itermon<<endl;
          iter->ind=*itermon*(iter->ind.GetCoeff());
        }
          else
        {
          iter->ind=mon(0);
        }
        }
      //for(;itermon!=Mk.end();iter++,itermon++)
      //  iter->ind=mon(0);
    }

    free(pr);
    free(pc);
      }

 //appliquer les permutation a MK!!!!!!!!
    // for(typename typPk::iterator iter=Pk.begin();iter!=Pk.end();iter++)
      //  cout<<"apres solve les ind "<<iter->ind<<endl;
    //for(typename typPk::iterator iter=Pk.begin();iter!=Pk.end();iter++)
    // cout<<"apres solve les pol "<<invconv<Poly>(*iter)<<endl;
    //
    //
    //APPLIQUER LES PERMUTYATIONS A MK!!
    //
    //
    //
    //
    if ((unsigned)my_rank(Mat)==Mk.size())
      //matrice de rang plein
      {
    typMk tmpSpoldejavu;
    typPk redspol,secd=secondmembre(Mat,Pk);;
    cout<<"matrice de rang plein "<<endl;
    Dump(Pk,dump);
    cout<<"Reduce Spol "<<endl;

    ReduceSpol(S,dump,redspol,b,w,serv);//tmpSpoldejavu);
    
    cout<<"secd.size() "<<secd.size()<<endl;
    my_merge(redspol,secd);
    if(redspol.size()==0)
      {
        //a voir....    Dump(Pk,dump);
        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;
        cout<<"redspol.size() "<<redspol.size()<<endl;
        if (tmpdeg==(k+1))
          my_merge(Spoldejavu,tmpSpoldejavu);
        k=tmpdeg;
        //cout<<"le mindeg ici vaut "<<k<<endl;
        //cout<<"Pk.size() avant recover "<<Pk.size()<<endl;
        recover(Pk,Mk,dump,k);


        //cout<<"Pk.size() apres recover "<<Pk.size()<<endl;
        forget(b,dump,k,recall);
        //forget(b,dump,k);
#ifdef DEB     
        cout<<"Pk.size() avant Crochetchoix "<<Pk.size()<<endl;
#endif     
        //NewCrochetchoix(P,Pk,Mk,redspol,k,dump,b,recall,Spoldejavu);
        NewCrochetchoix(P,Pk,Mk,redspol,k,dump,b,recall,w,serv);
        //NewCrochetchoix(P,Pk,Mk,redspol,k,dump,b);
#ifdef DEB     
        cout<<"Pk.size apres Crochetchoix "<<Pk.size()<<" et k "<<k<<endl;
#endif     
        NewDestroyredspol(redspol,Pk);
        serv.compress(Pk,dump,b,k);
        Dump(Pk,dump);

        L.destroystore();
        cout<<"kaquiPini"<<k<<endl;
        //misa jour de B dans crochet choix!!
        continue;
      }
      }
    else
      //la matrice n'est pas de rang plein
      {
    cout<<"matrice de rang pas plein "<<endl;
    typPk secd;
#ifdef BONRAJOUT
    AddB_dim(Mat,L,P,Pk,Mk,dump,b);
#else
    AddB(Mat,Pk,Mk,dump,b,serv);
#endif
    //
    //secondmembre supprime des trucs dans Pk!!
    //
    secd=secondmembre(Mat,Pk);
    rajoute_voisins(Pk,Mk,dump,b,w,serv);
    //ne selectionne que les non nuls
       if(secd.size()==0)
     {
       typPk redspol;
       Dump(Pk,dump);

       ReduceSpol(S,dump,redspol,b,w,serv);
#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)
         {
           //ici on modifie Pk dans AddB 
           //<=> forget(b,dump,k) AddB(..) Dump(Pk,dump);
           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);
           //Listedejafait(Mk,Spoldejavu);
           forget(b,dump,k,recall);
           //forget(b,dump,k);
           cout<<"il ya un passage par mat rang pas"
               <<"plein et pol non zero"<<endl;
           //NewCrochetchoix(P,Pk,Mk,redspol,k,dump,b,recall,Spoldejavu);
           NewCrochetchoix(P,Pk,Mk,redspol,k,dump,b,recall,w,serv);
           //NewCrochetchoix(P,Pk,Mk,redspol,k,dump,b);
           NewDestroyredspol(redspol,Pk);
           serv.compress(Pk,dump,b,k);
           Dump(Pk,dump); 

           L.destroystore();
           continue;
         }
     }
       else
     {
       //on a des pol qui se reduisent pas a 0
       //cad un defaut de commuatation dans les coins
       typPk redspol;
       //for(int i=Pk.size();i>rank(Mat);i--)
       //  Pk.pop_back();
       //cout<<"PK. size "<<Pk.size()<<" Mat.nbcol "<<Mat.ncol<<endl;
       //cout<<"rank(Mat) "<<rank(Mat)<<endl;
       //int j=0;
       //cout<<"avant recover et meme avant le dump "<<endl;
       //for(typename typPk::iterator iter = secd.begin();iter!=secd.end()
       //    ;iter++,j++)
       // cout<<"pol de secd num "<<j<<endl<<invconv<Poly>(*iter)<<endl;
       //      AddB(Mat,Pk,Mk,b);
       //cout<<"apres ADDB le dump "<<endl;
       //for(typename typPk::iterator iter = Pk.begin();iter!=Pk.end()
       //    ;iter++)
       // cout<<invconv<Poly>(*iter)<<endl;
       Dump(Pk,dump);
 
       //cout<<"secd.size()" <<secd.size()<<endl;
       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);
       //cout<<"k "<<k<<endl;
       //Listedejafait(Mk,Spoldejavu);
       //cout<<"apres recover"<<endl;
       //      for(typename typPk::iterator iter = Pk.begin();iter!=Pk.end()
       //    ;iter++)
       //  cout<<invconv<Poly>(*iter)<<endl;
       //cout<<"les Spol non reduits"<<endl;
       //for(typename typPk::iterator iter = secd.begin();iter!=secd.end()
       //    ;iter++)
       //  cout<<invconv<Poly>(*iter)<<endl;
       forget(b,dump,k,recall);
       
       //forget(b,dump,k);
       //cout<<"il ya un passage par mat pas rang plein et Spol non zero"<<endl;
       //for(typename typPk::iterator iter = secd.begin();iter!=secd.end()
       //    ;iter++)
       // cout<<invconv<Poly>(*iter)<<endl;
       //NewCrochetchoix(P,Pk,Mk,redspol,k,dump,b,recall,Spoldejavu);
       NewCrochetchoix(P,Pk,Mk,secd,k,dump,b,recall,w,serv);
       //NewCrochetchoix(P,Pk,Mk,secd,k,dump,b);
       NewDestroyredspol(secd,Pk);
#ifdef BONRAJOUT
       cout<<"Apres NewCrochetchoix"<<endl;

       for(typename Base::const_iterator p=b.begin();p!=b.end();p++)
         {
           for(int i=0;i<p->taille1;i++)
         {
           cout<<"p.accept[i] "<<p->accept[i]<<endl;
         }
           for(int i=0;i<p->taille2;i++)
         {
           cout<<"p.refuse[i] "<<p->refuse[i]<<endl;
         }
         }
#endif
       //for(typename typPk::iterator iter = Pk.begin();iter!=Pk.end()
       //    ;iter++)
       // cout<<invconv<Poly>(*iter)<<endl;
       serv.compress(Pk,dump,b,k);
       Dump(Pk,dump);

       L.destroystore();
       continue;
     }     
      }     
  }
    
    Mat.destroystore();
  
#ifdef DEBUG
  for(typename Base::const_iterator p=b.begin();p!=b.end();p++)
    {
      for(int i=0;i<p->taille1;i++)
    {
      cout<<"p.accept[i] "<<p->accept[i]<<endl;
    }
      for(int i=0;i<p->taille2;i++)
    {
      cout<<"p.refuse[i] "<<p->refuse[i]<<endl;
    }
    }
#endif
  
  destroy_space(&w);
//  delete[] &sol2;
//  delete[] &sol3;
 
  cout<<"sortie d'algo flash et dimension "<<endl;//<<critere(b,k)<<endl;
  cout<<"TPS SDP "<<tempsCDSP<<endl;
  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.. :-)

    }
#endif //ALREADY_corealgo3

        }
//    cout<<endl;
//    cout<<"g trouve ca comme nvlle eq "<<endl<<tmp<<endl;
      newpol.push_back(tmp); 
         
    }
      delete[] S;
      delete[] V;
      delete[] work;
      delete[] matdense;
    }
  for(int i=1;i<nbconstraint;i++)
    {
      free(constraints[i].blocks->iindices);
      free(constraints[i].blocks->jindices);
      delete [] constraints[i].blocks->entries;
      delete [] constraints[i].blocks;
    }
  delete [] constraints;
  delete [] bb;
  delete [] C.blocks[1].data.mat;
  delete [] C.blocks;
  // il faut desallouer les contraintes mieux (les matrices pointees
  //il faut desalluer C
  //Precision(53);
  //cout<<"en sortie "<<newpol.empty()<<endl;
}

#include"genekersdpa.hpp"

template<typename typmatmap, typename typserv>
void  write_to_sdpa_fic(typmatmap &matrixmap,  int &dim, typserv &serv, 
            int d)
{
  ofstream tmpfic;
  typename typserv::monom_t m(1);
  COEFF *tmpval=matrixmap[m];
  char nomdufic[50];
  sprintf(nomdufic,"tmpfile_%d",d);
  tmpfic.open(nomdufic);
  tmpfic<<setprecision(80);
  tmpfic<<"\" Ceci est un message \""<<endl;
  tmpfic<<matrixmap.size()-1<<" =  mDIM"<<endl;
  tmpfic<<1<<" =  nBLOCK"<<endl;
  tmpfic<<dim<<" =  bLOCKsTRUCT"<<endl;
  tmpfic<<"{";
  for(int i=0;i<((long)matrixmap.size())-2;i++)
    tmpfic<<"0,";
  tmpfic<<"0}"<<endl;
  tmpfic<<"{";
  for(int i=0;i<dim-1;i++)
    {
      tmpfic<<"{";
      for(int j=0;j<dim-1;j++)
    {
      //cout<<(-1*matrixmap[m][i*dim+j])<<" ";
      tmpfic<<(COEFF)(-1*matrixmap[m][i*dim+j])<<",";
    }
      cout<<endl;
      tmpfic<<(COEFF)(-1*matrixmap[m][i*dim+dim-1])<<"},";
    }
  tmpfic<<"{";

  for(int j=0;j<dim-1;j++)
    tmpfic<<-1*matrixmap[m][(dim-1)*dim+j]<<",";
  tmpfic<<-1*matrixmap[m][dim*dim-1]<<"}}"<<endl;
 
  matrixmap.erase(matrixmap.find(m));
  for(typename typmatmap::iterator itermat=matrixmap.begin();
      itermat!=matrixmap.end();itermat++)
    {
      //cout<<"matrice de "<<itermat->first<<endl;
      COEFF *tt=itermat->second;
      tmpfic<<"{";
      for(int i=0;i<dim-1;i++)
    {
      tmpfic<<"{";
      for(int j=0;j<dim-1;j++)
        tmpfic<<tt[i*dim+j]<<",";
      tmpfic<<tt[i*dim+dim-1]<<"},";
    }
      tmpfic<<"{";
      
      for(int j=0;j<dim-1;j++)
    tmpfic<<tt[(dim-1)*dim+j]<<",";
      tmpfic<<tt[dim*dim-1]<<"}}"<<endl;
      
    }
  matrixmap[m]=tmpval;
  tmpfic.close();
}

template<typename typmatmap, typename coeff, typename typserv>
void read_sol_from_sdpa(coeff *&sol, typmatmap &matmap,int dim, typserv &serv)
{
  typedef typename typserv::monom_t mon;
  ifstream tmpfic;
  string ligne,ligne2;
  typename string::iterator debut;
  int i;
  coeff *xVec,*xMat;
  stringstream tmpstr;
  system(
     "perl -i.bak -0777 -ne 'if (/^xMat *= *(.*)(?=yMat)/ms) {$toto=$1; $toto=~s/[[:blank:]{}]\\+?//g; $toto=~s/,\\+?/ /g; print $toto}' lenom"      // "perl -0777 -i.bak -ne '/^xMat *= *(.*)(?=yMat)/ms and $toto=$1 and $toto=~s/[[:blank:]{}]\\+?//g and $toto=~s/,\\+?/ /g and print $toto' lenom"
     );
  tmpfic.open("lenom");
#if 0
  tmpfic>>ligne;//chaine Xvec
  cout<<"ligne xVec :"<<ligne<<endl;
  tmpfic>>ligne;// les coordonnées interessantes
  cout<<"ligne coordq :"<<ligne<<endl;
  dim=count(ligne.begin(),ligne.end(),'i')+1;
  xVec=new coeff[dim];
  sol=new coeff[dim*dim];
  i=0;
  int tmpindex;
  for(string::iterator iter=ligne.begin()+1;iter!=ligne.end();
      iter=ligne.begin()+tmpindex+1)
    {
      stringstream tmpstr;
      cout<<"iter "<<iter-ligne.begin()<<endl;
      tmpindex=ligne.find(",",iter-ligne.begin());
      if (tmpindex==string::npos) tmpindex=ligne.size()-1;
      cout<<"tmpindex "<<tmpindex<<endl;
      copy(iter,ligne.begin()+tmpindex,ostream_iterator<char>(tmpstr,""));
      tmpstr>>ligne2;
      cout<<"eeeee "<<ligne2<<" "<<ligne.find(",",iter-ligne.begin())<<endl;
      tmpstr<<ligne2;
      tmpstr>>xVec[i++];
      cout<<"i "<<i<<endl;
    }
#endif
  //en theorie maintenant on a xVec
#if 0  
  tmpfic>>ligne;//chaine xMat
  cout<<"ligne xmat :"<<ligne<<endl;
  tmpfic>>ligne;//chaine '{'
  for(i=0;i<dim;i++)
    {
      tmpfic>>ligne;// les coordonnées interessantes
      int j=0;
      for(string::iterator iter=ligne.begin()+ligne.find_last_of('{');
      iter!=ligne.end();
      iter=ligne.begin()+ligne.find(",",iter-ligne.begin()))
    {
      stringstream tmpstr;
      //      copy(iter,ligne.begin()+ligne.find(',',iter-ligne.begin())
      //     ,ostream_iterator<char>(tmpstr,""));
      int toto=ligne.find(",",iter-ligne.begin());
      cout<<"ligne "<<ligne<<endl;
      cout<<"toto "<<toto<<" "<<string::npos<<endl;
      if(toto==string::npos) toto=ligne.size()-2;
      cout<<"toto "<<toto<<" "<<string::npos<<endl;
      tmpstr<<ligne.substr(iter-ligne.begin(),toto);
        tmpstr>>xMat[dim*j++ + i];
    }
    }
#endif
  //maintenant on a relu le xVec et le Xmat
  //Reconstruction de la solution
  sol=new coeff[dim*dim];
  for(int i=0;i<dim*dim;i++)
    {
      tmpfic>>sol[i];
    } 
  tmpfic.close();
  cout<<"Solution "<<endl;
  for(int i=0;i<dim*dim;i++)
    cout<<sol[i]<<" ";
  cout<<endl;
  // copy(sol,sol+dim*dim,ostream_iterator<string>(cout," "));
#if 0
for(int i=0;i<dim*dim;i++)
    sol[i]+=matmap[mon(1)][i];
  matmap.erase(matmap.find(mon(1)));
  int j=0;
  for(typename typmatmap::iterator itermat=matmap.begin();
      itermat!=matmap.end();itermat++)
    {
      for(int i=0;i<dim*dim;i++)
    sol[i]-=xVec[j]*itermat->second[i];
      j++;
    }
#endif
}

template<typename typP, typename typdump,typename Base, typename typserv>
void generickernelsdpa(typP &newpol, int k, 
           const typdump &dump, Base &b, typserv &serv)
{
  typedef typename typP::value_type::order_t ord;
  typedef typename typserv::monom_t Monomial;
  //
  //Allocation du problem et des
  //contraintes
  COEFF * C;
  map<Monomial,COEFF*,ord> matrixmap;
  int i;
  
  //
  //On introduit un variable par monome de degre d en dehors de B
  //On va contruire l'operateur de de Hankel associé  //
  
  //
  //On commence par enumerer les monomes de degre plus petit que k
  //
  //
  typP stockprod,stockproj;//dans stockprod on a des polynomes
  //
  //
  //
  int nbconstraint=0;
  typedef  list<typename typserv::monom_t> typstock;  
  list<typename typserv::monom_t> stockmon,stockksur2;
  map<mon,int,ord> mapintligne,mapintcolonne,maphankel;
  enumeratemon(stockmon,k,b,dump);
  //
  //ICI on cree un index pour le monomes de degre k
  //il n'a a priori rien a voir avec int2mon/mon2int du reste du code 
  //sic.....
  enumeratemon(stockksur2,k/2,b,dump);
  //
  //pour le suite il nous faut les monomes de B de degre <=k/2
  //

  for(typename list<typename typserv::monom_t>::iterator 
    iter=stockksur2.begin(); iter!=stockksur2.end();iter++)
    if(!IsinB(*iter,b)) stockksur2.erase(iter--);
  i=1;
  for(typename list<typename typserv::monom_t>::iterator 
    iter=stockksur2.begin();iter!=stockksur2.end();iter++,i++)
    { 
      int j=1;
      for(typename list<typename typserv::monom_t>::iterator 
    iter2=stockksur2.begin();iter2!=stockksur2.end();iter2++,j++)
    {
      typename typserv::monom_t mono=*iter * (*iter2);
//    cout<<"monome "<<mono<<" "<<i<<" "<<j<<endl;
      if (!mapintligne.count(mono))
        {
          mapintligne[mono]=i;
          mapintcolonne[mono]=j;
        }
    }
    }
  //cout<<"passé"<<endl;

  // 
  //  On  genere les formes normales des produits de monomes de
  // de tous les monomes de   degre <=k/2 dez B.
  //
  int dim=stockksur2.size();
  for(typename typstock::iterator i=stockmon.begin();
      i!=stockmon.end();i++)
    if(IsinB(*i,b))
       {
     cout<<"ici "<<*i<<" dim "<<dim<<endl;
     matrixmap[*i]=new COEFF [dim*dim];
     for(int ii=0;ii<dim*dim;ii++)
       matrixmap[*i][ii]=0;
       }
  

 int ii=0;
 cout<<"coiucou"<<endl;
  for(typename typstock::iterator i=stockksur2.begin();
      i!=stockksur2.end();i++,ii++)
    {
      int jj=ii;
      cout<<"coiucou"<<endl;
      for(typename typstock::iterator j=i;j!=stockksur2.end();jj++,j++)
    {
       
      typename typserv::monom_t tmpmon=(*j)*(*i);
      //cout<<"coiucoufffffff "<<tmpmon<<endl;
      if (IsinB(tmpmon,b))
        {
          matrixmap[tmpmon][ii*dim+jj]+=1;
          if(ii!=jj)
        matrixmap[tmpmon][jj*dim+ii]+=1;
        }
      else
        {
          typP tmplist;
          tmplist.push_back(tmpmon);
          proj(tmplist,dump,b,serv);
          // cout<<"ici tmpmon "<<tmpmon<<endl;
          //cout<<"tmplist.front "<<tmplist.front()<<endl;
          for(typename typP::value_type::iterator iter=tmplist.front().begin();
          iter!=tmplist.front().end();iter++)
        {
          Monomial verytmpmon=*iter;
          verytmpmon.SetCoeff(1);
          //cout<<"tmpmon "<<verytmpmon<<" "<<*iter<<endl;
          matrixmap[verytmpmon][ii*dim+jj]+=iter->GetCoeff();
          if(ii!=jj)
            matrixmap[verytmpmon][jj*dim+ii]+=iter->GetCoeff();

        }
        }
    }
    }
 
  if(dim>1)
    {
      struct timeval tvini, tvfin;
      COEFF *sol;
      static int d=0;
      static char nom[1024];
      gettimeofday(&tvini,NULL);
      cout<<"coucou dim "<<dim<<endl;
      write_to_sdpa_fic(matrixmap,dim,serv,d);
      sprintf(nom,"sdpa_gmp -dd tmpfile_%d -o lenom",d++);
      system(nom);
      read_sol_from_sdpa(sol,matrixmap,dim,serv);
      
      
      gettimeofday(&tvfin,NULL);
      tempsCDSP+=tvfin.tv_sec-tvini.tv_sec+1e-6*(tvfin.tv_usec-tvini.tv_usec);
    
      //
      //cout<<"coiucou"<<endl;
      // A ce niveau la il faut verifier le rang
      // Le cas echeant recuperer le kernel
      //
      //  cout<<"return code "<<return_code<<endl;
      long n=stockksur2.size();
      COEFF *V=new COEFF[n*n];
      COEFF *S=new COEFF[n];
      COEFF *work=new COEFF[16*n];
      long lwork=16*n,info;
      long kk=0;//servira pour le rang 0
      dgesvd_((char*)"N",(char*)"A",&n,&n,sol,
          &n,S,(COEFF*)NULL,&n,V,&n,work,&lwork,&info);
#if 1
      cout<<"info svd "<<info<<endl;
      cout<<"val sing"<<endl;
      for(kk=0;kk<n;kk++)
    cout<<S[kk]<<" ";
      cout<<endl;
#endif
      cout<<"coiucou"<<endl;
      for(kk=1;kk<n;kk++)
    //if(S[0]>S[k]*1e6) break;//MAGIC
    if((abs(S[kk-1])==0) ||(abs(S[kk-1])>abs(S[kk])*1e6)) break;//MAGIC
#if 1     
      cout<<"kk ici "<<kk<<" et n "<<n<<endl;
#endif
      for(int j=0;j<n;j++)
    {
      for(int jj=0;jj<n;jj++)
        cout<<V[n*(jj)+j]<<" ";
      cout<<endl;
    }
      //
      //On construit les nouvelles equations 
      //
      for(;kk<(int)n;kk++)
    {
#if 1
      cout<<"equation dans le noyau"<<endl;
#endif
      typedef typename typP::value_type polyalp;
      polyalp tmp(0); 
      for(typename list<typename typserv::monom_t>::iterator 
        iter=stockksur2.begin();
          iter!=stockksur2.end();iter++)
        {
          
          //cout<<"dans construct eq "<<k<<" map "<<mapintcolonne[*iter]<<endl;
          //cout<<V[k+n*(mapintcolonne[*iter]-1)]<<" "<<*iter<<" ";
          if(!Iszero(abs(V[kk+n*(mapintcolonne[*iter]-1)])))
        
        {
          //      cout<<"tmp avant"<<endl<<tmp<<endl;
          //cout<<"ajout "<<endl<<polyalp(*iter*V[k+n*(mapintcolonne[*iter]-1)])<<endl;
          tmp+=polyalp(*iter*(COEFF)V[kk+n*(mapintcolonne[*iter]-1)]);
          //cout<<"tmp aapre"<<endl<<tmp<<endl;
        }
          //iter->first;// est le monome
          //iter->second;//est l'entier associé
     }
      //      cout<<endl;
      cout<<"g trouve ca comme nvlle eq "<<endl<<tmp<<endl;
      newpol.push_back(tmp); 
      
    }

      delete[] S;
      delete[] V;
      delete[] work;
      delete[] sol;
    }
}

template<typename typdump,typename Base, typename typserv>
int testsdp(int k, const typdump &dump,const Base &b,const typserv &serv)
{
  return !(k%2);
}
template<typename typP,typename typPk,typename typdump,typename Base
     , template<typename  T> class tmptypmat ,typename monomial_server>
void algo(typP P,typdump &dump,Base &b, monomial_server &serv)
{
#ifdef PEQUAN
  int toto=0;
  FILE *fic;
  char name[8];
#endif
  typedef typename typP::value_type polyalp;
  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;
  //typP recall 
  typPk recall;
  //Base b;
  workspace<typename typP::value_type::coeff_t> w;
  typedef tmptypmat<typename typP::value_type::coeff_t> typMat;
  typMat Mat,L;
  int onemoretime=1,nouveaumon,allpolused=0,maxdeg,k,*pr,*pc;
  cout<<"avant init"<<endl;
  
  init_algo<typMat>(P,nouveaumon,maxdeg,k,Pk,Mk,b,dump,w,serv);
  cout<<"apres init"<<endl;
  cout<<"onemoretime "<<onemoretime<<endl;
  cout<<"nouveaumon "<<nouveaumon<<endl;
  cout<<"k "<<k<<endl;
  cout<<"maxdeg "<<maxdeg<<endl;
#ifndef GROEBNER

  
  //  while((critere(b,k)==-1)||(k<=maxdeg))
#ifdef ONEMORETIME
  cout<<"one"<<endl;
  while(nouveaumon||(k<=maxdeg)||onemoretime)
#else
    while(nouveaumon||(k<=maxdeg))
#endif
#else
    while(!GB_stop(k)||(k<=maxdeg))
#endif
 
    {
#ifdef ONEMORETIME
       cout<<"two"<<endl;
       cout<<"nouveaumon"<<endl;
      if(!nouveaumon)
    cout<<"si"<<endl;
    onemoretime=0;
#endif
    //if (toto>=5) {exit(0);}
    //toto++;
        
    int killspol;
    //test si on est dans les conditions d'application
   gettimeofday(&initclock,NULL); 
   cout<<"onemoretime "<<onemoretime<<endl;
   cout<<"nouveaumon"<<nouveaumon<< endl;
   cout<<"k "<<k<<endl;
   cout<<"maxdeg "<<maxdeg<<endl;
   cout<<"testsdp(k,dump,b,serv) "<<testsdp(k,dump,b,serv)<<endl;
   if(testsdp(k,dump,b,serv)||(!onemoretime))
      //envoie la routine de calcul de sdp
      {
    int mindeg_newpol;
    typP newpol;
    cout<<"un nouveau tour de boucle et k vaut "<<k<<endl;
    if(!onemoretime)//sdpa!!!!!!!!
      //  generickernel(newpol,2*k,dump,b,serv);
     generickernel_testT(newpol,2*k,dump,b,serv);
      //  generickernelsdpa(newpol,2*k,dump,b,serv);
    else
      //  generickernel(newpol,k,dump,b,serv);
      generickernel_testT(newpol,k,dump,b,serv);
    //generickernelsdpa(newpol,k,dump,b,serv);
      gettimeofday(&tmpclock,NULL);
      tempsdssdp+=tmpclock.tv_sec-initclock.tv_sec+1e-6*(tmpclock.tv_usec-initclock.tv_usec);      

    //sdprealrad(newpol,dump,b,serv);
    //penser a decroitre k le cas echeant avec un coup de recover
    cout<<"newpol "<<newpol.empty()<<endl;
    if(!newpol.empty())
      {
        mindeg_newpol=Degree(newpol.front());
//      cout<<"mindeg "<<mindeg_newpol<<" k "<<k<<endl;
        for(typename typP::iterator iter=newpol.begin();
        iter!=newpol.end();iter++)
          mindeg_newpol=(mindeg_newpol<Degree(*iter)
                  ?mindeg_newpol:Degree(*iter));
        for(typename typP::iterator iter=newpol.begin();
        iter!=newpol.end();iter++)
          if(Degree(*iter)==mindeg_newpol)
        P.push_back(*iter);
        if(k>=mindeg_newpol)
          {
        list<mon *> exceed;
            list<int> sizeexceed;
        typPk tmpPk;
        conv_merge(tmpPk,newpol,exceed,sizeexceed,b,serv);
//      cout<<"merde merde k "<<k<<" mindeg_newpol "<<mindeg_newpol<<endl;
        k=mindeg_newpol;
        //      forget(b,dump,k,recall);
        //              recover(Pk,Mk,dump,k);
        recover(Pk,Mk,dump,k);

        //Listedejafait(Mk,Spoldejavu);
//      cout<<"Pk.size() apres recover "<<Pk.size()<<endl;
        if((k>0)||(k==-1))
          forget(b,dump,k,recall);
        else
          forget0(b,dump,k,recall);
//      cout<<"forget fait"<<endl;
        //forget(b,dump,k);
        NewCrochetchoix(P,Pk,Mk,tmpPk,k,dump,b,recall,w,serv);
        serv.compress(Pk,dump,b,k);
        cout<<"compress"<<endl;
        Dump(Pk,dump);
        continue;
          }
      }
      }
#ifdef BONRAJOUT
      for(typename Base::const_iterator p=b.begin();p!=b.end();p++)
        {
    for(int i=0;i<p->taille1;i++)
      {
        cout<<"p.accept[i] "<<p->accept[i]<<endl;
      }
    for(int i=0;i<p->taille2;i++)
      {
        cout<<"p.refuse[i] "<<p->refuse[i]<<endl;
      }
        }
#endif
#if 1//def DEB

    //cout<<"mon a la fin de la boulcle de l'algo "<<Mk.size()<<endl;
      //for(typename typMk::iterator iter=Mk.begin();iter!=Mk.end();iter++)
      // cout<<*iter<<endl;  
  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<<"les sizes "<<iter->size<<endl;
      {
    int cpt=0;
    cout<<invconv<typename typP::value_type>(*iter,serv)<<endl;       
    for(int i=0;i<iter->sizenf;i++)
      for(int j=0;j<8;j++)
        if (((iter->nfind[i]>>j)&1) && (iter->nf[cpt++]==0))
          {
        cout<<"ici ca couille a la place"<<8*i+j<<endl;
        cout<<iter->sizenf<<" "<<iter->size<<endl;
        exit(1);
          }
      }
#endif   

  //  cout<<"Spolordsup"<<endl;
    S=Spolordsup(Pk,b,Spoldejavu);
    //S.erase(S.begin(),S.end());
    //S=Spolordsup(Pk,b);
    cout<<endl;
    cout<<endl<<"newpkmkmatrixof"<<endl;
    //cout<<"Pk.size() "<<Pk.size()<<endl;
    //killspol=!newPkMkMatrixof(Mat,Pk,P,Mk,k,b,dump,recall,Spoldejavu);
    killspol=!newPkMkMatrixof(Mat,Pk,P,Mk,k,b,dump,recall,w,serv);
#ifdef PEQUAN
    sprintf(name,"mat%d",toto);
    fic=fopen(name,"w");
    printmatfile_pequan(Mat,fic);
    fclose(fic);
    toto++;
#endif
    //    if (toto>=5) {cout<<"killredspol "<<killspol<<endl; exit(0);}
    // killspol=!newPkMkMatrixof(Mat,Pk,P,Mk,k,b,dump);
    if(killspol) S.erase(S.begin(),S.end());
    if (k+1>=maxdeg) allpolused=1;
    if(Mk.size()==0) nouveaumon=0;
    //cout<<"j'en suis a k="<<k<<endl;
    //cout<<"Ici dans algo Mat"<<endl;
    //#ifdef BONRAJOUT
    //affdebug(Mat);
    //#endif
    //Solve affecte a Mat la valeur U
    //cout<<"solve"<<endl;
    //for(typename typPk::iterator iter=Pk.begin();iter!=Pk.end();iter++)
    //  cout<<"avant solve les ind "<<iter->ind<<endl;
    //for(typename typPk::iterator iter=Pk.begin();iter!=Pk.end();iter++)
    //  cout<<"avant solve les pol "<<invconv<Poly>(*iter)<<endl;
    //if(k==3) exit(-10);
    //for(typename typMk::iterator iter=Mk.begin();iter!=Mk.end();iter++)
    //  cout<<"monomes dans Mk "<<*iter<<endl;
    
    if (Mat.ncol!=0)
      {
    //cout<<"debut du solve"<<endl;
    Solve(Mat,L,Pk,&pr,&pc,w);
//  cout<<"fin du solve"<<endl;
    //for(int kk=0;kk<Mk.size();kk++)
    //  cout<<"permc "<<kk<<" "<<pc[kk]<<endl;
    inverse(pc,Mk.size());
    Dopermu(Mk,pc);
    {
      //ici on remet les ind a la bonne valuer 
      //a inclure dans une petite fonction inline apres
      int j=0;
      typename typMk::iterator itermon=Mk.begin();
      typename typPk::iterator iter;
      for(iter=Pk.begin();
          itermon!=Mk.end();iter++,itermon++,j++)
        {
          if(!Iszero(Mat(j,j)))
        {
          //          cout<<"ligne "<<j<<" je mets le monome "<<*itermon<<endl;
          iter->ind=*itermon*(iter->ind.GetCoeff());
        }
          else
        {
          iter->ind=mon(0);
        }
        }
      //for(;itermon!=Mk.end();iter++,itermon++)
      //  iter->ind=mon(0);
    }

    free(pr);
    free(pc);
      }

 //appliquer les permutation a MK!!!!!!!!
    // for(typename typPk::iterator iter=Pk.begin();iter!=Pk.end();iter++)
      //  cout<<"apres solve les ind "<<iter->ind<<endl;
    //for(typename typPk::iterator iter=Pk.begin();iter!=Pk.end();iter++)
    // cout<<"apres solve les pol "<<invconv<Poly>(*iter)<<endl;
    //
    //
    //APPLIQUER LES PERMUTYATIONS A MK!!
    //
    //
    //
    //
    if ((unsigned)my_rank(Mat)==Mk.size())
      //matrice de rang plein
      {
    typMk tmpSpoldejavu;
    typPk redspol,secd=secondmembre(Mat,Pk);;
    //secondmembre2(Mat,Pk,secd);
    //typename typPk::iterator iter=Pk.begin();
    cout<<"matrice de rang plein "<<endl;
    //for(unsigned int i=0;i<Mk.size();i++,iter++);
    //Pk.erase(iter,Pk.end());
    //cout<<"Dump "<<endl;
    Dump(Pk,dump);
    //cout<<"Reduce Spol "<<endl;
    
    ReduceSpol(S,dump,redspol,b,w,serv);//tmpSpoldejavu);
    //cout<<"secd.size() "<<secd.size()<<endl;
    my_merge(redspol,secd);
    if(redspol.size()==0)
      {
        //a voir....    Dump(Pk,dump);
        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;
        cout<<"redspol.size() "<<redspol.size()<<endl;
        //cout<<invconv<typename typP::value_type>(redspol.front())<<endl;
        if (tmpdeg==(k+1))
          my_merge(Spoldejavu,tmpSpoldejavu);
        k=tmpdeg;
        //cout<<"le mindeg ici vaut "<<k<<endl;
        //cout<<"Pk.size() avant recover "<<Pk.size()<<endl;
        recover(Pk,Mk,dump,k);

        //Listedejafait(Mk,Spoldejavu);
        //cout<<"Pk.size() apres recover "<<Pk.size()<<endl;
        forget(b,dump,k,recall);
        //forget(b,dump,k);
#ifdef DEB     
        cout<<"Pk.size() avant Crochetchoix "<<Pk.size()<<endl;
#endif     
        //NewCrochetchoix(P,Pk,Mk,redspol,k,dump,b,recall,Spoldejavu);
        NewCrochetchoix(P,Pk,Mk,redspol,k,dump,b,recall,w,serv);
        //NewCrochetchoix(P,Pk,Mk,redspol,k,dump,b);
#ifdef DEB     
        cout<<"Pk.size apres Crochetchoix "<<Pk.size()<<" et k "<<k<<endl;
#endif     
        NewDestroyredspol(redspol,Pk);
        serv.compress(Pk,dump,b,k);
        Dump(Pk,dump);
        L.destroystore();
        //misa jour de B dans crochet choix!!
        continue;
      }
      }
    else
      //la matrice n'est pas de rang plein
      {
    cout<<"matrice de rang pas plein "<<endl;
    typPk secd;
#ifdef BONRAJOUT
    AddB_dim(Mat,L,P,Pk,Mk,dump,b);
#else
    AddB(Mat,Pk,Mk,dump,b,serv);
#endif
    //
    //secondmembre supprime des trucs dans Pk!!
    //
    secd=secondmembre(Mat,Pk);
    rajoute_voisins(Pk,Mk,dump,b,w,serv);
    //ne selectionne que les non nuls
       if(secd.size()==0)
     {
       typPk redspol;
       //for(int i=Pk.size();i>rank(Mat);i--)
       //{
       //  if(Pk.back().size!=0)
       // MAC_REV_FREE<typename typMat::coeff_t>(Pk.rbegin()->nf
       //    ,Pk.rbegin()->size*sizeof(typename typMat::coeff_t));
       //  Pk.pop_back();
       //}//on vire les 0 avant de dumper
       //      AddB(Mat,Pk,Mk,dump,b);
       Dump(Pk,dump);
       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)
         {
           // forget(b,dump,k);
           //AddB(Mat,Pk,Mk,b);
           //Dump(Pk,dump);
           //ici on modifie Pk dans AddB 
           //<=> forget(b,dump,k) AddB(..) Dump(Pk,dump);
           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);
           //Listedejafait(Mk,Spoldejavu);
           forget(b,dump,k,recall);
           //forget(b,dump,k);
           cout<<"il ya un passage par mat rang pas"
               <<"plein et pol non zero"<<endl;
           //NewCrochetchoix(P,Pk,Mk,redspol,k,dump,b,recall,Spoldejavu);
           NewCrochetchoix(P,Pk,Mk,redspol,k,dump,b,recall,w,serv);
           //NewCrochetchoix(P,Pk,Mk,redspol,k,dump,b);
           NewDestroyredspol(redspol,Pk);
           serv.compress(Pk,dump,b,k);
           Dump(Pk,dump); 
           L.destroystore();
           continue;
         }
     }
       else
     {
       //on a des pol qui se reduisent pas a 0
       //cad un defaut de commuatation dans les coins
       typPk redspol;
       //for(int i=Pk.size();i>rank(Mat);i--)
       //  Pk.pop_back();
       //cout<<"PK. size "<<Pk.size()<<" Mat.nbcol "<<Mat.ncol<<endl;
       //cout<<"rank(Mat) "<<rank(Mat)<<endl;
       //int j=0;
       //cout<<"avant recover et meme avant le dump "<<endl;
       //for(typename typPk::iterator iter = secd.begin();iter!=secd.end()
       //    ;iter++,j++)
       // cout<<"pol de secd num "<<j<<endl<<invconv<Poly>(*iter)<<endl;
       //      AddB(Mat,Pk,Mk,b);
       //cout<<"apres ADDB le dump "<<endl;
       //for(typename typPk::iterator iter = Pk.begin();iter!=Pk.end()
       //    ;iter++)
       // cout<<invconv<Poly>(*iter)<<endl;
       Dump(Pk,dump);
       //cout<<"secd.size()" <<secd.size()<<endl;
       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);
       //cout<<"k "<<k<<endl;
       //Listedejafait(Mk,Spoldejavu);
       //cout<<"apres recover"<<endl;
       //      for(typename typPk::iterator iter = Pk.begin();iter!=Pk.end()
       //    ;iter++)
       //  cout<<invconv<Poly>(*iter)<<endl;
       //cout<<"les Spol non reduits"<<endl;
       //for(typename typPk::iterator iter = secd.begin();iter!=secd.end()
       //    ;iter++)
       //  cout<<invconv<Poly>(*iter)<<endl;
       forget(b,dump,k,recall);
       
       //forget(b,dump,k);
       //cout<<"il ya un passage par mat pas rang plein et Spol non zero"<<endl;
       //for(typename typPk::iterator iter = secd.begin();iter!=secd.end()
       //    ;iter++)
       // cout<<invconv<Poly>(*iter)<<endl;
       //NewCrochetchoix(P,Pk,Mk,redspol,k,dump,b,recall,Spoldejavu);
       NewCrochetchoix(P,Pk,Mk,secd,k,dump,b,recall,w,serv);
       //NewCrochetchoix(P,Pk,Mk,secd,k,dump,b);
       NewDestroyredspol(secd,Pk);
#ifdef BONRAJOUT
       cout<<"Apres NewCrochetchoix"<<endl;

       for(typename Base::const_iterator p=b.begin();p!=b.end();p++)
         {
           for(int i=0;i<p->taille1;i++)
         {
           cout<<"p.accept[i] "<<p->accept[i]<<endl;
         }
           for(int i=0;i<p->taille2;i++)
         {
           cout<<"p.refuse[i] "<<p->refuse[i]<<endl;
         }
         }
#endif
       //for(typename typPk::iterator iter = Pk.begin();iter!=Pk.end()
       //    ;iter++)
       // cout<<invconv<Poly>(*iter)<<endl;
       serv.compress(Pk,dump,b,k);
       Dump(Pk,dump);
       L.destroystore();
       continue;
     }
      
      }
  }
  
  Mat.destroystore();
  //while nouveau mon etc...
  // Pk=recomposePk(dump);
  //return Pk;
  //  return;
#ifdef DEBUG
  for(typename Base::const_iterator p=b.begin();p!=b.end();p++)
    {
      for(int i=0;i<p->taille1;i++)
    {
      cout<<"p.accept[i] "<<p->accept[i]<<endl;
    }
      for(int i=0;i<p->taille2;i++)
    {
      cout<<"p.refuse[i] "<<p->refuse[i]<<endl;
    }
    }
#endif
  destroy_space(&w);
  cout<<"sortie d'algo flash et dimension "<<endl;//<<critere(b,k)<<endl;
  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.. :-)

    }

template<typename typP,typename typPk,typename typdump,typename Base
     , template<typename  T> class tmptypmat ,typename monomial_server>
void algo(typP P,typdump &dump,Base &b, monomial_server &serv,typP F)
{
#ifdef PEQUAN
  int toto=0;
  FILE *fic;
  char name[8];
#endif
  typedef typename typP::value_type polyalp;
  typedef list<typename typPk::value_type::monom_t> typMk;
  typedef typename typMk::value_type mon;
  typedef typename typPk::value_type pol;
  cout<<"entra aqui "<<endl; 
  typMk Mk;
  typMk Spoldejavu;
  typPk Pk,S;
  typPk recall;
  typP Pini;
  workspace<typename typP::value_type::coeff_t> w;
  typedef tmptypmat<typename typP::value_type::coeff_t> typMat;
  typMat Mat,L;
  int onemoretime=1,nouveaumon,allpolused=0,maxdeg,k,maxdegb,kb,*pr,*pc,optimo=0,k1;
  int nogap=0,deg=0,nok=1, noreduced=0, kbon,kini;
 
  typP newpol,newpol1;
  COEFF *sol2,*sol3;
  cout<<"avant init"<<endl;
  
  init_algo<typMat>(P,nouveaumon,maxdeg,k,Pk,Mk,b,dump,w,serv);
  Pini=P;
  kini=k;
  cout<<"apres init"<<endl;
  cout<<"onemoretime "<<onemoretime<<endl;
  cout<<"nouveaumon "<<nouveaumon<<endl;
  cout<<"k "<<k<<endl;
  cout<<"maxdeg "<<maxdeg<<endl;
#ifndef GROEBNER
 
#ifdef ONEMORETIME
  cout<<"one"<<endl;
  while(nouveaumon||(k<=maxdeg)||onemoretime)
#else
    while(nouveaumon||(k<=maxdeg)|| (!optimo) || nok )//|| (k!=deg))

#endif
#else
    while(!GB_stop(k)||(k<=maxdeg))
#endif
 
    {
#ifdef ONEMORETIME
       cout<<"two"<<endl;
       cout<<"nouveaumon"<<endl;
      if(!nouveaumon)
    cout<<"si"<<endl;
    onemoretime=0;
#endif
    
        
    int killspol;
    //test si on est dans les conditions d'application
   gettimeofday(&initclock,NULL); 
   cout<<"onemoretime "<<onemoretime<<endl;
   cout<<"nouveaumon"<<nouveaumon<< endl;
   cout<<"k "<<k<<endl;
   cout<<"maxdeg "<<maxdeg<<endl;
   cout<<"testsdp(k,dump,b,serv) "<<testsdp(k,dump,b,serv)<<endl;
   for(typename Base::const_iterator p=b.begin();p!=b.end();p++)
        {
    for(int i=0;i<p->taille1;i++)
      {
        cout<<"p.accept[i] "<<p->accept[i]<<endl;
      }
    for(int i=0;i<p->taille2;i++)
      {
        cout<<"p.refuse[i] "<<p->refuse[i]<<endl;
      }
        }
//todo este if es por ver si el noyau de k+1 se reduce con la base que hemos calculado o no   
//hay un problema en la reinicializacion de las variables cuando el noyau no se reduce
     cout<<"k"<<k<<endl;
     cout<<"maxdeg"<<maxdeg<<endl;
     cout<<"optimo"<<optimo<<endl;
     cout<<"nok"<<nok<<endl;
 

//   if(testsdp(k,dump,b,serv)||(!onemoretime))
     if((testsdp(k,dump,b,serv) && (!optimo)) || (k==deg))
      //envoie la routine de calcul de sdp
      {
    int mindeg_newpol;
    
    
    
    
    cout<<"un nouveau tour de boucle et k vaut "<<k<<endl;
//  if(!onemoretime)//sdpa!!!!!!!!  
//   generickernel_testF(newpol,2*k,dump,b,serv,F,*&sol2);
//  else
    
    cout<<"deg"<<deg<<endl;
    
      if (nogap)
      {
      cout<<"sol3"<<k<<endl;
      cout<<"kbon"<<kbon<<endl;
      if (k==deg)
      { cout<<"pasas por aqui"<<endl;
        newpol1.erase(newpol1.begin(),newpol1.end());
//      newpol=newpol1;
        
        for(typename typP::iterator iter=newpol.begin();iter!=newpol.end();
            iter++)
           {
             cout<<*iter<<" ";
             cout<<endl;
           }
      } 
     
      
      newpol1.erase(newpol1.begin(),newpol1.end());
//#ifdef CSDP
//    generickernel_testTT(newpol1,k,dump,b,serv,F,*&sol3);
//#else
      generickernel_testF(newpol1,k,dump,b,serv,F,*&sol3);
//#endif
      cout<<"solucionprimal k"<< sol2[2] << endl;
        cout<<"solucionprimal k+1"<< sol3[2] << endl;
        cout<<"diferenciasprimales"<<abs(sol2[2]-sol3[2])*1e+1<<endl;
        cout<<"k1"<<k1<<endl;
        cout<<"k"<<k<<endl;
        cout<<"gap"<<abs(sol3[2]-sol3[3])*1e+4<<endl;
        cout<<"deg"<<deg<<endl;
        cout<<"!newpol.empty()"<<!newpol.empty()<<endl;
        cout<<"newpol1.empty()"<<newpol1.empty()<<endl;
        
     
        if (((abs(sol2[2]-sol3[2])*1e+1<1) && (!newpol.empty()) && (k1!=k))
          || ((k==deg)) )
//      if ((abs(sol3[0])*1e+5<1) && (abs(sol2[2]-sol3[2])*1e+5<1) && (!newpol.empty()) && (k1!=k))
         
        {  
         if (k==deg && newpol1.empty())  
          {
        
        nok=0;
        continue;
        
          }
          else
          {
        if (k!=deg)
        {  
          optimo=1;  
          deg=k+2;
          cout<<"deg dentro"<<deg<<endl;
          int numkerf=0;
             cout<<"noyau bon"<<endl;
             for(typename typP::iterator iter=newpol.begin();iter!=newpol.end();
             iter++,numkerf++)
           {
             cout<<*iter<<" ";
             cout<<endl;
           }
         mindeg_newpol=Degree(newpol.front());
         cout<<"mindeg "<<mindeg_newpol<<" k1 "<<k1<<endl;
         for(typename typP::iterator iter=newpol.begin();
        iter!=newpol.end();iter++)
          mindeg_newpol=(mindeg_newpol<Degree(*iter)
                  ?mindeg_newpol:Degree(*iter));
         cout<<"mindeg "<<mindeg_newpol<<" k1 "<<k1<<endl; 
        }
        if (k==deg && (!newpol.empty()))
        { 
//       for(typename typP::iterator iter=newpol1.begin();
//      iter!=newpol1.end();iter++)
//       newpol.push_back(*iter);
//       for(typename typP::iterator iter=newpol.begin();iter!=newpol.end();
//             iter++)
//         {
//             cout<<*iter<<"newpol2fois ";
//             cout<<endl;
//         }
                 newpol.erase(newpol.begin(),newpol.end());
         newpol=newpol1;
         mindeg_newpol=Degree(newpol.front());
         cout<<"mindeg2fois"<<mindeg_newpol<<endl;
        }
//      nok=0;
        
//       for(typename typP::iterator iterP=P.begin();
//      iterP!=P.end();iterP++)
//       newpol.push_back(*iterP);
         P.erase(P.begin(),P.end());
        for(typename typP::iterator iter=newpol.begin();
        iter!=newpol.end();iter++)
          if(Degree(*iter)==mindeg_newpol)
        P.push_back(*iter);
        if(k-2>=mindeg_newpol)
          {
        list<mon *> exceed;
            list<int> sizeexceed;
        typPk tmpPk;
        conv_merge(tmpPk,newpol,exceed,sizeexceed,b,serv);
        k=mindeg_newpol;
                
//      if (!nok) deg=0;
//      else deg=k*2;
        cout<<"k noyau bon"<< k<<endl;
        
        
        recover(Pk,Mk,dump,k);


//      cout<<"Pk.size() apres recover "<<Pk.size()<<endl;
        if (k!=deg)
        {
        if((k>0)||(k==-1))
          forget(b,dump,k,recall);
        else
          forget0(b,dump,k,recall);
        }

        NewCrochetchoix(P,Pk,Mk,tmpPk,k,dump,b,recall,w,serv);
        for(typename typP::iterator iter=P.begin();iter!=P.end();
                 iter++)
                 cout<<*iter<<" ";
                 cout<<endl;
        serv.compress(Pk,dump,b,k);
        cout<<"compress"<<endl;
        Dump(Pk,dump);

        continue;
          }
          }
        }
        else
        {
          
          cout<<"pasa por aqui cambiamos"<<endl;
          sol2=sol3;
          newpol=newpol1;
          
          
       } 
      }
      else
      {
      cout<<"sol2"<<k<<endl;  
      k1=k;
      newpol.erase(newpol.begin(),newpol.end());
//#ifdef CSDP
//    generickernel_testTT(newpol,k,dump,b,serv,F,*&sol2);
//#else
      generickernel_testF(newpol,k,dump,b,serv,F,*&sol2);
//#endif
      int numker=0;
          
           for(typename typP::iterator iter=newpol.begin();iter!=newpol.end();
            iter++,numker++)
          cout<<*iter<<" ";
          cout<<endl;
      cout<<"newpol "<<newpol.empty()<<endl;
      cout<<"numker"<<numker<<endl;
      //pour le case de polynome dans degree 2
      if (k==2 && maxdeg==1)
      {
        nogap=1;
        optimo=1;
        nok=0;
        
      }
      else{
        
      cout<<"gap"<<sol2[0]<<endl;
      cout<<"gapx"<<abs(sol2[0])*1e+4<<endl;
      if (abs(sol2[0])*1e+4<1){
        nogap=1;
        for(typename typP::iterator iter=newpol.begin();iter!=newpol.end();
        iter++,numker++)
          cout<<*iter<<" ";
        cout<<endl;
        cout<<"newpol "<<newpol.empty()<<endl;
        cout<<"numker"<<numker<<endl;
        
       }
      }
      
     }

      } 


      
 

#ifdef BONRAJOUT
      for(typename Base::const_iterator p=b.begin();p!=b.end();p++)
        {
    for(int i=0;i<p->taille1;i++)
      {
        cout<<"p.accept[i] "<<p->accept[i]<<endl;
      }
    for(int i=0;i<p->taille2;i++)
      {
        cout<<"p.refuse[i] "<<p->refuse[i]<<endl;
      }
        }
#endif
#ifdef DEB

    //cout<<"mon a la fin de la boulcle de l'algo "<<Mk.size()<<endl;
      //for(typename typMk::iterator iter=Mk.begin();iter!=Mk.end();iter++)
      // cout<<*iter<<endl;  
  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<<"les sizes "<<iter->size<<endl;
      {
    int cpt=0;
    cout<<invconv<typename typP::value_type>(*iter)<<endl;       
    for(int i=0;i<iter->sizenf;i++)
      for(int j=0;j<8;j++)
        if (((iter->nfind[i]>>j)&1) && (iter->nf[cpt++]==0))
          {
        cout<<"ici ca couille a la place"<<8*i+j<<endl;
        cout<<iter->sizenf<<" "<<iter->size<<endl;
        exit(1);
          }
      }
#endif   
   
    S=Spolordsup(Pk,b,Spoldejavu);
    
  
    cout<<"newpkmkmatrixof"<<endl;
    cout<<"k"<<k<<endl;
  
    killspol=!newPkMkMatrixof(Mat,Pk,P,Mk,k,b,dump,recall,w,serv);
#ifdef PEQUAN
    sprintf(name,"mat%d",toto);
    fic=fopen(name,"w");
    printmatfile_pequan(Mat,fic);
    fclose(fic);
    toto++;
#endif
    
    if(killspol) S.erase(S.begin(),S.end());
    if (k+1>=maxdeg) allpolused=1;
    cout<<"Mk.size()"<<Mk.size()<<endl;
    if(Mk.size()==0) nouveaumon=0;
    //Solve affecte a Mat la valeur U
    //cout<<"solve"<<endl;
    for(typename typPk::iterator iter=Pk.begin();iter!=Pk.end();iter++)
      cout<<"avant solve les ind "<<iter->ind<<endl;
    for(typename typMk::iterator iter=Mk.begin();iter!=Mk.end();iter++)
      cout<<"monomes dans Mk "<<*iter<<endl;
    cout<<"Mat.ncol"<<Mat.ncol<<endl;
    if (Mat.ncol!=0)
      {
    //cout<<"debut du solve"<<endl;
    Solve(Mat,L,Pk,&pr,&pc,w);
//  cout<<"fin du solve"<<endl;
    //for(int kk=0;kk<Mk.size();kk++)
    //  cout<<"permc "<<kk<<" "<<pc[kk]<<endl;
    inverse(pc,Mk.size());
    Dopermu(Mk,pc);
    {
      //ici on remet les ind a la bonne valuer 
      //a inclure dans une petite fonction inline apres
      int j=0;
      typename typMk::iterator itermon=Mk.begin();
      typename typPk::iterator iter;
      for(iter=Pk.begin();
          itermon!=Mk.end();iter++,itermon++,j++)
        {
          if(!Iszero(Mat(j,j)))
        {
          //          cout<<"ligne "<<j<<" je mets le monome "<<*itermon<<endl;
          iter->ind=*itermon*(iter->ind.GetCoeff());
        }
          else
        {
          iter->ind=mon(0);
        }
        }
      //for(;itermon!=Mk.end();iter++,itermon++)
      //  iter->ind=mon(0);
    }

    free(pr);
    free(pc);
      }

 //appliquer les permutation a MK!!!!!!!!
    // for(typename typPk::iterator iter=Pk.begin();iter!=Pk.end();iter++)
      //  cout<<"apres solve les ind "<<iter->ind<<endl;
    //for(typename typPk::iterator iter=Pk.begin();iter!=Pk.end();iter++)
    // cout<<"apres solve les pol "<<invconv<Poly>(*iter)<<endl;
    //
    //
    //APPLIQUER LES PERMUTYATIONS A MK!!
    //
    //
    //
    //
    if ((unsigned)my_rank(Mat)==Mk.size())
      //matrice de rang plein
      {
    typMk tmpSpoldejavu;
    typPk redspol,secd=secondmembre(Mat,Pk);;
    cout<<"matrice de rang plein "<<endl;
    Dump(Pk,dump);
    cout<<"Reduce Spol "<<endl;

    ReduceSpol(S,dump,redspol,b,w,serv);//tmpSpoldejavu);
    
    cout<<"secd.size() "<<secd.size()<<endl;
    my_merge(redspol,secd);
    if(redspol.size()==0)
      {
        //a voir....    Dump(Pk,dump);
        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;
        cout<<"redspol.size() "<<redspol.size()<<endl;
        if (tmpdeg==(k+1))
          my_merge(Spoldejavu,tmpSpoldejavu);
        k=tmpdeg;
        //cout<<"le mindeg ici vaut "<<k<<endl;
        //cout<<"Pk.size() avant recover "<<Pk.size()<<endl;
        recover(Pk,Mk,dump,k);


        //cout<<"Pk.size() apres recover "<<Pk.size()<<endl;
        forget(b,dump,k,recall);
        //forget(b,dump,k);
#ifdef DEB     
        cout<<"Pk.size() avant Crochetchoix "<<Pk.size()<<endl;
#endif     
        //NewCrochetchoix(P,Pk,Mk,redspol,k,dump,b,recall,Spoldejavu);
        NewCrochetchoix(P,Pk,Mk,redspol,k,dump,b,recall,w,serv);
        //NewCrochetchoix(P,Pk,Mk,redspol,k,dump,b);
#ifdef DEB     
        cout<<"Pk.size apres Crochetchoix "<<Pk.size()<<" et k "<<k<<endl;
#endif     
        NewDestroyredspol(redspol,Pk);
        serv.compress(Pk,dump,b,k);
        Dump(Pk,dump);

        L.destroystore();
        cout<<"kaquiPini"<<k<<endl;
        //misa jour de B dans crochet choix!!
        continue;
      }
      }
    else
      //la matrice n'est pas de rang plein
      {
    cout<<"matrice de rang pas plein "<<endl;
    typPk secd;
#ifdef BONRAJOUT
    AddB_dim(Mat,L,P,Pk,Mk,dump,b);
#else
    AddB(Mat,Pk,Mk,dump,b,serv);
#endif
    //
    //secondmembre supprime des trucs dans Pk!!
    //
    secd=secondmembre(Mat,Pk);
    rajoute_voisins(Pk,Mk,dump,b,w,serv);
    //ne selectionne que les non nuls
       if(secd.size()==0)
     {
       typPk redspol;
       Dump(Pk,dump);

       ReduceSpol(S,dump,redspol,b,w,serv);
#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)
         {
           //ici on modifie Pk dans AddB 
           //<=> forget(b,dump,k) AddB(..) Dump(Pk,dump);
           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);
           //Listedejafait(Mk,Spoldejavu);
           forget(b,dump,k,recall);
           //forget(b,dump,k);
           cout<<"il ya un passage par mat rang pas"
               <<"plein et pol non zero"<<endl;
           //NewCrochetchoix(P,Pk,Mk,redspol,k,dump,b,recall,Spoldejavu);
           NewCrochetchoix(P,Pk,Mk,redspol,k,dump,b,recall,w,serv);
           //NewCrochetchoix(P,Pk,Mk,redspol,k,dump,b);
           NewDestroyredspol(redspol,Pk);
           serv.compress(Pk,dump,b,k);
           Dump(Pk,dump); 

           L.destroystore();
           continue;
         }
     }
       else
     {
       //on a des pol qui se reduisent pas a 0
       //cad un defaut de commuatation dans les coins
       typPk redspol;
       //for(int i=Pk.size();i>rank(Mat);i--)
       //  Pk.pop_back();
       //cout<<"PK. size "<<Pk.size()<<" Mat.nbcol "<<Mat.ncol<<endl;
       //cout<<"rank(Mat) "<<rank(Mat)<<endl;
       //int j=0;
       //cout<<"avant recover et meme avant le dump "<<endl;
       //for(typename typPk::iterator iter = secd.begin();iter!=secd.end()
       //    ;iter++,j++)
       // cout<<"pol de secd num "<<j<<endl<<invconv<Poly>(*iter)<<endl;
       //      AddB(Mat,Pk,Mk,b);
       //cout<<"apres ADDB le dump "<<endl;
       //for(typename typPk::iterator iter = Pk.begin();iter!=Pk.end()
       //    ;iter++)
       // cout<<invconv<Poly>(*iter)<<endl;
       Dump(Pk,dump);
 
       //cout<<"secd.size()" <<secd.size()<<endl;
       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);
       //cout<<"k "<<k<<endl;
       //Listedejafait(Mk,Spoldejavu);
       //cout<<"apres recover"<<endl;
       //      for(typename typPk::iterator iter = Pk.begin();iter!=Pk.end()
       //    ;iter++)
       //  cout<<invconv<Poly>(*iter)<<endl;
       //cout<<"les Spol non reduits"<<endl;
       //for(typename typPk::iterator iter = secd.begin();iter!=secd.end()
       //    ;iter++)
       //  cout<<invconv<Poly>(*iter)<<endl;
       forget(b,dump,k,recall);
       
       //forget(b,dump,k);
       //cout<<"il ya un passage par mat pas rang plein et Spol non zero"<<endl;
       //for(typename typPk::iterator iter = secd.begin();iter!=secd.end()
       //    ;iter++)
       // cout<<invconv<Poly>(*iter)<<endl;
       //NewCrochetchoix(P,Pk,Mk,redspol,k,dump,b,recall,Spoldejavu);
       NewCrochetchoix(P,Pk,Mk,secd,k,dump,b,recall,w,serv);
       //NewCrochetchoix(P,Pk,Mk,secd,k,dump,b);
       NewDestroyredspol(secd,Pk);
#ifdef BONRAJOUT
       cout<<"Apres NewCrochetchoix"<<endl;

       for(typename Base::const_iterator p=b.begin();p!=b.end();p++)
         {
           for(int i=0;i<p->taille1;i++)
         {
           cout<<"p.accept[i] "<<p->accept[i]<<endl;
         }
           for(int i=0;i<p->taille2;i++)
         {
           cout<<"p.refuse[i] "<<p->refuse[i]<<endl;
         }
         }
#endif
       //for(typename typPk::iterator iter = Pk.begin();iter!=Pk.end()
       //    ;iter++)
       // cout<<invconv<Poly>(*iter)<<endl;
       serv.compress(Pk,dump,b,k);
       Dump(Pk,dump);

       L.destroystore();
       continue;
     }     
      }     
  }
    
    Mat.destroystore();
  
#ifdef DEBUG
  for(typename Base::const_iterator p=b.begin();p!=b.end();p++)
    {
      for(int i=0;i<p->taille1;i++)
    {
      cout<<"p.accept[i] "<<p->accept[i]<<endl;
    }
      for(int i=0;i<p->taille2;i++)
    {
      cout<<"p.refuse[i] "<<p->refuse[i]<<endl;
    }
    }
#endif
  
  destroy_space(&w);
//  delete[] &sol2;
//  delete[] &sol3;
 
  cout<<"sortie d'algo flash et dimension "<<endl;//<<critere(b,k)<<endl;
  cout<<"TPS SDP "<<tempsCDSP<<endl;
  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.. :-)

    }
#endif //ALREADY_corealgo3

  //
  
  //
  //On commence par enumerer les monomes de degre plus petit que k
  //
  //
  typP stockprod,stockproj;//dans stockprod on a des polynomes
  //
  //
  //
  int nbconstraint=0;
  typedef  list<typename typserv::monom_t> typstock;  
  list<typename typserv::monom_t> stockmon,stockksur2;
  map<mon,int,ord> mapintligne,mapintcolonne,maphankel;
  enumeratemon(stockmon,k,b,dump);
  //
  //ICI on cree un index pour le monomes de degre k
  //il n'a a priori rien a voir avec int2mon/mon2int du reste du code 
  //sic.....
  enumeratemon(stockksur2,k/2,b,dump);
  //
  //pour le suite il nous faut les monomes de B de degre <=k/2
  //

  for(typename list<typename typserv::monom_t>::iterator 
    iter=stockksur2.begin(); iter!=stockksur2.end();iter++)
    if(!IsinB(*iter,b)) stockksur2.erase(iter--);
  i=1;
  for(typename list<typename typserv::monom_t>::iterator 
    iter=stockksur2.begin();iter!=stockksur2.end();iter++,i++)
    { 
      int j=1;
      for(typename list<typename typserv::monom_t>::iterator 
    iter2=stockksur2.begin();iter2!=stockksur2.end();iter2++,j++)
    {
      typename typserv::monom_t mono=*iter * (*iter2);
//    cout<<"monome "<<mono<<" "<<i<<" "<<j<<endl;
      if (!mapintligne.count(mono))
        {
          mapintligne[mono]=i;
          mapintcolonne[mono]=j;
        }
    }
    }
  //cout<<"passé"<<endl;

  // 
  //  On  genere les formes normales des produits de monomes de
  // de tous les monomes de   degre <=k/2 dez B.
  //
  int dim=stockksur2.size();
  for(typename typstock::iterator i=stockmon.begin();
      i!=stockmon.end();i++)
    if(IsinB(*i,b))
       {
     cout<<"ici "<<*i<<" dim "<<dim<<endl;
     matrixmap[*i]=new COEFF [dim*dim];
     for(int ii=0;ii<dim*dim;ii++)
       matrixmap[*i][ii]=0;
       }
  

 int ii=0;
 cout<<"coiucou"<<endl;
  for(typename typstock::iterator i=stockksur2.begin();
      i!=stockksur2.end();i++,ii++)
    {
      int jj=ii;
      cout<<"coiucou"<<endl;
      for(typename typstock::iterator j=i;j!=stockksur2.end();jj++,j++)
    {
       
      typename typserv::monom_t tmpmon=(*j)*(*i);
      //cout<<"coiucoufffffff "<<tmpmon<<endl;
      if (IsinB(tmpmon,b))
        {
          matrixmap[tmpmon][ii*dim+jj]+=1;
          if(ii!=jj)
        matrixmap[tmpmon][jj*dim+ii]+=1;
        }
      else
        {
          typP tmplist;
          tmplist.push_back(tmpmon);
          proj(tmplist,dump,b,serv);
          // cout<<"ici tmpmon "<<tmpmon<<endl;
          //cout<<"tmplist.front "<<tmplist.front()<<endl;
          for(typename typP::value_type::iterator iter=tmplist.front().begin();
          iter!=tmplist.front().end();iter++)
        {
          Monomial verytmpmon=*iter;
          verytmpmon.SetCoeff(1);
          //cout<<"tmpmon "<<verytmpmon<<" "<<*iter<<endl;
          matrixmap[verytmpmon][ii*dim+jj]+=iter->GetCoeff();
          if(ii!=jj)
            matrixmap[verytmpmon][jj*dim+ii]+=iter->GetCoeff();

        }
        }
    }
    }
 
  if(dim>1)
    {
      struct timeval tvini, tvfin;
      COEFF *sol;
      static int d=0;
      static char nom[1024];
      gettimeofday(&tvini,NULL);
      cout<<"coucou dim "<<dim<<endl;
      write_to_sdpa_fic(matrixmap,dim,serv,d);
      sprintf(nom,"sdpa_gmp -dd tmpfile_%d -o lenom",d++);
      system(nom);
      read_sol_from_sdpa(sol,matrixmap,dim,serv);
      
      
      gettimeofday(&tvfin,NULL);
      tempsCDSP+=tvfin.tv_sec-tvini.tv_sec+1e-6*(tvfin.tv_usec-tvini.tv_usec);
    
      //
      //cout<<"coiucou"<<endl;
      // A ce niveau la il faut verifier le rang
      // Le cas echeant recuperer le kernel
      //
      //  cout<<"return code "<<return_code<<endl;
      long n=stockksur2.size();
      COEFF *V=new COEFF[n*n];
      COEFF *S=new COEFF[n];
      COEFF *work=new COEFF[16*n];
      long lwork=16*n,info;
      long kk=0;//servira pour le rang 0
      dgesvd_((char*)"N",(char*)"A",&n,&n,sol,
          &n,S,(COEFF*)NULL,&n,V,&n,work,&lwork,&info);
#if 1
      cout<<"info svd "<<info<<endl;
      cout<<"val sing"<<endl;
      for(kk=0;kk<n;kk++)
    cout<<S[kk]<<" ";
      cout<<endl;
#endif
      cout<<"coiucou"<<endl;
      for(kk=1;kk<n;kk++)
    //if(S[0]>S[k]*1e6) break;//MAGIC
    if((abs(S[kk-1])==0) ||(abs(S[kk-1])>abs(S[kk])*1e6)) break;//MAGIC
#if 1     
      cout<<"kk ici "<<kk<<" et n "<<n<<endl;
#endif
      for(int j=0;j<n;j++)
    {
      for(int jj=0;jj<n;jj++)
        cout<<V[n*(jj)+j]<<" ";
      cout<<endl;
    }
      //
      //On construit les nouvelles equations 
      //
      for(;kk<(int)n;kk++)
    {
#if 1
      cout<<"equation dans le noyau"<<endl;
#endif
      typedef typename typP::value_type polyalp;
      polyalp tmp(0); 
      for(typename list<typename typserv::monom_t>::iterator 
        iter=stockksur2.begin();
          iter!=stockksur2.end();iter++)
        {
          
          //cout<<"dans construct eq "<<k<<" map "<<mapintcolonne[*iter]<<endl;
          //cout<<V[k+n*(mapintcolonne[*iter]-1)]<<" "<<*iter<<" ";
          if(!Iszero(abs(V[kk+n*(mapintcolonne[*iter]-1)])))
        
        {
          //      cout<<"tmp avant"<<endl<<tmp<<endl;
          //cout<<"ajout "<<endl<<polyalp(*iter*V[k+n*(mapintcolonne[*iter]-1)])<<endl;
          tmp+=polyalp(*iter*(COEFF)V[kk+n*(mapintcolonne[*iter]-1)]);
          //cout<<"tmp aapre"<<endl<<tmp<<endl;
        }
          //iter->first;// est le monome
          //iter->second;//est l'entier associé     }
      //      cout<<endl;
      cout<<"g trouve ca comme nvlle eq "<<endl<<tmp<<endl;
      newpol.push_back(tmp); 
      
    }

      delete[] S;
      delete[] V;
      delete[] work;
      delete[] sol;
    }
}

template<typename typdump,typename Base, typename typserv>
int testsdp(int k, const typdump &dump,const Base &b,const typserv &serv)
{
  return !(k%2);
}
template<typename typP,typename typPk,typename typdump,typename Base
     , template<typename  T> class tmptypmat ,typename monomial_server>
void algo(typP P,typdump &dump,Base &b, monomial_server &serv)
{
#ifdef PEQUAN
  int toto=0;
  FILE *fic;
  char name[8];
#endif
  typedef typename typP::value_type polyalp;
  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;
  //typP recall 
  typPk recall;
  //Base b;
  workspace<typename typP::value_type::coeff_t> w;
  typedef tmptypmat<typename typP::value_type::coeff_t> typMat;
  typMat Mat,L;
  int onemoretime=1,nouveaumon,allpolused=0,maxdeg,k,*pr,*pc;
  cout<<"avant init"<<endl;
  
  init_algo<typMat>(P,nouveaumon,maxdeg,k,Pk,Mk,b,dump,w,serv);
  cout<<"apres init"<<endl;
  cout<<"onemoretime "<<onemoretime<<endl;
  cout<<"nouveaumon "<<nouveaumon<<endl;
  cout<<"k "<<k<<endl;
  cout<<"maxdeg "<<maxdeg<<endl;
#ifndef GROEBNER

  
  //  while((critere(b,k)==-1)||(k<=maxdeg))
#ifdef ONEMORETIME
  cout<<"one"<<endl;
  while(nouveaumon||(k<=maxdeg)||onemoretime)
#else
    while(nouveaumon||(k<=maxdeg))
#endif
#else
    while(!GB_stop(k)||(k<=maxdeg))
#endif
 
    {
#ifdef ONEMORETIME
       cout<<"two"<<endl;
       cout<<"nouveaumon"<<endl;
      if(!nouveaumon)
    cout<<"si"<<endl;
    onemoretime=0;
#endif
    //if (toto>=5) {exit(0);}
    //toto++;
        
    int killspol;
    //test si on est dans les conditions d'application
   gettimeofday(&initclock,NULL); 
   cout<<"onemoretime "<<onemoretime<<endl;
   cout<<"nouveaumon"<<nouveaumon<< endl;
   cout<<"k "<<k<<endl;
   cout<<"maxdeg "<<maxdeg<<endl;
   cout<<"testsdp(k,dump,b,serv) "<<testsdp(k,dump,b,serv)<<endl;
   if(testsdp(k,dump,b,serv)||(!onemoretime))
      //envoie la routine de calcul de sdp
      {
    int mindeg_newpol;
    typP newpol;
    cout<<"un nouveau tour de boucle et k vaut "<<k<<endl;
    if(!onemoretime)//sdpa!!!!!!!!
      //  generickernel(newpol,2*k,dump,b,serv);
     generickernel_testT(newpol,2*k,dump,b,serv);
      //  generickernelsdpa(newpol,2*k,dump,b,serv);
    else
      //  generickernel(newpol,k,dump,b,serv);
      generickernel_testT(newpol,k,dump,b,serv);
    //generickernelsdpa(newpol,k,dump,b,serv);
      gettimeofday(&tmpclock,NULL);
      tempsdssdp+=tmpclock.tv_sec-initclock.tv_sec+1e-6*(tmpclock.tv_usec-initclock.tv_usec);      

    //sdprealrad(newpol,dump,b,serv);
    //penser a decroitre k le cas echeant avec un coup de recover
    cout<<"newpol "<<newpol.empty()<<endl;
    if(!newpol.empty())
      {
        mindeg_newpol=Degree(newpol.front());
//      cout<<"mindeg "<<mindeg_newpol<<" k "<<k<<endl;
        for(typename typP::iterator iter=newpol.begin();
        iter!=newpol.end();iter++)
          mindeg_newpol=(mindeg_newpol<Degree(*iter)
                  ?mindeg_newpol:Degree(*iter));
        for(typename typP::iterator iter=newpol.begin();
        iter!=newpol.end();iter++)
          if(Degree(*iter)==mindeg_newpol)
        P.push_back(*iter);
        if(k>=mindeg_newpol)
          {
        list<mon *> exceed;
            list<int> sizeexceed;
        typPk tmpPk;
        conv_merge(tmpPk,newpol,exceed,sizeexceed,b,serv);
//      cout<<"merde merde k "<<k<<" mindeg_newpol "<<mindeg_newpol<<endl;
        k=mindeg_newpol;
        //      forget(b,dump,k,recall);
        //              recover(Pk,Mk,dump,k);
        recover(Pk,Mk,dump,k);

        //Listedejafait(Mk,Spoldejavu);
//      cout<<"Pk.size() apres recover "<<Pk.size()<<endl;
        if((k>0)||(k==-1))
          forget(b,dump,k,recall);
        else
          forget0(b,dump,k,recall);
//      cout<<"forget fait"<<endl;
        //forget(b,dump,k);
        NewCrochetchoix(P,Pk,Mk,tmpPk,k,dump,b,recall,w,serv);
        serv.compress(Pk,dump,b,k);
        cout<<"compress"<<endl;
        Dump(Pk,dump);
        continue;
          }
      }
      }
#ifdef BONRAJOUT
      for(typename Base::const_iterator p=b.begin();p!=b.end();p++)
        {
    for(int i=0;i<p->taille1;i++)
      {
        cout<<"p.accept[i] "<<p->accept[i]<<endl;
      }
    for(int i=0;i<p->taille2;i++)
      {
        cout<<"p.refuse[i] "<<p->refuse[i]<<endl;
      }
        }
#endif
#if 1//def DEB

    //cout<<"mon a la fin de la boulcle de l'algo "<<Mk.size()<<endl;
      //for(typename typMk::iterator iter=Mk.begin();iter!=Mk.end();iter++)
      // cout<<*iter<<endl;  
  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<<"les sizes "<<iter->size<<endl;
      {
    int cpt=0;
    cout<<invconv<typename typP::value_type>(*iter,serv)<<endl;       
    for(int i=0;i<iter->sizenf;i++)
      for(int j=0;j<8;j++)
        if (((iter->nfind[i]>>j)&1) && (iter->nf[cpt++]==0))
          {
        cout<<"ici ca couille a la place"<<8*i+j<<endl;
        cout<<iter->sizenf<<" "<<iter->size<<endl;
        exit(1);
          }
      }
#endif   

  //  cout<<"Spolordsup"<<endl;
    S=Spolordsup(Pk,b,Spoldejavu);
    //S.erase(S.begin(),S.end());
    //S=Spolordsup(Pk,b);
    cout<<endl;
    cout<<endl<<"newpkmkmatrixof"<<endl;
    //cout<<"Pk.size() "<<Pk.size()<<endl;
    //killspol=!newPkMkMatrixof(Mat,Pk,P,Mk,k,b,dump,recall,Spoldejavu);
    killspol=!newPkMkMatrixof(Mat,Pk,P,Mk,k,b,dump,recall,w,serv);
#ifdef PEQUAN
    sprintf(name,"mat%d",toto);
    fic=fopen(name,"w");
    printmatfile_pequan(Mat,fic);
    fclose(fic);
    toto++;
#endif
    //    if (toto>=5) {cout<<"killredspol "<<killspol<<endl; exit(0);}
    // killspol=!newPkMkMatrixof(Mat,Pk,P,Mk,k,b,dump);
    if(killspol) S.erase(S.begin(),S.end());
    if (k+1>=maxdeg) allpolused=1;
    if(Mk.size()==0) nouveaumon=0;
    //cout<<"j'en suis a k="<<k<<endl;
    //cout<<"Ici dans algo Mat"<<endl;
    //#ifdef BONRAJOUT
    //affdebug(Mat);
    //#endif
    //Solve affecte a Mat la valeur U
    //cout<<"solve"<<endl;
    //for(typename typPk::iterator iter=Pk.begin();iter!=Pk.end();iter++)
    //  cout<<"avant solve les ind "<<iter->ind<<endl;
    //for(typename typPk::iterator iter=Pk.begin();iter!=Pk.end();iter++)
    //  cout<<"avant solve les pol "<<invconv<Poly>(*iter)<<endl;
    //if(k==3) exit(-10);
    //for(typename typMk::iterator iter=Mk.begin();iter!=Mk.end();iter++)
    //  cout<<"monomes dans Mk "<<*iter<<endl;
    
    if (Mat.ncol!=0)
      {
    //cout<<"debut du solve"<<endl;
    Solve(Mat,L,Pk,&pr,&pc,w);
//  cout<<"fin du solve"<<endl;
    //for(int kk=0;kk<Mk.size();kk++)
    //  cout<<"permc "<<kk<<" "<<pc[kk]<<endl;
    inverse(pc,Mk.size());
    Dopermu(Mk,pc);
    {
      //ici on remet les ind a la bonne valuer 
      //a inclure dans une petite fonction inline apres
      int j=0;
      typename typMk::iterator itermon=Mk.begin();
      typename typPk::iterator iter;
      for(iter=Pk.begin();
          itermon!=Mk.end();iter++,itermon++,j++)
        {
          if(!Iszero(Mat(j,j)))
        {
          //          cout<<"ligne "<<j<<" je mets le monome "<<*itermon<<endl;
          iter->ind=*itermon*(iter->ind.GetCoeff());
        }
          else
        {
          iter->ind=mon(0);
        }
        }
      //for(;itermon!=Mk.end();iter++,itermon++)
      //  iter->ind=mon(0);
    }

    free(pr);
    free(pc);
      }

 //appliquer les permutation a MK!!!!!!!!
    // for(typename typPk::iterator iter=Pk.begin();iter!=Pk.end();iter++)
      //  cout<<"apres solve les ind "<<iter->ind<<endl;
    //for(typename typPk::iterator iter=Pk.begin();iter!=Pk.end();iter++)
    // cout<<"apres solve les pol "<<invconv<Poly>(*iter)<<endl;
    //
    //
    //APPLIQUER LES PERMUTYATIONS A MK!!
    //
    //
    //
    //
    if ((unsigned)my_rank(Mat)==Mk.size())
      //matrice de rang plein
      {
    typMk tmpSpoldejavu;
    typPk redspol,secd=secondmembre(Mat,Pk);;
    //secondmembre2(Mat,Pk,secd);
    //typename typPk::iterator iter=Pk.begin();
    cout<<"matrice de rang plein "<<endl;
    //for(unsigned int i=0;i<Mk.size();i++,iter++);
    //Pk.erase(iter,Pk.end());
    //cout<<"Dump "<<endl;
    Dump(Pk,dump);
    //cout<<"Reduce Spol "<<endl;
    
    ReduceSpol(S,dump,redspol,b,w,serv);//tmpSpoldejavu);
    //cout<<"secd.size() "<<secd.size()<<endl;
    my_merge(redspol,secd);
    if(redspol.size()==0)
      {
        //a voir....    Dump(Pk,dump);
        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;
        cout<<"redspol.size() "<<redspol.size()<<endl;
        //cout<<invconv<typename typP::value_type>(redspol.front())<<endl;
        if (tmpdeg==(k+1))
          my_merge(Spoldejavu,tmpSpoldejavu);
        k=tmpdeg;
        //cout<<"le mindeg ici vaut "<<k<<endl;
        //cout<<"Pk.size() avant recover "<<Pk.size()<<endl;
        recover(Pk,Mk,dump,k);

        //Listedejafait(Mk,Spoldejavu);
        //cout<<"Pk.size() apres recover "<<Pk.size()<<endl;
        forget(b,dump,k,recall);
        //forget(b,dump,k);
#ifdef DEB     
        cout<<"Pk.size() avant Crochetchoix "<<Pk.size()<<endl;
#endif     
        //NewCrochetchoix(P,Pk,Mk,redspol,k,dump,b,recall,Spoldejavu);
        NewCrochetchoix(P,Pk,Mk,redspol,k,dump,b,recall,w,serv);
        //NewCrochetchoix(P,Pk,Mk,redspol,k,dump,b);
#ifdef DEB     
        cout<<"Pk.size apres Crochetchoix "<<Pk.size()<<" et k "<<k<<endl;
#endif     
        NewDestroyredspol(redspol,Pk);
        serv.compress(Pk,dump,b,k);
        Dump(Pk,dump);
        L.destroystore();
        //misa jour de B dans crochet choix!!
        continue;
      }
      }
    else
      //la matrice n'est pas de rang plein
      {
    cout<<"matrice de rang pas plein "<<endl;
    typPk secd;
#ifdef BONRAJOUT
    AddB_dim(Mat,L,P,Pk,Mk,dump,b);
#else
    AddB(Mat,Pk,Mk,dump,b,serv);
#endif
    //
    //secondmembre supprime des trucs dans Pk!!
    //
    secd=secondmembre(Mat,Pk);
    rajoute_voisins(Pk,Mk,dump,b,w,serv);
    //ne selectionne que les non nuls
       if(secd.size()==0)
     {
       typPk redspol;
       //for(int i=Pk.size();i>rank(Mat);i--)
       //{
       //  if(Pk.back().size!=0)
       // MAC_REV_FREE<typename typMat::coeff_t>(Pk.rbegin()->nf
       //    ,Pk.rbegin()->size*sizeof(typename typMat::coeff_t));
       //  Pk.pop_back();
       //}//on vire les 0 avant de dumper
       //      AddB(Mat,Pk,Mk,dump,b);
       Dump(Pk,dump);
       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)
         {
           // forget(b,dump,k);
           //AddB(Mat,Pk,Mk,b);
           //Dump(Pk,dump);
           //ici on modifie Pk dans AddB 
           //<=> forget(b,dump,k) AddB(..) Dump(Pk,dump);
           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);
           //Listedejafait(Mk,Spoldejavu);
           forget(b,dump,k,recall);
           //forget(b,dump,k);
           cout<<"il ya un passage par mat rang pas"
               <<"plein et pol non zero"<<endl;
           //NewCrochetchoix(P,Pk,Mk,redspol,k,dump,b,recall,Spoldejavu);
           NewCrochetchoix(P,Pk,Mk,redspol,k,dump,b,recall,w,serv);
           //NewCrochetchoix(P,Pk,Mk,redspol,k,dump,b);
           NewDestroyredspol(redspol,Pk);
           serv.compress(Pk,dump,b,k);
           Dump(Pk,dump); 
           L.destroystore();
           continue;
         }
     }
       else
     {
       //on a des pol qui se reduisent pas a 0
       //cad un defaut de commuatation dans les coins
       typPk redspol;
       //for(int i=Pk.size();i>rank(Mat);i--)
       //  Pk.pop_back();
       //cout<<"PK. size "<<Pk.size()<<" Mat.nbcol "<<Mat.ncol<<endl;
       //cout<<"rank(Mat) "<<rank(Mat)<<endl;
       //int j=0;
       //cout<<"avant recover et meme avant le dump "<<endl;
       //for(typename typPk::iterator iter = secd.begin();iter!=secd.end()
       //    ;iter++,j++)
       // cout<<"pol de secd num "<<j<<endl<<invconv<Poly>(*iter)<<endl;
       //      AddB(Mat,Pk,Mk,b);
       //cout<<"apres ADDB le dump "<<endl;
       //for(typename typPk::iterator iter = Pk.begin();iter!=Pk.end()
       //    ;iter++)
       // cout<<invconv<Poly>(*iter)<<endl;
       Dump(Pk,dump);
       //cout<<"secd.size()" <<secd.size()<<endl;
       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);
       //cout<<"k "<<k<<endl;
       //Listedejafait(Mk,Spoldejavu);
       //cout<<"apres recover"<<endl;
       //      for(typename typPk::iterator iter = Pk.begin();iter!=Pk.end()
       //    ;iter++)
       //  cout<<invconv<Poly>(*iter)<<endl;
       //cout<<"les Spol non reduits"<<endl;
       //for(typename typPk::iterator iter = secd.begin();iter!=secd.end()
       //    ;iter++)
       //  cout<<invconv<Poly>(*iter)<<endl;
       forget(b,dump,k,recall);
       
       //forget(b,dump,k);
       //cout<<"il ya un passage par mat pas rang plein et Spol non zero"<<endl;
       //for(typename typPk::iterator iter = secd.begin();iter!=secd.end()
       //    ;iter++)
       // cout<<invconv<Poly>(*iter)<<endl;
       //NewCrochetchoix(P,Pk,Mk,redspol,k,dump,b,recall,Spoldejavu);
       NewCrochetchoix(P,Pk,Mk,secd,k,dump,b,recall,w,serv);
       //NewCrochetchoix(P,Pk,Mk,secd,k,dump,b);
       NewDestroyredspol(secd,Pk);
#ifdef BONRAJOUT
       cout<<"Apres NewCrochetchoix"<<endl;

       for(typename Base::const_iterator p=b.begin();p!=b.end();p++)
         {
           for(int i=0;i<p->taille1;i++)
         {
           cout<<"p.accept[i] "<<p->accept[i]<<endl;
         }
           for(int i=0;i<p->taille2;i++)
         {
           cout<<"p.refuse[i] "<<p->refuse[i]<<endl;
         }
         }
#endif
       //for(typename typPk::iterator iter = Pk.begin();iter!=Pk.end()
       //    ;iter++)
       // cout<<invconv<Poly>(*iter)<<endl;
       serv.compress(Pk,dump,b,k);
       Dump(Pk,dump);
       L.destroystore();
       continue;
     }
      
      }
  }
  
  Mat.destroystore();
  //while nouveau mon etc...
  // Pk=recomposePk(dump);
  //return Pk;
  //  return;
#ifdef DEBUG
  for(typename Base::const_iterator p=b.begin();p!=b.end();p++)
    {
      for(int i=0;i<p->taille1;i++)
    {
      cout<<"p.accept[i] "<<p->accept[i]<<endl;
    }
      for(int i=0;i<p->taille2;i++)
    {
      cout<<"p.refuse[i] "<<p->refuse[i]<<endl;
    }
    }
#endif
  destroy_space(&w);
  cout<<"sortie d'algo flash et dimension "<<endl;//<<critere(b,k)<<endl;
  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.. :-)

    }

template<typename typP,typename typPk,typename typdump,typename Base
     , template<typename  T> class tmptypmat ,typename monomial_server>
void algo(typP P,typdump &dump,Base &b, monomial_server &serv,typP F)
{
#ifdef PEQUAN
  int toto=0;
  FILE *fic;
  char name[8];
#endif
  typedef typename typP::value_type polyalp;
  typedef list<typename typPk::value_type::monom_t> typMk;
  typedef typename typMk::value_type mon;
  typedef typename typPk::value_type pol;
  cout<<"entra aqui "<<endl; 
  typMk Mk;
  typMk Spoldejavu;
  typPk Pk,S;
  typPk recall;
  typP Pini;
  workspace<typename typP::value_type::coeff_t> w;
  typedef tmptypmat<typename typP::value_type::coeff_t> typMat;
  typMat Mat,L;
  int onemoretime=1,nouveaumon,allpolused=0,maxdeg,k,maxdegb,kb,*pr,*pc,optimo=0,k1;
  int nogap=0,deg=0,nok=1, noreduced=0, kbon,kini;
 
  typP newpol,newpol1;
  COEFF *sol2,*sol3;
  cout<<"avant init"<<endl;
  
  init_algo<typMat>(P,nouveaumon,maxdeg,k,Pk,Mk,b,dump,w,serv);
  Pini=P;
  kini=k;
  cout<<"apres init"<<endl;
  cout<<"onemoretime "<<onemoretime<<endl;
  cout<<"nouveaumon "<<nouveaumon<<endl;
  cout<<"k "<<k<<endl;
  cout<<"maxdeg "<<maxdeg<<endl;
#ifndef GROEBNER
 
#ifdef ONEMORETIME
  cout<<"one"<<endl;
  while(nouveaumon||(k<=maxdeg)||onemoretime)
#else
    while(nouveaumon||(k<=maxdeg)|| (!optimo) || nok )//|| (k!=deg))

#endif
#else
    while(!GB_stop(k)||(k<=maxdeg))
#endif
 
    {
#ifdef ONEMORETIME
       cout<<"two"<<endl;
       cout<<"nouveaumon"<<endl;
      if(!nouveaumon)
    cout<<"si"<<endl;
    onemoretime=0;
#endif
    
        
    int killspol;
    //test si on est dans les conditions d'application
   gettimeofday(&initclock,NULL); 
   cout<<"onemoretime "<<onemoretime<<endl;
   cout<<"nouveaumon"<<nouveaumon<< endl;
   cout<<"k "<<k<<endl;
   cout<<"maxdeg "<<maxdeg<<endl;
   cout<<"testsdp(k,dump,b,serv) "<<testsdp(k,dump,b,serv)<<endl;
   for(typename Base::const_iterator p=b.begin();p!=b.end();p++)
        {
    for(int i=0;i<p->taille1;i++)
      {
        cout<<"p.accept[i] "<<p->accept[i]<<endl;
      }
    for(int i=0;i<p->taille2;i++)
      {
        cout<<"p.refuse[i] "<<p->refuse[i]<<endl;
      }
        }
//todo este if es por ver si el noyau de k+1 se reduce con la base que hemos calculado o no   
//hay un problema en la reinicializacion de las variables cuando el noyau no se reduce
     cout<<"k"<<k<<endl;
     cout<<"maxdeg"<<maxdeg<<endl;
     cout<<"optimo"<<optimo<<endl;
     cout<<"nok"<<nok<<endl;
 

//   if(testsdp(k,dump,b,serv)||(!onemoretime))
     if((testsdp(k,dump,b,serv) && (!optimo)) || (k==deg))
      //envoie la routine de calcul de sdp
      {
    int mindeg_newpol;
    
    
    
    
    cout<<"un nouveau tour de boucle et k vaut "<<k<<endl;
//  if(!onemoretime)//sdpa!!!!!!!!  
//   generickernel_testF(newpol,2*k,dump,b,serv,F,*&sol2);
//  else
    
    cout<<"deg"<<deg<<endl;
    
      if (nogap)
      {
      cout<<"sol3"<<k<<endl;
      cout<<"kbon"<<kbon<<endl;
      if (k==deg)
      { cout<<"pasas por aqui"<<endl;
        newpol1.erase(newpol1.begin(),newpol1.end());
//      newpol=newpol1;
        
        for(typename typP::iterator iter=newpol.begin();iter!=newpol.end();
            iter++)
           {
             cout<<*iter<<" ";
             cout<<endl;
           }
      } 
     
      
      newpol1.erase(newpol1.begin(),newpol1.end());
//#ifdef CSDP
//    generickernel_testTT(newpol1,k,dump,b,serv,F,*&sol3);
//#else
      generickernel_testF(newpol1,k,dump,b,serv,F,*&sol3);
//#endif
      cout<<"solucionprimal k"<< sol2[2] << endl;
        cout<<"solucionprimal k+1"<< sol3[2] << endl;
        cout<<"diferenciasprimales"<<abs(sol2[2]-sol3[2])*1e+1<<endl;
        cout<<"k1"<<k1<<endl;
        cout<<"k"<<k<<endl;
        cout<<"gap"<<abs(sol3[2]-sol3[3])*1e+4<<endl;
        cout<<"deg"<<deg<<endl;
        cout<<"!newpol.empty()"<<!newpol.empty()<<endl;
        cout<<"newpol1.empty()"<<newpol1.empty()<<endl;
        
     
        if (((abs(sol2[2]-sol3[2])*1e+1<1) && (!newpol.empty()) && (k1!=k))
          || ((k==deg)) )
//      if ((abs(sol3[0])*1e+5<1) && (abs(sol2[2]-sol3[2])*1e+5<1) && (!newpol.empty()) && (k1!=k))
         
        {  
         if (k==deg && newpol1.empty())  
          {
        
        nok=0;
        continue;
        
          }
          else
          {
        if (k!=deg)
        {  
          optimo=1;  
          deg=k+2;
          cout<<"deg dentro"<<deg<<endl;
          int numkerf=0;
             cout<<"noyau bon"<<endl;
             for(typename typP::iterator iter=newpol.begin();iter!=newpol.end();
             iter++,numkerf++)
           {
             cout<<*iter<<" ";
             cout<<endl;
           }
         mindeg_newpol=Degree(newpol.front());
         cout<<"mindeg "<<mindeg_newpol<<" k1 "<<k1<<endl;
         for(typename typP::iterator iter=newpol.begin();
        iter!=newpol.end();iter++)
          mindeg_newpol=(mindeg_newpol<Degree(*iter)
                  ?mindeg_newpol:Degree(*iter));
         cout<<"mindeg "<<mindeg_newpol<<" k1 "<<k1<<endl; 
        }
        if (k==deg && (!newpol.empty()))
        { 
//       for(typename typP::iterator iter=newpol1.begin();
//      iter!=newpol1.end();iter++)
//       newpol.push_back(*iter);
//       for(typename typP::iterator iter=newpol.begin();iter!=newpol.end();
//             iter++)
//         {
//             cout<<*iter<<"newpol2fois ";
//             cout<<endl;
//         }
                 newpol.erase(newpol.begin(),newpol.end());
         newpol=newpol1;
         mindeg_newpol=Degree(newpol.front());
         cout<<"mindeg2fois"<<mindeg_newpol<<endl;
        }
//      nok=0;
        
//       for(typename typP::iterator iterP=P.begin();
//      iterP!=P.end();iterP++)
//       newpol.push_back(*iterP);
         P.erase(P.begin(),P.end());
        for(typename typP::iterator iter=newpol.begin();
        iter!=newpol.end();iter++)
          if(Degree(*iter)==mindeg_newpol)
        P.push_back(*iter);
        if(k-2>=mindeg_newpol)
          {
        list<mon *> exceed;
            list<int> sizeexceed;
        typPk tmpPk;
        conv_merge(tmpPk,newpol,exceed,sizeexceed,b,serv);
        k=mindeg_newpol;
                
//      if (!nok) deg=0;
//      else deg=k*2;
        cout<<"k noyau bon"<< k<<endl;
        
        
        recover(Pk,Mk,dump,k);


//      cout<<"Pk.size() apres recover "<<Pk.size()<<endl;
        if (k!=deg)
        {
        if((k>0)||(k==-1))
          forget(b,dump,k,recall);
        else
          forget0(b,dump,k,recall);
        }

        NewCrochetchoix(P,Pk,Mk,tmpPk,k,dump,b,recall,w,serv);
        for(typename typP::iterator iter=P.begin();iter!=P.end();
                 iter++)
                 cout<<*iter<<" ";
                 cout<<endl;
        serv.compress(Pk,dump,b,k);
        cout<<"compress"<<endl;
        Dump(Pk,dump);

        continue;
          }
          }
        }
        else
        {
          
          cout<<"pasa por aqui cambiamos"<<endl;
          sol2=sol3;
          newpol=newpol1;
          
          
       } 
      }
      else
      {
      cout<<"sol2"<<k<<endl;  
      k1=k;
      newpol.erase(newpol.begin(),newpol.end());
//#ifdef CSDP
//    generickernel_testTT(newpol,k,dump,b,serv,F,*&sol2);
//#else
      generickernel_testF(newpol,k,dump,b,serv,F,*&sol2);
//#endif
      int numker=0;
          
           for(typename typP::iterator iter=newpol.begin();iter!=newpol.end();
            iter++,numker++)
          cout<<*iter<<" ";
          cout<<endl;
      cout<<"newpol "<<newpol.empty()<<endl;
      cout<<"numker"<<numker<<endl;
      //pour le case de polynome dans degree 2
      if (k==2 && maxdeg==1)
      {
        nogap=1;
        optimo=1;
        nok=0;
        
      }
      else{
        
      cout<<"gap"<<sol2[0]<<endl;
      cout<<"gapx"<<abs(sol2[0])*1e+4<<endl;
      if (abs(sol2[0])*1e+4<1){
        nogap=1;
        for(typename typP::iterator iter=newpol.begin();iter!=newpol.end();
        iter++,numker++)
          cout<<*iter<<" ";
        cout<<endl;
        cout<<"newpol "<<newpol.empty()<<endl;
        cout<<"numker"<<numker<<endl;
        
       }
      }
      
     }

      } 


      
 

#ifdef BONRAJOUT
      for(typename Base::const_iterator p=b.begin();p!=b.end();p++)
        {
    for(int i=0;i<p->taille1;i++)
      {
        cout<<"p.accept[i] "<<p->accept[i]<<endl;
      }
    for(int i=0;i<p->taille2;i++)
      {
        cout<<"p.refuse[i] "<<p->refuse[i]<<endl;
      }
        }
#endif
#ifdef DEB

    //cout<<"mon a la fin de la boulcle de l'algo "<<Mk.size()<<endl;
      //for(typename typMk::iterator iter=Mk.begin();iter!=Mk.end();iter++)
      // cout<<*iter<<endl;  
  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<<"les sizes "<<iter->size<<endl;
      {
    int cpt=0;
    cout<<invconv<typename typP::value_type>(*iter)<<endl;       
    for(int i=0;i<iter->sizenf;i++)
      for(int j=0;j<8;j++)
        if (((iter->nfind[i]>>j)&1) && (iter->nf[cpt++]==0))
          {
        cout<<"ici ca couille a la place"<<8*i+j<<endl;
        cout<<iter->sizenf<<" "<<iter->size<<endl;
        exit(1);
          }
      }
#endif   
   
    S=Spolordsup(Pk,b,Spoldejavu);
    
  
    cout<<"newpkmkmatrixof"<<endl;
    cout<<"k"<<k<<endl;
  
    killspol=!newPkMkMatrixof(Mat,Pk,P,Mk,k,b,dump,recall,w,serv);
#ifdef PEQUAN
    sprintf(name,"mat%d",toto);
    fic=fopen(name,"w");
    printmatfile_pequan(Mat,fic);
    fclose(fic);
    toto++;
#endif
    
    if(killspol) S.erase(S.begin(),S.end());
    if (k+1>=maxdeg) allpolused=1;
    cout<<"Mk.size()"<<Mk.size()<<endl;
    if(Mk.size()==0) nouveaumon=0;
    //Solve affecte a Mat la valeur U
    //cout<<"solve"<<endl;
    for(typename typPk::iterator iter=Pk.begin();iter!=Pk.end();iter++)
      cout<<"avant solve les ind "<<iter->ind<<endl;
    for(typename typMk::iterator iter=Mk.begin();iter!=Mk.end();iter++)
      cout<<"monomes dans Mk "<<*iter<<endl;
    cout<<"Mat.ncol"<<Mat.ncol<<endl;
    if (Mat.ncol!=0)
      {
    //cout<<"debut du solve"<<endl;
    Solve(Mat,L,Pk,&pr,&pc,w);
//  cout<<"fin du solve"<<endl;
    //for(int kk=0;kk<Mk.size();kk++)
    //  cout<<"permc "<<kk<<" "<<pc[kk]<<endl;
    inverse(pc,Mk.size());
    Dopermu(Mk,pc);
    {
      //ici on remet les ind a la bonne valuer 
      //a inclure dans une petite fonction inline apres
      int j=0;
      typename typMk::iterator itermon=Mk.begin();
      typename typPk::iterator iter;
      for(iter=Pk.begin();
          itermon!=Mk.end();iter++,itermon++,j++)
        {
          if(!Iszero(Mat(j,j)))
        {
          //          cout<<"ligne "<<j<<" je mets le monome "<<*itermon<<endl;
          iter->ind=*itermon*(iter->ind.GetCoeff());
        }
          else
        {
          iter->ind=mon(0);
        }
        }
      //for(;itermon!=Mk.end();iter++,itermon++)
      //  iter->ind=mon(0);
    }

    free(pr);
    free(pc);
      }

 //appliquer les permutation a MK!!!!!!!!
    // for(typename typPk::iterator iter=Pk.begin();iter!=Pk.end();iter++)
      //  cout<<"apres solve les ind "<<iter->ind<<endl;
    //for(typename typPk::iterator iter=Pk.begin();iter!=Pk.end();iter++)
    // cout<<"apres solve les pol "<<invconv<Poly>(*iter)<<endl;
    //
    //
    //APPLIQUER LES PERMUTYATIONS A MK!!
    //
    //
    //
    //
    if ((unsigned)my_rank(Mat)==Mk.size())
      //matrice de rang plein
      {
    typMk tmpSpoldejavu;
    typPk redspol,secd=secondmembre(Mat,Pk);;
    cout<<"matrice de rang plein "<<endl;
    Dump(Pk,dump);
    cout<<"Reduce Spol "<<endl;

    ReduceSpol(S,dump,redspol,b,w,serv);//tmpSpoldejavu);
    
    cout<<"secd.size() "<<secd.size()<<endl;
    my_merge(redspol,secd);
    if(redspol.size()==0)
      {
        //a voir....    Dump(Pk,dump);
        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;
        cout<<"redspol.size() "<<redspol.size()<<endl;
        if (tmpdeg==(k+1))
          my_merge(Spoldejavu,tmpSpoldejavu);
        k=tmpdeg;
        //cout<<"le mindeg ici vaut "<<k<<endl;
        //cout<<"Pk.size() avant recover "<<Pk.size()<<endl;
        recover(Pk,Mk,dump,k);


        //cout<<"Pk.size() apres recover "<<Pk.size()<<endl;
        forget(b,dump,k,recall);
        //forget(b,dump,k);
#ifdef DEB     
        cout<<"Pk.size() avant Crochetchoix "<<Pk.size()<<endl;
#endif     
        //NewCrochetchoix(P,Pk,Mk,redspol,k,dump,b,recall,Spoldejavu);
        NewCrochetchoix(P,Pk,Mk,redspol,k,dump,b,recall,w,serv);
        //NewCrochetchoix(P,Pk,Mk,redspol,k,dump,b);
#ifdef DEB     
        cout<<"Pk.size apres Crochetchoix "<<Pk.size()<<" et k "<<k<<endl;
#endif     
        NewDestroyredspol(redspol,Pk);
        serv.compress(Pk,dump,b,k);
        Dump(Pk,dump);

        L.destroystore();
        cout<<"kaquiPini"<<k<<endl;
        //misa jour de B dans crochet choix!!
        continue;
      }
      }
    else
      //la matrice n'est pas de rang plein
      {
    cout<<"matrice de rang pas plein "<<endl;
    typPk secd;
#ifdef BONRAJOUT
    AddB_dim(Mat,L,P,Pk,Mk,dump,b);
#else
    AddB(Mat,Pk,Mk,dump,b,serv);
#endif
    //
    //secondmembre supprime des trucs dans Pk!!
    //
    secd=secondmembre(Mat,Pk);
    rajoute_voisins(Pk,Mk,dump,b,w,serv);
    //ne selectionne que les non nuls
       if(secd.size()==0)
     {
       typPk redspol;
       Dump(Pk,dump);

       ReduceSpol(S,dump,redspol,b,w,serv);
#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)
         {
           //ici on modifie Pk dans AddB 
           //<=> forget(b,dump,k) AddB(..) Dump(Pk,dump);
           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);
           //Listedejafait(Mk,Spoldejavu);
           forget(b,dump,k,recall);
           //forget(b,dump,k);
           cout<<"il ya un passage par mat rang pas"
               <<"plein et pol non zero"<<endl;
           //NewCrochetchoix(P,Pk,Mk,redspol,k,dump,b,recall,Spoldejavu);
           NewCrochetchoix(P,Pk,Mk,redspol,k,dump,b,recall,w,serv);
           //NewCrochetchoix(P,Pk,Mk,redspol,k,dump,b);
           NewDestroyredspol(redspol,Pk);
           serv.compress(Pk,dump,b,k);
           Dump(Pk,dump); 

           L.destroystore();
           continue;
         }
     }
       else
     {
       //on a des pol qui se reduisent pas a 0
       //cad un defaut de commuatation dans les coins
       typPk redspol;
       //for(int i=Pk.size();i>rank(Mat);i--)
       //  Pk.pop_back();
       //cout<<"PK. size "<<Pk.size()<<" Mat.nbcol "<<Mat.ncol<<endl;
       //cout<<"rank(Mat) "<<rank(Mat)<<endl;
       //int j=0;
       //cout<<"avant recover et meme avant le dump "<<endl;
       //for(typename typPk::iterator iter = secd.begin();iter!=secd.end()
       //    ;iter++,j++)
       // cout<<"pol de secd num "<<j<<endl<<invconv<Poly>(*iter)<<endl;
       //      AddB(Mat,Pk,Mk,b);
       //cout<<"apres ADDB le dump "<<endl;
       //for(typename typPk::iterator iter = Pk.begin();iter!=Pk.end()
       //    ;iter++)
       // cout<<invconv<Poly>(*iter)<<endl;
       Dump(Pk,dump);
 
       //cout<<"secd.size()" <<secd.size()<<endl;
       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);
       //cout<<"k "<<k<<endl;
       //Listedejafait(Mk,Spoldejavu);
       //cout<<"apres recover"<<endl;
       //      for(typename typPk::iterator iter = Pk.begin();iter!=Pk.end()
       //    ;iter++)
       //  cout<<invconv<Poly>(*iter)<<endl;
       //cout<<"les Spol non reduits"<<endl;
       //for(typename typPk::iterator iter = secd.begin();iter!=secd.end()
       //    ;iter++)
       //  cout<<invconv<Poly>(*iter)<<endl;
       forget(b,dump,k,recall);
       
       //forget(b,dump,k);
       //cout<<"il ya un passage par mat pas rang plein et Spol non zero"<<endl;
       //for(typename typPk::iterator iter = secd.begin();iter!=secd.end()
       //    ;iter++)
       // cout<<invconv<Poly>(*iter)<<endl;
       //NewCrochetchoix(P,Pk,Mk,redspol,k,dump,b,recall,Spoldejavu);
       NewCrochetchoix(P,Pk,Mk,secd,k,dump,b,recall,w,serv);
       //NewCrochetchoix(P,Pk,Mk,secd,k,dump,b);
       NewDestroyredspol(secd,Pk);
#ifdef BONRAJOUT
       cout<<"Apres NewCrochetchoix"<<endl;

       for(typename Base::const_iterator p=b.begin();p!=b.end();p++)
         {
           for(int i=0;i<p->taille1;i++)
         {
           cout<<"p.accept[i] "<<p->accept[i]<<endl;
         }
           for(int i=0;i<p->taille2;i++)
         {
           cout<<"p.refuse[i] "<<p->refuse[i]<<endl;
         }
         }
#endif
       //for(typename typPk::iterator iter = Pk.begin();iter!=Pk.end()
       //    ;iter++)
       // cout<<invconv<Poly>(*iter)<<endl;
       serv.compress(Pk,dump,b,k);
       Dump(Pk,dump);

       L.destroystore();
       continue;
     }     
      }     
  }
    
    Mat.destroystore();
  
#ifdef DEBUG
  for(typename Base::const_iterator p=b.begin();p!=b.end();p++)
    {
      for(int i=0;i<p->taille1;i++)
    {
      cout<<"p.accept[i] "<<p->accept[i]<<endl;
    }
      for(int i=0;i<p->taille2;i++)
    {
      cout<<"p.refuse[i] "<<p->refuse[i]<<endl;
    }
    }
#endif
  
  destroy_space(&w);
//  delete[] &sol2;
//  delete[] &sol3;
 
  cout<<"sortie d'algo flash et dimension "<<endl;//<<critere(b,k)<<endl;
  cout<<"TPS SDP "<<tempsCDSP<<endl;
  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.. :-)

    }
#endif //ALREADY_corealgo3

        }
      //      cout<<endl;
      cout<<"g trouve ca comme nvlle eq "<<endl<<tmp<<endl;
      newpol.push_back(tmp); 
      
    }

      delete[] S;
      delete[] V;
      delete[] work;
      delete[] sol;
    }
}

template<typename typdump,typename Base, typename typserv>
int testsdp(int k, const typdump &dump,const Base &b,const typserv &serv)
{
  return !(k%2);
}
template<typename typP,typename typPk,typename typdump,typename Base
     , template<typename  T> class tmptypmat ,typename monomial_server>
void algo(typP P,typdump &dump,Base &b, monomial_server &serv)
{
#ifdef PEQUAN
  int toto=0;
  FILE *fic;
  char name[8];
#endif
  typedef typename typP::value_type polyalp;
  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;
  //typP recall 
  typPk recall;
  //Base b;
  workspace<typename typP::value_type::coeff_t> w;
  typedef tmptypmat<typename typP::value_type::coeff_t> typMat;
  typMat Mat,L;
  int onemoretime=1,nouveaumon,allpolused=0,maxdeg,k,*pr,*pc;
  cout<<"avant init"<<endl;
  
  init_algo<typMat>(P,nouveaumon,maxdeg,k,Pk,Mk,b,dump,w,serv);
  cout<<"apres init"<<endl;
  cout<<"onemoretime "<<onemoretime<<endl;
  cout<<"nouveaumon "<<nouveaumon<<endl;
  cout<<"k "<<k<<endl;
  cout<<"maxdeg "<<maxdeg<<endl;
#ifndef GROEBNER

  
  //  while((critere(b,k)==-1)||(k<=maxdeg))
#ifdef ONEMORETIME
  cout<<"one"<<endl;
  while(nouveaumon||(k<=maxdeg)||onemoretime)
#else
    while(nouveaumon||(k<=maxdeg))
#endif
#else
    while(!GB_stop(k)||(k<=maxdeg))
#endif
 
    {
#ifdef ONEMORETIME
       cout<<"two"<<endl;
       cout<<"nouveaumon"<<endl;
      if(!nouveaumon)
    cout<<"si"<<endl;
    onemoretime=0;
#endif
    //if (toto>=5) {exit(0);}
    //toto++;
        
    int killspol;
    //test si on est dans les conditions d'application
   gettimeofday(&initclock,NULL); 
   cout<<"onemoretime "<<onemoretime<<endl;
   cout<<"nouveaumon"<<nouveaumon<< endl;
   cout<<"k "<<k<<endl;
   cout<<"maxdeg "<<maxdeg<<endl;
   cout<<"testsdp(k,dump,b,serv) "<<testsdp(k,dump,b,serv)<<endl;
   if(testsdp(k,dump,b,serv)||(!onemoretime))
      //envoie la routine de calcul de sdp
      {
    int mindeg_newpol;
    typP newpol;
    cout<<"un nouveau tour de boucle et k vaut "<<k<<endl;
    if(!onemoretime)//sdpa!!!!!!!!
      //  generickernel(newpol,2*k,dump,b,serv);
     generickernel_testT(newpol,2*k,dump,b,serv);
      //  generickernelsdpa(newpol,2*k,dump,b,serv);
    else
      //  generickernel(newpol,k,dump,b,serv);
      generickernel_testT(newpol,k,dump,b,serv);
    //generickernelsdpa(newpol,k,dump,b,serv);
      gettimeofday(&tmpclock,NULL);
      tempsdssdp+=tmpclock.tv_sec-initclock.tv_sec+1e-6*(tmpclock.tv_usec-initclock.tv_usec);      

    //sdprealrad(newpol,dump,b,serv);
    //penser a decroitre k le cas echeant avec un coup de recover
    cout<<"newpol "<<newpol.empty()<<endl;
    if(!newpol.empty())
      {
        mindeg_newpol=Degree(newpol.front());
//      cout<<"mindeg "<<mindeg_newpol<<" k "<<k<<endl;
        for(typename typP::iterator iter=newpol.begin();
        iter!=newpol.end();iter++)
          mindeg_newpol=(mindeg_newpol<Degree(*iter)
                  ?mindeg_newpol:Degree(*iter));
        for(typename typP::iterator iter=newpol.begin();
        iter!=newpol.end();iter++)
          if(Degree(*iter)==mindeg_newpol)
        P.push_back(*iter);
        if(k>=mindeg_newpol)
          {
        list<mon *> exceed;
            list<int> sizeexceed;
        typPk tmpPk;
        conv_merge(tmpPk,newpol,exceed,sizeexceed,b,serv);
//      cout<<"merde merde k "<<k<<" mindeg_newpol "<<mindeg_newpol<<endl;
        k=mindeg_newpol;
        //      forget(b,dump,k,recall);
        //              recover(Pk,Mk,dump,k);
        recover(Pk,Mk,dump,k);

        //Listedejafait(Mk,Spoldejavu);
//      cout<<"Pk.size() apres recover "<<Pk.size()<<endl;
        if((k>0)||(k==-1))
          forget(b,dump,k,recall);
        else
          forget0(b,dump,k,recall);
//      cout<<"forget fait"<<endl;
        //forget(b,dump,k);
        NewCrochetchoix(P,Pk,Mk,tmpPk,k,dump,b,recall,w,serv);
        serv.compress(Pk,dump,b,k);
        cout<<"compress"<<endl;
        Dump(Pk,dump);
        continue;
          }
      }
      }
#ifdef BONRAJOUT
      for(typename Base::const_iterator p=b.begin();p!=b.end();p++)
        {
    for(int i=0;i<p->taille1;i++)
      {
        cout<<"p.accept[i] "<<p->accept[i]<<endl;
      }
    for(int i=0;i<p->taille2;i++)
      {
        cout<<"p.refuse[i] "<<p->refuse[i]<<endl;
      }
        }
#endif
#if 1//def DEB

    //cout<<"mon a la fin de la boulcle de l'algo "<<Mk.size()<<endl;
      //for(typename typMk::iterator iter=Mk.begin();iter!=Mk.end();iter++)
      // cout<<*iter<<endl;  
  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<<"les sizes "<<iter->size<<endl;
      {
    int cpt=0;
    cout<<invconv<typename typP::value_type>(*iter,serv)<<endl;       
    for(int i=0;i<iter->sizenf;i++)
      for(int j=0;j<8;j++)
        if (((iter->nfind[i]>>j)&1) && (iter->nf[cpt++]==0))
          {
        cout<<"ici ca couille a la place"<<8*i+j<<endl;
        cout<<iter->sizenf<<" "<<iter->size<<endl;
        exit(1);
          }
      }
#endif   

  //  cout<<"Spolordsup"<<endl;
    S=Spolordsup(Pk,b,Spoldejavu);
    //S.erase(S.begin(),S.end());
    //S=Spolordsup(Pk,b);
    cout<<endl;
    cout<<endl<<"newpkmkmatrixof"<<endl;
    //cout<<"Pk.size() "<<Pk.size()<<endl;
    //killspol=!newPkMkMatrixof(Mat,Pk,P,Mk,k,b,dump,recall,Spoldejavu);
    killspol=!newPkMkMatrixof(Mat,Pk,P,Mk,k,b,dump,recall,w,serv);
#ifdef PEQUAN
    sprintf(name,"mat%d",toto);
    fic=fopen(name,"w");
    printmatfile_pequan(Mat,fic);
    fclose(fic);
    toto++;
#endif
    //    if (toto>=5) {cout<<"killredspol "<<killspol<<endl; exit(0);}
    // killspol=!newPkMkMatrixof(Mat,Pk,P,Mk,k,b,dump);
    if(killspol) S.erase(S.begin(),S.end());
    if (k+1>=maxdeg) allpolused=1;
    if(Mk.size()==0) nouveaumon=0;
    //cout<<"j'en suis a k="<<k<<endl;
    //cout<<"Ici dans algo Mat"<<endl;
    //#ifdef BONRAJOUT
    //affdebug(Mat);
    //#endif
    //Solve affecte a Mat la valeur U
    //cout<<"solve"<<endl;
    //for(typename typPk::iterator iter=Pk.begin();iter!=Pk.end();iter++)
    //  cout<<"avant solve les ind "<<iter->ind<<endl;
    //for(typename typPk::iterator iter=Pk.begin();iter!=Pk.end();iter++)
    //  cout<<"avant solve les pol "<<invconv<Poly>(*iter)<<endl;
    //if(k==3) exit(-10);
    //for(typename typMk::iterator iter=Mk.begin();iter!=Mk.end();iter++)
    //  cout<<"monomes dans Mk "<<*iter<<endl;
    
    if (Mat.ncol!=0)
      {
    //cout<<"debut du solve"<<endl;
    Solve(Mat,L,Pk,&pr,&pc,w);
//  cout<<"fin du solve"<<endl;
    //for(int kk=0;kk<Mk.size();kk++)
    //  cout<<"permc "<<kk<<" "<<pc[kk]<<endl;
    inverse(pc,Mk.size());
    Dopermu(Mk,pc);
    {
      //ici on remet les ind a la bonne valuer 
      //a inclure dans une petite fonction inline apres
      int j=0;
      typename typMk::iterator itermon=Mk.begin();
      typename typPk::iterator iter;
      for(iter=Pk.begin();
          itermon!=Mk.end();iter++,itermon++,j++)
        {
          if(!Iszero(Mat(j,j)))
        {
          //          cout<<"ligne "<<j<<" je mets le monome "<<*itermon<<endl;
          iter->ind=*itermon*(iter->ind.GetCoeff());
        }
          else
        {
          iter->ind=mon(0);
        }
        }
      //for(;itermon!=Mk.end();iter++,itermon++)
      //  iter->ind=mon(0);
    }

    free(pr);
    free(pc);
      }

 //appliquer les permutation a MK!!!!!!!!
    // for(typename typPk::iterator iter=Pk.begin();iter!=Pk.end();iter++)
      //  cout<<"apres solve les ind "<<iter->ind<<endl;
    //for(typename typPk::iterator iter=Pk.begin();iter!=Pk.end();iter++)
    // cout<<"apres solve les pol "<<invconv<Poly>(*iter)<<endl;
    //
    //
    //APPLIQUER LES PERMUTYATIONS A MK!!
    //
    //
    //
    //
    if ((unsigned)my_rank(Mat)==Mk.size())
      //matrice de rang plein
      {
    typMk tmpSpoldejavu;
    typPk redspol,secd=secondmembre(Mat,Pk);;
    //secondmembre2(Mat,Pk,secd);
    //typename typPk::iterator iter=Pk.begin();
    cout<<"matrice de rang plein "<<endl;
    //for(unsigned int i=0;i<Mk.size();i++,iter++);
    //Pk.erase(iter,Pk.end());
    //cout<<"Dump "<<endl;
    Dump(Pk,dump);
    //cout<<"Reduce Spol "<<endl;
    
    ReduceSpol(S,dump,redspol,b,w,serv);//tmpSpoldejavu);
    //cout<<"secd.size() "<<secd.size()<<endl;
    my_merge(redspol,secd);
    if(redspol.size()==0)
      {
        //a voir....    Dump(Pk,dump);
        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;
        cout<<"redspol.size() "<<redspol.size()<<endl;
        //cout<<invconv<typename typP::value_type>(redspol.front())<<endl;
        if (tmpdeg==(k+1))
          my_merge(Spoldejavu,tmpSpoldejavu);
        k=tmpdeg;
        //cout<<"le mindeg ici vaut "<<k<<endl;
        //cout<<"Pk.size() avant recover "<<Pk.size()<<endl;
        recover(Pk,Mk,dump,k);

        //Listedejafait(Mk,Spoldejavu);
        //cout<<"Pk.size() apres recover "<<Pk.size()<<endl;
        forget(b,dump,k,recall);
        //forget(b,dump,k);
#ifdef DEB     
        cout<<"Pk.size() avant Crochetchoix "<<Pk.size()<<endl;
#endif     
        //NewCrochetchoix(P,Pk,Mk,redspol,k,dump,b,recall,Spoldejavu);
        NewCrochetchoix(P,Pk,Mk,redspol,k,dump,b,recall,w,serv);
        //NewCrochetchoix(P,Pk,Mk,redspol,k,dump,b);
#ifdef DEB     
        cout<<"Pk.size apres Crochetchoix "<<Pk.size()<<" et k "<<k<<endl;
#endif     
        NewDestroyredspol(redspol,Pk);
        serv.compress(Pk,dump,b,k);
        Dump(Pk,dump);
        L.destroystore();
        //misa jour de B dans crochet choix!!
        continue;
      }
      }
    else
      //la matrice n'est pas de rang plein
      {
    cout<<"matrice de rang pas plein "<<endl;
    typPk secd;
#ifdef BONRAJOUT
    AddB_dim(Mat,L,P,Pk,Mk,dump,b);
#else
    AddB(Mat,Pk,Mk,dump,b,serv);
#endif
    //
    //secondmembre supprime des trucs dans Pk!!
    //
    secd=secondmembre(Mat,Pk);
    rajoute_voisins(Pk,Mk,dump,b,w,serv);
    //ne selectionne que les non nuls
       if(secd.size()==0)
     {
       typPk redspol;
       //for(int i=Pk.size();i>rank(Mat);i--)
       //{
       //  if(Pk.back().size!=0)
       // MAC_REV_FREE<typename typMat::coeff_t>(Pk.rbegin()->nf
       //    ,Pk.rbegin()->size*sizeof(typename typMat::coeff_t));
       //  Pk.pop_back();
       //}//on vire les 0 avant de dumper
       //      AddB(Mat,Pk,Mk,dump,b);
       Dump(Pk,dump);
       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)
         {
           // forget(b,dump,k);
           //AddB(Mat,Pk,Mk,b);
           //Dump(Pk,dump);
           //ici on modifie Pk dans AddB 
           //<=> forget(b,dump,k) AddB(..) Dump(Pk,dump);
           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);
           //Listedejafait(Mk,Spoldejavu);
           forget(b,dump,k,recall);
           //forget(b,dump,k);
           cout<<"il ya un passage par mat rang pas"
               <<"plein et pol non zero"<<endl;
           //NewCrochetchoix(P,Pk,Mk,redspol,k,dump,b,recall,Spoldejavu);
           NewCrochetchoix(P,Pk,Mk,redspol,k,dump,b,recall,w,serv);
           //NewCrochetchoix(P,Pk,Mk,redspol,k,dump,b);
           NewDestroyredspol(redspol,Pk);
           serv.compress(Pk,dump,b,k);
           Dump(Pk,dump); 
           L.destroystore();
           continue;
         }
     }
       else
     {
       //on a des pol qui se reduisent pas a 0
       //cad un defaut de commuatation dans les coins
       typPk redspol;
       //for(int i=Pk.size();i>rank(Mat);i--)
       //  Pk.pop_back();
       //cout<<"PK. size "<<Pk.size()<<" Mat.nbcol "<<Mat.ncol<<endl;
       //cout<<"rank(Mat) "<<rank(Mat)<<endl;
       //int j=0;
       //cout<<"avant recover et meme avant le dump "<<endl;
       //for(typename typPk::iterator iter = secd.begin();iter!=secd.end()
       //    ;iter++,j++)
       // cout<<"pol de secd num "<<j<<endl<<invconv<Poly>(*iter)<<endl;
       //      AddB(Mat,Pk,Mk,b);
       //cout<<"apres ADDB le dump "<<endl;
       //for(typename typPk::iterator iter = Pk.begin();iter!=Pk.end()
       //    ;iter++)
       // cout<<invconv<Poly>(*iter)<<endl;
       Dump(Pk,dump);
       //cout<<"secd.size()" <<secd.size()<<endl;
       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);
       //cout<<"k "<<k<<endl;
       //Listedejafait(Mk,Spoldejavu);
       //cout<<"apres recover"<<endl;
       //      for(typename typPk::iterator iter = Pk.begin();iter!=Pk.end()
       //    ;iter++)
       //  cout<<invconv<Poly>(*iter)<<endl;
       //cout<<"les Spol non reduits"<<endl;
       //for(typename typPk::iterator iter = secd.begin();iter!=secd.end()
       //    ;iter++)
       //  cout<<invconv<Poly>(*iter)<<endl;
       forget(b,dump,k,recall);
       
       //forget(b,dump,k);
       //cout<<"il ya un passage par mat pas rang plein et Spol non zero"<<endl;
       //for(typename typPk::iterator iter = secd.begin();iter!=secd.end()
       //    ;iter++)
       // cout<<invconv<Poly>(*iter)<<endl;
       //NewCrochetchoix(P,Pk,Mk,redspol,k,dump,b,recall,Spoldejavu);
       NewCrochetchoix(P,Pk,Mk,secd,k,dump,b,recall,w,serv);
       //NewCrochetchoix(P,Pk,Mk,secd,k,dump,b);
       NewDestroyredspol(secd,Pk);
#ifdef BONRAJOUT
       cout<<"Apres NewCrochetchoix"<<endl;

       for(typename Base::const_iterator p=b.begin();p!=b.end();p++)
         {
           for(int i=0;i<p->taille1;i++)
         {
           cout<<"p.accept[i] "<<p->accept[i]<<endl;
         }
           for(int i=0;i<p->taille2;i++)
         {
           cout<<"p.refuse[i] "<<p->refuse[i]<<endl;
         }
         }
#endif
       //for(typename typPk::iterator iter = Pk.begin();iter!=Pk.end()
       //    ;iter++)
       // cout<<invconv<Poly>(*iter)<<endl;
       serv.compress(Pk,dump,b,k);
       Dump(Pk,dump);
       L.destroystore();
       continue;
     }
      
      }
  }
  
  Mat.destroystore();
  //while nouveau mon etc...
  // Pk=recomposePk(dump);
  //return Pk;
  //  return;
#ifdef DEBUG
  for(typename Base::const_iterator p=b.begin();p!=b.end();p++)
    {
      for(int i=0;i<p->taille1;i++)
    {
      cout<<"p.accept[i] "<<p->accept[i]<<endl;
    }
      for(int i=0;i<p->taille2;i++)
    {
      cout<<"p.refuse[i] "<<p->refuse[i]<<endl;
    }
    }
#endif
  destroy_space(&w);
  cout<<"sortie d'algo flash et dimension "<<endl;//<<critere(b,k)<<endl;
  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.. :-)

    }

template<typename typP,typename typPk,typename typdump,typename Base
     , template<typename  T> class tmptypmat ,typename monomial_server>
void algo(typP P,typdump &dump,Base &b, monomial_server &serv,typP F)
{
#ifdef PEQUAN
  int toto=0;
  FILE *fic;
  char name[8];
#endif
  typedef typename typP::value_type polyalp;
  typedef list<typename typPk::value_type::monom_t> typMk;
  typedef typename typMk::value_type mon;
  typedef typename typPk::value_type pol;
  cout<<"entra aqui "<<endl; 
  typMk Mk;
  typMk Spoldejavu;
  typPk Pk,S;
  typPk recall;
  typP Pini;
  workspace<typename typP::value_type::coeff_t> w;
  typedef tmptypmat<typename typP::value_type::coeff_t> typMat;
  typMat Mat,L;
  int onemoretime=1,nouveaumon,allpolused=0,maxdeg,k,maxdegb,kb,*pr,*pc,optimo=0,k1;
  int nogap=0,deg=0,nok=1, noreduced=0, kbon,kini;
 
  typP newpol,newpol1;
  COEFF *sol2,*sol3;
  cout<<"avant init"<<endl;
  
  init_algo<typMat>(P,nouveaumon,maxdeg,k,Pk,Mk,b,dump,w,serv);
  Pini=P;
  kini=k;
  cout<<"apres init"<<endl;
  cout<<"onemoretime "<<onemoretime<<endl;
  cout<<"nouveaumon "<<nouveaumon<<endl;
  cout<<"k "<<k<<endl;
  cout<<"maxdeg "<<maxdeg<<endl;
#ifndef GROEBNER
 
#ifdef ONEMORETIME
  cout<<"one"<<endl;
  while(nouveaumon||(k<=maxdeg)||onemoretime)
#else
    while(nouveaumon||(k<=maxdeg)|| (!optimo) || nok )//|| (k!=deg))

#endif
#else
    while(!GB_stop(k)||(k<=maxdeg))
#endif
 
    {
#ifdef ONEMORETIME
       cout<<"two"<<endl;
       cout<<"nouveaumon"<<endl;
      if(!nouveaumon)
    cout<<"si"<<endl;
    onemoretime=0;
#endif
    
        
    int killspol;
    //test si on est dans les conditions d'application
   gettimeofday(&initclock,NULL); 
   cout<<"onemoretime "<<onemoretime<<endl;
   cout<<"nouveaumon"<<nouveaumon<< endl;
   cout<<"k "<<k<<endl;
   cout<<"maxdeg "<<maxdeg<<endl;
   cout<<"testsdp(k,dump,b,serv) "<<testsdp(k,dump,b,serv)<<endl;
   for(typename Base::const_iterator p=b.begin();p!=b.end();p++)
        {
    for(int i=0;i<p->taille1;i++)
      {
        cout<<"p.accept[i] "<<p->accept[i]<<endl;
      }
    for(int i=0;i<p->taille2;i++)
      {
        cout<<"p.refuse[i] "<<p->refuse[i]<<endl;
      }
        }
//todo este if es por ver si el noyau de k+1 se reduce con la base que hemos calculado o no   
//hay un problema en la reinicializacion de las variables cuando el noyau no se reduce
     cout<<"k"<<k<<endl;
     cout<<"maxdeg"<<maxdeg<<endl;
     cout<<"optimo"<<optimo<<endl;
     cout<<"nok"<<nok<<endl;
 

//   if(testsdp(k,dump,b,serv)||(!onemoretime))
     if((testsdp(k,dump,b,serv) && (!optimo)) || (k==deg))
      //envoie la routine de calcul de sdp
      {
    int mindeg_newpol;
    
    
    
    
    cout<<"un nouveau tour de boucle et k vaut "<<k<<endl;
//  if(!onemoretime)//sdpa!!!!!!!!  
//   generickernel_testF(newpol,2*k,dump,b,serv,F,*&sol2);
//  else
    
    cout<<"deg"<<deg<<endl;
    
      if (nogap)
      {
      cout<<"sol3"<<k<<endl;
      cout<<"kbon"<<kbon<<endl;
      if (k==deg)
      { cout<<"pasas por aqui"<<endl;
        newpol1.erase(newpol1.begin(),newpol1.end());
//      newpol=newpol1;
        
        for(typename typP::iterator iter=newpol.begin();iter!=newpol.end();
            iter++)
           {
             cout<<*iter<<" ";
             cout<<endl;
           }
      } 
     
      
      newpol1.erase(newpol1.begin(),newpol1.end());
//#ifdef CSDP
//    generickernel_testTT(newpol1,k,dump,b,serv,F,*&sol3);
//#else
      generickernel_testF(newpol1,k,dump,b,serv,F,*&sol3);
//#endif
      cout<<"solucionprimal k"<< sol2[2] << endl;
        cout<<"solucionprimal k+1"<< sol3[2] << endl;
        cout<<"diferenciasprimales"<<abs(sol2[2]-sol3[2])*1e+1<<endl;
        cout<<"k1"<<k1<<endl;
        cout<<"k"<<k<<endl;
        cout<<"gap"<<abs(sol3[2]-sol3[3])*1e+4<<endl;
        cout<<"deg"<<deg<<endl;
        cout<<"!newpol.empty()"<<!newpol.empty()<<endl;
        cout<<"newpol1.empty()"<<newpol1.empty()<<endl;
        
     
        if (((abs(sol2[2]-sol3[2])*1e+1<1) && (!newpol.empty()) && (k1!=k))
          || ((k==deg)) )
//      if ((abs(sol3[0])*1e+5<1) && (abs(sol2[2]-sol3[2])*1e+5<1) && (!newpol.empty()) && (k1!=k))
         
        {  
         if (k==deg && newpol1.empty())  
          {
        
        nok=0;
        continue;
        
          }
          else
          {
        if (k!=deg)
        {  
          optimo=1;  
          deg=k+2;
          cout<<"deg dentro"<<deg<<endl;
          int numkerf=0;
             cout<<"noyau bon"<<endl;
             for(typename typP::iterator iter=newpol.begin();iter!=newpol.end();
             iter++,numkerf++)
           {
             cout<<*iter<<" ";
             cout<<endl;
           }
         mindeg_newpol=Degree(newpol.front());
         cout<<"mindeg "<<mindeg_newpol<<" k1 "<<k1<<endl;
         for(typename typP::iterator iter=newpol.begin();
        iter!=newpol.end();iter++)
          mindeg_newpol=(mindeg_newpol<Degree(*iter)
                  ?mindeg_newpol:Degree(*iter));
         cout<<"mindeg "<<mindeg_newpol<<" k1 "<<k1<<endl; 
        }
        if (k==deg && (!newpol.empty()))
        { 
//       for(typename typP::iterator iter=newpol1.begin();
//      iter!=newpol1.end();iter++)
//       newpol.push_back(*iter);
//       for(typename typP::iterator iter=newpol.begin();iter!=newpol.end();
//             iter++)
//         {
//             cout<<*iter<<"newpol2fois ";
//             cout<<endl;
//         }
                 newpol.erase(newpol.begin(),newpol.end());
         newpol=newpol1;
         mindeg_newpol=Degree(newpol.front());
         cout<<"mindeg2fois"<<mindeg_newpol<<endl;
        }
//      nok=0;
        
//       for(typename typP::iterator iterP=P.begin();
//      iterP!=P.end();iterP++)
//       newpol.push_back(*iterP);
         P.erase(P.begin(),P.end());
        for(typename typP::iterator iter=newpol.begin();
        iter!=newpol.end();iter++)
          if(Degree(*iter)==mindeg_newpol)
        P.push_back(*iter);
        if(k-2>=mindeg_newpol)
          {
        list<mon *> exceed;
            list<int> sizeexceed;
        typPk tmpPk;
        conv_merge(tmpPk,newpol,exceed,sizeexceed,b,serv);
        k=mindeg_newpol;
                
//      if (!nok) deg=0;
//      else deg=k*2;
        cout<<"k noyau bon"<< k<<endl;
        
        
        recover(Pk,Mk,dump,k);


//      cout<<"Pk.size() apres recover "<<Pk.size()<<endl;
        if (k!=deg)
        {
        if((k>0)||(k==-1))
          forget(b,dump,k,recall);
        else
          forget0(b,dump,k,recall);
        }

        NewCrochetchoix(P,Pk,Mk,tmpPk,k,dump,b,recall,w,serv);
        for(typename typP::iterator iter=P.begin();iter!=P.end();
                 iter++)
                 cout<<*iter<<" ";
                 cout<<endl;
        serv.compress(Pk,dump,b,k);
        cout<<"compress"<<endl;
        Dump(Pk,dump);

        continue;
          }
          }
        }
        else
        {
          
          cout<<"pasa por aqui cambiamos"<<endl;
          sol2=sol3;
          newpol=newpol1;
          
          
       } 
      }
      else
      {
      cout<<"sol2"<<k<<endl;  
      k1=k;
      newpol.erase(newpol.begin(),newpol.end());
//#ifdef CSDP
//    generickernel_testTT(newpol,k,dump,b,serv,F,*&sol2);
//#else
      generickernel_testF(newpol,k,dump,b,serv,F,*&sol2);
//#endif
      int numker=0;
          
           for(typename typP::iterator iter=newpol.begin();iter!=newpol.end();
            iter++,numker++)
          cout<<*iter<<" ";
          cout<<endl;
      cout<<"newpol "<<newpol.empty()<<endl;
      cout<<"numker"<<numker<<endl;
      //pour le case de polynome dans degree 2
      if (k==2 && maxdeg==1)
      {
        nogap=1;
        optimo=1;
        nok=0;
        
      }
      else{
        
      cout<<"gap"<<sol2[0]<<endl;
      cout<<"gapx"<<abs(sol2[0])*1e+4<<endl;
      if (abs(sol2[0])*1e+4<1){
        nogap=1;
        for(typename typP::iterator iter=newpol.begin();iter!=newpol.end();
        iter++,numker++)
          cout<<*iter<<" ";
        cout<<endl;
        cout<<"newpol "<<newpol.empty()<<endl;
        cout<<"numker"<<numker<<endl;
        
       }
      }
      
     }

      } 


      
 

#ifdef BONRAJOUT
      for(typename Base::const_iterator p=b.begin();p!=b.end();p++)
        {
    for(int i=0;i<p->taille1;i++)
      {
        cout<<"p.accept[i] "<<p->accept[i]<<endl;
      }
    for(int i=0;i<p->taille2;i++)
      {
        cout<<"p.refuse[i] "<<p->refuse[i]<<endl;
      }
        }
#endif
#ifdef DEB

    //cout<<"mon a la fin de la boulcle de l'algo "<<Mk.size()<<endl;
      //for(typename typMk::iterator iter=Mk.begin();iter!=Mk.end();iter++)
      // cout<<*iter<<endl;  
  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<<"les sizes "<<iter->size<<endl;
      {
    int cpt=0;
    cout<<invconv<typename typP::value_type>(*iter)<<endl;       
    for(int i=0;i<iter->sizenf;i++)
      for(int j=0;j<8;j++)
        if (((iter->nfind[i]>>j)&1) && (iter->nf[cpt++]==0))
          {
        cout<<"ici ca couille a la place"<<8*i+j<<endl;
        cout<<iter->sizenf<<" "<<iter->size<<endl;
        exit(1);
          }
      }
#endif   
   
    S=Spolordsup(Pk,b,Spoldejavu);
    
  
    cout<<"newpkmkmatrixof"<<endl;
    cout<<"k"<<k<<endl;
  
    killspol=!newPkMkMatrixof(Mat,Pk,P,Mk,k,b,dump,recall,w,serv);
#ifdef PEQUAN
    sprintf(name,"mat%d",toto);
    fic=fopen(name,"w");
    printmatfile_pequan(Mat,fic);
    fclose(fic);
    toto++;
#endif
    
    if(killspol) S.erase(S.begin(),S.end());
    if (k+1>=maxdeg) allpolused=1;
    cout<<"Mk.size()"<<Mk.size()<<endl;
    if(Mk.size()==0) nouveaumon=0;
    //Solve affecte a Mat la valeur U
    //cout<<"solve"<<endl;
    for(typename typPk::iterator iter=Pk.begin();iter!=Pk.end();iter++)
      cout<<"avant solve les ind "<<iter->ind<<endl;
    for(typename typMk::iterator iter=Mk.begin();iter!=Mk.end();iter++)
      cout<<"monomes dans Mk "<<*iter<<endl;
    cout<<"Mat.ncol"<<Mat.ncol<<endl;
    if (Mat.ncol!=0)
      {
    //cout<<"debut du solve"<<endl;
    Solve(Mat,L,Pk,&pr,&pc,w);
//  cout<<"fin du solve"<<endl;
    //for(int kk=0;kk<Mk.size();kk++)
    //  cout<<"permc "<<kk<<" "<<pc[kk]<<endl;
    inverse(pc,Mk.size());
    Dopermu(Mk,pc);
    {
      //ici on remet les ind a la bonne valuer 
      //a inclure dans une petite fonction inline apres
      int j=0;
      typename typMk::iterator itermon=Mk.begin();
      typename typPk::iterator iter;
      for(iter=Pk.begin();
          itermon!=Mk.end();iter++,itermon++,j++)
        {
          if(!Iszero(Mat(j,j)))
        {
          //          cout<<"ligne "<<j<<" je mets le monome "<<*itermon<<endl;
          iter->ind=*itermon*(iter->ind.GetCoeff());
        }
          else
        {
          iter->ind=mon(0);
        }
        }
      //for(;itermon!=Mk.end();iter++,itermon++)
      //  iter->ind=mon(0);
    }

    free(pr);
    free(pc);
      }

 //appliquer les permutation a MK!!!!!!!!
    // for(typename typPk::iterator iter=Pk.begin();iter!=Pk.end();iter++)
      //  cout<<"apres solve les ind "<<iter->ind<<endl;
    //for(typename typPk::iterator iter=Pk.begin();iter!=Pk.end();iter++)
    // cout<<"apres solve les pol "<<invconv<Poly>(*iter)<<endl;
    //
    //
    //APPLIQUER LES PERMUTYATIONS A MK!!
    //
    //
    //
    //
    if ((unsigned)my_rank(Mat)==Mk.size())
      //matrice de rang plein
      {
    typMk tmpSpoldejavu;
    typPk redspol,secd=secondmembre(Mat,Pk);;
    cout<<"matrice de rang plein "<<endl;
    Dump(Pk,dump);
    cout<<"Reduce Spol "<<endl;

    ReduceSpol(S,dump,redspol,b,w,serv);//tmpSpoldejavu);
    
    cout<<"secd.size() "<<secd.size()<<endl;
    my_merge(redspol,secd);
    if(redspol.size()==0)
      {
        //a voir....    Dump(Pk,dump);
        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;
        cout<<"redspol.size() "<<redspol.size()<<endl;
        if (tmpdeg==(k+1))
          my_merge(Spoldejavu,tmpSpoldejavu);
        k=tmpdeg;
        //cout<<"le mindeg ici vaut "<<k<<endl;
        //cout<<"Pk.size() avant recover "<<Pk.size()<<endl;
        recover(Pk,Mk,dump,k);


        //cout<<"Pk.size() apres recover "<<Pk.size()<<endl;
        forget(b,dump,k,recall);
        //forget(b,dump,k);
#ifdef DEB     
        cout<<"Pk.size() avant Crochetchoix "<<Pk.size()<<endl;
#endif     
        //NewCrochetchoix(P,Pk,Mk,redspol,k,dump,b,recall,Spoldejavu);
        NewCrochetchoix(P,Pk,Mk,redspol,k,dump,b,recall,w,serv);
        //NewCrochetchoix(P,Pk,Mk,redspol,k,dump,b);
#ifdef DEB     
        cout<<"Pk.size apres Crochetchoix "<<Pk.size()<<" et k "<<k<<endl;
#endif     
        NewDestroyredspol(redspol,Pk);
        serv.compress(Pk,dump,b,k);
        Dump(Pk,dump);

        L.destroystore();
        cout<<"kaquiPini"<<k<<endl;
        //misa jour de B dans crochet choix!!
        continue;
      }
      }
    else
      //la matrice n'est pas de rang plein
      {
    cout<<"matrice de rang pas plein "<<endl;
    typPk secd;
#ifdef BONRAJOUT
    AddB_dim(Mat,L,P,Pk,Mk,dump,b);
#else
    AddB(Mat,Pk,Mk,dump,b,serv);
#endif
    //
    //secondmembre supprime des trucs dans Pk!!
    //
    secd=secondmembre(Mat,Pk);
    rajoute_voisins(Pk,Mk,dump,b,w,serv);
    //ne selectionne que les non nuls
       if(secd.size()==0)
     {
       typPk redspol;
       Dump(Pk,dump);

       ReduceSpol(S,dump,redspol,b,w,serv);
#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)
         {
           //ici on modifie Pk dans AddB 
           //<=> forget(b,dump,k) AddB(..) Dump(Pk,dump);
           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);
           //Listedejafait(Mk,Spoldejavu);
           forget(b,dump,k,recall);
           //forget(b,dump,k);
           cout<<"il ya un passage par mat rang pas"
               <<"plein et pol non zero"<<endl;
           //NewCrochetchoix(P,Pk,Mk,redspol,k,dump,b,recall,Spoldejavu);
           NewCrochetchoix(P,Pk,Mk,redspol,k,dump,b,recall,w,serv);
           //NewCrochetchoix(P,Pk,Mk,redspol,k,dump,b);
           NewDestroyredspol(redspol,Pk);
           serv.compress(Pk,dump,b,k);
           Dump(Pk,dump); 

           L.destroystore();
           continue;
         }
     }
       else
     {
       //on a des pol qui se reduisent pas a 0
       //cad un defaut de commuatation dans les coins
       typPk redspol;
       //for(int i=Pk.size();i>rank(Mat);i--)
       //  Pk.pop_back();
       //cout<<"PK. size "<<Pk.size()<<" Mat.nbcol "<<Mat.ncol<<endl;
       //cout<<"rank(Mat) "<<rank(Mat)<<endl;
       //int j=0;
       //cout<<"avant recover et meme avant le dump "<<endl;
       //for(typename typPk::iterator iter = secd.begin();iter!=secd.end()
       //    ;iter++,j++)
       // cout<<"pol de secd num "<<j<<endl<<invconv<Poly>(*iter)<<endl;
       //      AddB(Mat,Pk,Mk,b);
       //cout<<"apres ADDB le dump "<<endl;
       //for(typename typPk::iterator iter = Pk.begin();iter!=Pk.end()
       //    ;iter++)
       // cout<<invconv<Poly>(*iter)<<endl;
       Dump(Pk,dump);
 
       //cout<<"secd.size()" <<secd.size()<<endl;
       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);
       //cout<<"k "<<k<<endl;
       //Listedejafait(Mk,Spoldejavu);
       //cout<<"apres recover"<<endl;
       //      for(typename typPk::iterator iter = Pk.begin();iter!=Pk.end()
       //    ;iter++)
       //  cout<<invconv<Poly>(*iter)<<endl;
       //cout<<"les Spol non reduits"<<endl;
       //for(typename typPk::iterator iter = secd.begin();iter!=secd.end()
       //    ;iter++)
       //  cout<<invconv<Poly>(*iter)<<endl;
       forget(b,dump,k,recall);
       
       //forget(b,dump,k);
       //cout<<"il ya un passage par mat pas rang plein et Spol non zero"<<endl;
       //for(typename typPk::iterator iter = secd.begin();iter!=secd.end()
       //    ;iter++)
       // cout<<invconv<Poly>(*iter)<<endl;
       //NewCrochetchoix(P,Pk,Mk,redspol,k,dump,b,recall,Spoldejavu);
       NewCrochetchoix(P,Pk,Mk,secd,k,dump,b,recall,w,serv);
       //NewCrochetchoix(P,Pk,Mk,secd,k,dump,b);
       NewDestroyredspol(secd,Pk);
#ifdef BONRAJOUT
       cout<<"Apres NewCrochetchoix"<<endl;

       for(typename Base::const_iterator p=b.begin();p!=b.end();p++)
         {
           for(int i=0;i<p->taille1;i++)
         {
           cout<<"p.accept[i] "<<p->accept[i]<<endl;
         }
           for(int i=0;i<p->taille2;i++)
         {
           cout<<"p.refuse[i] "<<p->refuse[i]<<endl;
         }
         }
#endif
       //for(typename typPk::iterator iter = Pk.begin();iter!=Pk.end()
       //    ;iter++)
       // cout<<invconv<Poly>(*iter)<<endl;
       serv.compress(Pk,dump,b,k);
       Dump(Pk,dump);

       L.destroystore();
       continue;
     }     
      }     
  }
    
    Mat.destroystore();
  
#ifdef DEBUG
  for(typename Base::const_iterator p=b.begin();p!=b.end();p++)
    {
      for(int i=0;i<p->taille1;i++)
    {
      cout<<"p.accept[i] "<<p->accept[i]<<endl;
    }
      for(int i=0;i<p->taille2;i++)
    {
      cout<<"p.refuse[i] "<<p->refuse[i]<<endl;
    }
    }
#endif
  
  destroy_space(&w);
//  delete[] &sol2;
//  delete[] &sol3;
 
  cout<<"sortie d'algo flash et dimension "<<endl;//<<critere(b,k)<<endl;
  cout<<"TPS SDP "<<tempsCDSP<<endl;
  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.. :-)

    }
#endif //ALREADY_corealgo3