polynomial.h

#ifndef SCIL_POLYNOMIAL_H
#define SCIL_POLYNOMIAL_H

/*
Thu Mar  5 16:03:20 CET 2009
baumann
class for polynomials
*/

#include<scil/core/monomial.h>

namespace SCIL {
   class ILP_Problem;
   class polynomial;

std::ostream& operator<<(std::ostream& o,const polynomial& p);
polynomial operator*(double d, const polynomial& p);

class polynomial {
   private:
      std::list<monomial> p;

   public:
      polynomial() {};
      polynomial(const var& v) {
         p.push_back(monomial(v));
      }
      polynomial(const monomial& m) {
         p.push_back(m);
      }

      polynomial(const row& r) {
         row_entry::list_constiterator it = r.begin();
         for( it=r.begin(); it!=r.end(); it++ ) {
            if( it->Var != nil ) {
               p.push_back(monomial(it->coeff, it->Var));
            } else {
               std::cerr<<"Polynomial:    Warning: constant term is ignored"<<std::endl;
            }
         }
      }

      inline std::list<monomial> get_p() const {
         return p;
      }

      double value(solution& sol) {
         std::list<monomial>::iterator it;
         double val = 0.;
         for( it = p.begin(); it != p.end(); it++)
            val += (*it).value(sol);
         return val;
      }

      void normalize(bool clean = false);

      polynomial& operator+=(const polynomial& p);
      polynomial operator+(const polynomial& p);
      polynomial& operator+=(const monomial& m);
      polynomial operator+(const monomial& m);
      polynomial& operator+=(const row& r);
      polynomial operator+(const row& r);
      polynomial& operator+=(const var& v);
      polynomial operator+(const var& v);
      polynomial& operator-=(const polynomial& p);
      polynomial operator-(const polynomial& p);
      polynomial& operator-=(const monomial& m);
      polynomial operator-(const monomial& m);
      polynomial& operator-=(const row& r);
      polynomial operator-(const row& r);
      polynomial& operator-=(const var& v);
      polynomial operator-(const var& v);
      polynomial& operator*=(double d);
      polynomial operator*(double d);
      polynomial operator*(const monomial& m);
      polynomial& operator*=(const monomial& m);
      polynomial operator*(const polynomial& p);
      polynomial& operator*=(const polynomial& p);
      polynomial operator*(const var& v);
      polynomial& operator*=(const var& v);
      polynomial operator*(const row& r);
      polynomial& operator*=(const row& r);
      pol_constraint operator<=(double rhs);
      pol_constraint operator>=(double rhs);
      pol_constraint operator==(double rhs);
};

class pol_constraint {
   friend class ILP_Problem;
   private:
      polynomial p;
      cons_sense s;
      double rhs;

   public:
      pol_constraint(polynomial _p, cons_sense _s, double _rhs)
      : p(_p), s(_s), rhs(_rhs) {
      }

};

};
#endif

---