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 ↑

0 comments (0 inline)

...	...	@@ -65,64 +65,76 @@
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	}

@@ -33,64 +33,65 @@
 		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);

...	...	@@ -49,64 +49,77 @@
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);

@@ -46,64 +46,65 @@
 		    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);

@@ -82,64 +82,97 @@
 		    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);

RhodeCode

Login to your account

@@ -64,64 +64,65 @@
 		    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);

@@ -30,64 +30,100 @@
 		  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()));
+		  }

@@ -914,64 +914,72 @@
 		      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;
@@ -1178,76 +1186,82 @@
 		                    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) {

@@ -3,64 +3,69 @@
 		 * 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; }

@@ -62,64 +62,77 @@
 		    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]);