LEMON/LEMON-official Changeset - r630:99a31b399b59

Repositories » LEMON » LEMON-official

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

Changeset - r630:99a31b399b59

« 625:a2e6b1
« 629:7a28e2

633:7c1206 »
632:65fbcf »
631:33c6b6 »

r630:99a31b399b59

Tue, 14 Apr 2009 11:40:33

[Not Reviewed]

0 comments (0 inline)

alpar (Alpar Juttner)
alpar@cs.elte.hu

Merge

0 16 0

merge default

0 files changed with 187 insertions and 198 deletions:

lemon/cbc.cc

lemon/cbc.h

lemon/clp.cc

lemon/clp.h

lemon/cplex.cc

lemon/cplex.h

lemon/glpk.cc

lemon/glpk.h

lemon/lp_base.h

lemon/lp_skeleton.cc

lemon/lp_skeleton.h

lemon/soplex.cc

lemon/soplex.h

test/lp_test.cc

test/mip_test.cc

tools/lemon-0.x-to-1.x.sh

↑ Collapse diff ↑

lemon/cbc.cc

Show inline comments

@@ -46,30 +46,33 @@
 		#include "coin/CglFlowCover.hpp"
 		#include "coin/CglMixedIntegerRounding.hpp"
 		#include "coin/CbcHeuristic.hpp"
 		namespace lemon {
 		  CbcMip::CbcMip() {
 		    _prob = new CoinModel();
 		    _prob->setProblemName("LEMON");
 		    _osi_solver = 0;
 		    _cbc_model = 0;
 		    messageLevel(MESSAGE_NOTHING);
+		  }
 		  CbcMip::CbcMip(const CbcMip& other) {
 		    _prob = new CoinModel(*other._prob);
 		    _prob->setProblemName("LEMON");
 		    _osi_solver = 0;
 		    _cbc_model = 0;
 		    messageLevel(MESSAGE_NOTHING);
+		  }
 		  CbcMip::~CbcMip() {
 		    delete _prob;
 		    if (_osi_solver) delete _osi_solver;
 		    if (_cbc_model) delete _cbc_model;
+		  }
 		  const char* CbcMip::_solverName() const { return "CbcMip"; }
 		  int CbcMip::_addCol() {
 		    _prob->addColumn(0, 0, 0, -COIN_DBL_MAX, COIN_DBL_MAX, 0.0, 0, false);
@@ -261,42 +264,26 @@
 		    _osi_solver = new OsiOslSolverInterface();
 		#else
 		#error Cannot instantiate Osi solver
 		#endif
 		    _osi_solver->loadFromCoinModel(*_prob);
 		    if (_cbc_model) {
 		      delete _cbc_model;
+		    }
 		    _cbc_model= new CbcModel(*_osi_solver);
 		    switch (_message_level) {
 		    case MESSAGE_NO_OUTPUT:
 		      _osi_solver->messageHandler()->setLogLevel(0);
 		      _cbc_model->setLogLevel(0);
 		      break;
 		    case MESSAGE_ERROR_MESSAGE:
 		      _osi_solver->messageHandler()->setLogLevel(1);
 		      _cbc_model->setLogLevel(1);
 		      break;
 		    case MESSAGE_NORMAL_OUTPUT:
 		      _osi_solver->messageHandler()->setLogLevel(2);
 		      _cbc_model->setLogLevel(2);
 		      break;
 		    case MESSAGE_FULL_OUTPUT:
 		      _osi_solver->messageHandler()->setLogLevel(3);
 		      _cbc_model->setLogLevel(3);
 		      break;
+		    }
 		    _osi_solver->messageHandler()->setLogLevel(_message_level);
 		    _cbc_model->setLogLevel(_message_level);
 		    _cbc_model->initialSolve();
 		    _cbc_model->solver()->setHintParam(OsiDoReducePrint, true, OsiHintTry);
 		    if (!_cbc_model->isInitialSolveAbandoned() &&
 		        _cbc_model->isInitialSolveProvenOptimal() &&
 		        !_cbc_model->isInitialSolveProvenPrimalInfeasible() &&
 		        !_cbc_model->isInitialSolveProvenDualInfeasible()) {
 		      CglProbing generator1;
 		      generator1.setUsingObjective(true);
 		      generator1.setMaxPass(3);
@@ -444,17 +431,33 @@
 		      _osi_solver = 0;
+		    }
 		    if (_cbc_model) {
 		      delete _cbc_model;
 		      _cbc_model = 0;
+		    }
 		    _prob = new CoinModel();
 		    rows.clear();
 		    cols.clear();
+		  }
 		  void CbcMip::messageLevel(MessageLevel m) {
 		    _message_level = m;
 		  void CbcMip::_messageLevel(MessageLevel level) {
 		    switch (level) {
 		    case MESSAGE_NOTHING:
 		      _message_level = 0;
 		      break;
 		    case MESSAGE_ERROR:
 		      _message_level = 1;
 		      break;
 		    case MESSAGE_WARNING:
 		      _message_level = 1;
 		      break;
 		    case MESSAGE_NORMAL:
 		      _message_level = 2;
 		      break;
 		    case MESSAGE_VERBOSE:
 		      _message_level = 3;
 		      break;
+		    }
+		  }
 		} //END OF NAMESPACE LEMON

lemon/cbc.h

Show inline comments

@@ -106,45 +106,24 @@
 		    virtual Sense _getSense() 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;
 		    virtual void _clear();
-		  public:
+		    virtual void _messageLevel(MessageLevel level);
 		    void _applyMessageLevel();
 		    ///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
-		    };
+		    int _message_level;
 		  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);
 		  };
