LEMON/LEMON-main Changeset - r746:e4554cd6b2bf

Repositories » LEMON » LEMON-main

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

Changeset - r746:e4554cd6b2bf

« 745:68792f

747:a42f46 »

r746:e4554cd6b2bf

Sun, 04 Oct 2009 00:28:42

[Not Reviewed]

0 comments (0 inline)

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

Faster add row operation (#203) One virtual function call instead of more

0 13 0

default

13 files changed with 137 insertions and 4 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

↑ Collapse diff ↑

lemon/cbc.cc

Show inline comments

@@ -49,96 +49,108 @@
#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);
    return _prob->numberColumns() - 1;
  }

  CbcMip* CbcMip::newSolver() const {
    CbcMip* newlp = new CbcMip;
    return newlp;
  }

  CbcMip* CbcMip::cloneSolver() const {
    CbcMip* copylp = new CbcMip(*this);
    return copylp;
  }

  int CbcMip::_addRow() {
    _prob->addRow(0, 0, 0, -COIN_DBL_MAX, COIN_DBL_MAX);
    return _prob->numberRows() - 1;
  }

  int CbcMip::_addRow(Value l, ExprIterator b, ExprIterator e, Value u) {
    std::vector<int> indexes;
    std::vector<Value> values;

    for(ExprIterator it = b; it != e; ++it) {
      indexes.push_back(it->first);
      values.push_back(it->second);
    }

    _prob->addRow(values.size(), &indexes.front(), &values.front(), l, u);
    return _prob->numberRows() - 1;
  }

  void CbcMip::_eraseCol(int i) {
    _prob->deleteColumn(i);
  }

  void CbcMip::_eraseRow(int i) {
    _prob->deleteRow(i);
  }

  void CbcMip::_eraseColId(int i) {
    cols.eraseIndex(i);
  }

  void CbcMip::_eraseRowId(int i) {
    rows.eraseIndex(i);
  }

  void CbcMip::_getColName(int c, std::string& name) const {
    name = _prob->getColumnName(c);
  }

  void CbcMip::_setColName(int c, const std::string& name) {
    _prob->setColumnName(c, name.c_str());
  }

  int CbcMip::_colByName(const std::string& name) const {
    return _prob->column(name.c_str());
  }

  void CbcMip::_getRowName(int r, std::string& name) const {
    name = _prob->getRowName(r);
  }

  void CbcMip::_setRowName(int r, const std::string& name) {
    _prob->setRowName(r, name.c_str());
  }

  int CbcMip::_rowByName(const std::string& name) const {
    return _prob->row(name.c_str());
  }

  void CbcMip::_setRowCoeffs(int i, ExprIterator b, ExprIterator e) {
    for (ExprIterator it = b; it != e; ++it) {
      _prob->setElement(i, it->first, it->second);
    }
  }

  void CbcMip::_getRowCoeffs(int ix, InsertIterator b) const {

lemon/cbc.h

Show inline comments

@@ -17,96 +17,97 @@
 		 */
 		// -*- C++ -*-
 		#ifndef LEMON_CBC_H
 		#define LEMON_CBC_H
 		///\file
 		///\brief Header of the LEMON-CBC mip solver interface.
 		///\ingroup lp_group
 		#include <lemon/lp_base.h>
 		class CoinModel;
 		class OsiSolverInterface;
 		class CbcModel;
 		namespace lemon {
 		  /// \brief Interface for the CBC MIP solver
 		  ///
 		  /// This class implements an interface for the CBC MIP solver.
 		  ///\ingroup lp_group
 		  class CbcMip : public MipSolver {
 		  protected:
 		    CoinModel *_prob;
 		    OsiSolverInterface *_osi_solver;
 		    CbcModel *_cbc_model;
 		  public:
 		    /// \e
 		    CbcMip();
 		    /// \e
 		    CbcMip(const CbcMip&);
 		    /// \e
 		    ~CbcMip();
 		    /// \e
 		    virtual CbcMip* newSolver() const;
 		    /// \e
 		    virtual CbcMip* cloneSolver() const;
 		  protected:
 		    virtual const char* _solverName() const;
 		    virtual int _addCol();
 		    virtual int _addRow();
 		    virtual int _addRow(Value l, ExprIterator b, ExprIterator e, Value u);
 		    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 sense);
 		    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;

lemon/clp.cc

Show inline comments

@@ -33,96 +33,109 @@
    cols = other.cols;
    _init_temporals();
    messageLevel(MESSAGE_NOTHING);
  }

  ClpLp::~ClpLp() {
    delete _prob;
    _clear_temporals();
  }

  void ClpLp::_init_temporals() {
    _primal_ray = 0;
    _dual_ray = 0;
  }

  void ClpLp::_clear_temporals() {
    if (_primal_ray) {
      delete[] _primal_ray;
      _primal_ray = 0;
    }
    if (_dual_ray) {
      delete[] _dual_ray;
      _dual_ray = 0;
    }
  }

  ClpLp* ClpLp::newSolver() const {
    ClpLp* newlp = new ClpLp;
    return newlp;
  }

  ClpLp* ClpLp::cloneSolver() const {
    ClpLp* copylp = new ClpLp(*this);
    return copylp;
  }

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

  int ClpLp::_addCol() {
    _prob->addColumn(0, 0, 0, -COIN_DBL_MAX, COIN_DBL_MAX, 0.0);
    return _prob->numberColumns() - 1;
  }

  int ClpLp::_addRow() {
    _prob->addRow(0, 0, 0, -COIN_DBL_MAX, COIN_DBL_MAX);
    return _prob->numberRows() - 1;
  }

  int ClpLp::_addRow(Value l, ExprIterator b, ExprIterator e, Value u) {
    std::vector<int> indexes;
    std::vector<Value> values;

    for(ExprIterator it = b; it != e; ++it) {
      indexes.push_back(it->first);
      values.push_back(it->second);
    }

    _prob->addRow(values.size(), &indexes.front(), &values.front(), l, u);
    return _prob->numberRows() - 1;
  }


  void ClpLp::_eraseCol(int c) {
    _col_names_ref.erase(_prob->getColumnName(c));
    _prob->deleteColumns(1, &c);
  }

  void ClpLp::_eraseRow(int r) {
    _row_names_ref.erase(_prob->getRowName(r));
    _prob->deleteRows(1, &r);
  }

  void ClpLp::_eraseColId(int i) {
    cols.eraseIndex(i);
    cols.shiftIndices(i);
  }

  void ClpLp::_eraseRowId(int i) {
    rows.eraseIndex(i);
    rows.shiftIndices(i);
  }

  void ClpLp::_getColName(int c, std::string& name) const {
    name = _prob->getColumnName(c);
  }

  void ClpLp::_setColName(int c, const std::string& name) {
    _prob->setColumnName(c, const_cast<std::string&>(name));
    _col_names_ref[name] = c;
  }

  int ClpLp::_colByName(const std::string& name) const {
    std::map<std::string, int>::const_iterator it = _col_names_ref.find(name);
    return it != _col_names_ref.end() ? it->second : -1;
  }

  void ClpLp::_getRowName(int r, std::string& name) const {
    name = _prob->getRowName(r);
  }

  void ClpLp::_setRowName(int r, const std::string& name) {
    _prob->setRowName(r, const_cast<std::string&>(name));
    _row_names_ref[name] = r;
  }

  int ClpLp::_rowByName(const std::string& name) const {
    std::map<std::string, int>::const_iterator it = _row_names_ref.find(name);
    return it != _row_names_ref.end() ? it->second : -1;
  }

lemon/clp.h

Show inline comments

@@ -30,96 +30,97 @@
 		class ClpSimplex;
 		namespace lemon {
 		  /// \ingroup lp_group
 		  ///
 		  /// \brief Interface for the CLP solver
 		  ///
 		  /// This class implements an interface for the Clp LP solver.  The
 		  /// Clp library is an object oriented lp solver library developed at
 		  /// the IBM. The CLP is part of the COIN-OR package and it can be
 		  /// used with Common Public License.
 		  class ClpLp : public LpSolver {
 		  protected:
 		    ClpSimplex* _prob;
 		    std::map<std::string, int> _col_names_ref;
 		    std::map<std::string, int> _row_names_ref;
 		  public:
 		    /// \e
 		    ClpLp();
 		    /// \e
 		    ClpLp(const ClpLp&);
 		    /// \e
 		    ~ClpLp();
 		    /// \e
 		    virtual ClpLp* newSolver() const;
 		    /// \e
 		    virtual ClpLp* cloneSolver() const;
 		  protected:
 		    mutable double* _primal_ray;
 		    mutable double* _dual_ray;
 		    void _init_temporals();
 		    void _clear_temporals();
 		  protected:
 		    virtual const char* _solverName() const;
 		    virtual int _addCol();
 		    virtual int _addRow();
 		    virtual int _addRow(Value l, ExprIterator b, ExprIterator e, Value u);
 		    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, ExprIterator);
 		    virtual void _getObjCoeffs(InsertIterator) 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 SolveExitStatus _solve();
 		    virtual Value _getPrimal(int i) const;
 		    virtual Value _getDual(int i) const;

lemon/cplex.cc

Show inline comments

@@ -66,96 +66,129 @@
 		    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;
+		  }
 		  int CplexBase::_addRow() {
 		    int i = CPXgetnumrows(cplexEnv(), _prob);
 		    const double ub = INF;
 		    const char s = 'L';
 		    CPXnewrows(cplexEnv(), _prob, 1, &ub, &s, 0, 0);
 		    return i;
+		  }
 		  int CplexBase::_addRow(Value lb, ExprIterator b,
 		                         ExprIterator e, Value ub) {
 		    int i = CPXgetnumrows(cplexEnv(), _prob);
 		    if (lb == -INF) {
 		      const char s = 'L';
 		      CPXnewrows(cplexEnv(), _prob, 1, &ub, &s, 0, 0);
 		    } else if (ub == INF) {
 		      const char s = 'G';
 		      CPXnewrows(cplexEnv(), _prob, 1, &lb, &s, 0, 0);
 		    } else if (lb == ub){
 		      const char s = 'E';
 		      CPXnewrows(cplexEnv(), _prob, 1, &lb, &s, 0, 0);
 		    } else {
 		      const char s = 'R';
 		      double len = ub - lb;
 		      CPXnewrows(cplexEnv(), _prob, 1, &lb, &s, &len, 0);
+		    }
 		    std::vector<int> indices;
 		    std::vector<int> rowlist;
 		    std::vector<Value> values;
 		    for(ExprIterator it=b; it!=e; ++it) {
 		      indices.push_back(it->first);
 		      values.push_back(it->second);
 		      rowlist.push_back(i);
+		    }
 		    CPXchgcoeflist(cplexEnv(), _prob, values.size(),
 		                   &rowlist.front(), &indices.front(), &values.front());
 		    return i;
+		  }
 		  void CplexBase::_eraseCol(int i) {
 		    CPXdelcols(cplexEnv(), _prob, i, i);
+		  }
 		  void CplexBase::_eraseRow(int i) {
 		    CPXdelrows(cplexEnv(), _prob, i, i);
+		  }
 		  void CplexBase::_eraseColId(int i) {
 		    cols.eraseIndex(i);
 		    cols.shiftIndices(i);
+		  }
 		  void CplexBase::_eraseRowId(int i) {
 		    rows.eraseIndex(i);
 		    rows.shiftIndices(i);
+		  }
 		  void CplexBase::_getColName(int col, std::string &name) const {
 		    int size;
 		    CPXgetcolname(cplexEnv(), _prob, 0, 0, 0, &size, col, col);
 		    if (size == 0) {
 		      name.clear();
 		      return;
+		    }
 		    size *= -1;
 		    std::vector<char> buf(size);
 		    char *cname;
 		    int tmp;
 		    CPXgetcolname(cplexEnv(), _prob, &cname, &buf.front(), size,
 		                  &tmp, col, col);
 		    name = cname;
+		  }
 		  void CplexBase::_setColName(int col, const std::string &name) {
 		    char *cname;
 		    cname = const_cast<char*>(name.c_str());
 		    CPXchgcolname(cplexEnv(), _prob, 1, &col, &cname);
+		  }
 		  int CplexBase::_colByName(const std::string& name) const {
 		    int index;
 		    if (CPXgetcolindex(cplexEnv(), _prob,
 		                       const_cast<char*>(name.c_str()), &index) == 0) {
 		      return index;
+		    }
 		    return -1;

lemon/cplex.h

Show inline comments

@@ -48,96 +48,97 @@
 		    class LicenseError : public Exception {
 		      friend class CplexEnv;
 		    private:
 		      LicenseError(int status);
 		      char _message[510];
 		    public:
 		      /// The short error message
 		      virtual const char* what() const throw() {
 		        return _message;
+		      }
 		    };
 		    /// Constructor
 		    CplexEnv();
 		    /// Shallow copy constructor
 		    CplexEnv(const CplexEnv&);
 		    /// Shallow assignement
 		    CplexEnv& operator=(const CplexEnv&);
 		    /// Destructor
 		    virtual ~CplexEnv();
 		  protected:
 		    cpxenv* cplexEnv() { return _env; }
 		    const cpxenv* cplexEnv() const { return _env; }
 		  };
 		  /// \brief Base interface for the CPLEX LP and MIP solver
 		  ///
 		  /// This class implements the common interface of the CPLEX LP and
 		  /// MIP solvers.
 		  /// \ingroup lp_group
 		  class CplexBase : virtual public LpBase {
 		  protected:
 		    CplexEnv _env;
 		    cpxlp* _prob;
 		    CplexBase();
 		    CplexBase(const CplexEnv&);
 		    CplexBase(const CplexBase &);
 		    virtual ~CplexBase();
 		    virtual int _addCol();
 		    virtual int _addRow();
 		    virtual int _addRow(Value l, ExprIterator b, ExprIterator e, Value u);
 		    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;
 		  private:
 		    void _set_row_bounds(int i, Value lb, Value ub);
 		  protected:
 		    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 sense);
 		    virtual Sense _getSense() const;

lemon/glpk.cc

Show inline comments

@@ -14,96 +14,132 @@
 		 * express or implied, and with no claim as to its suitability for any
 		 * purpose.
+		 *
 		 */
 		///\file
 		///\brief Implementation of the LEMON GLPK LP and MIP solver interface.
 		#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;
+		  }
 		  int GlpkBase::_addRow() {
 		    int i = glp_add_rows(lp, 1);
 		    glp_set_row_bnds(lp, i, GLP_FR, 0.0, 0.0);
 		    return i;
+		  }
 		  int GlpkBase::_addRow(Value lo, ExprIterator b,
 		                        ExprIterator e, Value up) {
 		    int i = glp_add_rows(lp, 1);
 		    if (lo == -INF) {
 		      if (up == INF) {
 		        glp_set_row_bnds(lp, i, GLP_FR, lo, up);
 		      } else {
 		        glp_set_row_bnds(lp, i, GLP_UP, lo, up);
+		      }
 		    } else {
 		      if (up == INF) {
 		        glp_set_row_bnds(lp, i, GLP_LO, lo, up);
 		      } else if (lo != up) {
 		        glp_set_row_bnds(lp, i, GLP_DB, lo, up);
 		      } else {
 		        glp_set_row_bnds(lp, i, GLP_FX, lo, up);
+		      }
+		    }
 		    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_row(lp, i, values.size() - 1,
 		                    &indexes.front(), &values.front());
 		    return i;
+		  }
 		  void GlpkBase::_eraseCol(int i) {
 		    int ca[2];
 		    ca[1] = i;
 		    glp_del_cols(lp, 1, ca);
+		  }
 		  void GlpkBase::_eraseRow(int i) {
 		    int ra[2];
 		    ra[1] = i;
 		    glp_del_rows(lp, 1, ra);
+		  }
 		  void GlpkBase::_eraseColId(int i) {
 		    cols.eraseIndex(i);
 		    cols.shiftIndices(i);
+		  }
 		  void GlpkBase::_eraseRowId(int i) {
 		    rows.eraseIndex(i);
 		    rows.shiftIndices(i);
+		  }
 		  void GlpkBase::_getColName(int c, std::string& name) const {
 		    const char *str = glp_get_col_name(lp, c);
 		    if (str) name = str;
 		    else name.clear();
+		  }
 		  void GlpkBase::_setColName(int c, const std::string & name) {
 		    glp_set_col_name(lp, c, const_cast<char*>(name.c_str()));
+		  }
 		  int GlpkBase::_colByName(const std::string& name) const {
 		    int k = glp_find_col(lp, const_cast<char*>(name.c_str()));
 		    return k > 0 ? k : -1;
+		  }
 		  void GlpkBase::_getRowName(int r, std::string& name) const {
 		    const char *str = glp_get_row_name(lp, r);
 		    if (str) name = str;
 		    else name.clear();
+		  }
 		  void GlpkBase::_setRowName(int r, const std::string & name) {
 		    glp_set_row_name(lp, r, const_cast<char*>(name.c_str()));
+		  }

