/home/coin/SVN-release/CoinAll-1.1.0/FlopCpp/src/MP_expression.hpp

Go to the documentation of this file.

// ******************** FlopCpp **********************************************
// File: MP_expression.hpp
// $Id$
// Author: Tim Helge Hultberg (thh@mat.ua.pt)
// Copyright (C) 2003 Tim Helge Hultberg
// All Rights Reserved.
// ****************************************************************************

#ifndef _MP_expression_hpp_
#define _MP_expression_hpp_

#include <vector>
#include <set>
using std::vector;
using std::set;

#include "MP_domain.hpp"
#include "MP_constant.hpp"
#include "MP_utilities.hpp"

namespace flopc {

  class MP_constraint;
  class TerminalExpression; 
  class MP_variable;
  class VariableRef;

  class MP {
    friend class MP_expression;
    friend class MP_constraint;
    friend class MP_model;
    friend class Messenger;
    friend class VerboseMessenger; 
    friend class CoefLess;
    friend class MP_expression_base;
    friend class VariableRef;

    struct Coef {
      Coef(int c, int r, double v, int s = 0) : 
        col(c), row(r), stage(s), val(v)  {}
      int col, row, stage;
      double val;
    };
    
    struct CoefLess {
      bool operator() (const MP::Coef& a, const MP::Coef& b) const;
    };

  protected:
    class GenerateFunctor : public Functor {
    public:
      GenerateFunctor(MP_constraint* r, vector<Coef>& cfs): R(r), Coefs(cfs) {}
      
      void setMultiplicator(vector<Constant>& mults, double m) {
        multiplicators = mults;
        M = m;
      }
      void setTerminalExpression(const TerminalExpression* c) {
        C = c;
      }
      
      void operator()() const;
    private:
      vector<Constant> multiplicators;
      MP_constraint* R;
      double M; // sign (1=lhs, -1=rhs)
      const TerminalExpression* C;
      vector<MP::Coef>& Coefs;
    };
  };

  
  class MP_expression_base {
    friend class MP_expression;
    friend class Handle<MP_expression_base*>;
  private:
    int count;
  public:
    MP_expression_base() : count(0) {}

    virtual double level() const = 0;
    virtual void generate(const MP_domain& domain,
                          vector<Constant> multiplicators,
                          MP::GenerateFunctor &f,
                          double m) const = 0;

    virtual void insertVariables(set<MP_variable*>& v) const = 0;

    virtual ~MP_expression_base() {}
  };


  class MP_expression : public Handle<MP_expression_base*> {
  public:
    MP_expression() : Handle<MP_expression_base*>(0) {}
    MP_expression(const Constant& c);
    MP_expression(const VariableRef& v);
    MP_expression(MP_expression_base* r) : Handle<MP_expression_base*>(r) {}
  };


  class TerminalExpression : public MP_expression_base {
  public:
    virtual double getValue() const = 0; 
    virtual int getColumn() const = 0;
    virtual int getStage() const = 0;
  };

  class VariableRef : public TerminalExpression {
    friend class MP_variable;
  public:
    int getColumn() const;
  private:
    VariableRef(MP_variable* v, 
                const MP_index_exp& i1,
                const MP_index_exp& i2,
                const MP_index_exp& i3,
                const MP_index_exp& i4,
                const MP_index_exp& i5);

    double level() const;

    void insertVariables(set<MP_variable*>& v) const {
      v.insert(V);
    }
    double getValue() const { 
      return 1.0;
    }
    int getStage() const { 
      return 0;
    }
    void generate(const MP_domain& domain,
                  vector<Constant> multiplicators,
                  MP::GenerateFunctor& f,
                  double m) const;
    MP_variable* V;
    int offset;
    const MP_index_exp I1,I2,I3,I4,I5;
  };

  MP_expression operator+(const MP_expression& e1, const MP_expression& e2);
  MP_expression operator+(const MP_expression& e1, const Constant& e2);
  MP_expression operator+(const Constant& e1, const MP_expression& e2);
  MP_expression operator-(const MP_expression& e1, const MP_expression& e2);
  MP_expression operator-(const MP_expression& e1, const Constant& e2);
  MP_expression operator-(const Constant& e1, const MP_expression& e2);
  MP_expression operator*(const Constant& e1, const MP_expression& e2); 
  MP_expression operator*(const MP_expression& e1, const Constant& e2);
  MP_expression operator/(const MP_expression& e1, const Constant& e2);
  MP_expression sum(const MP_domain& d, const MP_expression& e);

} // End of namespace flopc
#endif

---