/Users/mourrain/Devel/mmx/realroot/include/realroot/tensor_bernstein.hpp

Go to the documentation of this file.

#ifndef realroot_tensor_bernstein_hpp
#define realroot_tensor_bernstein_hpp

#include "realroot/tensor_monomials.hpp"

#define TMPL template<class C> 
#define Polynomial bernstein<C> 
namespace mmx {

namespace tensor
{
  template<class C>
  struct bernstein : monomials<C>
  {
    typedef monomials<C>                       base_type;
    typedef typename base_type::value_type     value_type;
    typedef typename base_type::vector_type    vector_type;
    typedef typename base_type::iterator       iterator;
    typedef typename base_type::const_iterator const_iterator;
    typedef typename base_type::size_type      size_type;

    bernstein( const C& x = 0 );
    bernstein( int v, int d): base_type(v,d) {
      convertm2b(*this);
    }
    bernstein( const C& c, int v, int d): base_type(c,v,d) {
      convertm2b(*this);
    }
    bernstein( const bernstein<C>& p) : base_type(p) {
      //      std::cout<<"\tcopy"<<std::endl;
    }

    template<class X, class O> 
    bernstein( const sparse::monomial_seq<X,O>& pol ):base_type(pol) {
      convertm2b(*this);
    }

    bernstein( const char* str ):base_type(str) {
      convertm2b(*this);
    }

    template<class VECT> 
    bernstein( const char* str, const VECT& bx):base_type(str) {
      convertm2b(*this, bx);
    }
    
    template<class O, class VECT> 
    bernstein( const sparse::monomial_seq<C,O>& pol, const VECT& bx):base_type(pol) {
      convertm2b(*this, bx);
    }
    

    template<class X, class O, class VECT> 
    bernstein(const sparse::monomial_seq<X,O>& mpol, const VECT& bx ):base_type(mpol)     {
      convertm2b(*this, bx);
    }

    bernstein( const eenv & e);
    bernstein( const eenv& e, const C& c );
    bernstein( int nvr, const int * szs, const int * vrs = 0 );

    bernstein& operator=( const C& x );
    C& operator[]( int i ) { return this->data[i]; };
    C  operator[]( int i ) const { return this->data[i]; };
    bool operator==( const C& c ) const { return base_type::esz() == 1 && base_type::data[0] == c; };
    bool operator==( const bernstein& mp ) const;
  };
  
  template<class C> inline
  unsigned size(const bernstein<C>& p) {return p.size();}

  template<class C> inline int 
  degree(const bernstein<C>& p) {return degree((const monomials<C>&)p);}

  template<class C> inline int
  degree(const bernstein<C>& p, int v) {return degree((const monomials<C>&)p,v);}


  TMPL Polynomial diff(const Polynomial& p, int v)
  {
    Polynomial dp(p);   diff(dp,p,v);   return dp;
  }

  template<class C,class U> void coefficients(Seq<U>& r, const Polynomial& p, int v){

  }
  
};

} //namespace mmx

#include "tensor_bernstein_fcts.hpp"

//======================================================================
namespace mmx {
# undef  Polynomial
# define Polynomial tensor::bernstein<C>
# define TMPL template<class C>

template<class A, class B> struct use;
struct operators_of;

TMPL struct use<operators_of,Polynomial> {

    static inline void 
    add (Polynomial &r, const Polynomial &a ) { 
      tensor::add (r, a); 
    }
    static inline void 
    add (Polynomial &r, const Polynomial &a, const Polynomial &b) {
      tensor::add (r, a, b); 
    }
    static inline void
    add (Polynomial &r, const Polynomial &a, const C & b) {
      tensor::add (r, a, b); 
    }
    static inline void
    add (Polynomial &r, const C & a, const Polynomial &b) {
      tensor::add (r, b, a); 
    }
    static inline void
    sub (Polynomial &r, const Polynomial &a ) {
      tensor::sub (r, a ); 
    }
    static inline void
    sub (Polynomial &r, const Polynomial &a, const Polynomial &b) {
      tensor::sub (r, a, b); 
    }
    static inline void
    sub (Polynomial &r, const C & a, const Polynomial &b) {
      tensor::sub (r, a, b); 
    }
    static inline void
    sub (Polynomial &r, const Polynomial &a, const C & b) {
      tensor::sub (r, a, b); 
    }
    static inline void
    mul (Polynomial &r, const Polynomial &a ) {
      tensor::mul (r, a ); 
    }
    static inline void
    mul (Polynomial &r, const Polynomial &a, const Polynomial &b) {
      tensor::mul (r, a, b); 
}
    static inline void
    mul (Polynomial &r, const Polynomial &a, const C & b) {
      tensor::mul (r, a, b); }
    static inline void
    mul (Polynomial &r, const C & a, const Polynomial &b) {
      tensor::mul (r, b, a); 
    }
    static inline void
    div (Polynomial &r, const Polynomial &a, const Polynomial &b) {
      tensor::div (r, a, b); 
    }
    static inline void
    div (Polynomial &r, const Polynomial &a, const C & b) {
      tensor::div (r, a, b); 
    }
   //  static inline void
//     rem (Polynomial &r, const Polynomial &a, const Polynomial &b) {
//       tensor::rem (r, b, a); 
//     }
};
# undef Polynomial
# undef TMPL
//====================================================================
} //namespace mmx
#undef TMPL
#undef Polynomial
#endif /* realroot_tensor_bernstein_hpp */