lemon/glpk.h

Show inline comments

@@ -9,96 +9,97 @@
 		 * 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
 		#if !defined _GLP_PROB && !defined GLP_PROB
 		#define _GLP_PROB
 		#define GLP_PROB
 		typedef struct { double _opaque_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 int _addRow(Value l, ExprIterator b, ExprIterator e, Value u);
 		    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();
 		    virtual void _messageLevel(MessageLevel level);

lemon/lp_base.h

Show inline comments

@@ -898,96 +898,104 @@
 		        value_type value;
 		      };
 		      ExprIterator(const std::map<int, Value>::const_iterator& host_it,
 		                   const _solver_bits::VarIndex& index)
 		        : _host_it(host_it), _index(index) {}
 		      reference operator*() {
 		        return std::make_pair(_index(_host_it->first), _host_it->second);
+		      }
 		      pointer operator->() {
 		        return pointer(operator*());
+		      }
 		      ExprIterator& operator++() { ++_host_it; return *this; }
 		      ExprIterator operator++(int) {
 		        ExprIterator tmp(*this); ++_host_it; return tmp;
+		      }
 		      ExprIterator& operator--() { --_host_it; return *this; }
 		      ExprIterator operator--(int) {
 		        ExprIterator tmp(*this); --_host_it; return tmp;
+		      }
 		      bool operator==(const ExprIterator& it) const {
 		        return _host_it == it._host_it;
+		      }
 		      bool operator!=(const ExprIterator& it) const {
 		        return _host_it != it._host_it;
+		      }
 		    };
 		  protected:
 		    //Abstract virtual functions
 		    virtual int _addColId(int col) { return cols.addIndex(col); }
 		    virtual int _addRowId(int row) { return rows.addIndex(row); }
 		    virtual void _eraseColId(int col) { cols.eraseIndex(col); }
 		    virtual void _eraseRowId(int row) { rows.eraseIndex(row); }
 		    virtual int _addCol() = 0;
 		    virtual int _addRow() = 0;
 		    virtual int _addRow(Value l, ExprIterator b, ExprIterator e, Value u) {
 		      int row = _addRow();
 		      _setRowCoeffs(row, b, e);
 		      _setRowLowerBound(row, l);
 		      _setRowUpperBound(row, u);
 		      return row;
+		    }
 		    virtual void _eraseCol(int col) = 0;
 		    virtual void _eraseRow(int row) = 0;
 		    virtual void _getColName(int col, std::string& name) const = 0;
 		    virtual void _setColName(int col, const std::string& name) = 0;
 		    virtual int _colByName(const std::string& name) const = 0;
 		    virtual void _getRowName(int row, std::string& name) const = 0;
 		    virtual void _setRowName(int row, const std::string& name) = 0;
 		    virtual int _rowByName(const std::string& name) const = 0;
 		    virtual void _setRowCoeffs(int i, ExprIterator b, ExprIterator e) = 0;
 		    virtual void _getRowCoeffs(int i, InsertIterator b) const = 0;
 		    virtual void _setColCoeffs(int i, ExprIterator b, ExprIterator e) = 0;
 		    virtual void _getColCoeffs(int i, InsertIterator b) const = 0;
 		    virtual void _setCoeff(int row, int col, Value value) = 0;
 		    virtual Value _getCoeff(int row, int col) const = 0;
 		    virtual void _setColLowerBound(int i, Value value) = 0;
 		    virtual Value _getColLowerBound(int i) const = 0;
 		    virtual void _setColUpperBound(int i, Value value) = 0;
 		    virtual Value _getColUpperBound(int i) const = 0;
 		    virtual void _setRowLowerBound(int i, Value value) = 0;
 		    virtual Value _getRowLowerBound(int i) const = 0;
 		    virtual void _setRowUpperBound(int i, Value value) = 0;
 		    virtual Value _getRowUpperBound(int i) const = 0;
 		    virtual void _setObjCoeffs(ExprIterator b, ExprIterator e) = 0;
 		    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
