include/realroot/polynomial_fcts.hpp

Go to the documentation of this file.

# ifndef realroot_polynomial_fcts_hpp
# define realroot_polynomial_fcts_hpp
# include <sstream>
# include <realroot/binomials.hpp>
# include <realroot/Seq.hpp>
//====================================================================
# define TMPL       template <class C, class Rep, class Ord>
# define VARIANT    with<Rep,Ord>
# define Polynomial polynomial<C,VARIANT>
//====================================================================
namespace mmx {
#ifndef WITH_POW                                                        
#define WITH_POW
  template<class T>
  T pow(const T& a, int i) {
    assert(i>=0);
    if(i == 1) return a;
    if(i > 0)
      {
        if (a == T(1))  return a;
        if (a == T(-1)) return (i % 2  == 0) ? T(1) : T(-1);
        T y(a);
        T z(1);
        unsigned int n = i;
        unsigned int m;
        while (n > 0) {
          m = n / 2;
          if (n %2 )
            {
              z *= y;
            }
          y = y * y;
          n = m;
        }
        return z;
      }
    return T(1);
  }
#endif //WITH_POW
//======================================================================
TMPL inline int 
nbvar(const Polynomial& mp ) { return mp.nbvar(); }

TMPL inline int 
degree(const Polynomial& mp ) { return degree(mp.rep()); }

TMPL inline int
degree(const Polynomial& mp, int v ) { 
  return degree(mp.rep(),v); 
}
TMPL inline unsigned 
size(const Polynomial& p) {
  return p.size();
}

TMPL std::ostream& 
operator<<(std::ostream& os, const Polynomial& mp ) {
  print(os, mp.rep(), Polynomial::Ring::vars()); return os;
}

  template<class OSTREAM, class C, class Rep, class Ord> inline OSTREAM& 
print(OSTREAM& os, const Polynomial& mp) {
  print(os,mp.rep()); return os;
}

template<class OSTREAM, class C, class Rep, class Ord> inline OSTREAM& 
print(OSTREAM& os, const Polynomial& mp, const variables& Var) {
  print(os,mp.rep(),Var); return os;
}
 
  
TMPL std::string 
as_string(const Polynomial & p){
  std::ostringstream s;
  print(s,p);
  return s.str();
}

TMPL std::string 
as_string(const Polynomial & p,const variables& var){
  std::ostringstream s;
  print(s,p,var);
  return s.str();
}


//--------------------------------------------------------------------
TMPL inline Polynomial 
diff(const Polynomial& pol, int v ) {
  Polynomial der;  diff(der.rep(),pol.rep(),v); return der;
}

//--------------------------------------------------------------------
TMPL inline Polynomial 
diff(const Polynomial& pol) {
  return diff(pol,0);//leading_variable(p.rep()));
}

TMPL inline Seq<C> 
coefficients(const Polynomial& pol) {
  return coefficients(pol.rep()); 
}

TMPL inline Seq<Polynomial> 
coefficients(const Polynomial& pol, int v) {
  typedef typename Polynomial::Ring Ring;
  Seq<Polynomial> res;
  coefficients(res,pol.rep(),v); 
  return res;
}

template<class Result, class C, class Rep, class Ord, class Parameters> inline
Result eval(const Polynomial& polynomial, const Parameters& parameters ) {
  Result result;
  eval(result, polynomial.rep(), parameters );
  return result;
}

template<class Result, class C, class Rep, class Ord, class Parameters> inline
Result eval(const Polynomial& polynomial, const Parameters& parameters, int n ) {
  Result result;
  eval(result, polynomial.rep(), parameters, n );
  return result; 
}

template<class Result, class C, class Rep, class Ord, class Parameters> inline void 
eval(Result& result, const Polynomial& polynomial, const Parameters& parameters ) {
  eval(result, polynomial.rep(), parameters ); 
}
//--------------------------------------------------------------------
TMPL inline Polynomial 
homogenize(const Polynomial& p, const Polynomial& v) {
  Polynomial r; homogenize(r.rep(),p.rep(),v.rep()); return r;
}

TMPL inline Polynomial 
homogenize(const Polynomial& p, int i, const Polynomial& v) {
  Polynomial r; homogenize(r.rep(),p.rep(),i,v.rep()); return r;
}


//======================================================================
namespace let {
  template<class C1, class R1, class C2, class R2> inline void
  assign(polynomial<C1, R1>& p, const polynomial<C2, R2>& q) {
    assign(p.rep(),q.rep());
  }

  template<class C1, class R1, class DOM, class C2, class R2> inline void
  assign(polynomial<C1, R1>& p, const polynomial<C2, R2>& q, const DOM& dmn) {
    assign(p.rep(),q.rep(), dmn);
  }
}

template<class POL1, class C2, class R2, class V2> 
inline POL1
as(const polynomial<C2, with<R2,V2> >& p) {
    POL1 res; 
    let::assign(res,p); 
    return res;
}
//======================================================================

namespace tensor {
  TMPL void 
  face(Polynomial& r, const Polynomial& p,int v, int f) {
    face(r.rep(),p.rep(),v,f); 
  }

  TMPL inline void 
  split(Polynomial& r, Polynomial& p, int v) {
    split(r.rep(),p.rep(),v); 
  }

}
//======================================================================
#ifndef WITH_BINOMIAL_POWER
#define WITH_BINOMIAL_POWER

template < class MP > MP 
binomial( typename MP::coeff_t coeff, int i, int d, typename MP::coeff_t a) {
  MP polynomial;
  typename MP::coeff_t tmp;
  for ( int k = 0 ; k <= d ; k++ )
    {
      tmp =  coeff * binomials<typename MP::coeff_t>()(d, k) * pow(a,d-k);
      polynomial += MP( typename MP::monom_t( tmp , i, k ) );
    }
  return polynomial;
}
#endif //WITH_BINOMIAL_POWER

//======================================================================
TMPL inline void 
shift( Polynomial & f, const C & t, const int & v ) { 
  shift( f.rep(), t, v ); 
}

TMPL inline void 
shift( Polynomial & r, const Polynomial & p, int d, int v=0) { 
  shift( r.rep(), p.rep(), d, v ); 
}
//======================================================================
TMPL inline void 
reciprocal( Polynomial & f, const int & v ) { 
  reciprocal( f.rep(), v ); 
}

    
TMPL typename Polynomial::Scalar
content(const Polynomial & p) {
  return content(p.rep());
}

//======================================================================
} //namespace mmx
#undef Polynomial
#undef TMPL
#endif //realroot_polynomial_fcts_hpp

---