RhodeCode

        break;

      case GLP_LO:

      case GLP_DB:

      case GLP_FX:

        if (lo == up)

          glp_set_row_bnds(lp, i, GLP_FX, lo, up);

        else

          glp_set_row_bnds(lp, i, GLP_DB, lo, up);

        break;

      default:

        break;

      }

    }

  }

  GlpkBase::Value GlpkBase::_getRowUpperBound(int i) const {

    int b = glp_get_row_type(lp, i);

    switch (b) {

    case GLP_UP:

    case GLP_DB:

    case GLP_FX:

      return glp_get_row_ub(lp, i);

    default:

      return INF;

    }

  }

  void GlpkBase::_setObjCoeffs(ExprIterator b, ExprIterator e) {

    for (int i = 1; i <= glp_get_num_cols(lp); ++i) {

      glp_set_obj_coef(lp, i, 0.0);

    }

    for (ExprIterator it = b; it != e; ++it) {

      glp_set_obj_coef(lp, it->first, it->second);

    }

  }

  void GlpkBase::_getObjCoeffs(InsertIterator b) const {

    for (int i = 1; i <= glp_get_num_cols(lp); ++i) {

      Value val = glp_get_obj_coef(lp, i);

      if (val != 0.0) {

        *b = std::make_pair(i, val);

        ++b;

      }

    }

  }

  void GlpkBase::_setObjCoeff(int i, Value obj_coef) {

    //i = 0 means the constant term (shift)

    glp_set_obj_coef(lp, i, obj_coef);

  }

  GlpkBase::Value GlpkBase::_getObjCoeff(int i) const {

    //i = 0 means the constant term (shift)

    return glp_get_obj_coef(lp, i);

  }

  void GlpkBase::_setSense(GlpkBase::Sense sense) {

    switch (sense) {

    case MIN:

      glp_set_obj_dir(lp, GLP_MIN);

      break;

    case MAX:

      glp_set_obj_dir(lp, GLP_MAX);

      break;

    }

  }

  GlpkBase::Sense GlpkBase::_getSense() const {

    switch(glp_get_obj_dir(lp)) {

    case GLP_MIN:

      return MIN;

    case GLP_MAX:

      return MAX;

    default:

      LEMON_ASSERT(false, "Wrong sense");

      return GlpkBase::Sense();

    }

  }

  void GlpkBase::_clear() {

    glp_erase_prob(lp);

    rows.clear();

    cols.clear();

  }

  void GlpkBase::freeEnv() {

    glp_free_env();

  }

  GlpkBase::FreeEnvHelper GlpkBase::freeEnvHelper;

  // GlpkLp members

  GlpkLp::GlpkLp()

    : LpBase(), LpSolver(), GlpkBase() {

    messageLevel(MESSAGE_NO_OUTPUT);

  }

  GlpkLp::GlpkLp(const GlpkLp& other)

    : LpBase(other), LpSolver(other), GlpkBase(other) {

    messageLevel(MESSAGE_NO_OUTPUT);

  }

  GlpkLp* GlpkLp::newSolver() const { return new GlpkLp; }

  GlpkLp* GlpkLp::cloneSolver() const { return new GlpkLp(*this); }

  const char* GlpkLp::_solverName() const { return "GlpkLp"; }

  void GlpkLp::_clear_temporals() {

    _primal_ray.clear();

    _dual_ray.clear();

  }

  GlpkLp::SolveExitStatus GlpkLp::_solve() {

    return solvePrimal();

  }

  GlpkLp::SolveExitStatus GlpkLp::solvePrimal() {

    _clear_temporals();

    glp_smcp smcp;

    glp_init_smcp(&smcp);

    switch (_message_level) {

    case MESSAGE_NO_OUTPUT:

      smcp.msg_lev = GLP_MSG_OFF;

      break;

    case MESSAGE_ERROR_MESSAGE:

      smcp.msg_lev = GLP_MSG_ERR;

      break;

    case MESSAGE_NORMAL_OUTPUT:

      smcp.msg_lev = GLP_MSG_ON;

      break;

    case MESSAGE_FULL_OUTPUT:

      smcp.msg_lev = GLP_MSG_ALL;

      break;

    }

    return SOLVED;

  }

  GlpkLp::SolveExitStatus GlpkLp::solveDual() {

    _clear_temporals();

    glp_smcp smcp;

    glp_init_smcp(&smcp);

    switch (_message_level) {

    case MESSAGE_NO_OUTPUT:

      smcp.msg_lev = GLP_MSG_OFF;

      break;

    case MESSAGE_ERROR_MESSAGE:

      smcp.msg_lev = GLP_MSG_ERR;

      break;

    case MESSAGE_NORMAL_OUTPUT:

      smcp.msg_lev = GLP_MSG_ON;

      break;

    case MESSAGE_FULL_OUTPUT:

      smcp.msg_lev = GLP_MSG_ALL;

      break;

    }

    smcp.meth = GLP_DUAL;

    return SOLVED;

  }

  GlpkLp::Value GlpkLp::_getPrimal(int i) const {

    return glp_get_col_prim(lp, i);

  }

  GlpkLp::Value GlpkLp::_getDual(int i) const {

    return glp_get_row_dual(lp, i);

  }

  GlpkLp::Value GlpkLp::_getPrimalValue() const {

    return glp_get_obj_val(lp);

  }

  GlpkLp::VarStatus GlpkLp::_getColStatus(int i) const {

    switch (glp_get_col_stat(lp, i)) {

    case GLP_BS:

      return BASIC;

    case GLP_UP:

      return UPPER;

    case GLP_LO:

      return LOWER;

    case GLP_NF:

      return FREE;

    case GLP_NS:

      return FIXED;

    default:

      LEMON_ASSERT(false, "Wrong column status");

      return GlpkLp::VarStatus();

    }

  }

  GlpkLp::VarStatus GlpkLp::_getRowStatus(int i) const {

    switch (glp_get_row_stat(lp, i)) {

    case GLP_BS:

      return BASIC;

    case GLP_UP:

      return UPPER;

    case GLP_LO:

      return LOWER;

    case GLP_NF:

      return FREE;

    case GLP_NS:

      return FIXED;

    default:

      LEMON_ASSERT(false, "Wrong row status");

      return GlpkLp::VarStatus();

    }

  }

  GlpkLp::Value GlpkLp::_getPrimalRay(int i) const {

    if (_primal_ray.empty()) {

      int row_num = glp_get_num_rows(lp);

      int col_num = glp_get_num_cols(lp);

      _primal_ray.resize(col_num + 1, 0.0);

      int index = glp_get_unbnd_ray(lp);

      if (index != 0) {

        // The primal ray is found in primal simplex second phase

        LEMON_ASSERT((index <= row_num ? glp_get_row_stat(lp, index) :

                      glp_get_col_stat(lp, index - row_num)) != GLP_BS,

                     "Wrong primal ray");

        bool negate = glp_get_obj_dir(lp) == GLP_MAX;

        if (index > row_num) {

          _primal_ray[index - row_num] = 1.0;

          if (glp_get_col_dual(lp, index - row_num) > 0) {

            negate = !negate;

          }

        } else {

          if (glp_get_row_dual(lp, index) > 0) {

            negate = !negate;

          }

        }

        std::vector<int> ray_indexes(row_num + 1);

        std::vector<Value> ray_values(row_num + 1);

        int ray_length = glp_eval_tab_col(lp, index, &ray_indexes.front(),

                                          &ray_values.front());

        for (int i = 1; i <= ray_length; ++i) {

          if (ray_indexes[i] > row_num) {

            _primal_ray[ray_indexes[i] - row_num] = ray_values[i];

          }

        }

        if (negate) {

          for (int i = 1; i <= col_num; ++i) {

            _primal_ray[i] = - _primal_ray[i];

          }

        }

      } else {

        for (int i = 1; i <= col_num; ++i) {

          idx = glp_get_col_bind(lp, index - row_num);

          if (glp_get_col_prim(lp, index - row_num) >

              glp_get_col_ub(lp, index - row_num)) {

            negate = true;

          }

        } else {

          idx = glp_get_row_bind(lp, index);

          if (glp_get_row_prim(lp, index) > glp_get_row_ub(lp, index)) {

            negate = true;

          }

        }

        _dual_ray[idx] = negate ?  - 1.0 : 1.0;

        glp_btran(lp, &_dual_ray.front());

      } else {

        double eps = 1e-7;

        // The dual ray is found in primal simplex first phase

        // We assume that the glpk minimizes the slack to get feasible solution

        for (int i = 1; i <= row_num; ++i) {

          int index = glp_get_bhead(lp, i);

          if (index <= row_num) {

            double res = glp_get_row_prim(lp, index);

            if (res > glp_get_row_ub(lp, index) + eps) {

              _dual_ray[i] = -1;

            } else if (res < glp_get_row_lb(lp, index) - eps) {

              _dual_ray[i] = 1;

            } else {

              _dual_ray[i] = 0;

            }

            _dual_ray[i] *= glp_get_rii(lp, index);

          } else {

            double res = glp_get_col_prim(lp, index - row_num);

            if (res > glp_get_col_ub(lp, index - row_num) + eps) {

              _dual_ray[i] = -1;

            } else if (res < glp_get_col_lb(lp, index - row_num) - eps) {

              _dual_ray[i] = 1;

            } else {

              _dual_ray[i] = 0;

            }

            _dual_ray[i] /= glp_get_sjj(lp, index - row_num);

          }

        }

        glp_btran(lp, &_dual_ray.front());

        for (int i = 1; i <= row_num; ++i) {

          _dual_ray[i] /= glp_get_rii(lp, i);

        }

      }

    }

    return _dual_ray[i];

  }

  GlpkLp::ProblemType GlpkLp::_getPrimalType() const {

    if (glp_get_status(lp) == GLP_OPT)

      return OPTIMAL;

    switch (glp_get_prim_stat(lp)) {

    case GLP_UNDEF:

      return UNDEFINED;

    case GLP_FEAS:

    case GLP_INFEAS:

      if (glp_get_dual_stat(lp) == GLP_NOFEAS) {

        return UNBOUNDED;

      } else {

        return UNDEFINED;

      }

    case GLP_NOFEAS:

      return INFEASIBLE;

    default:

      LEMON_ASSERT(false, "Wrong primal type");

      return  GlpkLp::ProblemType();

    }

  }

  GlpkLp::ProblemType GlpkLp::_getDualType() const {

    if (glp_get_status(lp) == GLP_OPT)

      return OPTIMAL;

    switch (glp_get_dual_stat(lp)) {

    case GLP_UNDEF:

      return UNDEFINED;

    case GLP_FEAS:

    case GLP_INFEAS:

      if (glp_get_prim_stat(lp) == GLP_NOFEAS) {

        return UNBOUNDED;

      } else {

        return UNDEFINED;

      }

    case GLP_NOFEAS:

      return INFEASIBLE;

    default:

      LEMON_ASSERT(false, "Wrong primal type");

      return  GlpkLp::ProblemType();

    }

  }

  }

  void GlpkLp::messageLevel(MessageLevel m) {

    _message_level = m;

  }

  // GlpkMip members

  GlpkMip::GlpkMip()

    : LpBase(), MipSolver(), GlpkBase() {

    messageLevel(MESSAGE_NO_OUTPUT);

  }

  GlpkMip::GlpkMip(const GlpkMip& other)

    : LpBase(), MipSolver(), GlpkBase(other) {

    messageLevel(MESSAGE_NO_OUTPUT);

  }

  void GlpkMip::_setColType(int i, GlpkMip::ColTypes col_type) {

    switch (col_type) {

    case INTEGER:

      glp_set_col_kind(lp, i, GLP_IV);

      break;

    case REAL:

      glp_set_col_kind(lp, i, GLP_CV);

      break;

    }

  }

  GlpkMip::ColTypes GlpkMip::_getColType(int i) const {

    switch (glp_get_col_kind(lp, i)) {

    case GLP_IV:

    case GLP_BV:

      return INTEGER;

    default:

      return REAL;

    }

  }

  GlpkMip::SolveExitStatus GlpkMip::_solve() {

    glp_smcp smcp;

    glp_init_smcp(&smcp);

    switch (_message_level) {

    case MESSAGE_NO_OUTPUT:

      smcp.msg_lev = GLP_MSG_OFF;

      break;

    case MESSAGE_ERROR_MESSAGE:

      smcp.msg_lev = GLP_MSG_ERR;

      break;

    case MESSAGE_NORMAL_OUTPUT:

      smcp.msg_lev = GLP_MSG_ON;

      break;

    case MESSAGE_FULL_OUTPUT:

      smcp.msg_lev = GLP_MSG_ALL;

      break;

    }

    smcp.meth = GLP_DUAL;

    if (glp_get_status(lp) != GLP_OPT) return SOLVED;

    glp_iocp iocp;

    glp_init_iocp(&iocp);

    switch (_message_level) {

    case MESSAGE_NO_OUTPUT:

      iocp.msg_lev = GLP_MSG_OFF;

      break;

    case MESSAGE_ERROR_MESSAGE:

      iocp.msg_lev = GLP_MSG_ERR;

      break;

    case MESSAGE_NORMAL_OUTPUT:

      iocp.msg_lev = GLP_MSG_ON;

      break;

    case MESSAGE_FULL_OUTPUT:

      iocp.msg_lev = GLP_MSG_ALL;

      break;

    }

    if (glp_intopt(lp, &iocp) != 0) return UNSOLVED;

    return SOLVED;

  }

  GlpkMip::ProblemType GlpkMip::_getType() const {

    switch (glp_get_status(lp)) {

    case GLP_OPT:

      switch (glp_mip_status(lp)) {

      case GLP_UNDEF:

        return UNDEFINED;

      case GLP_NOFEAS:

        return INFEASIBLE;

      case GLP_FEAS:

        return FEASIBLE;

      case GLP_OPT:

        return OPTIMAL;

      default:

        LEMON_ASSERT(false, "Wrong problem type.");

        return GlpkMip::ProblemType();

      }

    case GLP_NOFEAS:

      return INFEASIBLE;

    case GLP_INFEAS:

    case GLP_FEAS:

      if (glp_get_dual_stat(lp) == GLP_NOFEAS) {

        return UNBOUNDED;

      } else {

        return UNDEFINED;

      }

    default:

      LEMON_ASSERT(false, "Wrong problem type.");

      return GlpkMip::ProblemType();

    }

  }

  GlpkMip::Value GlpkMip::_getSol(int i) const {

    return glp_mip_col_val(lp, i);

  }

  GlpkMip::Value GlpkMip::_getSolValue() const {

    return glp_mip_obj_val(lp);

  }

  GlpkMip* GlpkMip::newSolver() const { return new GlpkMip; }

  GlpkMip* GlpkMip::cloneSolver() const {return new GlpkMip(*this); }

  const char* GlpkMip::_solverName() const { return "GlpkMip"; }

  void GlpkMip::messageLevel(MessageLevel m) {

    _message_level = m;

  }

} //END OF NAMESPACE LEMON

    virtual void _setRowLowerBound(int i, Value value);

    virtual Value _getRowLowerBound(int i) const;

    virtual void _setRowUpperBound(int i, Value value);

    virtual Value _getRowUpperBound(int i) const;

    virtual void _setObjCoeffs(ExprIterator b, ExprIterator e);

    virtual void _getObjCoeffs(InsertIterator b) const;

    virtual void _setObjCoeff(int i, Value obj_coef);

    virtual Value _getObjCoeff(int i) const;

    virtual void _setSense(Sense);

    virtual Sense _getSense() const;

    virtual void _clear();

  private:

    static void freeEnv();

    struct FreeEnvHelper {

      ~FreeEnvHelper() {

        freeEnv();

      }

    };

    static FreeEnvHelper freeEnvHelper;

  public:

    ///Pointer to the underlying GLPK data structure.

    LPX *lpx() {return lp;}

    ///Const pointer to the underlying GLPK data structure.

    const LPX *lpx() const {return lp;}

    ///Returns the constraint identifier understood by GLPK.

    int lpxRow(Row r) const { return rows(id(r)); }

    ///Returns the variable identifier understood by GLPK.

    int lpxCol(Col c) const { return cols(id(c)); }

  };

  /// \brief Interface for the GLPK LP solver

  ///

  /// This class implements an interface for the GLPK LP solver.

  ///\ingroup lp_group

  class GlpkLp : public LpSolver, public GlpkBase {

  public:

    ///\e

    GlpkLp();

    ///\e

    GlpkLp(const GlpkLp&);

    ///\e

    virtual GlpkLp* cloneSolver() const;

    ///\e

    virtual GlpkLp* newSolver() const;

  private:

    mutable std::vector<double> _primal_ray;

    mutable std::vector<double> _dual_ray;

    void _clear_temporals();

  protected:

    virtual const char* _solverName() const;

    virtual SolveExitStatus _solve();

    virtual Value _getPrimal(int i) const;

    virtual Value _getDual(int i) const;

    virtual Value _getPrimalValue() const;

    virtual VarStatus _getColStatus(int i) const;

    virtual VarStatus _getRowStatus(int i) const;

    virtual Value _getPrimalRay(int i) const;

    virtual Value _getDualRay(int i) const;

    virtual ProblemType _getPrimalType() const;

    virtual ProblemType _getDualType() const;

  public:

    ///Solve with primal simplex

    SolveExitStatus solvePrimal();

    ///Solve with dual simplex

    SolveExitStatus solveDual();

    ///Turns on or off the presolver

    ///Turns on (\c b is \c true) or off (\c b is \c false) the presolver

    ///

    ///The presolver is off by default.

    ///Enum for \c messageLevel() parameter

    enum MessageLevel {

      /// no output (default value)

      MESSAGE_NO_OUTPUT = 0,

      /// error messages only

      MESSAGE_ERROR_MESSAGE = 1,

      /// normal output

      MESSAGE_NORMAL_OUTPUT = 2,

      /// full output (includes informational messages)

      MESSAGE_FULL_OUTPUT = 3

    };

  private:

    MessageLevel _message_level;

  public:

    ///Set the verbosity of the messages

    ///Set the verbosity of the messages

    ///

    ///\param m is the level of the messages output by the solver routines.

    void messageLevel(MessageLevel m);

  };

  /// \brief Interface for the GLPK MIP solver

  ///

  /// This class implements an interface for the GLPK MIP solver.

  ///\ingroup lp_group

  class GlpkMip : public MipSolver, public GlpkBase {

  public:

    ///\e

    GlpkMip();

    ///\e

    GlpkMip(const GlpkMip&);

    virtual GlpkMip* cloneSolver() const;

    virtual GlpkMip* newSolver() const;

  protected:

    virtual const char* _solverName() const;

    virtual ColTypes _getColType(int col) const;

    virtual void _setColType(int col, ColTypes col_type);

    virtual SolveExitStatus _solve();

    virtual ProblemType _getType() const;

    virtual Value _getSol(int i) const;

    virtual Value _getSolValue() const;

    ///Enum for \c messageLevel() parameter

    enum MessageLevel {

      /// no output (default value)

      MESSAGE_NO_OUTPUT = 0,

      /// error messages only

      MESSAGE_ERROR_MESSAGE = 1,

      /// normal output

      MESSAGE_NORMAL_OUTPUT = 2,

      /// full output (includes informational messages)

      MESSAGE_FULL_OUTPUT = 3

    };

  private:

    MessageLevel _message_level;

  public:

    ///Set the verbosity of the messages

    ///Set the verbosity of the messages

    ///

    ///\param m is the level of the messages output by the solver routines.

    void messageLevel(MessageLevel m);

  };

} //END OF NAMESPACE LEMON

#endif //LEMON_GLPK_H