+		}
 		#endif

lemon/clp.cc

Show inline comments

@@ -15,33 +15,33 @@
 		 * purpose.
+		 *
 		 */
 		#include <lemon/clp.h>
 		#include <coin/ClpSimplex.hpp>
 		namespace lemon {
 		  ClpLp::ClpLp() {
 		    _prob = new ClpSimplex();
 		    _init_temporals();
-		    messageLevel(MESSAGE_NO_OUTPUT);
+		    messageLevel(MESSAGE_NOTHING);
+		  }
 		  ClpLp::ClpLp(const ClpLp& other) {
 		    _prob = new ClpSimplex(*other._prob);
 		    rows = other.rows;
 		    cols = other.cols;
 		    _init_temporals();
-		    messageLevel(MESSAGE_NO_OUTPUT);
+		    messageLevel(MESSAGE_NOTHING);
+		  }
 		  ClpLp::~ClpLp() {
 		    delete _prob;
 		    _clear_temporals();
+		  }
 		  void ClpLp::_init_temporals() {
 		    _primal_ray = 0;
 		    _dual_ray = 0;
+		  }
@@ -421,17 +421,33 @@
+		    }
+		  }
 		  void ClpLp::_clear() {
 		    delete _prob;
 		    _prob = new ClpSimplex();
 		    rows.clear();
 		    cols.clear();
 		    _col_names_ref.clear();
 		    _clear_temporals();
+		  }
 		  void ClpLp::messageLevel(MessageLevel m) {
 		    _prob->setLogLevel(static_cast<int>(m));
 		  void ClpLp::_messageLevel(MessageLevel level) {
 		    switch (level) {
 		    case MESSAGE_NOTHING:
 		      _prob->setLogLevel(0);
 		      break;
 		    case MESSAGE_ERROR:
 		      _prob->setLogLevel(1);
 		      break;
 		    case MESSAGE_WARNING:
 		      _prob->setLogLevel(2);
 		      break;
 		    case MESSAGE_NORMAL:
 		      _prob->setLogLevel(3);
 		      break;
 		    case MESSAGE_VERBOSE:
 		      _prob->setLogLevel(4);
 		      break;
+		    }
+		  }
 		} //END OF NAMESPACE LEMON

lemon/clp.h

Show inline comments

@@ -127,55 +127,37 @@
 		    virtual Value _getPrimalRay(int i) const;
 		    virtual Value _getDualRay(int i) const;
 		    virtual VarStatus _getColStatus(int i) const;
 		    virtual VarStatus _getRowStatus(int i) const;
 		    virtual ProblemType _getPrimalType() const;
 		    virtual ProblemType _getDualType() const;
 		    virtual void _clear();
 		    virtual void _messageLevel(MessageLevel);
 		  public:
 		    ///Solves LP with primal simplex method.
 		    SolveExitStatus solvePrimal();
 		    ///Solves LP with dual simplex method.
 		    SolveExitStatus solveDual();
 		    ///Solves LP with barrier method.
 		    SolveExitStatus solveBarrier();
 		    ///Returns the constraint identifier understood by CLP.
 		    int clpRow(Row r) const { return rows(id(r)); }
 		    ///Returns the variable identifier understood by CLP.
 		    int clpCol(Col c) const { return cols(id(c)); }
 		    ///Enum for \c messageLevel() parameter
 		    enum MessageLevel {
 		      /// no output (default value)
 		      MESSAGE_NO_OUTPUT = 0,
 		      /// print final solution
 		      MESSAGE_FINAL_SOLUTION = 1,
 		      /// print factorization
 		      MESSAGE_FACTORIZATION = 2,
 		      /// normal output
 		      MESSAGE_NORMAL_OUTPUT = 3,
 		      /// verbose output
 		      MESSAGE_VERBOSE_OUTPUT = 4
 		    };
 		    ///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_CLP_H

lemon/cplex.cc

Show inline comments

