polynomial_tensor.hpp

Go to the documentation of this file.

#ifndef realroot_polynomial_tensor_hpp
#define realroot_polynomial_tensor_hpp

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

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

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

  struct MonomialTensor {};

  template<class C> 
  struct use<polynomial_of,polynomial<C,with<MonomialTensor> > > {
    typedef C                                   Scalar;
    typedef monom<C>                            Monomial;
    typedef polynomial<C,with<MonomialTensor> > Polynomial;
    typedef ring<C, MonomialTensor>             Ring;

    typedef tensor::monomials<C>                rep_t;
    typedef Ring                                variable_t;


  };

  template<class C> 
  struct ring<C, MonomialTensor> {
    typedef C                                   Scalar;
    typedef monom<C>                         Monomial;
    typedef polynomial<C,with<MonomialTensor> > Polynomial;
    typedef ring<C, MonomialTensor>             Ring;

    typedef tensor::monomials<C>                rep_t;
    typedef ring<C, MonomialTensor>             self_t;
    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> struct ring_of;
  template<class C> struct ring_of<polynomial<C,with<MonomialTensor> > > {
    typedef ring<C, MonomialTensor> Ring;
  } ;

  template<class C> variables ring<C, MonomialTensor >::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]=POLYNOMIAL(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<MonomialTensor> >& p, 
           const polynomial<C, with<MonomialTensor> >& q){
      //int d = q.size();
      p = polynomial< D, with<MonomialTensor> >(0);

      const int * vr=q.rep().vrs();
      const int * sz=q.rep().szs();
      for (int i=0; i< q.nbvar();i++)
        p += polynomial< D, with<MonomialTensor> >(D(1),sz[i]-1,vr[i]);
      for(unsigned i=0;i<q.size();i++) p[i]= as<D>(q[i]);
    }
  }
} //namespace mmx
//====================================================================
# undef TMPL
# undef RING
# undef POLYNOMIAL
//====================================================================
# endif // realroot_polynom_mdse_hpp