polynomial_mthd.hpp

Go to the documentation of this file.

#ifndef realroot_polynomial_mthd_hpp
#define realroot_polynomial_mthd_hpp
//======================================================================
# include <realroot/parser.hpp>
# include <realroot/assign.hpp>

# define TMPL    template <class C, class Rep, class Ord>
# define VARIANT with<Rep,Ord>
# define SELF    polynomial<C, VARIANT>
//======================================================================
namespace mmx {
//----------------------------------------------------------------------
// template<class R>
// template<class X> inline
// polynomial<R>::polynomial( const X& x )
// { 
//   let::assign(*this,x); 
// }
//----------------------------------------------------------------------
extern "C" char *synaps_inputptr;

TMPL inline
SELF::polynomial( const char *   s, variables&  vars ): data() { 
  typedef SELF polynomial_t;
  //  std::cout<<SELF(std::vector<int>());
  //  *this = polynomial_t(0);
  //std::cout <<"Eq: >> "<<s<<std::endl ;
  int n = strlen(s);
  if (s[n-1]=='\n') {n--;}
  if(s[n-1]==';')
    {
      synaps_input = new char[n+1];
      memcpy(synaps_input,s,n); synaps_input[n]='\0';
      synaps_inputlim = synaps_input + n;
    }
  else
    {
      synaps_input = new char[n+2];
      memcpy(synaps_input,s,n); 
      synaps_input[n]=';'; synaps_input[n+1]='\0';
      synaps_inputlim = synaps_input + n+1;
    }
  synaps_inputptr=synaps_input;
  polynomial_t m(1);


  bool sign = true;
  bool first = true;
  int Ask;

  for (;;) {
    Ask = yylex();
    //std::cout<<"yylval "<<yylval<<std::endl;
    if (Ask == COEF) { /* monomial constant */
      coeff_t c;
      let::assign(c,yylval);
      //std::cout<<"coeff "<<c << " "<< yylval;
      free(yylval);
      m *= c;
      //std::cout<< " " << m<<std::endl;
    }
    else if (Ask == XID) {
      char* p = std::strchr(yylval,'^');
      //      std::cout<<yylval<<" exp "<<p<<std::endl;
      if (p == NULL)
    {
      m *= polynomial_t(1,1,vars[std::string(yylval)]);
      //      std::cout<<"var "<<m<<std::endl;
    }
      else {
    p++;
    m *= polynomial_t(1,atoi(p),vars[std::string(yylval,p-1)]);
    //  std::cout<<"var "<<m<<std::endl;
      }
      free(yylval);
    }
    else if (Ask == MULT);
    else if (Ask == SUM) {
      if (sign) {
    //  std::cout<<"add " <<m<<std::endl;
    if(m!=(C)0) *this += m;
    m = polynomial_t(1);
      } else {
    //  std::cout<<"sub " <<m<<std::endl;
    if(m!=(C)0) *this -= m;
    sign = true;
    m = polynomial_t(1);
      }
    }
    else if (Ask == MINUS) {
      if (first)
    sign = false;
      else if (sign) {
    //  std::cout<<"add " <<m<<std::endl;
    if(m!=(C)0) *this += m;
    sign = false;
    m = polynomial_t(1);
      }
      else {
    //  std::cout<<"sub " <<m<<std::endl;
    
    if(m!=(C)0) *this -= m;
    m = polynomial_t(1);
      }
    }
    else if (Ask == TERMINATE) {
      if (sign){
    //  std::cout<<"add " <<m<<std::endl;
    if(m!=(C)0) *this += m;
      }else{
    //  std::cout<<"sub " <<m<<std::endl;
    if(m!=(C)0) *this -= m;
      }
      break;
    }
    first = false;
  }
  delete[] synaps_input;
}
//----------------------------------------------------------------------
// TMPL inline
// SELF & SELF::operator= ( const char *   name ) { 
//   std::cout<<"= "<<std::endl;
//   *this=SELF(name);
//   return *this;
// }
//----------------------------------------------------------------------
TMPL inline
SELF & SELF::operator= ( const C& c) { 
  *this=SELF(c);
  return *this;
}
//----------------------------------------------------------------------
TMPL bool 
SELF::operator== (const typename SELF::value_type & c) const {
  return rep () == c; 
}
TMPL bool 
SELF::operator!= (const typename SELF::value_type & c) const {
  return ! (rep () == c); 
}
//----------------------------------------------------------------------
//TMPL
//template <class S> inline 
//SELF::polynomial (const polynomial<S> &mpol) : data (mpol) {};
//----------------------------------------------------------------------
TMPL template <class S, class UECT> inline 
SELF::polynomial (const char* s, const UECT& bx) 
  : data () {
  *this = self_t(s);
  for(unsigned i=0;i<bx.size();i++) restrict(rep(),i,bx[i].lower(),bx[i].upper());
};
//----------------------------------------------------------------------
  TMPL template <class S, class W, class VECT> inline 
SELF::polynomial (const polynomial<S,W> &pol, const VECT& bx) 
  : data () {
  let::assign(rep(),pol.rep());
  for(int i=0;i<(int)bx.size()-1;i+=2) restrict(rep(),i,bx[i],bx[i+1]);
};
//----------------------------------------------------------------------
//TMPL inline
//SELF::polynomial (const char *s) : data(mpoldst<C>(s)) {};
//----------------------------------------------------------------------
TMPL inline const typename SELF::value_type
SELF::operator[]( int i ) const { 
  return rep()[i]; };
//----------------------------------------------------------------------
TMPL inline  typename SELF::value_type & 
SELF::operator[]( int i ) { 
  return rep()[i]; }
//----------------------------------------------------------------------
// TMPL inline SELF &
// SELF::operator+= (const SELF &mp) {
//   add(rep(),mp.rep());  return *this; }
//----------------------------------------------------------------------
// TMPL inline SELF & 
// SELF::operator+= (const C & x) {
//   add (rep (), x);  return *this; }
//----------------------------------------------------------------------
TMPL inline bool 
SELF::operator== (const polynomial & mp) const {
  return rep () == mp.rep (); }
//----------------------------------------------------------------------
TMPL template <class S> inline SELF &
SELF::operator= (const polynomial<S, VARIANT> & pol) {
  this->~SELF();  new (this) SELF(pol);
  return *this;
};
//----------------------------------------------------------------------
} //namespace mmx
//======================================================================
# undef TMPL
# undef SELF
# undef VARIANT
//======================================================================
# endif //realroot_polynomial_mthd_hpp