@@ -63,38 +63,41 @@
 		  CplexEnv::~CplexEnv() {
 		    --(*_cnt);
 		    if (*_cnt == 0) {
 		      delete _cnt;
 		      CPXcloseCPLEX(&_env);
+		    }
+		  }
 		  CplexBase::CplexBase() : LpBase() {
 		    int status;
 		    _prob = CPXcreateprob(cplexEnv(), &status, "Cplex problem");
 		    messageLevel(MESSAGE_NOTHING);
+		  }
 		  CplexBase::CplexBase(const CplexEnv& env)
 		    : LpBase(), _env(env) {
 		    int status;
 		    _prob = CPXcreateprob(cplexEnv(), &status, "Cplex problem");
 		    messageLevel(MESSAGE_NOTHING);
+		  }
 		  CplexBase::CplexBase(const CplexBase& cplex)
 		    : LpBase() {
 		    int status;
 		    _prob = CPXcloneprob(cplexEnv(), cplex._prob, &status);
 		    rows = cplex.rows;
 		    cols = cplex.cols;
 		    messageLevel(MESSAGE_NOTHING);
+		  }
 		  CplexBase::~CplexBase() {
 		    CPXfreeprob(cplexEnv(),&_prob);
+		  }
 		  int CplexBase::_addCol() {
 		    int i = CPXgetnumcols(cplexEnv(), _prob);
 		    double lb = -INF, ub = INF;
 		    CPXnewcols(cplexEnv(), _prob, 1, 0, &lb, &ub, 0, 0);
 		    return i;
+		  }
@@ -429,24 +432,43 @@
 		      return CplexBase::Sense();
+		    }
+		  }
 		  void CplexBase::_clear() {
 		    CPXfreeprob(cplexEnv(),&_prob);
 		    int status;
 		    _prob = CPXcreateprob(cplexEnv(), &status, "Cplex problem");
 		    rows.clear();
 		    cols.clear();
+		  }
 		  void CplexBase::_messageLevel(MessageLevel level) {
 		    switch (level) {
 		    case MESSAGE_NOTHING:
 		      _message_enabled = false;
 		      break;
 		    case MESSAGE_ERROR:
 		    case MESSAGE_WARNING:
 		    case MESSAGE_NORMAL:
 		    case MESSAGE_VERBOSE:
 		      _message_enabled = true;
 		      break;
+		    }
+		  }
 		  void CplexBase::_applyMessageLevel() {
 		    CPXsetintparam(cplexEnv(), CPX_PARAM_SCRIND,
 		                   _message_enabled ? CPX_ON : CPX_OFF);
+		  }
 		  // CplexLp members
 		  CplexLp::CplexLp()
 		    : LpBase(), LpSolver(), CplexBase() {}
 		  CplexLp::CplexLp(const CplexEnv& env)
 		    : LpBase(), LpSolver(), CplexBase(env) {}
 		  CplexLp::CplexLp(const CplexLp& other)
 		    : LpBase(), LpSolver(), CplexBase(other) {}
 		  CplexLp::~CplexLp() {}
@@ -498,39 +520,43 @@
 		        return UNSOLVED;
 		      default:
 		        return SOLVED;
+		      }
 		    } else {
 		      return UNSOLVED;
+		    }
 		#endif
+		  }
 		  CplexLp::SolveExitStatus CplexLp::_solve() {
 		    _clear_temporals();
 		    _applyMessageLevel();
 		    return convertStatus(CPXlpopt(cplexEnv(), _prob));
+		  }
 		  CplexLp::SolveExitStatus CplexLp::solvePrimal() {
 		    _clear_temporals();
 		    _applyMessageLevel();
 		    return convertStatus(CPXprimopt(cplexEnv(), _prob));
+		  }
 		  CplexLp::SolveExitStatus CplexLp::solveDual() {
 		    _clear_temporals();
 		    _applyMessageLevel();
 		    return convertStatus(CPXdualopt(cplexEnv(), _prob));
+		  }
 		  CplexLp::SolveExitStatus CplexLp::solveBarrier() {
 		    _clear_temporals();
 		    _applyMessageLevel();
 		    return convertStatus(CPXbaropt(cplexEnv(), _prob));
+		  }
 		  CplexLp::Value CplexLp::_getPrimal(int i) const {
 		    Value x;
 		    CPXgetx(cplexEnv(), _prob, &x, i, i);
 		    return x;
+		  }
 		  CplexLp::Value CplexLp::_getDual(int i) const {
 		    Value y;
 		    CPXgetpi(cplexEnv(), _prob, &y, i, i);
@@ -591,25 +617,25 @@
 		      CPXgetray(cplexEnv(), _prob, &_primal_ray.front());
+		    }
 		    return _primal_ray[i];
