monomial.h

#ifndef SCIL_MONOMIAL_H
#define SCIL_MONOMIAL_H
#include<fstream>
#include<scil/global.h>
#include<scil/variable.h>
#include<scil/ilp_problem.h>
#include<scil/subproblem.h>
#include<scil/var_obj.h>
#include<list>
#include<vector>
#include<algorithm>

#define LEPS 1e-4

//FIXME
//#define ADDTRIV


namespace SCIL {
   class polynomial;
   class monomial;
}

namespace SCIL {
   SCIL::monomial operator*(double d, const SCIL::monomial& m);
   std::ostream& operator<<(std::ostream& o,const monomial& m);

   bool operator<(const monomial& p, const monomial& q);
   bool operator==(const monomial& p, const monomial& q);

class monomial {

   friend class polynomial;
   friend class monomial_inst;
   template <typename Graph> friend class qmonomial;
   friend class ILP_Problem;

   private:
      std::vector<var> A;
      var L;
      double c;
      bool maximal;

      inline void set_L(var& lin) {
         L=lin;
      }
      inline var& get_L() {
         return L;
      }
   public:
      typedef std::list<monomial>::iterator list_iterator;

      typedef std::list<monomial>::const_iterator list_constiterator;
      monomial() { }
      monomial(var a)
      : maximal(true) {
         A.push_back(a);
         c = 1.;
         L= NULL;
      }
      monomial(double co, var a)
         : c(co), maximal(true) {
            A.push_back(a);
            L= NULL;
         }
      monomial(double co, std::vector<var> a)
      : A(a), c(co), maximal(true) {
         std::sort( A.begin(), A.end() );

         std::vector<var>::const_iterator end;
         end = std::unique( A.begin(), A.end() );

         A.resize( end - A.begin() );
         L = NULL;
      }

      monomial(double co, var a, var b)
      : c(co), maximal(true) {
         A.push_back(a);
         A.push_back(b);

         std::sort( A.begin(), A.end() );

         std::vector<var>::const_iterator end;
         end = std::unique( A.begin(), A.end() );

         A.resize( end - A.begin() );
         L = NULL;
         maximal=true;
      }

      double value(solution& sol) {
         std::vector<var>::iterator it;
         double val = 1.;
         for( it = A.begin(); it != A.end(); it++ )
            val *= sol.value((*it));
         val *= c;
         return val;
      }


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

      inline std::vector<var> get_A() const {
         return A;
      }

      inline double get_coeff() const {
         return c;
      }

      inline int size() const {
         return A.size();
      }

      inline void set_coeff(double d) {
         c = d;
      }

      inline bool is_maximal() const {
         return maximal;
      }

      inline void set_not_maximal() {
         maximal = false;
      }

      monomial unite(monomial& q) const;

      monomial unite2(monomial& q) const;

      //bool operator==(monomial q) const;

      var& linearize(ILP_Problem& IP, bool set_c = true);
};

};
#endif

---