LEMON/LEMON-official Changeset - r585:ba124394367a

Repositories » LEMON » LEMON-official

Summary
Changelog
Files
Switch To
- loading...
Options
- Lightweight changelog
- Search
Pull Requests

Changeset - r585:ba124394367a

« 584:0fec6a

589:fc6c7a »

r585:ba124394367a

Mon, 23 Feb 2009 23:44:29

[Not Reviewed]

0 comments (0 inline)

deba@inf.elte.hu
deba@inf.elte.hu

Automatic GLPK env deallocation (#213)

0 4 0

default

4 files changed with 14 insertions and 10 deletions:

lemon/glpk.cc

lemon/glpk.h

test/lp_test.cc

test/mip_test.cc

↑ Collapse diff ↑

lemon/glpk.cc

Show inline comments

@@ -145,768 +145,770 @@
 		                                     ExprIterator e) {
 		    std::vector<int> indexes;
 		    std::vector<Value> values;
 		    indexes.push_back(0);
 		    values.push_back(0);
 		    for(ExprIterator it = b; it != e; ++it) {
 		      indexes.push_back(it->first);
 		      values.push_back(it->second);
+		    }
 		    glp_set_mat_col(lp, ix, values.size() - 1,
 		                    &indexes.front(), &values.front());
+		  }
 		  void GlpkBase::_getColCoeffs(int ix, InsertIterator b) const {
 		    int length = glp_get_mat_col(lp, ix, 0, 0);
 		    std::vector<int> indexes(length + 1);
 		    std::vector<Value> values(length + 1);
 		    glp_get_mat_col(lp, ix, &indexes.front(), &values.front());
 		    for (int i = 1; i  <= length; ++i) {
 		      *b = std::make_pair(indexes[i], values[i]);
 		      ++b;
+		    }
+		  }
 		  void GlpkBase::_setCoeff(int ix, int jx, Value value) {
 		    if (glp_get_num_cols(lp) < glp_get_num_rows(lp)) {
 		      int length = glp_get_mat_row(lp, ix, 0, 0);
 		      std::vector<int> indexes(length + 2);
 		      std::vector<Value> values(length + 2);
 		      glp_get_mat_row(lp, ix, &indexes.front(), &values.front());
 		      //The following code does not suppose that the elements of the
 		      //array indexes are sorted
 		      bool found = false;
 		      for (int i = 1; i  <= length; ++i) {
 		        if (indexes[i] == jx) {
 		          found = true;
 		          values[i] = value;
 		          break;
+		        }
+		      }
 		      if (!found) {
 		        ++length;
 		        indexes[length] = jx;
 		        values[length] = value;
+		      }
 		      glp_set_mat_row(lp, ix, length, &indexes.front(), &values.front());
 		    } else {
 		      int length = glp_get_mat_col(lp, jx, 0, 0);
 		      std::vector<int> indexes(length + 2);
 		      std::vector<Value> values(length + 2);
 		      glp_get_mat_col(lp, jx, &indexes.front(), &values.front());
 		      //The following code does not suppose that the elements of the
 		      //array indexes are sorted
 		      bool found = false;
 		      for (int i = 1; i <= length; ++i) {
 		        if (indexes[i] == ix) {
 		          found = true;
 		          values[i] = value;
 		          break;
+		        }
+		      }
 		      if (!found) {
 		        ++length;
 		        indexes[length] = ix;
 		        values[length] = value;
+		      }
 		      glp_set_mat_col(lp, jx, length, &indexes.front(), &values.front());
+		    }
+		  }
 		  GlpkBase::Value GlpkBase::_getCoeff(int ix, int jx) const {
 		    int length = glp_get_mat_row(lp, ix, 0, 0);
 		    std::vector<int> indexes(length + 1);
 		    std::vector<Value> values(length + 1);
 		    glp_get_mat_row(lp, ix, &indexes.front(), &values.front());
 		    for (int i = 1; i  <= length; ++i) {
 		      if (indexes[i] == jx) {
 		        return values[i];
+		      }
+		    }
 		    return 0;
+		  }
 		  void GlpkBase::_setColLowerBound(int i, Value lo) {
 		    LEMON_ASSERT(lo != INF, "Invalid bound");
 		    int b = glp_get_col_type(lp, i);
 		    double up = glp_get_col_ub(lp, i);
 		    if (lo == -INF) {
 		      switch (b) {
 		      case GLP_FR:
 		      case GLP_LO:
 		        glp_set_col_bnds(lp, i, GLP_FR, lo, up);
 		        break;
 		      case GLP_UP:
 		        break;
 		      case GLP_DB:
 		      case GLP_FX:
 		        glp_set_col_bnds(lp, i, GLP_UP, lo, up);
 		        break;
 		      default:
 		        break;
+		      }
 		    } else {
 		      switch (b) {
 		      case GLP_FR:
 		      case GLP_LO:
 		        glp_set_col_bnds(lp, i, GLP_LO, lo, up);
 		        break;
 		      case GLP_UP:
 		      case GLP_DB:
 		      case GLP_FX:
 		        if (lo == up)
 		          glp_set_col_bnds(lp, i, GLP_FX, lo, up);
 		        else
 		          glp_set_col_bnds(lp, i, GLP_DB, lo, up);
 		        break;
 		      default:
 		        break;
+		      }
+		    }
+		  }
 		  GlpkBase::Value GlpkBase::_getColLowerBound(int i) const {
 		    int b = glp_get_col_type(lp, i);
 		    switch (b) {
 		    case GLP_LO:
 		    case GLP_DB:
 		    case GLP_FX:
 		      return glp_get_col_lb(lp, i);
 		    default:
 		      return -INF;
+		    }
+		  }
 		  void GlpkBase::_setColUpperBound(int i, Value up) {
 		    LEMON_ASSERT(up != -INF, "Invalid bound");
 		    int b = glp_get_col_type(lp, i);
 		    double lo = glp_get_col_lb(lp, i);
 		    if (up == INF) {
 		      switch (b) {
 		      case GLP_FR:
 		      case GLP_LO:
 		        break;
 		      case GLP_UP:
 		        glp_set_col_bnds(lp, i, GLP_FR, lo, up);
 		        break;
 		      case GLP_DB:
 		      case GLP_FX:
 		        glp_set_col_bnds(lp, i, GLP_LO, lo, up);
 		        break;
 		      default:
 		        break;
+		      }
 		    } else {
 		      switch (b) {
 		      case GLP_FR:
 		        glp_set_col_bnds(lp, i, GLP_UP, lo, up);
 		        break;
 		      case GLP_UP:
 		        glp_set_col_bnds(lp, i, GLP_UP, lo, up);
 		        break;
 		      case GLP_LO:
 		      case GLP_DB:
 		      case GLP_FX:
 		        if (lo == up)
 		          glp_set_col_bnds(lp, i, GLP_FX, lo, up);
 		        else
 		          glp_set_col_bnds(lp, i, GLP_DB, lo, up);
 		        break;
 		      default:
 		        break;
+		      }
+		    }
+		  }
 		  GlpkBase::Value GlpkBase::_getColUpperBound(int i) const {
 		    int b = glp_get_col_type(lp, i);
 		      switch (b) {
 		      case GLP_UP:
 		      case GLP_DB:
 		      case GLP_FX:
 		        return glp_get_col_ub(lp, i);
 		      default:
 		        return INF;
+		      }
+		  }
 		  void GlpkBase::_setRowLowerBound(int i, Value lo) {
 		    LEMON_ASSERT(lo != INF, "Invalid bound");
 		    int b = glp_get_row_type(lp, i);
 		    double up = glp_get_row_ub(lp, i);
 		    if (lo == -INF) {
 		      switch (b) {
 		      case GLP_FR:
 		      case GLP_LO:
 		        glp_set_row_bnds(lp, i, GLP_FR, lo, up);
 		        break;
 		      case GLP_UP:
 		        break;
 		      case GLP_DB:
 		      case GLP_FX:
 		        glp_set_row_bnds(lp, i, GLP_UP, lo, up);
 		        break;
 		      default:
 		        break;
+		      }
 		    } else {
 		      switch (b) {
 		      case GLP_FR:
 		      case GLP_LO:
 		        glp_set_row_bnds(lp, i, GLP_LO, lo, up);
 		        break;
 		      case GLP_UP:
 		      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::_getRowLowerBound(int i) const {
 		    int b = glp_get_row_type(lp, i);
 		    switch (b) {
 		    case GLP_LO:
 		    case GLP_DB:
 		    case GLP_FX:
 		      return glp_get_row_lb(lp, i);
 		    default:
 		      return -INF;
+		    }
+		  }
 		  void GlpkBase::_setRowUpperBound(int i, Value up) {
 		    LEMON_ASSERT(up != -INF, "Invalid bound");
 		    int b = glp_get_row_type(lp, i);
 		    double lo = glp_get_row_lb(lp, i);
 		    if (up == INF) {
 		      switch (b) {
 		      case GLP_FR:
 		      case GLP_LO:
 		        break;
 		      case GLP_UP:
 		        glp_set_row_bnds(lp, i, GLP_FR, lo, up);
 		        break;
 		      case GLP_DB:
 		      case GLP_FX:
 		        glp_set_row_bnds(lp, i, GLP_LO, lo, up);
 		        break;
 		      default:
 		        break;
+		      }
 		    } else {
 		      switch (b) {
 		      case GLP_FR:
 		        glp_set_row_bnds(lp, i, GLP_UP, lo, up);
 		        break;
 		      case GLP_UP:
 		        glp_set_row_bnds(lp, i, GLP_UP, lo, up);
 		        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(), GlpkBase(), LpSolver() {
 		    messageLevel(MESSAGE_NO_OUTPUT);
+		  }
 		  GlpkLp::GlpkLp(const GlpkLp& other)
 		    : LpBase(other), GlpkBase(other), LpSolver(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;
+		    }
 		    if (glp_simplex(lp, &smcp) != 0) return UNSOLVED;
 		    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;
 		    if (glp_simplex(lp, &smcp) != 0) return UNSOLVED;
 		    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) {
 		          _primal_ray[i] = glp_get_col_prim(lp, i);
+		        }
+		      }
+		    }
 		    return _primal_ray[i];
+		  }
 		  GlpkLp::Value GlpkLp::_getDualRay(int i) const {
 		    if (_dual_ray.empty()) {
 		      int row_num = glp_get_num_rows(lp);
 		      _dual_ray.resize(row_num + 1, 0.0);
 		      int index = glp_get_unbnd_ray(lp);
 		      if (index != 0) {
 		        // The dual ray is found in dual 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 dual ray");
 		        int idx;
 		        bool negate = false;
 		        if (index > row_num) {
 		          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::presolver(bool b) {
 		    lpx_set_int_parm(lp, LPX_K_PRESOL, b ? 1 : 0);
+		  }
 		  void GlpkLp::messageLevel(MessageLevel m) {
 		    _message_level = m;
+		  }
 		  // GlpkMip members
 		  GlpkMip::GlpkMip()
 		    : LpBase(), GlpkBase(), MipSolver() {
 		    messageLevel(MESSAGE_NO_OUTPUT);
+		  }
 		  GlpkMip::GlpkMip(const GlpkMip& other)
 		    : LpBase(), GlpkBase(other), MipSolver() {
 		    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_simplex(lp, &smcp) != 0) return UNSOLVED;
 		    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:

lemon/glpk.h

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * This file is a part of LEMON, a generic C++ optimization library.
+		 *
 		 * Copyright (C) 2003-2008
 		 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
 		 * (Egervary Research Group on Combinatorial Optimization, EGRES).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
 		 * express or implied, and with no claim as to its suitability for any
 		 * purpose.
+		 *
 		 */
 		#ifndef LEMON_GLPK_H
 		#define LEMON_GLPK_H
 		///\file
 		///\brief Header of the LEMON-GLPK lp solver interface.
 		///\ingroup lp_group
 		#include <lemon/lp_base.h>
 		// forward declaration
 		#ifndef _GLP_PROB
 		#define _GLP_PROB
 		typedef struct { double _prob; } glp_prob;
 		/* LP/MIP problem object */
 		#endif
 		namespace lemon {
 		  /// \brief Base interface for the GLPK LP and MIP solver
 		  ///
 		  /// This class implements the common interface of the GLPK LP and MIP solver.
 		  /// \ingroup lp_group
 		  class GlpkBase : virtual public LpBase {
 		  protected:
 		    typedef glp_prob LPX;
 		    glp_prob* lp;
 		    GlpkBase();
 		    GlpkBase(const GlpkBase&);
 		    virtual ~GlpkBase();
 		  protected:
 		    virtual int _addCol();
 		    virtual int _addRow();
 		    virtual void _eraseCol(int i);
 		    virtual void _eraseRow(int i);
 		    virtual void _eraseColId(int i);
 		    virtual void _eraseRowId(int i);
 		    virtual void _getColName(int col, std::string& name) const;
 		    virtual void _setColName(int col, const std::string& name);
 		    virtual int _colByName(const std::string& name) const;
 		    virtual void _getRowName(int row, std::string& name) const;
 		    virtual void _setRowName(int row, const std::string& name);
 		    virtual int _rowByName(const std::string& name) const;
 		    virtual void _setRowCoeffs(int i, ExprIterator b, ExprIterator e);
 		    virtual void _getRowCoeffs(int i, InsertIterator b) const;
 		    virtual void _setColCoeffs(int i, ExprIterator b, ExprIterator e);
 		    virtual void _getColCoeffs(int i, InsertIterator b) const;
 		    virtual void _setCoeff(int row, int col, Value value);
 		    virtual Value _getCoeff(int row, int col) const;
 		    virtual void _setColLowerBound(int i, Value value);
 		    virtual Value _getColLowerBound(int i) const;
 		    virtual void _setColUpperBound(int i, Value value);
 		    virtual Value _getColUpperBound(int i) const;
 		    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:
 		    /// \brief Deallocates the globally allocated memory of GLPK.
 		    /// Deallocates the globally allocated memory of GLPK.  \note
 		    /// Usually, it do not have to be called, because the GLPK use
 		    /// only a small amount of global memory, and it is deallocated
 		    /// automatically at the end of program.
 		    static void freeEnv();
 		    ///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 GlpkBase, public LpSolver {
 		  public:
 		    ///\e
 		    GlpkLp();
 		    ///\e
 		    GlpkLp(const GlpkLp&);
 		  private:
 		    mutable std::vector<double> _primal_ray;
 		    mutable std::vector<double> _dual_ray;
 		    void _clear_temporals();
 		  protected:
 		    virtual GlpkLp* _cloneSolver() const;
 		    virtual GlpkLp* _newSolver() const;
 		    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;
 		    ///\todo It should be clarified
 		    ///
 		    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.
 		    void presolver(bool b);
 		    ///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 GlpkBase, public MipSolver {
 		  public:
 		    ///\e
 		    GlpkMip();
 		    ///\e
 		    GlpkMip(const GlpkMip&);
 		  protected:
 		    virtual GlpkMip* _cloneSolver() const;
 		    virtual GlpkMip* _newSolver() const;
 		    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

test/lp_test.cc

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * This file is a part of LEMON, a generic C++ optimization library.
+		 *
 		 * Copyright (C) 2003-2008
 		 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
 		 * (Egervary Research Group on Combinatorial Optimization, EGRES).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
 		 * express or implied, and with no claim as to its suitability for any
 		 * purpose.
+		 *
 		 */
 		#include <sstream>
 		#include <lemon/lp_skeleton.h>
 		#include "test_tools.h"
 		#include <lemon/tolerance.h>
 		#ifdef HAVE_CONFIG_H
 		#include <lemon/config.h>
 		#endif
 		#ifdef HAVE_GLPK
 		#include <lemon/glpk.h>
 		#endif
 		#ifdef HAVE_CPLEX
 		#include <lemon/cplex.h>
 		#endif
 		#ifdef HAVE_SOPLEX
 		#include <lemon/soplex.h>
 		#endif
 		#ifdef HAVE_CLP
 		#include <lemon/clp.h>
 		#endif
 		using namespace lemon;
 		void lpTest(LpSolver& lp)
+		{
 		  typedef LpSolver LP;
 		  std::vector<LP::Col> x(10);
 		  //  for(int i=0;i<10;i++) x.push_back(lp.addCol());
 		  lp.addColSet(x);
 		  lp.colLowerBound(x,1);
 		  lp.colUpperBound(x,1);
 		  lp.colBounds(x,1,2);
 		  std::vector<LP::Col> y(10);
 		  lp.addColSet(y);
 		  lp.colLowerBound(y,1);
 		  lp.colUpperBound(y,1);
 		  lp.colBounds(y,1,2);
 		  std::map<int,LP::Col> z;
 		  z.insert(std::make_pair(12,INVALID));
 		  z.insert(std::make_pair(2,INVALID));
 		  z.insert(std::make_pair(7,INVALID));
 		  z.insert(std::make_pair(5,INVALID));
 		  lp.addColSet(z);
 		  lp.colLowerBound(z,1);
 		  lp.colUpperBound(z,1);
 		  lp.colBounds(z,1,2);
+		  {
 		    LP::Expr e,f,g;
 		    LP::Col p1,p2,p3,p4,p5;
 		    LP::Constr c;
 		    p1=lp.addCol();
 		    p2=lp.addCol();
 		    p3=lp.addCol();
 		    p4=lp.addCol();
 		    p5=lp.addCol();
 		    e[p1]=2;
 		    *e=12;
 		    e[p1]+=2;
 		    *e+=12;
 		    e[p1]-=2;
 		    *e-=12;
 		    e=2;
 		    e=2.2;
 		    e=p1;
 		    e=f;
 		    e+=2;
 		    e+=2.2;
 		    e+=p1;
 		    e+=f;
 		    e-=2;
 		    e-=2.2;
 		    e-=p1;
 		    e-=f;
 		    e*=2;
 		    e*=2.2;
 		    e/=2;
 		    e/=2.2;
 		    e=((p1+p2)+(p1-p2)+(p1+12)+(12+p1)+(p1-12)+(12-p1)+
 		       (f+12)+(12+f)+(p1+f)+(f+p1)+(f+g)+
 		       (f-12)+(12-f)+(p1-f)+(f-p1)+(f-g)+
 .2*f+f*2.2+f/2.2+
 *f+f*2+f/2+
 .2*p1+p1*2.2+p1/2.2+
 *p1+p1*2+p1/2
 		       );
 		    c = (e  <= f  );
 		    c = (e  <= 2.2);
 		    c = (e  <= 2  );
 		    c = (e  <= p1 );
 		    c = (2.2<= f  );
 		    c = (2  <= f  );
 		    c = (p1 <= f  );
 		    c = (p1 <= p2 );
 		    c = (p1 <= 2.2);
 		    c = (p1 <= 2  );
 		    c = (2.2<= p2 );
 		    c = (2  <= p2 );
 		    c = (e  >= f  );
 		    c = (e  >= 2.2);
 		    c = (e  >= 2  );
 		    c = (e  >= p1 );
 		    c = (2.2>= f  );
 		    c = (2  >= f  );
 		    c = (p1 >= f  );
 		    c = (p1 >= p2 );
 		    c = (p1 >= 2.2);
 		    c = (p1 >= 2  );
 		    c = (2.2>= p2 );
 		    c = (2  >= p2 );
 		    c = (e  == f  );
 		    c = (e  == 2.2);
 		    c = (e  == 2  );
 		    c = (e  == p1 );
 		    c = (2.2== f  );
 		    c = (2  == f  );
 		    c = (p1 == f  );
 		    //c = (p1 == p2 );
 		    c = (p1 == 2.2);
 		    c = (p1 == 2  );
 		    c = (2.2== p2 );
 		    c = (2  == p2 );
 		    c = ((2 <= e) <= 3);
 		    c = ((2 <= p1) <= 3);
 		    c = ((2 >= e) >= 3);
 		    c = ((2 >= p1) >= 3);
 		    e[x[3]]=2;
 		    e[x[3]]=4;
 		    e[x[3]]=1;
 		    *e=12;
 		    lp.addRow(-LP::INF,e,23);
 		    lp.addRow(-LP::INF,3.0*(x[1]+x[2]/2)-x[3],23);
 		    lp.addRow(-LP::INF,3.0*(x[1]+x[2]*2-5*x[3]+12-x[4]/3)+2*x[4]-4,23);
 		    lp.addRow(x[1]+x[3]<=x[5]-3);
 		    lp.addRow((-7<=x[1]+x[3]-12)<=3);
 		    lp.addRow(x[1]<=x[5]);
 		    std::ostringstream buf;
 		    e=((p1+p2)+(p1-0.99*p2));
 		    //e.prettyPrint(std::cout);
 		    //(e<=2).prettyPrint(std::cout);
 		    double tolerance=0.001;
 		    e.simplify(tolerance);
 		    buf << "Coeff. of p2 should be 0.01";
 		    check(e[p2]>0, buf.str());
 		    tolerance=0.02;
 		    e.simplify(tolerance);
 		    buf << "Coeff. of p2 should be 0";
 		    check(const_cast<const LpSolver::Expr&>(e)[p2]==0, buf.str());
+		  }
+		  {
 		    LP::DualExpr e,f,g;
 		    LP::Row p1 = INVALID, p2 = INVALID, p3 = INVALID,
 		      p4 = INVALID, p5 = INVALID;
 		    e[p1]=2;
 		    e[p1]+=2;
 		    e[p1]-=2;
 		    e=p1;
 		    e=f;
 		    e+=p1;
 		    e+=f;
 		    e-=p1;
 		    e-=f;
 		    e*=2;
 		    e*=2.2;
 		    e/=2;
 		    e/=2.2;
 		    e=((p1+p2)+(p1-p2)+
 		       (p1+f)+(f+p1)+(f+g)+
 		       (p1-f)+(f-p1)+(f-g)+
 .2*f+f*2.2+f/2.2+
 *f+f*2+f/2+
 .2*p1+p1*2.2+p1/2.2+
 *p1+p1*2+p1/2
 		       );
+		  }
+		}
 		void solveAndCheck(LpSolver& lp, LpSolver::ProblemType stat,
 		                   double exp_opt) {
 		  using std::string;
 		  lp.solve();
 		  std::ostringstream buf;
 		  buf << "PrimalType should be: " << int(stat) << int(lp.primalType());
 		  check(lp.primalType()==stat, buf.str());
 		  if (stat ==  LpSolver::OPTIMAL) {
 		    std::ostringstream sbuf;
 		    sbuf << "Wrong optimal value: the right optimum is " << exp_opt;
 		    check(std::abs(lp.primal()-exp_opt) < 1e-3, sbuf.str());
+		  }
+		}
 		void aTest(LpSolver & lp)
+		{
 		  typedef LpSolver LP;
 		 //The following example is very simple
 		  typedef LpSolver::Row Row;
 		  typedef LpSolver::Col Col;
 		  Col x1 = lp.addCol();
 		  Col x2 = lp.addCol();
 		  //Constraints
 		  Row upright=lp.addRow(x1+2*x2 <=1);
 		  lp.addRow(x1+x2 >=-1);
 		  lp.addRow(x1-x2 <=1);
 		  lp.addRow(x1-x2 >=-1);
 		  //Nonnegativity of the variables
 		  lp.colLowerBound(x1, 0);
 		  lp.colLowerBound(x2, 0);
 		  //Objective function
 		  lp.obj(x1+x2);
 		  lp.sense(lp.MAX);
 		  //Testing the problem retrieving routines
 		  check(lp.objCoeff(x1)==1,"First term should be 1 in the obj function!");
 		  check(lp.sense() == lp.MAX,"This is a maximization!");
 		  check(lp.coeff(upright,x1)==1,"The coefficient in question is 1!");
 		  check(lp.colLowerBound(x1)==0,
 		        "The lower bound for variable x1 should be 0.");
 		  check(lp.colUpperBound(x1)==LpSolver::INF,
 		        "The upper bound for variable x1 should be infty.");
 		  check(lp.rowLowerBound(upright) == -LpSolver::INF,
 		        "The lower bound for the first row should be -infty.");
 		  check(lp.rowUpperBound(upright)==1,
 		        "The upper bound for the first row should be 1.");
 		  LpSolver::Expr e = lp.row(upright);
 		  check(e[x1] == 1, "The first coefficient should 1.");
 		  check(e[x2] == 2, "The second coefficient should 1.");
 		  lp.row(upright, x1+x2 <=1);
 		  e = lp.row(upright);
 		  check(e[x1] == 1, "The first coefficient should 1.");
 		  check(e[x2] == 1, "The second coefficient should 1.");
 		  LpSolver::DualExpr de = lp.col(x1);
 		  check(  de[upright] == 1, "The first coefficient should 1.");
 		  LpSolver* clp = lp.cloneSolver();
 		  //Testing the problem retrieving routines
 		  check(clp->objCoeff(x1)==1,"First term should be 1 in the obj function!");
 		  check(clp->sense() == clp->MAX,"This is a maximization!");
 		  check(clp->coeff(upright,x1)==1,"The coefficient in question is 1!");
 		  //  std::cout<<lp.colLowerBound(x1)<<std::endl;
 		  check(clp->colLowerBound(x1)==0,
 		        "The lower bound for variable x1 should be 0.");
 		  check(clp->colUpperBound(x1)==LpSolver::INF,
 		        "The upper bound for variable x1 should be infty.");
 		  check(lp.rowLowerBound(upright)==-LpSolver::INF,
 		        "The lower bound for the first row should be -infty.");
 		  check(lp.rowUpperBound(upright)==1,
 		        "The upper bound for the first row should be 1.");
 		  e = clp->row(upright);
 		  check(e[x1] == 1, "The first coefficient should 1.");
 		  check(e[x2] == 1, "The second coefficient should 1.");
 		  de = clp->col(x1);
 		  check(de[upright] == 1, "The first coefficient should 1.");
 		  delete clp;
 		  //Maximization of x1+x2
 		  //over the triangle with vertices (0,0) (0,1) (1,0)
 		  double expected_opt=1;
 		  solveAndCheck(lp, LpSolver::OPTIMAL, expected_opt);
 		  //Minimization
 		  lp.sense(lp.MIN);
 		  expected_opt=0;
 		  solveAndCheck(lp, LpSolver::OPTIMAL, expected_opt);
 		  //Vertex (-1,0) instead of (0,0)
 		  lp.colLowerBound(x1, -LpSolver::INF);
 		  expected_opt=-1;
 		  solveAndCheck(lp, LpSolver::OPTIMAL, expected_opt);
 		  //Erase one constraint and return to maximization
 		  lp.erase(upright);
 		  lp.sense(lp.MAX);
 		  expected_opt=LpSolver::INF;
 		  solveAndCheck(lp, LpSolver::UNBOUNDED, expected_opt);
 		  //Infeasibilty
 		  lp.addRow(x1+x2 <=-2);
 		  solveAndCheck(lp, LpSolver::INFEASIBLE, expected_opt);
+		}
 		int main()
+		{
 		  LpSkeleton lp_skel;
 		  lpTest(lp_skel);
 		#ifdef HAVE_GLPK
+		  {
 		    GlpkLp lp_glpk1,lp_glpk2;
 		    lpTest(lp_glpk1);
 		    aTest(lp_glpk2);
+		  }
 		  GlpkLp::freeEnv();
 		#endif
 		#ifdef HAVE_CPLEX
 		  try {
 		    CplexLp lp_cplex1,lp_cplex2;
 		    lpTest(lp_cplex1);
 		    aTest(lp_cplex2);
 		  } catch (CplexEnv::LicenseError& error) {
 		#ifdef LEMON_FORCE_CPLEX_CHECK
 		    check(false, error.what());
 		#else
 		    std::cerr << error.what() << std::endl;
 		    std::cerr << "Cplex license check failed, lp check skipped" << std::endl;
 		#endif
+		  }
 		#endif
 		#ifdef HAVE_SOPLEX
+		  {
 		    SoplexLp lp_soplex1,lp_soplex2;
 		    lpTest(lp_soplex1);
 		    aTest(lp_soplex2);
+		  }
 		#endif
 		#ifdef HAVE_CLP
+		  {
 		    ClpLp lp_clp1,lp_clp2;
 		    lpTest(lp_clp1);
 		    aTest(lp_clp2);
+		  }
 		#endif
 		  return 0;
+		}

test/mip_test.cc

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * This file is a part of LEMON, a generic C++ optimization library.
+		 *
 		 * Copyright (C) 2003-2008
 		 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
 		 * (Egervary Research Group on Combinatorial Optimization, EGRES).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
 		 * express or implied, and with no claim as to its suitability for any
 		 * purpose.
+		 *
 		 */
 		#include "test_tools.h"
 		#ifdef HAVE_CONFIG_H
 		#include <lemon/config.h>
 		#endif
 		#ifdef HAVE_CPLEX
 		#include <lemon/cplex.h>
 		#endif
 		#ifdef HAVE_GLPK
 		#include <lemon/glpk.h>
 		#endif
 		using namespace lemon;
 		void solveAndCheck(MipSolver& mip, MipSolver::ProblemType stat,
 		                   double exp_opt) {
 		  using std::string;
 		  mip.solve();
 		  //int decimal,sign;
 		  std::ostringstream buf;
 		  buf << "Type should be: " << int(stat)<<" and it is "<<int(mip.type());
 		  //  itoa(stat,buf1, 10);
 		  check(mip.type()==stat, buf.str());
 		  if (stat ==  MipSolver::OPTIMAL) {
 		    std::ostringstream sbuf;
 		    buf << "Wrong optimal value: the right optimum is " << exp_opt;
 		    check(std::abs(mip.solValue()-exp_opt) < 1e-3, sbuf.str());
 		    //+ecvt(exp_opt,2)
+		  }
+		}
 		void aTest(MipSolver& mip)
+		{
 		 //The following example is very simple
 		  typedef MipSolver::Row Row;
 		  typedef MipSolver::Col Col;
 		  Col x1 = mip.addCol();
 		  Col x2 = mip.addCol();
 		  //Objective function
 		  mip.obj(x1);
 		  mip.max();
 		  //Unconstrained optimization
 		  mip.solve();
 		  //Check it out!
 		  //Constraints
 		  mip.addRow(2*x1+x2 <=2);
 		  mip.addRow(x1-2*x2 <=0);
 		  //Nonnegativity of the variable x1
 		  mip.colLowerBound(x1, 0);
 		  //Maximization of x1
 		  //over the triangle with vertices (0,0),(4/5,2/5),(0,2)
 		  double expected_opt=4.0/5.0;
 		  solveAndCheck(mip, MipSolver::OPTIMAL, expected_opt);
 		  //Restrict x2 to integer
 		  mip.colType(x2,MipSolver::INTEGER);
 		  expected_opt=1.0/2.0;
 		  solveAndCheck(mip, MipSolver::OPTIMAL, expected_opt);
 		  //Restrict both to integer
 		  mip.colType(x1,MipSolver::INTEGER);
 		  expected_opt=0;
 		  solveAndCheck(mip, MipSolver::OPTIMAL, expected_opt);
+		}
 		int main()
+		{
 		#ifdef HAVE_GLPK
+		  {
 		    GlpkMip mip1;
 		    aTest(mip1);
+		  }
 		  GlpkLp::freeEnv();
 		#endif
 		#ifdef HAVE_CPLEX
 		  try {
 		    CplexMip mip2;
 		    aTest(mip2);
 		  } catch (CplexEnv::LicenseError& error) {
 		#ifdef LEMON_FORCE_CPLEX_CHECK
 		    check(false, error.what());
 		#else
 		    std::cerr << error.what() << std::endl;
 		    std::cerr << "Cplex license check failed, lp check skipped" << std::endl;
 		#endif
+		  }
 		#endif
 		  return 0;
+		}

0 comments (0 inline)

RhodeCode

Login to your account