+		  }
 		  CplexLp::Value CplexLp::_getDualRay(int i) const {
 		    if (_dual_ray.empty()) {
+		    }
 		    return _dual_ray[i];
+		  }
-		  //7.5-os cplex statusai (Vigyazat: a 9.0-asei masok!)
+		  // Cplex 7.0 status values
 		  // This table lists the statuses, returned by the CPXgetstat()
 		  // routine, for solutions to LP problems or mixed integer problems. If
 		  // no solution exists, the return value is zero.
 		  // For Simplex, Barrier
 		  // 1          CPX_OPTIMAL
 		  //          Optimal solution found
 		  // 2          CPX_INFEASIBLE
 		  //          Problem infeasible
 		  // 3    CPX_UNBOUNDED
 		  //          Problem unbounded
 		  // 4          CPX_OBJ_LIM
@@ -638,25 +664,25 @@
 		  //          Aborted in barrier, primal infeasible
 		  // 16          CPX_ABORT_PRIM_DUAL_INFEAS
 		  //          Aborted in barrier, primal and dual infeasible
 		  // 17          CPX_ABORT_PRIM_DUAL_FEAS
 		  //          Aborted in barrier, primal and dual feasible
 		  // 18          CPX_ABORT_CROSSOVER
 		  //          Aborted in crossover
 		  // 19          CPX_INForUNBD
 		  //          Infeasible or unbounded
 		  // 20   CPX_PIVOT
 		  //       User pivot used
 		  //
-		  //     Ezeket hova tegyem:
+		  // Pending return values
 		  // ??case CPX_ABORT_DUAL_INFEAS
 		  // ??case CPX_ABORT_CROSSOVER
 		  // ??case CPX_INForUNBD
 		  // ??case CPX_PIVOT
 		  //Some more interesting stuff:
 		  // CPX_PARAM_PROBMETHOD  1062  int  LPMETHOD
 		  // 0 Automatic
 		  // 1 Primal Simplex
 		  // 2 Dual Simplex
 		  // 3 Network Simplex
@@ -709,25 +735,24 @@
 		      case CPX_STAT_OPTIMAL:
 		        return OPTIMAL;
 		      case CPX_STAT_UNBOUNDED:
 		        return UNBOUNDED;
 		      case CPX_STAT_INFEASIBLE:
 		        return INFEASIBLE;
 		      default:
 		        return UNDEFINED;
+		      }
 		#else
 		    statusSwitch(cplexEnv(),stat);
 		    //CPXgetstat(cplexEnv(), _prob);
 		    //printf("A primal status: %d, CPX_OPTIMAL=%d \n",stat,CPX_OPTIMAL);
 		    switch (stat) {
 		    case 0:
 		      return UNDEFINED; //Undefined
 		    case CPX_OPTIMAL://Optimal
 		      return OPTIMAL;
 		    case CPX_UNBOUNDED://Unbounded
 		      return INFEASIBLE;//In case of dual simplex
 		      //return UNBOUNDED;
 		    case CPX_INFEASIBLE://Infeasible
 		      //    case CPX_IT_LIM_INFEAS:
 		      //     case CPX_TIME_LIM_INFEAS:
 		      //     case CPX_NUM_BEST_INFEAS:
@@ -742,25 +767,25 @@
 		      //     case CPX_TIME_LIM_FEAS:
 		      //     case CPX_NUM_BEST_FEAS:
 		      //     case CPX_ABORT_FEAS:
 		      //     case CPX_ABORT_PRIM_DUAL_FEAS:
 		      //       return FEASIBLE;
 		    default:
 		      return UNDEFINED; //Everything else comes here
 		      //FIXME error
+		    }
 		#endif
+		  }
-		  //9.0-as cplex verzio statusai
+		  // Cplex 9.0 status values
 		  // CPX_STAT_ABORT_DUAL_OBJ_LIM
 		  // CPX_STAT_ABORT_IT_LIM
 		  // CPX_STAT_ABORT_OBJ_LIM
 		  // CPX_STAT_ABORT_PRIM_OBJ_LIM
 		  // CPX_STAT_ABORT_TIME_LIM
 		  // CPX_STAT_ABORT_USER
 		  // CPX_STAT_FEASIBLE_RELAXED
 		  // CPX_STAT_INFEASIBLE
 		  // CPX_STAT_INForUNBD
 		  // CPX_STAT_NUM_BEST
 		  // CPX_STAT_OPTIMAL
 		  // CPX_STAT_OPTIMAL_FACE_UNBOUNDED
@@ -855,24 +880,25 @@
 		      return INTEGER;
 		    case 'C':
 		      return REAL;
 		    default:
 		      LEMON_ASSERT(false, "Invalid column type");
 		      return ColTypes();
