sdpstuff.hpp

Go to the documentation of this file.

//ca n'est pas le bon test mais cela dezvrait mperlmettre de limiter la 
//casse

template<typename Base, typename typstock, typename typdump>
void computestockmon_d(typstock &stockmon, const Base &b,  const typdump &dump, int  maxdeg)
{
  //typedef typename typdump::value_type::pol_t pol;
  //typedef typename pol::monom_t mon; 
  typedef typename typstock::value_type mon;
  //int taillequo=0,tmp=0;
  //  mon *who=NULL;
  list<mon> current;
  current.push_back(mon(1));
  stockmon.push_back(mon(1));
  //on a le degre max
  //le quotient est connexe a 1 donc on part 
  //de 1 et on decrit le reste en multipliant par les variables
  for(int i=0;i<maxdeg;i++)
    {
      list<mon> tmpcurrent=current;
      //my_merge(stockmon,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++)
        current.push_back((*iter)*mon(i,1));
    }
      //maintenant on tri;
      for(typename list<mon>::iterator iter=current.begin();iter!=current.end();iter++)
    if((IsinB(*iter,b))&&(!member(stockmon,*iter)))
      {
        stockmon.push_back(*iter);
      }
      else
    {
      current.erase(iter--);
    }
    }
  return;
} 

template<typename typdump, typename Base, typename typserv>
int testsdp(typdump &dump, Base &b, typserv &serv)
{
  int nb_degmoitie=0,nb_deg=0,currentdeg=0;
  typename typdump::iterator iter
  for(iter=dump.begin();
      currentdeg<dump.size()/2;iter++,currentdeg++)
    nb_degmoitie+=iter->sizemonquo;
  for(;iter!=dump.size();iter++)
    nb_deg+=iter->sizemonquo;
  return (nb_degmoitie*nb_degmoitie)/2<nb_deg;
}

template<typename T, typename typdump, typename Base, typename typserv>
void compute_normforms(T* tab, const typdump &dump, const Base &b
               , const typserv &serv,int k)
{
  //Il faut calculer toutes les formes normales de tous
  //les produits de monomes
  typedef Base::mon mon;
  // ICI il ya une optimisatiopn qui consisterait a lire 
  // les monome de servmon dans l'ordre dans lequel ils apparaissent 
  //pour engendrer lismonbase
  list<mon> listmonbase;
  computestockmon_d(listmonbase,b,dump,k);
  for(typename .....)
  //engendrer les monomes dnt il faut les nf

  //calculer les nf

  //remplir le tableau
}

template<typename typP, typename typdump, typename Base, typename typserv>
void sdprealrad(typP &newpol, const typdump & dump, const Base &b, 
        const typser v & serv,int k)
{
  //il faut le nombre de variables
  int nbvarsdp;
  int tailledublock;//nb equations de formes normales
  //
  DSDP solver;
  SDPCone mycone;
  LPCone lpcone;//ineqalites lineaires 
  //ICI il reste a initialiser le solver
  DSDPCreate(m,solver);
  //DSDPSetDObjective(solver,numvar,doubleobjective);
  //par defaut c 0 pour toutes les contraintes ce qu'il nous faut
  
  //DSDPCreateSDPCone(solver,1,&mycone);
  SDPConeSetblockSize(mycone,0,tailledublock);
  //ICI il faut calculer les differentes equations  
  compute_normforms(tableau,dump,b,serv,int k);
  SDPConeSetADenseVecMat(mycone,numblock,numvar,dimension,alpha,
             tableau,nnz);

  DSDPCreateLPCone(solver,&lpcone);
  LPConeSetData(lpcone,n,nnzin,row,aval);
  
  DSDPSetup(solver);
  DSDPSolve(solver);
  DSDPComputeX(dsdp);
  //
  //ICI il faudrait recuperer X et trouver les nouvelles equations
  //
  
  DSDPDestroy(dsdp);
}