/Users/mourrain/Devel/mmx/realroot/include/realroot/polynomial.hpp

Go to the documentation of this file.

#ifndef realroot_polynomial_hpp
#define realroot_polynomial_hpp

//======================================================================
#include <realroot/shared_object.hpp>
#include <realroot/texp_sup.hpp>
#include <realroot/variables.hpp>
#include <realroot/monomial.hpp>
#include <realroot/ring.hpp>

#define TMPL    template <class C, class Rep, class Ord>
#define VARIANT with<Rep,Ord>
#define SELF    polynomial<C, VARIANT>

//======================================================================
namespace mmx {

template<class A, class B> struct use;
struct operators_of;

  template<class C, class V>   struct polynomial;
#ifndef DECL_WITH
#define DECL_WITH
  template<class V, class W=V> struct with;
#endif //DECL_WITH

struct polynomial_of {};
TMPL
struct polynomial<C,VARIANT> 
{
  typedef polynomial<C,VARIANT>                   self_t;
  typedef use<polynomial_of,self_t>               Def;
  typedef typename Def::Ring                      Ring;
  typedef Ring                                    V;  
  typedef typename Def::rep_t                     R;
  typedef typename Def::rep_t                     rep_t;
  typedef use<operators_of,R>                     Op;
  typedef C                                       scalar_t;
  typedef C                                       Scalar;
  typedef C                                       value_type;
  typedef C                                       coeff_t;
  typedef typename R::size_type                   size_type;
  typedef R                                       rep_type;
  typedef Ord                                     order_t;
  typedef typename R::iterator                    iterator;
  typedef typename R::const_iterator              const_iterator;
  typedef typename R::reverse_iterator            reverse_iterator;
  typedef typename R::const_reverse_iterator      const_reverse_iterator;

  typedef typename Def::Monomial                  Monomial;


  shared_object<R> data;
  R &       rep()       { return (*data);}
  const R & rep() const { return (*data);}

//----------------------------------------------------------------------
  polynomial(): data() {};

  polynomial( int c) : data() { rep()= R((Scalar)c); }
  polynomial( const C& c): data() { rep() = R(c); }
  polynomial( const C& c, int d, unsigned v=0) : data() { rep()=R(c,d,v); }
  polynomial( const Monomial & m): data() { rep()=R(m);}
  polynomial( const self_t & P): data(P.data) {}
 ~polynomial() {}

  template<class S, class VECT> 
  polynomial( const char * s, const VECT& bx);

  template<class S, class W, class VECT> 
  polynomial( const polynomial<S,W>& pol, const VECT& bx);

  polynomial( const char * s, variables& vars = Ring::vars());
  polynomial( const char * s, const variables& vars) {
    variables v(vars);
    *this= self_t(s,v);
  }
//----------------------------------------------------------------------

  bool operator==( const C& c ) const;
  bool operator!=( const C& c ) const;
  bool operator==( const self_t& mp ) const;
  
  //  polynomial & operator= ( const char* );
  self_t & operator = ( const C& );
  self_t & operator = ( const self_t & x ) { data=x.data; return *this;}

  template<class S>
  polynomial& operator = ( const polynomial<S,VARIANT>& pol );

  template<class X>
  polynomial& operator+= ( const X & x )      { *this = *this + x; return *this; };
  polynomial& operator+= ( const self_t& p )  { Op::add(rep(),p.rep()); return *this;}
  polynomial& operator+= ( const C& c )       { Op::add(rep(),c); return *this; }

  template<class X>
  polynomial& operator-= ( const X & x )      { *this = *this - x; return *this; };
  polynomial& operator-= ( const self_t& p )  { Op::sub(rep(),p.rep()); return *this;}
  polynomial& operator-= ( const C& c )       { Op::sub(rep(),c); return *this; }

  template<class X>
  polynomial& operator*= ( const X & x )      { *this = *this * x; return *this; };
  polynomial& operator*= ( const C& c)        { Op::mul(rep(),c); return *this; }
  polynomial& operator*= ( const Monomial& m) { Op::mul(rep(),m); return *this; }
  polynomial& operator*= ( const self_t& p)   { Op::mul(rep(),p.rep()); return *this; }


  polynomial& operator/= ( const C& c)        { Op::div(rep(),c); return *this; }
  polynomial& operator/= ( const self_t& p)   { Op::div(rep(),p.rep()); return *this; }

  // Iterator functions
  iterator               begin()        {return rep().begin();}
  const_iterator         begin()  const {return rep().begin();}
  iterator               end()          {return rep().end();}
  const_iterator         end()    const {return rep().end();}
  
  reverse_iterator       rbegin()       {return rep().rbegin();}
  const_reverse_iterator rbegin() const {return rep().rbegin();}
  reverse_iterator       rend()         {return rep().rend();}
  const_reverse_iterator rend()   const {return rep().rend();}

  unsigned size()  const {return rep().size();}

  int nbvar() const {return rep().nbvar();}

  const C coefof(int * deg) {return rep().entry(deg);}

  const C  operator[]( int i ) const;
  C& operator[]( int i ) ;
  //  std::string varname( int i ) const ;
  //  void lexsort();

  C operator()(const C& x) const {
    assert(rep().nbvar()<=1);
    C r; eval(r,rep(),x); return r;
  }

  template<class T>
  T operator()(const T& x) const {
    //    assert(rep().nbvar()==1);
    T r; eval(r,rep(),x); return r;
  }

  template<class T>
  T operator()(const T& x, const T& y) const {
    T p[2]={x,y};
    T r; eval(r,rep(),p,2); return r;
    // delete p;
  } 

  template<class T>
  T operator()(const T& x, const T& y, const T& z) const {
    T p[3]={x,y,z};
    T r; eval(r,rep(),p,3); return r;
    // delete p;
  }

  template<class T>
  T operator()(const T& x, unsigned n) const {
    T r; eval(r,rep(), x, n); return r;
  }

  template<class T>
  typename T::value_type at(const T& x) const {
    typename T::value_type r; eval_at(r,rep(), x); return r;
  }
};
} // namespace mmx
//====================================================================
# undef TMPL
# undef SELF
# undef VARIANT
//======================================================================
# include <realroot/polynomial_mthd.hpp>
# include <realroot/polynomial_fcts.hpp>
# include <realroot/polynomial_operators.hpp>
//====================================================================
#endif //realroot_polynomial_hpp