ring_univariate.hpp

Go to the documentation of this file.

#ifndef realroot_ring_univariate_hpp
#define realroot_ring_univariate_hpp

#include <realroot/Seq.hpp>
#include <realroot/vector_monomials.hpp>
#include <realroot/monomial.hpp>
#include <realroot/polynomial.hpp>
#include <realroot/ring.hpp>

#define TMPL template<class C>
#define RING ring<C, Univariate >
#define POLYNOMIAL polynomial< C, with<Univariate> >
namespace mmx {

  struct Univariate {};

  template<class A, class B> struct use;
  template<class C, class V> struct polynomial;
  template<class C, class V> struct with;

  template<class C> 
  struct use<polynomial_of, polynomial< C, with<Univariate> > > {
    typedef ring<C, Univariate >     Ring;
    typedef C                        scalar_t;
    typedef polynomial< C, with<Univariate> >  Polynomial;
    typedef monom<C>                  Monomial;
    typedef Ring                      variable_t;
    typedef univariate::monomials<C>  rep_t;
  };

  template<class C> 
  struct ring<C, Univariate > {
    typedef ring<C, Univariate > self_t;
    typedef univariate::monomials<C> rep_t;
    typedef C                        scalar_t;
    typedef polynomial< C, with<Univariate> >  Polynomial;
    typedef monom<C>                  Monomial;
    typedef self_t                    variable_t;

    ring(const char* s) {var = variables(s); }

    static variables var;
    static variables& vars () { return var;}
    static int nbvar() { return var.nbvar(); }

    Polynomial operator[](int i) const {
      return Polynomial((C)1,1,i);
    }
  };
  template<class C> variables ring<C, Univariate >::var;

  //====================================================================
  TMPL inline Seq<POLYNOMIAL>
  coefficients(const POLYNOMIAL & f, const int & v ) {
    int N = degree(f,v)+1;
    Seq<POLYNOMIAL> r(N);
    typename POLYNOMIAL::Monomial m;
    for(int i=0;i<N; i++) {
      r[i]=0;
    }
    return r;
  }

  TMPL inline Seq<C>
  coefficients(const POLYNOMIAL & f) {
    Seq<C> r;
    for(int i=0;i<f.size(); i++) {
      r<<f[i];
    }
    return r;
  }


  namespace let {
    template<class C, class D> inline void
    assign(polynomial<D, with<Univariate> >& p, 
      const polynomial<C, with<Univariate> >& q){
      int d = degree(q);
      p = polynomial< D, with<Univariate> >(D(1),d);
      for(int i=0;i<=d;i++) p[i]= D(q[i]);
    }
  }
//====================================================================
} //namespace mmx
# undef TMPL
# undef RING
# undef POLYNOMIAL
# endif // realroot_polynom_mdse_hpp