ring_monomial_tensor_glue.hpp

Go to the documentation of this file.

#ifndef realroot_tensor_monomials_glue_hpp
#define realroot_tensor_monomials_glue_hpp
//====================================================================
#include <basix/mmx_syntax.hpp>
#include <numerix/kernel.hpp>
#include <realroot/Seq.hpp>
#include <realroot/declare_glue.hpp>
#include <realroot/ring_monomial_tensor.hpp>

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

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



  TMPL RING 
  ring_tensor_generic(const scalar_set<C>& rg, const MonomialTensor& 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_tensor_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((ent) 0);
    print_flatten(r,p.rep(),Ring::vars());
    return r;
  }

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

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

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

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

  TMPL vector<generic>
  polynomial_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_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_polynomial_tensor_glue_hpp