ring_bernstein_tensor_glue.hpp

Go to the documentation of this file.

#ifndef realroot_ring_bernstein_glue_hpp
#define realroot_ring_bernstein_glue_hpp
#include <basix/mmx_syntax.hpp>
#include <numerix/kernel.hpp>
#include <realroot/Seq.hpp>
#include <realroot/declare_glue.hpp>
#include <realroot/ring_sparse.hpp>
#include <realroot/ring_monomial_tensor.hpp>
#include <realroot/ring_bernstein_tensor.hpp>
#define TMPL template <class C>
#define RING ring<C,Bernstein>
#define POLYNOMIAL polynomial<C, with<Bernstein> >
//======================================================================
namespace mmx {
  DECLARE_CLASS(Bernstein,"Bernstein")

  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());
    }
    Lv<<syntactic("Bernstein");
    return apply (GEN_ACCESS, Lv);
  }

  TMPL RING 
  ring_bernstein_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_tensor_of(const ring<C, Bernstein > & r) {
    typedef ring<C, Bernstein >  Ring;
    std::string v;
    for(int i=0; i<r.nbvar(); i++) {
      v += Ring::var[i];
      if(i<r.nbvar()-1) v +=" ";
    }
    return RING(v.data());;
  }

  TMPL RING 
  ring_bernstein_of(const ring<C, Sparse, DegRevLex > & r) {
    std::string v;
    for(int i=0; i<r.nbvar(); i++) {
      v += ring<C, Sparse, DegRevLex >::var[i];
      if(i<r.nbvar()-1) v +=" ";
    }
    return RING(v.data());;
  }


  TMPL RING 
  ring_bernstein_generic(const scalar_set<C>& rg, const Bernstein& b,  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_bernstein_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) {
    syntactic r(0);
    POLYNOMIAL tmp(p);
    tensor::convertb2m(tmp.rep());
    print_flatten(r,tmp.rep(),RING::vars());
    return r;
  }

  TMPL POLYNOMIAL 
  polynomial_bernstein_tensor(const RING& r, const C& c) {
    return POLYNOMIAL(c);
  }

  TMPL POLYNOMIAL 
  polynomial_bernstein_tensor(const RING& r, const C& c, const int& d, const int& v) {
    return POLYNOMIAL(c,d,v);
  }

  TMPL POLYNOMIAL 
  polynomial_bernstein_tensor(const RING& r, const string& s) {
    return POLYNOMIAL(as_charp(s));
  }
  
  TMPL POLYNOMIAL 
  polynomial_bernstein_tensor(const RING& r, const generic& s) {
    return POLYNOMIAL(as_charp(as_mmx(s)));
  }
  
  TMPL POLYNOMIAL
  polynomial_bernstein_tensor_of(const polynomial<C, with<Sparse,DegRevLex> > & f) {
    POLYNOMIAL r;
    convert(r.rep(), f.rep());
    return r;
  }

  TMPL polynomial<C, with<Sparse,DegRevLex> >
  polynomial_sparse_of(const POLYNOMIAL & f) {
    polynomial<C, with<Sparse,DegRevLex> > r;
    convert(r.rep(), f.rep());
    return r;
  }

  TMPL polynomial<C, with<MonomialTensor> >
  polynomial_tensor_of(const POLYNOMIAL & f) {
    polynomial<C, with<MonomialTensor> > r;
    convert(r.rep(), f.rep());
    return r;
  }

  TMPL vector<generic>
  polynomial_bernstein_tensor_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_bernstein_tensor_coefficients(const POLYNOMIAL& p) {
    vector<generic> r;
   for(unsigned i=0; i< p.size();i++)
     r<< as<generic>(p[i]);
   return r;
  }
} //namespace mmx
//======================================================================
#undef TMPL
#undef RING
#undef POLYNOMIAL
#endif //realroot_ring_bernstein_tensor_glue_hpp