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

Go to the documentation of this file.

#ifndef realroot_tensor_monomial_hpp
#define realroot_tensor_monomial_hpp

#include <vector>
#include <iterator>
#include <realroot/shared_object.hpp>
#include <realroot/sparse_monomials.hpp>
#include <realroot/tensor_eenv.hpp>
#include <realroot/binomials.hpp>

namespace mmx {

namespace tensor
{
 
  template<class C>
  struct monomials
  {
    typedef C coeff_t;
    typedef std::vector<C>  vector_type;
    //typedef vectdse<C>  vector_type;
    typedef C * iterator;
    //    typedef typename vector_type::const_iterator const_iterator;
    typedef const C * const_iterator;
    typedef std::reverse_iterator<iterator>        reverse_iterator;
    typedef std::reverse_iterator<const_iterator>  const_reverse_iterator;
    typedef typename vector_type::size_type size_type;
    typedef coeff_t value_type;
    static binomials<C> binoms;
    eenv           env;
    vector_type    data;
    //    shared_object<monomials_rep<C> > data;
    //    monomials_rep<C> &       rep()       { return (*data);}
    //    const monomials_rep<C> & rep() const { return (*data);}
    monomials();
    monomials( const C& x);
    monomials( const C& c, int d, unsigned v);
    monomials( int v, int d);
    template<class X, class O> 
    monomials( const sparse::monomial_seq<X,O>& );
    monomials( const eenv & e);
    monomials( const eenv& e, const C& c );
    monomials( int nvr, const int * szs, const int * vrs = 0 );

    void resize(int l) {};
    C * begin() { return &(data[0]); };
    C * end  () { return &(data[0])+esz(); };

    const_iterator begin() const { return &(data[0]); };
    const_iterator   end() const { return &(data[esz()]); };

    reverse_iterator 
    rbegin()       {
      return reverse_iterator(&(data[0])+esz()); 
    }
    const_reverse_iterator 
    rbegin() const {
      return const_reverse_iterator(&(data[0])+esz()); 
    }
    reverse_iterator 
    rend()         {
      return reverse_iterator(&(data[0])); 
    }
    const_reverse_iterator 
    rend()   const {
      return const_reverse_iterator(&(data[0])); 
    }


    int  esz()   const { return env.sz(); };
    int  size()  const { return env.sz(); };
    int  nbvar() const { return env.nvr(); };
    int  nvr()   const { return env.nvr(); };
    int * szs() { return env.szs(); };
    int * vrs() { return env.vrs(); };
    int * str() { return env.str(); };
    const int * szs() const { return env.szs(); };
    const int * vrs() const { return env.vrs(); };
    const int * str() const { return env.str(); };

    const C & operator[]( int i ) const { return data[i]; };
    C & operator[]( int i ) { return data[i]; };
    bool hasvar( int& lv, int gv ) const;
    bool operator==( const C& c ) const { 
      return esz() == 1 && data[0] == c; }
    bool operator==( const monomials& mpl ) const ;
    void swap( monomials<C>& a ) { std::swap(env,a.env); data.swap(a.data); };    
    // Return coefficient of x^deg
      const C entry(std::vector<int> deg);
  };
  
};


} //namespace mmx

#include "realroot/tensor_monomials_fcts.hpp"


//======================================================================
namespace mmx {
# define Polynomial tensor::monomials<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
#endif /* realroot_tensor_monomial_hpp */