synaps/usolve/Small_degree.h

#ifndef _synaps_solve_Small_degree_H_
#define _synaps_solve_Small_degree_H_


#include <synaps/init.h>
#include <synaps/arithm/Interval.h>
#include <synaps/arithm/traits.h>

#include <synaps/upol/UPolDse.h>
//#include <synaps/usolve.h>
#include <synaps/usolve/solver_base.h>
#include <synaps/usolve/algebraic/root_of.h>
#include <synaps/usolve/sturm/solve_small.h>


__BEGIN_NAMESPACE_SYNAPS

template < class NT >
struct Small_degree : public NumberTraits<NT>
{
   typedef NumberTraits<NT>   NTR;
  
  typedef  RR      RL;
  typedef typename NTR::FT FT;
  typedef typename NTR::RT RT;
  typedef typename NTR::XT XT;

  typedef Interval<FT>             FIT;
  typedef Interval<XT>             XIT;
  typedef Interval<XT>             RIT;
  //  typedef typename NTR::RIT            RIT;
  
  
  typedef UPolDse<RT>       Poly;
  typedef UPolDse<RT>       RT_Poly;
  typedef UPolDse<FT>       FT_Poly;  
  typedef UPolDse<XT>       XT_Poly;  
  typedef UPolDse<RL>       RL_Poly;  

  //  typedef typename ALGEBRAIC::MPoly_2_2<RT>       MPoly_2_2;
  typedef UPolDse< UPolDse<RT> >                  Poly_2;

  typedef typename ALGEBRAIC::root_of<RT, Poly>   RO_t;
  typedef typename ALGEBRAIC::root_of<RT, Poly>   root_t;
  typedef typename ALGEBRAIC::root_of<RT, Poly>   solution_type;


  typedef Small_degree            self_t;
};




template < class NT >
Seq< typename Small_degree<NT>::RO_t >
solve( const typename Small_degree<NT>::Poly& f,
       Small_degree<NT>)
{
    assert(UPOLDAR::degree(f) <= 4);

    typedef Small_degree<NT>   K;
    typedef typename K::RT            RT;
    typedef typename K::Poly          Poly;
    typedef typename K::RO_t          RO_t;
    
    Seq<RO_t> sol;
    ALGEBRAIC::solve_small_degree(f, 1, std::back_inserter(sol.rep()), K());
    return sol;
}


template < class NT,
           class OutputIterator>
OutputIterator
solve( const typename Small_degree<NT>::Poly& f,
       OutputIterator it,
       Small_degree<NT>)
{
    assert(UPOLDAR::degree(f) <= 4);

    typedef Small_degree<NT>   K;

    return ALGEBRAIC::solve_small_degree(f, 1, it, K());
}







__END_NAMESPACE_SYNAPS

#endif // _synaps_solve_Small_degree_H_