@@ -1162,108 +1170,114 @@
 		          i.set(addRow());
 		          s++;
+		        }
 		      return s;
+		    }
 		#endif
 		    ///Set a row (i.e a constraint) of the LP
 		    ///\param r is the row to be modified
 		    ///\param l is lower bound (-\ref INF means no bound)
 		    ///\param e is a linear expression (see \ref Expr)
 		    ///\param u is the upper bound (\ref INF means no bound)
 		    void row(Row r, Value l, const Expr &e, Value u) {
 		      e.simplify();
 		      _setRowCoeffs(rows(id(r)), ExprIterator(e.comps.begin(), cols),
 		                    ExprIterator(e.comps.end(), cols));
 		      _setRowLowerBound(rows(id(r)),l - *e);
 		      _setRowUpperBound(rows(id(r)),u - *e);
+		    }
 		    ///Set a row (i.e a constraint) of the LP
 		    ///\param r is the row to be modified
 		    ///\param c is a linear expression (see \ref Constr)
 		    void row(Row r, const Constr &c) {
 		      row(r, c.lowerBounded()?c.lowerBound():-INF,
 		          c.expr(), c.upperBounded()?c.upperBound():INF);
+		    }
 		    ///Get a row (i.e a constraint) of the LP
 		    ///\param r is the row to get
 		    ///\return the expression associated to the row
 		    Expr row(Row r) const {
 		      Expr e;
 		      _getRowCoeffs(rows(id(r)), InsertIterator(e.comps, cols));
 		      return e;
+		    }
 		    ///Add a new row (i.e a new constraint) to the LP
 		    ///\param l is the lower bound (-\ref INF means no bound)
 		    ///\param e is a linear expression (see \ref Expr)
 		    ///\param u is the upper bound (\ref INF means no bound)
 		    ///\return The created row.
 		    Row addRow(Value l,const Expr &e, Value u) {
 		      Row r=addRow();
 		      row(r,l,e,u);
 		      Row r;
 		      e.simplify();
 		      r._id = _addRowId(_addRow(l - *e, ExprIterator(e.comps.begin(), cols),
 		                                ExprIterator(e.comps.end(), cols), u - *e));
 		      return r;
+		    }
 		    ///Add a new row (i.e a new constraint) to the LP
 		    ///\param c is a linear expression (see \ref Constr)
 		    ///\return The created row.
 		    Row addRow(const Constr &c) {
 		      Row r=addRow();
 		      row(r,c);
 		      Row r;
 		      c.expr().simplify();
 		      r._id = _addRowId(_addRow(c.lowerBounded()?c.lowerBound():-INF,
 		                                ExprIterator(c.expr().comps.begin(), cols),
 		                                ExprIterator(c.expr().comps.end(), cols),
 		                                c.upperBounded()?c.upperBound():INF));
 		      return r;
+		    }
 		    ///Erase a column (i.e a variable) from the LP
 		    ///\param c is the column to be deleted
 		    void erase(Col c) {
 		      _eraseCol(cols(id(c)));
 		      _eraseColId(cols(id(c)));
+		    }
 		    ///Erase a row (i.e a constraint) from the LP
 		    ///\param r is the row to be deleted
 		    void erase(Row r) {
 		      _eraseRow(rows(id(r)));
 		      _eraseRowId(rows(id(r)));
+		    }
 		    /// Get the name of a column
 		    ///\param c is the coresponding column
 		    ///\return The name of the colunm
 		    std::string colName(Col c) const {
 		      std::string name;
 		      _getColName(cols(id(c)), name);
 		      return name;
+		    }
 		    /// Set the name of a column
 		    ///\param c is the coresponding column
 		    ///\param name The name to be given
 		    void colName(Col c, const std::string& name) {
 		      _setColName(cols(id(c)), name);
+		    }
 		    /// Get the column by its name
 		    ///\param name The name of the column
 		    ///\return the proper column or \c INVALID
 		    Col colByName(const std::string& name) const {
 		      int k = _colByName(name);
 		      return k != -1 ? Col(cols[k]) : Col(INVALID);
+		    }
 		    /// Get the name of a row
 		    ///\param r is the coresponding row
 		    ///\return The name of the row