+		    }
+		  }
 		  CplexMip::SolveExitStatus CplexMip::_solve() {
 		    int status;
 		    _applyMessageLevel();
 		    status = CPXmipopt (cplexEnv(), _prob);
 		    if (status==0)
 		      return SOLVED;
 		    else
 		      return UNSOLVED;
+		  }
 		  CplexMip::ProblemType CplexMip::_getType() const {
 		    int stat = CPXgetstat(cplexEnv(), _prob);

lemon/cplex.h

Show inline comments

@@ -135,32 +135,47 @@
 		    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 sense);
 		    virtual Sense _getSense() const;
 		    virtual void _clear();
 		    virtual void _messageLevel(MessageLevel level);
 		    void _applyMessageLevel();
 		    bool _message_enabled;
 		  public:
 		    /// Returns the used \c CplexEnv instance
 		    const CplexEnv& env() const { return _env; }
 		    /// \brief Returns the const cpxenv pointer
 		    ///
 		    /// \note The cpxenv might be destructed with the solver.
 		    const cpxenv* cplexEnv() const { return _env.cplexEnv(); }
 		    /// \brief Returns the const cpxenv pointer
 		    ///
 		    /// \note The cpxenv might be destructed with the solver.
 		    cpxenv* cplexEnv() { return _env.cplexEnv(); }
 		    /// Returns the cplex problem object
 		    cpxlp* cplexLp() { return _prob; }
 		    /// Returns the cplex problem object
 		    const cpxlp* cplexLp() const { return _prob; }
 		  };
 		  /// \brief Interface for the CPLEX LP solver
 		  ///
 		  /// This class implements an interface for the CPLEX LP solver.
 		  ///\ingroup lp_group
 		  class CplexLp : public LpSolver, public CplexBase {
 		  public:
 		    /// \e
 		    CplexLp();

lemon/glpk.cc

Show inline comments

@@ -22,32 +22,34 @@
 		#include <lemon/glpk.h>
 		#include <glpk.h>
 		#include <lemon/assert.h>
 		namespace lemon {
 		  // GlpkBase members
 		  GlpkBase::GlpkBase() : LpBase() {
 		    lp = glp_create_prob();
 		    glp_create_index(lp);
 		    messageLevel(MESSAGE_NOTHING);
+		  }
 		  GlpkBase::GlpkBase(const GlpkBase &other) : LpBase() {
 		    lp = glp_create_prob();
 		    glp_copy_prob(lp, other.lp, GLP_ON);
 		    glp_create_index(lp);
 		    rows = other.rows;
 		    cols = other.cols;
 		    messageLevel(MESSAGE_NOTHING);
+		  }
 		  GlpkBase::~GlpkBase() {
 		    glp_delete_prob(lp);
+		  }
 		  int GlpkBase::_addCol() {
 		    int i = glp_add_cols(lp, 1);
 		    glp_set_col_bnds(lp, i, GLP_FR, 0.0, 0.0);
 		    return i;
+		  }
@@ -517,74 +519,79 @@
+		  }
 		  void GlpkBase::_clear() {
 		    glp_erase_prob(lp);
 		    rows.clear();
 		    cols.clear();
+		  }
 		  void GlpkBase::freeEnv() {
 		    glp_free_env();
+		  }
 		  void GlpkBase::_messageLevel(MessageLevel level) {
 		    switch (level) {
 		    case MESSAGE_NOTHING:
 		      _message_level = GLP_MSG_OFF;
 		      break;
 		    case MESSAGE_ERROR:
 		      _message_level = GLP_MSG_ERR;
 		      break;
 		    case MESSAGE_WARNING:
 		      _message_level = GLP_MSG_ERR;
 		      break;
 		    case MESSAGE_NORMAL:
 		      _message_level = GLP_MSG_ON;
 		      break;
 		    case MESSAGE_VERBOSE:
 		      _message_level = GLP_MSG_ALL;
 		      break;
+		    }
+		  }
 		  GlpkBase::FreeEnvHelper GlpkBase::freeEnvHelper;
 		  // GlpkLp members
 		  GlpkLp::GlpkLp()
 		    : LpBase(), LpSolver(), GlpkBase() {
 		    messageLevel(MESSAGE_NO_OUTPUT);
 		    presolver(false);
+		  }
 		  GlpkLp::GlpkLp(const GlpkLp& other)
 		    : LpBase(other), LpSolver(other), GlpkBase(other) {
 		    messageLevel(MESSAGE_NO_OUTPUT);
 		    presolver(false);
+		  }
 		  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;
+		    }
 		    smcp.msg_lev = _message_level;
 		    smcp.presolve = _presolve;
 		    // If the basis is not valid we get an error return value.
 		    // In this case we can try to create a new basis.
 		    switch (glp_simplex(lp, &smcp)) {
 		    case 0:
 		      break;
 		    case GLP_EBADB:
 		    case GLP_ESING:
 		    case GLP_ECOND:
 		      glp_term_out(false);
 		      glp_adv_basis(lp, 0);
@@ -595,38 +602,25 @@
 		      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.msg_lev = _message_level;
 		    smcp.meth = GLP_DUAL;
 		    smcp.presolve = _presolve;
 		    // If the basis is not valid we get an error return value.
 		    // In this case we can try to create a new basis.
 		    switch (glp_simplex(lp, &smcp)) {
 		    case 0:
 		      break;
 		    case GLP_EBADB:
 		    case GLP_ESING:
 		    case GLP_ECOND:
 		      glp_term_out(false);
@@ -849,38 +843,32 @@
 		    case GLP_NOFEAS:
 		      return INFEASIBLE;
 		    default:
 		      LEMON_ASSERT(false, "Wrong primal type");
 		      return  GlpkLp::ProblemType();
+		    }
+		  }
 		  void GlpkLp::presolver(bool presolve) {
 		    _presolve = presolve;
+		  }
 		  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;
