include/realroot/solver_run.hpp

Go to the documentation of this file.

/*******************************************************************
 *   This file is part of the source code of the realroot kernel.
 *   Author(s): B. Mourrain, GALAAD, INRIA
 ********************************************************************/
# ifndef realroot_solver_run_hpp
# define realroot_solver_run_hpp
//====================================================================
# include <string>
# include <fstream>
# include <realroot/polynomial_xml.hpp>
# include <realroot/solver.hpp>
# define begin_polynomial "<polynomial"
# define end_polynomial "</polynomial>"
//====================================================================
namespace mmx {

  template<class POL, class SLV> 
  void run_solver(int argc, char** argv){                                                       
    double total=0,start,end;                             
    
    using std::cout;
    using std::endl;
    using std::string;
    
    int N=0;
    bool verbose=true;
    for(int i=0;i<argc;i++)
      if (string(argv[i]) == string("-h")) {                                 
          std::cout<<"Usage: "<<argv[0]<<" file [-h|-q|-v|-prec]\n"
                   <<" -q      : quiet computation\n"
                   <<" -v      : verbose computation\n"
                   <<" -prec N : precision of result with N digits"
                   <<std::endl;
        return;                                                   
      } else if (string(argv[i]) == string("-v"))                 
        verbose=true;                                               
      else if (string(argv[i]) == string("-q"))                   
        verbose=false;                                               
      else if (string(argv[i]) == string("-prec"))
        N = atoi(argv[i+1]);                                        
    
    std::ifstream in(argv[1],std::ios::in);
    if(!in.good()) {                                    
      std::cout<<"file: "<<argv[1]<<std::endl;
      return;                                 
    }
    std::string s;
    typedef POL upol_t;                          
    Seq<POL>  L;                         
    POL p;
    int nbp=0;
    int deg=0;
    variables Vr("x");
    while(xml::read(in,p,Vr) && (N==0 || nbp < N)) {
      L<<p;                            
      deg= std::max(deg,degree(p));              
      nbp++;
    }
    int nr=0;
    for(typename Seq<POL>::const_iterator it = L.begin(); it != L.end(); ++it) {
      if(verbose) {        
        xml::print(std::cout,*it,"polynomial")<<std::endl;
        typename SLV::Solutions sol;
        if(N>0) SLV::set_precision(N);
        SLV::solve(sol,*it);
        nr+= sol.size();                       
        xml::print(std::cout,sol,"solution")<<std::endl;
      } else { 
        typename SLV::Solutions sol;
        start = clock();
        SLV::solve(sol,*it);
        end = clock();  total += (end - start);
        nr+= sol.size();
      }
    }
    cout << "<nb_pol>" <<  nbp << "</nb_pol>";
    cout << "<degree>" <<  deg << "</degree>";
    cout << "<nb_root>" <<nr<<"</nb_root>";
    if(!verbose) {
      cout << "<time>" << (total / CLOCKS_PER_SEC) << "</time> ";
      cout << "<speed>" << int(nr/(total / CLOCKS_PER_SEC)) << "</speed>";
    }
    std::cout<<std::endl;
  }

}
//====================================================================
#endif  //realroot_solver_hpp

---