polynomial_dual_glue.hpp

Go to the documentation of this file.

#ifndef realroot_sparse_dual_glue_hpp
#define realroot_sparse_dual_glue_hpp
#include <basix/mmx_syntax.hpp>
#include <realroot/polynomial_dual.hpp>
#define TMPL template <class C>
#define RING       ring<C, Dual,DegRevLex>
#define RING_POL   ring<C, Sparse,DegRevLex>
#define Polynomial polynomial<C, with<Dual,DegRevLex> >
//======================================================================
namespace mmx {
  TMPL unsigned hash(const RING& p){ return 1;}
  TMPL unsigned exact_hash(const RING& p){ return 1;}
  TMPL unsigned soft_hash(const RING& p){ return 1;}
  TMPL bool exact_eq (const RING& p, const RING& q){ return true;}
  TMPL bool exact_neq(const RING& p, const RING& q){ return false;}

  TMPL bool operator ==(const RING& p, const RING& q){ return true;}
  TMPL bool operator !=(const RING& p, const RING& q){ return false;}
  
  TMPL syntactic flatten(const RING& Rg) { 
    syntactic CF= flatten(scalar_set<C>());
    vector<syntactic> rg; rg <<CF;
    vector<syntactic> Lv; 
    for(int i=0;i<Rg.nbvar();i++)
      Lv<<syntactic(string("d")<<RING_POL::var[i].data());
    rg << apply(GEN_SQTUPLE,Lv);
    return apply (GEN_ACCESS, rg);
  }

  TMPL RING dual_of(const RING_POL& rg) { 
    return RING();
  }

  TMPL RING dual_of(const RING_POL& rg, const generic& x) { 
    return RING();
  }

  TMPL syntactic flatten(const Polynomial& p) {
    typedef typename Polynomial::const_iterator iterator;
    syntactic r(0);
    for(iterator it=p.begin(); it!=p.end();it++)
      {
    syntactic m= flatten(it->coeff());
    for(unsigned i=0;i<it->nbvar();i++)
      {
        syntactic v = string("d")<<RING_POL::var[i].data();
        m = m*pow(v,syntactic(-(*it)[i]));
      }
    r+=m;
      }
    return r;
  }

  TMPL Polynomial 
  polynomial_dual(const RING& rg, const C& c) {
    return Polynomial(c);
  }

  TMPL Polynomial 
  polynomial_dual(const RING& rg, const C& c, int d, int v) {
    return Polynomial(c,v,d);
  }

  TMPL Polynomial 
  polynomial_dual(const RING& rg, const string& s) {
    return Polynomial(as_charp(s));
  }
  TMPL Polynomial 
  polynomial_dual(const RING& r, const generic& s) {
    return Polynomial(as_charp(as_mmx(s)));
  }

  TMPL vector<generic>
  polynomial_dual_coefficients(const Polynomial& f, const int & v) {
    Seq<Polynomial> l = coefficients(f,v);
    vector<generic> r;
    for(unsigned i=0; i< l.size(); i++)
      r<< as<generic>(l[i]);
    return r;
  }
  
  TMPL vector<generic>
  polynomial_dual_coefficients(const Polynomial& p) {
    typedef typename Polynomial::const_iterator const_iterator;
    vector<generic> r;
    for(const_iterator it=p.begin(); it!=p.end();it++)
     r<< as<generic>(it->coeff());
    return r;
  }
} //namespace mmx
//======================================================================
#undef TMPL
#undef RING
#undef RING_POL
#undef Polynomial
#endif //realroot_sparse_dual_glue_hpp