+		    }
+		  }
@@ -891,76 +879,50 @@
 		    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.msg_lev = _message_level;
 		    smcp.meth = GLP_DUAL;
 		    // If the basis is not valid we get an error return value.
 		    // In this case we can try to create a new basis.
 		    switch (glp_simplex(lp, &smcp)) {
 		    case 0:
 		      break;
 		    case GLP_EBADB:
 		    case GLP_ESING:
 		    case GLP_ECOND:
 		      glp_term_out(false);
 		      glp_adv_basis(lp, 0);
 		      glp_term_out(true);
 		      if (glp_simplex(lp, &smcp) != 0) return UNSOLVED;
 		      break;
 		    default:
 		      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;
+		    }
 		    iocp.msg_lev = _message_level;
 		    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;
@@ -993,17 +955,13 @@
 		    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

lemon/glpk.h

Show inline comments

@@ -91,36 +91,42 @@
 		    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();
 		    virtual void _messageLevel(MessageLevel level);
 		  private:
 		    static void freeEnv();
 		    struct FreeEnvHelper {
 		      ~FreeEnvHelper() {
 		        freeEnv();
+		      }
 		    };
 		    static FreeEnvHelper freeEnvHelper;
 		  protected:
 		    int _message_level;
 		  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)); }
@@ -182,48 +188,24 @@
 		    bool _presolve;
 		  public:
 		    ///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 presolve);
 		    ///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
@@ -235,43 +217,19 @@
 		  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

lemon/lp_base.h

Show inline comments

@@ -60,24 +60,39 @@
 		      ///limit has been exceeded)
 		      UNSOLVED = 1
 		    };
 		    ///Direction of the optimization
 		    enum Sense {
 		      /// Minimization
 		      MIN,
 		      /// Maximization
 		      MAX
 		    };
 		    ///Enum for \c messageLevel() parameter
 		    enum MessageLevel {
 		      /// no output (default value)
 		      MESSAGE_NOTHING,
 		      /// error messages only
 		      MESSAGE_ERROR,
 		      /// warnings
 		      MESSAGE_WARNING,
 		      /// normal output
 		      MESSAGE_NORMAL,
 		      /// verbose output
 		      MESSAGE_VERBOSE
 		    };
 		    ///The floating point type used by the solver
 		    typedef double Value;
 		    ///The infinity constant
 		    static const Value INF;
 		    ///The not a number constant
 		    static const Value NaN;
 		    friend class Col;
 		    friend class ColIt;
 		    friend class Row;
 		    friend class RowIt;
@@ -964,24 +979,26 @@
 		    virtual void _getObjCoeffs(InsertIterator b) const = 0;
 		    virtual void _setObjCoeff(int i, Value obj_coef) = 0;
 		    virtual Value _getObjCoeff(int i) const = 0;
 		    virtual void _setSense(Sense) = 0;
 		    virtual Sense _getSense() const = 0;
 		    virtual void _clear() = 0;
 		    virtual const char* _solverName() const = 0;
 		    virtual void _messageLevel(MessageLevel level) = 0;
 		    //Own protected stuff
 		    //Constant component of the objective function
 		    Value obj_const_comp;
 		    LpBase() : rows(), cols(), obj_const_comp(0) {}
 		  public:
 		    /// Virtual destructor
 		    virtual ~LpBase() {}
