synaps/mpol/MPolDse.h

#ifndef SYNAPS_MPOLDSE_VIEW_H
#define SYNAPS_MPOLDSE_VIEW_H

#include <synaps/init.h>
#include <synaps/base/shared_object.h>
#include <synaps/arithm/traits.h>
#include <synaps/arithm/texp.h>
#include <synaps/mpol/MPol.h>
#include <synaps/mpol/mpoldse/monomial.h>
#include <synaps/mpol/mpoldse/bernstein.h>

__BEGIN_NAMESPACE_SYNAPS
template< class C, class R = mpoldse::monomial<C> > 
struct MPolDse //: arithm::overloaded
{
  typedef C                               value_type;
  typedef C                               coeff_t;
  typedef typename R::size_type           size_type;
  typedef R                               rep_type;
  typedef typename R::iterator            iterator;
  typedef typename R::const_iterator      const_iterator;
  typedef MPolDse<C,R>                    self_t;
  shared_object<R> data;
  R &       rep()       { return (*data);}
  const R & rep() const { return (*data);}
  MPolDse( int nvr, const int * szs, const int * vrs );
  MPolDse( const C& x = 0 );
  template<class O, class E> 
  MPolDse( const MPol<C,O,E>& mpol );
  MPolDse( const char * s ) ;
  template<class X> 
  MPolDse( const X& x );
  
  iterator               begin()        {return rep().begin();}
  const_iterator         begin()  const {return rep().begin();}
  iterator               end()          {return rep().end();}
  const_iterator         end()    const {return rep().end();}
  
  bool operator==( const C& c ) const;
  bool operator==( const MPolDse& mp ) const;
  
  MPolDse & operator=( const char * name);
  template<class X>
  MPolDse & operator= ( const X & x );

  template<class O, class E>
  MPolDse& operator = ( const MPol<C,O,E>& mpol );
  template<class X>
  MPolDse& operator+= ( const X & x ) 
  { 
    *this = *this + x; return *this; 
  } ;
  
  MPolDse& operator+= ( const MPolDse& );
  MPolDse& operator+= ( const C& );
  template<class X>
  MPolDse& operator-= ( const X & x ) { *this = *this - x; return *this; };
  MPolDse& operator-= ( const MPolDse& );
  MPolDse& operator-= ( const C& );
  template<class X>
  MPolDse& operator*= ( const X & x ) { *this = *this * x; return *this; };
  MPolDse& operator*= ( const C& );  
  MPolDse& operator*= ( const MPolDse& );
  const int * vrs() const { return rep().env.vrs(); };
  const int * szs() const { return rep().env.szs(); };
  int nvars() const;
  int nvr() const { return nvars(); };
  int varid( int i ) const;
  const C& operator[]( int i ) const;
  C& operator[]( int i ) ;
  //  std::string varname( int i ) const ;
  //  void lexsort();
};

template<class C, class R>
int nbvar( const MPolDse<C,R>& mp ) { return mp.nvr(); };
template<class C, class R> 
std::ostream& operator<<( std::ostream& o, const MPolDse<C,R>& mp );
template<class C, class R> 
bool operator==( const C& c, const MPolDse<C,R>& mp );
template<class C, class R>
MPolDse<C,R> operator^( const MPolDse<C,R>& a, unsigned n );
/*
  template<class C, class R> void split( MPolDse<C,R>& l, MPolDse<C,R>& r );
  template<class C, class R> void split( MPolDse<C,R>& l, MPolDse<C,R>& r, const MPolDse<C,R>& p );
*/

template<class Coeff, class Rep>
void diff( MPolDse<Coeff,Rep>& derivative, const MPolDse<Coeff,Rep>& polynom, int v );

template<class Result, class Coeff, class Rep, class Parameters>
void eval( Result& result, const MPolDse<Coeff,Rep>& polynom, const Parameters& parameters ) ;

template<class It>
void MPolDseSystem( It b, It e )
{
  mpoldse::eenv tmp(b->rep().env);
  It i = b;
  i++;
  for ( ; i != e; i ++ )
    tmp = mpoldse::eenv::mrgvrs(tmp,i->rep().env);
  for ( i = b; i != e; i ++ )
    i->rep().env = mpoldse::eenv::rewrite(tmp,i->rep().env);
};

template<class C, class R>
void subs0( MPolDse<C,R>& a, const MPolDse<C,R>& b, const C& v )
{
  
};

__END_NAMESPACE_SYNAPS

#include "mpoldse/MPolDse.C"

#endif