synaps/mpol/Dual.h

/*********************************************************************
*      This file is part of the source code of the SYNAPS library.
*      Author(s): B. Mourrain, GALAAD, INRIA                 
**********************************************************************/

#ifndef synaps_mpol_Dual_h
#define synaps_mpol_Dual_h 

#include <synaps/mpol/MPol.h>
#include <synaps/mpol/AllVariables.h>

//--------------------------------------------------------------------
__BEGIN_NAMESPACE_SYNAPS
//----------------------------------------------------------------------

template <class C,
          class O=DegLex,
          class R=std::list<Monom<C,dynamicexp<int> > > >
struct Dual: public MPol<C,O,R> {

  shared_object<R>  data;
  R &       rep()       {return (*data);}
  const R & rep() const {return (*data);}

  // Types
  typedef typename R::value_type             monom_t;
  typedef C                                  coeff_t;
  typedef O                                  order_t;
  typedef typename R::iterator               iterator;
  typedef typename R::const_iterator         const_iterator;
  typedef typename R::reverse_iterator       reverse_iterator;
  typedef typename R::const_reverse_iterator const_reverse_iterator;
  typedef MPol<C,O,R>                        poly_t;
  typedef Dual<C,O,R>                        self_t;

  // Constructors
  Dual(): poly_t() {}
  Dual(const monom_t & m):  poly_t(m) {neg_exponent(*this);}
  Dual(const coeff_t & c): poly_t(c) {}
  Dual(const int & i): poly_t(i) {}

  Dual(int n, const monom_t * t): poly_t(n,t) {neg_exponent(*this);}

  Dual(const self_t & P): poly_t(P){}
  Dual(const char * s, Variables& vars = Variables::default_): 
    poly_t(s,vars) {neg_exponent(*this);}
  Dual(const char * s, const Variables& vars):
    poly_t(s,vars) {neg_exponent(*this);}

  template<class S>
  Dual(const VAL<S>& M) {using let::assign; assign(*this,M.rep());}


  template<class Q>
  Dual(const Dual<C,Q,R>& p) : poly_t(p) {}
  
  // Destructor
  // no dynamic allocation at this level.

  //  static Variable var;

  // Assignment operators
  self_t & operator =(const self_t & x)  
  { 
    this->MPol<C,O,R>::operator=(x); return *this;
  }
  self_t & operator =(const coeff_t & c) {*this=self_t(c); return *this;}
  self_t & operator =(int n)             {*this=self_t(n); return *this;}
  self_t & operator =(const monom_t & m) {*this=self_t(m); return *this;}
  template<class S>
  self_t & operator =(const VAL<S> & M)  {assign(*this,M.rep());return *this;}

  C operator()(const poly_t& p);

};

template<class C, class O, class R>
void neg_exponent(Dual<C,O,R>& p)
{
  typedef typename Dual<C,O,R>::iterator iterator;
  for(iterator it=p.begin();it != p.end();it++)
    {
      for(unsigned j=0;j<(it->nvars()+1);j++)
        {
          it->setexpt(j,-(*it)[j]);
        }
    }
}
//--------------------------------------------------------------------
template<class C, class O, class R>
C Dual<C,O,R>::operator()(const MPol<C,O,R>& p)
{
  MPol<C,O,R> t= ((MPol<C,O,R>)(*this))*p;
  typedef typename MPol<C,O,R>::reverse_iterator iterator;
  iterator it;
  for(it=t.rbegin(); it != t.rend();it++)
    {
      bool nul=true;
      for(unsigned j=0;j<(it->nvars()+1) && nul;j++)  
        {
          if((*it)[j]!=0) nul=false;
        }
      if(nul) return it->coeff();
    }
  return C(0);
}
//--------------------------------------------------------------------
template<class C, class O, class R>
Dual<C,O,R> operator*(const MPol<C,O,R>& p, const Dual<C,O,R>& l)
{
  MPol<C,O,R> t= p* (MPol<C,O,R>)l;
  Dual<C,O,R> res;
  typedef typename Dual<C,O,R>::const_iterator iterator;
  for(iterator it=t.begin();it != t.end();it++)
    {
      bool neg=true;
      for(unsigned j=0;j<(it->nvars()+1) && neg;j++)  
        {
          if((*it)[j]>0) neg=false;
        }
      if(neg) res+=(*it);
    }
  return res;
}
//--------------------------------------------------------------------
template<class C, class O, class R>
MPol<C,O,R> operator*(const Dual<C,O,R>& l, const MPol<C,O,R>& p)
{
  MPol<C,O,R> t= ((MPol<C,O,R>)l)*p;
  MPol<C,O,R> res;
  typedef typename Dual<C,O,R>::const_iterator iterator;
  for(iterator it=t.begin();it != t.end();it++)
    {
      bool pos=true;
      for(unsigned j=0;j<(it->nvars()+1) && pos;j++)  
        {
          if((*it)[j]<0) pos=false;
        }
      if(pos) res+=(*it);
    }
  return res;
}
//--------------------------------------------------------------------
namespace MONOMIAL
{
  template <class R> inline
  std::ostream & print_pp (std::ostream & os, const R & m, const AllVariables<'d'>& V)
  { 
    bool first=true;
    for (typename R::size_type i = 0; i < m.rep().size(); ++i)
      {
        if (m[i] !=0)
          {
            if(first)
              first =false;
            else
              os<<'*';
            os << V[i];
            if (m[i] != -1)
              os << '^' <<(-m[i]);
          }
      }
    return os;
  }
}
//--------------------------------------------------------------------

template <class C, class O, class R>
std::ostream & operator<< (std::ostream & os, const Dual<C,O,R> & P)
{
  MPOLDST::print(os,P, AllVariables<'d'>()); return os;
}

__END_NAMESPACE_SYNAPS
//======================================================================

#endif // synaps_mpol_Dual_h