@@ -1518,24 +1535,27 @@
 		    ///Query the direction of the optimization
 		    Sense sense() const {return _getSense(); }
 		    ///Set the sense to maximization
 		    void max() { _setSense(MAX); }
 		    ///Set the sense to maximization
 		    void min() { _setSense(MIN); }
 		    ///Clears the problem
 		    void clear() { _clear(); }
 		    /// Sets the message level of the solver
 		    void messageLevel(MessageLevel level) { _messageLevel(level); }
 		    ///@}
 		  };
 		  /// Addition
 		  ///\relates LpBase::Expr
 		  ///
 		  inline LpBase::Expr operator+(const LpBase::Expr &a, const LpBase::Expr &b) {
 		    LpBase::Expr tmp(a);
 		    tmp+=b;
 		    return tmp;

lemon/lp_skeleton.cc

Show inline comments

@@ -75,24 +75,26 @@
 		  void SkeletonSolverBase::_setObjCoeff(int, Value) {}
 		  SkeletonSolverBase::Value SkeletonSolverBase::_getObjCoeff(int) const
 		  {  return 0; }
 		  void SkeletonSolverBase::_setSense(Sense) {}
 		  SkeletonSolverBase::Sense SkeletonSolverBase::_getSense() const
 		  { return MIN; }
 		  void SkeletonSolverBase::_clear() {
 		    row_num = col_num = 0;
+		  }
 		  void SkeletonSolverBase::_messageLevel(MessageLevel) {}
 		  LpSkeleton::SolveExitStatus LpSkeleton::_solve() { return SOLVED; }
 		  LpSkeleton::Value LpSkeleton::_getPrimal(int) const { return 0; }
 		  LpSkeleton::Value LpSkeleton::_getDual(int) const { return 0; }
 		  LpSkeleton::Value LpSkeleton::_getPrimalValue() const { return 0; }
 		  LpSkeleton::Value LpSkeleton::_getPrimalRay(int) const { return 0; }
 		  LpSkeleton::Value LpSkeleton::_getDualRay(int) const { return 0; }
 		  LpSkeleton::ProblemType LpSkeleton::_getPrimalType() const
 		  { return UNDEFINED; }

lemon/lp_skeleton.h

Show inline comments

@@ -131,24 +131,26 @@
 		    virtual void _setObjCoeff(int i, Value obj_coef);
 		    /// \e
 		    virtual Value _getObjCoeff(int i) const;
 		    ///\e
 		    virtual void _setSense(Sense);
 		    ///\e
 		    virtual Sense _getSense() const;
 		    ///\e
 		    virtual void _clear();
 		    ///\e
 		    virtual void _messageLevel(MessageLevel);
 		  };
 		  /// \brief Skeleton class for an LP solver interface
 		  ///
 		  ///This class does nothing, but it can serve as a skeleton when
 		  ///implementing an interface to new solvers.
 		  ///\ingroup lp_group
 		  class LpSkeleton : public LpSolver, public SkeletonSolverBase {
 		  public:
 		    ///\e
 		    LpSkeleton() : LpSolver(), SkeletonSolverBase() {}

lemon/soplex.cc

Show inline comments

@@ -11,51 +11,54 @@
 		 * 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 <iostream>
 		#include <lemon/soplex.h>
 		#include <soplex.h>
 		#include <spxout.h>
 		///\file
 		///\brief Implementation of the LEMON-SOPLEX lp solver interface.
 		namespace lemon {
 		  SoplexLp::SoplexLp() {
 		    soplex = new soplex::SoPlex;
 		    messageLevel(MESSAGE_NOTHING);
+		  }
 		  SoplexLp::~SoplexLp() {
 		    delete soplex;
+		  }
 		  SoplexLp::SoplexLp(const SoplexLp& lp) {
 		    rows = lp.rows;
 		    cols = lp.cols;
 		    soplex = new soplex::SoPlex;
 		    (*static_cast<soplex::SPxLP*>(soplex)) = *(lp.soplex);
 		    _col_names = lp._col_names;
 		    _col_names_ref = lp._col_names_ref;
 		    _row_names = lp._row_names;
 		    _row_names_ref = lp._row_names_ref;
 		    messageLevel(MESSAGE_NOTHING);
+		  }
 		  void SoplexLp::_clear_temporals() {
 		    _primal_values.clear();
 		    _dual_values.clear();
+		  }
 		  SoplexLp* SoplexLp::newSolver() const {
 		    SoplexLp* newlp = new SoplexLp();
 		    return newlp;
+		  }
@@ -263,24 +266,26 @@
 		  void SoplexLp::_setObjCoeff(int i, Value obj_coef) {
 		    soplex->changeObj(i, obj_coef);
+		  }
 		  SoplexLp::Value SoplexLp::_getObjCoeff(int i) const {
 		    return soplex->obj(i);
+		  }
 		  SoplexLp::SolveExitStatus SoplexLp::_solve() {
 		    _clear_temporals();
 		    _applyMessageLevel();
 		    soplex::SPxSolver::Status status = soplex->solve();
 		    switch (status) {
 		    case soplex::SPxSolver::OPTIMAL:
 		    case soplex::SPxSolver::INFEASIBLE:
 		    case soplex::SPxSolver::UNBOUNDED:
 		      return SOLVED;
 		    default:
 		      return UNSOLVED;
+		    }
+		  }
@@ -410,14 +415,38 @@
 		  void SoplexLp::_clear() {
 		    soplex->clear();
 		    _col_names.clear();
 		    _col_names_ref.clear();
 		    _row_names.clear();
 		    _row_names_ref.clear();
 		    cols.clear();
 		    rows.clear();
 		    _clear_temporals();
+		  }
 		  void SoplexLp::_messageLevel(MessageLevel level) {
 		    switch (level) {
 		    case MESSAGE_NOTHING:
 		      _message_level = -1;
 		      break;
 		    case MESSAGE_ERROR:
 		      _message_level = soplex::SPxOut::ERROR;
 		      break;
 		    case MESSAGE_WARNING:
 		      _message_level = soplex::SPxOut::WARNING;
 		      break;
 		    case MESSAGE_NORMAL:
 		      _message_level = soplex::SPxOut::INFO2;
 		      break;
 		    case MESSAGE_VERBOSE:
 		      _message_level = soplex::SPxOut::DEBUG;
 		      break;
+		    }
+		  }
 		  void SoplexLp::_applyMessageLevel() {
 		    soplex::Param::setVerbose(_message_level);
+		  }
 		} //namespace lemon

lemon/soplex.h

Show inline comments

@@ -135,18 +135,23 @@
 		    virtual Value _getPrimalRay(int i) const;
 		    virtual Value _getDualRay(int i) const;
 		    virtual VarStatus _getColStatus(int i) const;
 		    virtual VarStatus _getRowStatus(int i) const;
 		    virtual ProblemType _getPrimalType() const;
 		    virtual ProblemType _getDualType() const;
 		    virtual void _clear();
 		    void _messageLevel(MessageLevel m);
 		    void _applyMessageLevel();
 		    int _message_level;
 		  };
 		} //END OF NAMESPACE LEMON
 		#endif //LEMON_SOPLEX_H

