polynomial_sparse_glue.hpp

Go to the documentation of this file.

#ifndef realroot_sparse_monomial_glue_hpp
#define realroot_sparse_monomial_glue_hpp
#include <basix/mmx_syntax.hpp>
#include <numerix/kernel.hpp>
#include <realroot/polynomial_sparse.hpp>
#include <realroot/polynomial_glue.hpp>
#define TMPL template <class C>
#define RING ring<C, Sparse,DegRevLex >
#define Polynomial polynomial< C, with<Sparse,DegRevLex> >

#define SparseDegRevLex with<Sparse,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> Lv; Lv <<CF;
    for(int i=0;i<rg.nbvar();i++)
      Lv<<syntactic(RING::var[i].data());
    return apply (GEN_ACCESS, Lv);
  }

  TMPL RING 
  ring_sparse_string(const scalar_set<C>& rg, const vector<string>& s) {
    string v;
    for(nat i=0;i<N(s);i++)   v <<" "<<s[i];
    return RING(as_charp(v));
  }

  TMPL RING 
  ring_sparse_generic(const scalar_set<C>& rg, const vector<generic>& s) {
    string v;
    for(nat i=0;i<N(s);i++) v <<" "<<as_mmx(s[i]);
    return RING(as_charp(v));
  }

  TMPL RING ring_sparse_extend_generic(const RING& R, const vector<generic>& s) {
    int nv= RING::nbvar();
    for(nat j=0;j<N(s);j++) 
      R[nv+j] = Polynomial(as_charp(as_mmx(s[j])));
    return R;
  }

  TMPL syntactic flatten(const Polynomial& p) {
    typedef typename Polynomial::const_iterator iterator;
    typedef typename Polynomial::Ring           Ring;
    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 = Ring::var[i].data();
    m = m*pow(v,syntactic((*it)[i]));
      }
      r+=m;
    }
    return r;
  }

 TMPL Polynomial 
 polynomial_sparse(const RING& r, const C& c) {
    return Polynomial(c);
 }

 TMPL Polynomial 
 polynomial_sparse(const RING& r, const C& c, const int& d, const int& v) {
   return Polynomial(c,d,v);
 }
 TMPL Polynomial 
 polynomial_sparse(const RING& r, const string& s) {
    return Polynomial(as_charp(s));
 }

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

 TMPL vector<generic>
 polynomial_sparse_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_sparse_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;
 }

 TMPL vector<generic>
 polynomial_sparse_monomials(const Polynomial& p) {
   typedef typename Polynomial::const_iterator const_iterator;
   typedef typename Polynomial::Monomial       Monomial;
   vector<generic> r;
   for(const_iterator it=p.begin(); it!=p.end();it++){
     Monomial m(*it);
     m.coeff()= C(1);
     r<< as<generic>(Polynomial(m));
   }
   return r;
 }

 TMPL generic
 polynomial_sparse_eval_generic(const Polynomial& p, const vector<generic>& v) {
  return sparse::eval<generic>(p.rep(),v);
 }

} //namespace mmx
//======================================================================
#undef TMPL
#undef RING
#undef Polynomial
#endif //realroot_sparse_monomial_glue_hpp