MP_model.hpp

Go to the documentation of this file.

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

#ifndef _MP_model_hpp_
#define _MP_model_hpp_

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

#include "MP_expression.hpp"
#include "MP_constraint.hpp"
#include <CoinPackedVector.hpp>
class OsiSolverInterface;

namespace flopc {

  class MP_variable;
  class MP_index;
  class MP_set;

  class Messenger {
  public:
    virtual void logMessage(int level, const char * const msg){}
    friend class MP_model;
  private:
    virtual void constraintDebug(string name, const vector<MP::Coef>& cfs) {}
    virtual void objectiveDebug(const vector<MP::Coef>& cfs) {}
    virtual void statistics(int bm, int m, int bn, int n, int nz) {}
    virtual void generationTime(double t) {}
  protected:
    virtual ~Messenger() {}
  };

  class NormalMessenger : public Messenger {
    friend class MP_model;
  private:
    virtual void statistics(int bm, int m, int bn, int n, int nz);
    virtual void generationTime(double t);
  };

  class VerboseMessenger : public NormalMessenger {
    friend class MP_model;
  private:
    virtual void constraintDebug(string name, const vector<MP::Coef>& cfs);
    virtual void objectiveDebug(const vector<MP::Coef>& cfs);
  };

  class MP_model {
    friend class MP_constraint;
  public:
    typedef enum {MINIMIZE=1, MAXIMIZE=-1} MP_direction;

    typedef enum {  
      OPTIMAL, 
      PRIMAL_INFEASIBLE, 
      DUAL_INFEASIBLE, 
      ABANDONED,
      SOLVER_ONLY,
      ATTACHED,
      DETACHED
    } MP_status;

    MP_model(OsiSolverInterface* s, Messenger* m = new NormalMessenger);

    ~MP_model();

    MP_status getStatus()const {
      return mSolverState;
    }
    void silent() {
      delete messenger;
      messenger = new Messenger;
    }
    void verbose() {
      delete messenger;
      messenger = new VerboseMessenger;
    }

    void setSolver(OsiSolverInterface* s) {
      Solver = s;
    }

    OsiSolverInterface* operator->() {
      return Solver;
    }

    MP_model& add(MP_constraint& constraint);

    void maximize();
    void maximize(const MP_expression &obj);
    void minimize();
    void minimize(const MP_expression &obj);
   
    void minimize_max(MP_set& d, const MP_expression &obj);

    void setObjective(const MP_expression& o);
    void attach(OsiSolverInterface *solver = 0);
    void detach();
    MP_model::MP_status solve(const MP_model::MP_direction &dir);
    double getInfinity() const;

    void add(MP_variable* v);
    void addRow(const Constraint& constraint); 

    static MP_model &getDefaultModel();
    static MP_model *getCurrentModel();
    Messenger *getMessenger(){ 
      return messenger;
    }
  private:
    typedef std::set<MP_variable* >::iterator varIt;
    typedef std::set<MP_constraint* >::iterator conIt;
    static MP_model& default_model;
    static MP_model* current_model;
    MP_model(const MP_model&);
    MP_model& operator=(const MP_model&);

    Messenger* messenger;
   
    
    static void assemble(vector<MP::Coef>& v, vector<MP::Coef>& av);
    void add(MP_constraint* constraint);
    MP_expression Objective;
    set<MP_constraint *> Constraints;
    set<MP_variable *> Variables;
  public:
    OsiSolverInterface* Solver; 
  private:
    int m;
    int n;
    int nz;
    int *Cst;
    int *Clg;
    int *Rnr;
    double *Elm;
    double *bl;
    double *bu;
    double *c;
    double *l;
    double *u;
    MP_status mSolverState;

  };
    
  std::ostream &operator<<(std::ostream &os, 
                           const MP_model::MP_status &condition);
  std::ostream &operator<<(std::ostream &os, 
                           const MP_model::MP_direction &direction);

} // End of namespace flopc
#endif