test/lp_test.cc

Show inline comments

@@ -386,30 +386,25 @@
 		    aTest(lp_glpk2);
 		    cloneTest<GlpkLp>();
+		  }
 		#endif
 		#ifdef HAVE_CPLEX
 		  try {
 		    CplexLp lp_cplex1,lp_cplex2;
 		    lpTest(lp_cplex1);
 		    aTest(lp_cplex2);
 		    cloneTest<CplexLp>();
 		  } 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);
 		    cloneTest<SoplexLp>();
+		  }
 		#endif

test/mip_test.cc

Show inline comments

@@ -134,30 +134,25 @@
 		    GlpkMip mip1;
 		    aTest(mip1);
 		    cloneTest<GlpkMip>();
+		  }
 		#endif
 		#ifdef HAVE_CPLEX
 		  try {
 		    CplexMip mip2;
 		    aTest(mip2);
 		    cloneTest<CplexMip>();
 		  } 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_CBC
+		  {
 		    CbcMip mip1;
 		    aTest(mip1);
 		    cloneTest<CbcMip>();
+		  }
 		#endif
 		  return 0;

tools/lemon-0.x-to-1.x.sh

Show inline comments

@@ -80,24 +80,28 @@
 		        -e "s/\<DefProcessedMapToBeDefaultMap\>/SetStandardProcessedMap/g"\
 		        -e "s/\<copyGraph\>/graphCopy/g"\
 		        -e "s/\<copyDigraph\>/digraphCopy/g"\
 		        -e "s/\<HyperCubeDigraph\>/HypercubeGraph/g"\
 		        -e "s/\<IntegerMap\>/RangeMap/g"\
 		        -e "s/\<integerMap\>/rangeMap/g"\
 		        -e "s/\<\([sS]\)tdMap\>/\1parseMap/g"\
 		        -e "s/\<\([Ff]\)unctorMap\>/\1unctorToMap/g"\
 		        -e "s/\<\([Mm]\)apFunctor\>/\1apToFunctor/g"\
 		        -e "s/\<\([Ff]\)orkWriteMap\>/\1orkMap/g"\
 		        -e "s/\<StoreBoolMap\>/LoggerBoolMap/g"\
 		        -e "s/\<storeBoolMap\>/loggerBoolMap/g"\
 		        -e "s/\<InvertableMap\>/CrossRefMap/g"\
 		        -e "s/\<invertableMap\>/crossRefMap/g"\
 		        -e "s/\<DescriptorMap\>/RangeIdMap/g"\
 		        -e "s/\<descriptorMap\>/rangeIdMap/g"\
 		        -e "s/\<BoundingBox\>/Box/g"\
 		        -e "s/\<readNauty\>/readNautyGraph/g"\
 		        -e "s/\<RevDigraphAdaptor\>/ReverseDigraph/g"\
 		        -e "s/\<revDigraphAdaptor\>/reverseDigraph/g"\
 		        -e "s/\<SubDigraphAdaptor\>/SubDigraph/g"\
 		        -e "s/\<subDigraphAdaptor\>/subDigraph/g"\
 		        -e "s/\<SubGraphAdaptor\>/SubGraph/g"\
 		        -e "s/\<subGraphAdaptor\>/subGraph/g"\
 		        -e "s/\<NodeSubDigraphAdaptor\>/FilterNodes/g"\
 		        -e "s/\<nodeSubDigraphAdaptor\>/filterNodes/g"\
 		        -e "s/\<ArcSubDigraphAdaptor\>/FilterArcs/g"\
 		        -e "s/\<arcSubDigraphAdaptor\>/filterArcs/g"\

0 comments (0 inline)

RhodeCode

Login to your account