lemon/lp_skeleton.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 <lemon/lp_skeleton.h>
 		///\file
 		///\brief A skeleton file to implement LP solver interfaces
 		namespace lemon {
 		  int SkeletonSolverBase::_addCol()
+		  {
 		    return ++col_num;
+		  }
 		  int SkeletonSolverBase::_addRow()
+		  {
 		    return ++row_num;
+		  }
 		  int SkeletonSolverBase::_addRow(Value, ExprIterator, ExprIterator, Value)
+		  {
 		    return ++row_num;
+		  }
 		  void SkeletonSolverBase::_eraseCol(int) {}
 		  void SkeletonSolverBase::_eraseRow(int) {}
 		  void SkeletonSolverBase::_getColName(int, std::string &) const {}
 		  void SkeletonSolverBase::_setColName(int, const std::string &) {}
 		  int SkeletonSolverBase::_colByName(const std::string&) const { return -1; }
 		  void SkeletonSolverBase::_getRowName(int, std::string &) const {}
 		  void SkeletonSolverBase::_setRowName(int, const std::string &) {}
 		  int SkeletonSolverBase::_rowByName(const std::string&) const { return -1; }
 		  void SkeletonSolverBase::_setRowCoeffs(int, ExprIterator, ExprIterator) {}
 		  void SkeletonSolverBase::_getRowCoeffs(int, InsertIterator) const {}
 		  void SkeletonSolverBase::_setColCoeffs(int, ExprIterator, ExprIterator) {}
 		  void SkeletonSolverBase::_getColCoeffs(int, InsertIterator) const {}
 		  void SkeletonSolverBase::_setCoeff(int, int, Value) {}
 		  SkeletonSolverBase::Value SkeletonSolverBase::_getCoeff(int, int) const
 		  { return 0; }
 		  void SkeletonSolverBase::_setColLowerBound(int, Value) {}
 		  SkeletonSolverBase::Value SkeletonSolverBase::_getColLowerBound(int) const
 		  {  return 0; }
 		  void SkeletonSolverBase::_setColUpperBound(int, Value) {}
 		  SkeletonSolverBase::Value SkeletonSolverBase::_getColUpperBound(int) const
 		  {  return 0; }
 		  void SkeletonSolverBase::_setRowLowerBound(int, Value) {}
 		  SkeletonSolverBase::Value SkeletonSolverBase::_getRowLowerBound(int) const
 		  {  return 0; }
 		  void SkeletonSolverBase::_setRowUpperBound(int, Value) {}
 		  SkeletonSolverBase::Value SkeletonSolverBase::_getRowUpperBound(int) const
 		  {  return 0; }
 		  void SkeletonSolverBase::_setObjCoeffs(ExprIterator, ExprIterator) {}
 		  void SkeletonSolverBase::_getObjCoeffs(InsertIterator) const {};
 		  void SkeletonSolverBase::_setObjCoeff(int, Value) {}
 		  SkeletonSolverBase::Value SkeletonSolverBase::_getObjCoeff(int) const
 		  {  return 0; }
 		  void SkeletonSolverBase::_setSense(Sense) {}
 		  SkeletonSolverBase::Sense SkeletonSolverBase::_getSense() const
 		  { return MIN; }

lemon/lp_skeleton.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_LP_SKELETON_H
 		#define LEMON_LP_SKELETON_H
 		#include <lemon/lp_base.h>
 		///\file
 		///\brief Skeleton file to implement LP/MIP solver interfaces
 		///
 		///The classes in this file do nothing, but they can serve as skeletons when
 		///implementing an interface to new solvers.
 		namespace lemon {
 		  ///A skeleton class to implement LP/MIP solver base interface
 		  ///This class does nothing, but it can serve as a skeleton when
 		  ///implementing an interface to new solvers.
 		  class SkeletonSolverBase : public virtual LpBase {
 		    int col_num,row_num;
 		  protected:
 		    SkeletonSolverBase()
 		      : col_num(-1), row_num(-1) {}
 		    /// \e
 		    virtual int _addCol();
 		    /// \e
 		    virtual int _addRow();
 		    /// \e
 		    virtual int _addRow(Value l, ExprIterator b, ExprIterator e, Value u);
 		    /// \e
 		    virtual void _eraseCol(int i);
 		    /// \e
 		    virtual void _eraseRow(int i);
 		    /// \e
 		    virtual void _getColName(int col, std::string& name) const;
 		    /// \e
 		    virtual void _setColName(int col, const std::string& name);
 		    /// \e
 		    virtual int _colByName(const std::string& name) const;
 		    /// \e
 		    virtual void _getRowName(int row, std::string& name) const;
 		    /// \e
 		    virtual void _setRowName(int row, const std::string& name);
 		    /// \e
 		    virtual int _rowByName(const std::string& name) const;
 		    /// \e
 		    virtual void _setRowCoeffs(int i, ExprIterator b, ExprIterator e);
 		    /// \e
 		    virtual void _getRowCoeffs(int i, InsertIterator b) const;
 		    /// \e
 		    virtual void _setColCoeffs(int i, ExprIterator b, ExprIterator e);
 		    /// \e
 		    virtual void _getColCoeffs(int i, InsertIterator b) const;
 		    /// Set one element of the coefficient matrix
 		    virtual void _setCoeff(int row, int col, Value value);
 		    /// Get one element of the coefficient matrix
 		    virtual Value _getCoeff(int row, int col) const;
 		    /// The lower bound of a variable (column) have to be given by an
 		    /// extended number of type Value, i.e. a finite number of type
 		    /// Value or -\ref INF.
 		    virtual void _setColLowerBound(int i, Value value);
 		    /// \e
 		    /// The lower bound of a variable (column) is an
 		    /// extended number of type Value, i.e. a finite number of type
 		    /// Value or -\ref INF.
 		    virtual Value _getColLowerBound(int i) const;
 		    /// The upper bound of a variable (column) have to be given by an
 		    /// extended number of type Value, i.e. a finite number of type
 		    /// Value or \ref INF.
 		    virtual void _setColUpperBound(int i, Value value);

lemon/soplex.cc

Show inline comments

@@ -46,96 +46,109 @@
 		    _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;
+		  }
 		  SoplexLp* SoplexLp::cloneSolver() const {
 		    SoplexLp* newlp = new SoplexLp(*this);
 		    return newlp;
+		  }
 		  const char* SoplexLp::_solverName() const { return "SoplexLp"; }
 		  int SoplexLp::_addCol() {
 		    soplex::LPCol c;
 		    c.setLower(-soplex::infinity);
 		    c.setUpper(soplex::infinity);
 		    soplex->addCol(c);
 		    _col_names.push_back(std::string());
 		    return soplex->nCols() - 1;
+		  }
 		  int SoplexLp::_addRow() {
 		    soplex::LPRow r;
 		    r.setLhs(-soplex::infinity);
 		    r.setRhs(soplex::infinity);
 		    soplex->addRow(r);
 		    _row_names.push_back(std::string());
 		    return soplex->nRows() - 1;
+		  }
 		  int SoplexLp::_addRow(Value l, ExprIterator b, ExprIterator e, Value u) {
 		    soplex::DSVector v;
 		    for (ExprIterator it = b; it != e; ++it) {
 		      v.add(it->first, it->second);
+		    }
 		    soplex::LPRow r(l, v, u);
 		    soplex->addRow(r);
 		    _row_names.push_back(std::string());
 		    return soplex->nRows() - 1;
+		  }
 		  void SoplexLp::_eraseCol(int i) {
 		    soplex->removeCol(i);
 		    _col_names_ref.erase(_col_names[i]);
 		    _col_names[i] = _col_names.back();
 		    _col_names_ref[_col_names.back()] = i;
 		    _col_names.pop_back();
+		  }
 		  void SoplexLp::_eraseRow(int i) {
 		    soplex->removeRow(i);
 		    _row_names_ref.erase(_row_names[i]);
 		    _row_names[i] = _row_names.back();
 		    _row_names_ref[_row_names.back()] = i;
 		    _row_names.pop_back();
+		  }
 		  void SoplexLp::_eraseColId(int i) {
 		    cols.eraseIndex(i);
 		    cols.relocateIndex(i, cols.maxIndex());
+		  }
 		  void SoplexLp::_eraseRowId(int i) {
 		    rows.eraseIndex(i);
 		    rows.relocateIndex(i, rows.maxIndex());
+		  }
 		  void SoplexLp::_getColName(int c, std::string &name) const {
 		    name = _col_names[c];
+		  }
 		  void SoplexLp::_setColName(int c, const std::string &name) {
 		    _col_names_ref.erase(_col_names[c]);
 		    _col_names[c] = name;
 		    if (!name.empty()) {
 		      _col_names_ref.insert(std::make_pair(name, c));
+		    }
+		  }
 		  int SoplexLp::_colByName(const std::string& name) const {
 		    std::map<std::string, int>::const_iterator it =
 		      _col_names_ref.find(name);
 		    if (it != _col_names_ref.end()) {
 		      return it->second;
 		    } else {
 		      return -1;
+		    }
+		  }

lemon/soplex.h

Show inline comments

@@ -39,96 +39,97 @@
 		  /// \brief Interface for the SOPLEX solver
 		  ///
 		  /// This class implements an interface for the SoPlex LP solver.
 		  /// The SoPlex library is an object oriented lp solver library
 		  /// developed at the Konrad-Zuse-Zentrum f�r Informationstechnik
 		  /// Berlin (ZIB). You can find detailed information about it at the
 		  /// <tt>http://soplex.zib.de</tt> address.
 		  class SoplexLp : public LpSolver {
 		  private:
 		    soplex::SoPlex* soplex;
 		    std::vector<std::string> _col_names;
 		    std::map<std::string, int> _col_names_ref;
 		    std::vector<std::string> _row_names;
 		    std::map<std::string, int> _row_names_ref;
 		  private:
 		    // these values cannot be retrieved element by element
 		    mutable std::vector<Value> _primal_values;
 		    mutable std::vector<Value> _dual_values;
 		    mutable std::vector<Value> _primal_ray;
 		    mutable std::vector<Value> _dual_ray;
 		    void _clear_temporals();
 		  public:
 		    /// \e
 		    SoplexLp();
 		    /// \e
 		    SoplexLp(const SoplexLp&);
 		    /// \e
 		    ~SoplexLp();
 		    /// \e
 		    virtual SoplexLp* newSolver() const;
 		    /// \e
 		    virtual SoplexLp* cloneSolver() const;
 		  protected:
 		    virtual const char* _solverName() const;
 		    virtual int _addCol();
 		    virtual int _addRow();
 		    virtual int _addRow(Value l, ExprIterator b, ExprIterator e, Value u);
 		    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 sense);
 		    virtual Sense _getSense() const;
 		    virtual SolveExitStatus _solve();
 		    virtual Value _getPrimal(int i) const;
 		    virtual Value _getDual(int i) const;
 		    virtual Value _getPrimalValue() const;

0 comments (0 inline)

...	...	@@ -49,96 +49,108 @@
49	49	#include "coin/CbcHeuristic.hpp"
50	50
51	51	namespace lemon {
52	52
53	53	CbcMip::CbcMip() {
54	54	_prob = new CoinModel();
55	55	_prob->setProblemName("LEMON");
56	56	_osi_solver = 0;
57	57	_cbc_model = 0;
58	58	messageLevel(MESSAGE_NOTHING);
59	59	}
60	60
61	61	CbcMip::CbcMip(const CbcMip& other) {
62	62	_prob = new CoinModel(*other._prob);
63	63	_prob->setProblemName("LEMON");
64	64	_osi_solver = 0;
65	65	_cbc_model = 0;
66	66	messageLevel(MESSAGE_NOTHING);
67	67	}
68	68
69	69	CbcMip::~CbcMip() {
70	70	delete _prob;
71	71	if (_osi_solver) delete _osi_solver;
72	72	if (_cbc_model) delete _cbc_model;
73	73	}
74	74
75	75	const char* CbcMip::_solverName() const { return "CbcMip"; }
76	76
77	77	int CbcMip::_addCol() {
78	78	_prob->addColumn(0, 0, 0, -COIN_DBL_MAX, COIN_DBL_MAX, 0.0, 0, false);
79	79	return _prob->numberColumns() - 1;
80	80	}
81	81
82	82	CbcMip* CbcMip::newSolver() const {
83	83	CbcMip* newlp = new CbcMip;
84	84	return newlp;
85	85	}
86	86
87	87	CbcMip* CbcMip::cloneSolver() const {
88	88	CbcMip* copylp = new CbcMip(*this);
89	89	return copylp;
90	90	}
91	91
92	92	int CbcMip::_addRow() {
93	93	_prob->addRow(0, 0, 0, -COIN_DBL_MAX, COIN_DBL_MAX);
94	94	return _prob->numberRows() - 1;
95	95	}
96	96
	97	int CbcMip::_addRow(Value l, ExprIterator b, ExprIterator e, Value u) {
	98	std::vector<int> indexes;
	99	std::vector<Value> values;
	100
	101	for(ExprIterator it = b; it != e; ++it) {
	102	indexes.push_back(it->first);
	103	values.push_back(it->second);
	104	}
	105
	106	_prob->addRow(values.size(), &indexes.front(), &values.front(), l, u);
	107	return _prob->numberRows() - 1;
	108	}
97	109
98	110	void CbcMip::_eraseCol(int i) {
99	111	_prob->deleteColumn(i);
100	112	}
101	113
102	114	void CbcMip::_eraseRow(int i) {
103	115	_prob->deleteRow(i);
104	116	}
105	117
106	118	void CbcMip::_eraseColId(int i) {
107	119	cols.eraseIndex(i);
108	120	}
109	121
110	122	void CbcMip::_eraseRowId(int i) {
111	123	rows.eraseIndex(i);
112	124	}
113	125
114	126	void CbcMip::_getColName(int c, std::string& name) const {
115	127	name = _prob->getColumnName(c);
116	128	}
117	129
118	130	void CbcMip::_setColName(int c, const std::string& name) {
119	131	_prob->setColumnName(c, name.c_str());
120	132	}
121	133
122	134	int CbcMip::_colByName(const std::string& name) const {
123	135	return _prob->column(name.c_str());
124	136	}
125	137
126	138	void CbcMip::_getRowName(int r, std::string& name) const {
127	139	name = _prob->getRowName(r);
128	140	}
129	141
130	142	void CbcMip::_setRowName(int r, const std::string& name) {
131	143	_prob->setRowName(r, name.c_str());
132	144	}
133	145
134	146	int CbcMip::_rowByName(const std::string& name) const {
135	147	return _prob->row(name.c_str());
136	148	}
137	149
138	150	void CbcMip::_setRowCoeffs(int i, ExprIterator b, ExprIterator e) {
139	151	for (ExprIterator it = b; it != e; ++it) {
140	152	_prob->setElement(i, it->first, it->second);
141	153	}
142	154	}
143	155
144	156	void CbcMip::_getRowCoeffs(int ix, InsertIterator b) const {

...	...	@@ -33,96 +33,109 @@
33	33	cols = other.cols;
34	34	_init_temporals();
35	35	messageLevel(MESSAGE_NOTHING);
36	36	}
37	37
38	38	ClpLp::~ClpLp() {
39	39	delete _prob;
40	40	_clear_temporals();
41	41	}
42	42
43	43	void ClpLp::_init_temporals() {
44	44	_primal_ray = 0;
45	45	_dual_ray = 0;
46	46	}
47	47
48	48	void ClpLp::_clear_temporals() {
49	49	if (_primal_ray) {
50	50	delete[] _primal_ray;
51	51	_primal_ray = 0;
52	52	}
53	53	if (_dual_ray) {
54	54	delete[] _dual_ray;
55	55	_dual_ray = 0;
56	56	}
57	57	}
58	58
59	59	ClpLp* ClpLp::newSolver() const {
60	60	ClpLp* newlp = new ClpLp;
61	61	return newlp;
62	62	}
63	63
64	64	ClpLp* ClpLp::cloneSolver() const {
65	65	ClpLp* copylp = new ClpLp(*this);
66	66	return copylp;
67	67	}
68	68
69	69	const char* ClpLp::_solverName() const { return "ClpLp"; }
70	70
71	71	int ClpLp::_addCol() {
72	72	_prob->addColumn(0, 0, 0, -COIN_DBL_MAX, COIN_DBL_MAX, 0.0);
73	73	return _prob->numberColumns() - 1;
74	74	}
75	75
76	76	int ClpLp::_addRow() {
77	77	_prob->addRow(0, 0, 0, -COIN_DBL_MAX, COIN_DBL_MAX);
78	78	return _prob->numberRows() - 1;
79	79	}
80	80
	81	int ClpLp::_addRow(Value l, ExprIterator b, ExprIterator e, Value u) {
	82	std::vector<int> indexes;
	83	std::vector<Value> values;
	84
	85	for(ExprIterator it = b; it != e; ++it) {
	86	indexes.push_back(it->first);
	87	values.push_back(it->second);
	88	}
	89
	90	_prob->addRow(values.size(), &indexes.front(), &values.front(), l, u);
	91	return _prob->numberRows() - 1;
	92	}
	93
81	94
82	95	void ClpLp::_eraseCol(int c) {
83	96	_col_names_ref.erase(_prob->getColumnName(c));
84	97	_prob->deleteColumns(1, &c);
85	98	}
86	99
87	100	void ClpLp::_eraseRow(int r) {
88	101	_row_names_ref.erase(_prob->getRowName(r));
89	102	_prob->deleteRows(1, &r);
90	103	}
91	104
92	105	void ClpLp::_eraseColId(int i) {
93	106	cols.eraseIndex(i);
94	107	cols.shiftIndices(i);
95	108	}
96	109
97	110	void ClpLp::_eraseRowId(int i) {
98	111	rows.eraseIndex(i);
99	112	rows.shiftIndices(i);
100	113	}
101	114
102	115	void ClpLp::_getColName(int c, std::string& name) const {
103	116	name = _prob->getColumnName(c);
104	117	}
105	118
106	119	void ClpLp::_setColName(int c, const std::string& name) {
107	120	_prob->setColumnName(c, const_cast<std::string&>(name));
108	121	_col_names_ref[name] = c;
109	122	}
110	123
111	124	int ClpLp::_colByName(const std::string& name) const {
112	125	std::map<std::string, int>::const_iterator it = _col_names_ref.find(name);
113	126	return it != _col_names_ref.end() ? it->second : -1;
114	127	}
115	128
116	129	void ClpLp::_getRowName(int r, std::string& name) const {
117	130	name = _prob->getRowName(r);
118	131	}
119	132
120	133	void ClpLp::_setRowName(int r, const std::string& name) {
121	134	_prob->setRowName(r, const_cast<std::string&>(name));
122	135	_row_names_ref[name] = r;
123	136	}
124	137
125	138	int ClpLp::_rowByName(const std::string& name) const {
126	139	std::map<std::string, int>::const_iterator it = _row_names_ref.find(name);
127	140	return it != _row_names_ref.end() ? it->second : -1;
128	141	}

RhodeCode

Login to your account