solver.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_hpp
# define realroot_solver_hpp
# include <realroot/subdivisor.hpp>
//====================================================================
//====================================================================
namespace mmx {

#define solver_default_precision 20

  template<class C, class MTH> struct solver_of {
    typedef typename MTH::Cell Cell;
    typedef typename MTH::Strategy Strategy;
    typedef typename MTH::Solutions Solutions;
 
  } ;

  template<class C,class M> struct solver {
    typedef solver_of<C,M> MTH;
    typedef typename MTH::Cell Cell;
    typedef typename MTH::Strategy Strategy;
    typedef typename MTH::Solutions Solutions;

    template<class POL> static Solutions 
    solve(const POL& p) {
       Cell* c = new Cell(p);
       subdivisor<Cell, Strategy> slv(c);
       slv.run();
       return slv.solutions();
    }

    template<class POL, class DOM> static Solutions 
    solve(const POL& p, const DOM& dmn) {
      Cell* c = new Cell(p,dmn);
       subdivisor<Cell, Strategy> slv(c);
       slv.run();
       return slv.solutions();
    }
  };

  struct Isolate     
  { 
    static const bool isole=true; 
  };
  struct Approximate 
  { 
    static const bool isole=false; 
    double eps;
    Approximate(): eps(1e-6) {}
    Approximate(double e): eps(e) {}
  };

  //  template<class R, class MTH> struct solver;

  template<class POL, class SLV> typename solver<typename POL::Scalar,SLV>::Solutions 
  solve(const POL& p, const SLV& s) {
    typedef solver<typename POL::Scalar,SLV> solver_t;
    typename solver<typename POL::Scalar,SLV>::Solutions sol;
    solver_t::solve(sol,p);
    return sol;
  }
  
  template<class POL, class SLV> 
  typename solver<typename POL::Scalar,SLV>::Solutions 
  solve(const POL& p, SLV& s) {
    typedef  solver<typename POL::Scalar,SLV>  solver_t;
    typename solver<typename POL::Scalar,SLV>::Solutions sol;
    solver_t::solve(sol,p);
    return sol;
  }
  

  template<class POL,class SLV,class Domain> 
  typename solver<typename POL::Scalar,SLV>::Solutions 
  solve(const POL& p, const SLV& s, const Domain& D) {
    typedef solver<typename POL::Scalar,SLV> solver_t;
    typename solver<typename POL::Scalar,SLV>::Solutions sol;
    solver_t::solve(sol,p,D);
    return sol;
  }

  template<class POL,class SLV,class Domain1, class Domain2> 
  typename solver<typename POL::Scalar,SLV>::Solutions 
  solve(const POL& p, const SLV& s, const Domain1& D1, const Domain2& D2) {
    typedef solver<typename POL::Scalar,SLV> solver_t;
    typename solver<typename POL::Scalar,SLV>::Solutions sol;
    solver_t::solve(sol,p,D1,D2);
    return sol;
  }


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