lemon: comparison lemon/lp

equal deleted inserted replaced

-:162d03c876d4
+:5bacace54e72
 #include<lemon/assert.h>
 #include<lemon/core.h>
 #include<lemon/bits/solver_bits.h>
+#include<lemon/bits/stl_iterators.h>
 ///\file
 ///\brief The interface of the LP solver interface.
 ///\ingroup lp_group
 namespace lemon {
 ///\ingroup lp_group
 class LpBase {
 protected:
-_solver_bits::VarIndex rows;
+_solver_bits::VarIndex _rows;
-_solver_bits::VarIndex cols;
+_solver_bits::VarIndex _cols;
 public:
 ///Possible outcomes of an LP solving procedure
 enum SolveExitStatus {
 /// Sets the iterator to the first Col.
 ///
 ColIt(const LpBase &solver) : _solver(&solver)
 {
-_solver->cols.firstItem(_id);
+_solver->_cols.firstItem(_id);
 }
 /// Invalid constructor \& conversion
 /// Initialize the iterator to be invalid.
 /// \sa Invalid for more details.
 /// Assign the iterator to the next column.
 ///
 ColIt &operator++()
 {
-_solver->cols.nextItem(_id);
+_solver->_cols.nextItem(_id);
 return *this;
 }
 };
+/// \brief Gets the collection of the columns of the LP problem.
+///
+/// This function can be used for iterating on
+/// the columns of the LP problem. It returns a wrapped ColIt, which looks
+/// like an STL container (by having begin() and end())
+/// which you can use in range-based for loops, STL algorithms, etc.
+/// For example you can write:
+///\code
+/// for(auto c: lp.cols())
+///   doSomething(c);
+LemonRangeWrapper1<ColIt, LpBase> cols() {
+return LemonRangeWrapper1<ColIt, LpBase>(*this);
+}
 /// \brief Returns the ID of the column.
 static int id(const Col& col) { return col._id; }
 /// \brief Returns the column with the given ID.
 ///
 /// Sets the iterator to the first Row.
 ///
 RowIt(const LpBase &solver) : _solver(&solver)
 {
-_solver->rows.firstItem(_id);
+_solver->_rows.firstItem(_id);
 }
 /// Invalid constructor \& conversion
 /// Initialize the iterator to be invalid.
 /// \sa Invalid for more details.
 /// Assign the iterator to the next row.
 ///
 RowIt &operator++()
 {
-_solver->rows.nextItem(_id);
+_solver->_rows.nextItem(_id);
 return *this;
 }
 };
+/// \brief Gets the collection of the rows of the LP problem.
+///
+/// This function can be used for iterating on
+/// the rows of the LP problem. It returns a wrapped RowIt, which looks
+/// like an STL container (by having begin() and end())
+/// which you can use in range-based for loops, STL algorithms, etc.
+/// For example you can write:
+///\code
+/// for(auto c: lp.rows())
+///   doSomething(c);
+LemonRangeWrapper1<RowIt, LpBase> rows() {
+return LemonRangeWrapper1<RowIt, LpBase>(*this);
+}
 /// \brief Returns the ID of the row.
 static int id(const Row& row) { return row._id; }
 /// \brief Returns the row with the given ID.
 ///
 protected:
 //Abstract virtual functions
-virtual int _addColId(int col) { return cols.addIndex(col); }
+virtual int _addColId(int col) { return _cols.addIndex(col); }
-virtual int _addRowId(int row) { return rows.addIndex(row); }
+virtual int _addRowId(int row) { return _rows.addIndex(row); }
-virtual void _eraseColId(int col) { cols.eraseIndex(col); }
+virtual void _eraseColId(int col) { _cols.eraseIndex(col); }
-virtual void _eraseRowId(int row) { rows.eraseIndex(row); }
+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) {
 //Own protected stuff
 //Constant component of the objective function
 Value obj_const_comp;
-LpBase() : rows(), cols(), obj_const_comp(0) {}
+LpBase() : _rows(), _cols(), obj_const_comp(0) {}
 public:
 ///Unsupported file format exception
 class UnsupportedFormatError : public Exception
 ///\param c is the column to be modified
 ///\param e is a dual linear expression (see \ref DualExpr)
 ///a better one.
 void col(Col c, const DualExpr &e) {
 e.simplify();
-_setColCoeffs(cols(id(c)), ExprIterator(e.comps.begin(), rows),
+_setColCoeffs(_cols(id(c)), ExprIterator(e.comps.begin(), _rows),
-ExprIterator(e.comps.end(), rows));
+ExprIterator(e.comps.end(), _rows));
 }
 ///Get a column (i.e a dual constraint) of the LP
 ///\param c is the column to get
 ///\return the dual expression associated to the column
 DualExpr col(Col c) const {
 DualExpr e;
-_getColCoeffs(cols(id(c)), InsertIterator(e.comps, rows));
+_getColCoeffs(_cols(id(c)), InsertIterator(e.comps, _rows));
 return e;
 }
 ///Add a new column to the LP
 ///\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),
+_setRowCoeffs(_rows(id(r)), ExprIterator(e.comps.begin(), _cols),
-ExprIterator(e.comps.end(), cols));
+ExprIterator(e.comps.end(), _cols));
-_setRowLowerBound(rows(id(r)),l - *e);
+_setRowLowerBound(_rows(id(r)),l - *e);
-_setRowUpperBound(rows(id(r)),u - *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 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));
+_getRowCoeffs(_rows(id(r)), InsertIterator(e.comps, _cols));
 return e;
 }
 ///Add a new row (i.e a new constraint) to the LP
 ///\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;
 e.simplify();
-r._id = _addRowId(_addRow(l - *e, ExprIterator(e.comps.begin(), cols),
+r._id = _addRowId(_addRow(l - *e, ExprIterator(e.comps.begin(), _cols),
-ExprIterator(e.comps.end(), cols), u - *e));
+ExprIterator(e.comps.end(), _cols), u - *e));
 return r;
 }
 ///Add a new row (i.e a new constraint) to the LP
 ///\return The created row.
 Row addRow(const Constr &c) {
 Row r;
 c.expr().simplify();
 r._id = _addRowId(_addRow(c.lowerBounded()?c.lowerBound()-*c.expr():-INF,
-ExprIterator(c.expr().comps.begin(), cols),
+ExprIterator(c.expr().comps.begin(), _cols),
-ExprIterator(c.expr().comps.end(), cols),
+ExprIterator(c.expr().comps.end(), _cols),
 c.upperBounded()?c.upperBound()-*c.expr():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)));
+_eraseCol(_cols(id(c)));
-_eraseColId(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)));
+_eraseRow(_rows(id(r)));
-_eraseRowId(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);
+_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);
+_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);
+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
 std::string rowName(Row r) const {
 std::string name;
-_getRowName(rows(id(r)), name);
+_getRowName(_rows(id(r)), name);
 return name;
 }
 /// Set the name of a row
 ///\param r is the coresponding row
 ///\param name The name to be given
 void rowName(Row r, const std::string& name) {
-_setRowName(rows(id(r)), name);
+_setRowName(_rows(id(r)), name);
 }
 /// Get the row by its name
 ///\param name The name of the row
 ///\return the proper row or \c INVALID
 Row rowByName(const std::string& name) const {
 int k = _rowByName(name);
-return k != -1 ? Row(rows[k]) : Row(INVALID);
+return k != -1 ? Row(_rows[k]) : Row(INVALID);
 }
 /// Set an element of the coefficient matrix of the LP
 ///\param r is the row of the element to be modified
 ///\param c is the column of the element to be modified
 ///\param val is the new value of the coefficient
 void coeff(Row r, Col c, Value val) {
-_setCoeff(rows(id(r)),cols(id(c)), val);
+_setCoeff(_rows(id(r)),_cols(id(c)), val);
 }
 /// Get an element of the coefficient matrix of the LP
 ///\param r is the row of the element
 ///\param c is the column of the element
 ///\return the corresponding coefficient
 Value coeff(Row r, Col c) const {
-return _getCoeff(rows(id(r)),cols(id(c)));
+return _getCoeff(_rows(id(r)),_cols(id(c)));
 }
 /// Set the lower bound of a column (i.e a variable)
 /// The lower bound of a variable (column) has to be given by an
 /// extended number of type Value, i.e. a finite number of type
 /// Value or -\ref INF.
 void colLowerBound(Col c, Value value) {
-_setColLowerBound(cols(id(c)),value);
+_setColLowerBound(_cols(id(c)),value);
 }
 /// Get the lower bound of a column (i.e a variable)
 /// This function returns the lower bound for column (variable) \c c
 /// (this might be -\ref INF as well).
 ///\return The lower bound for column \c c
 Value colLowerBound(Col c) const {
-return _getColLowerBound(cols(id(c)));
+return _getColLowerBound(_cols(id(c)));
 }
 ///\brief Set the lower bound of  several columns
 ///(i.e variables) at once
 ///
 /// The upper bound of a variable (column) has to be given by an
 /// extended number of type Value, i.e. a finite number of type
 /// Value or \ref INF.
 void colUpperBound(Col c, Value value) {
-_setColUpperBound(cols(id(c)),value);
+_setColUpperBound(_cols(id(c)),value);
 };
 /// Get the upper bound of a column (i.e a variable)
 /// This function returns the upper bound for column (variable) \c c
 /// (this might be \ref INF as well).
 /// \return The upper bound for column \c c
 Value colUpperBound(Col c) const {
-return _getColUpperBound(cols(id(c)));
+return _getColUpperBound(_cols(id(c)));
 }
 ///\brief Set the upper bound of  several columns
 ///(i.e variables) at once
 ///
 /// The lower and the upper bounds of
 /// a variable (column) have to be given by an
 /// extended number of type Value, i.e. a finite number of type
 /// Value, -\ref INF or \ref INF.
 void colBounds(Col c, Value lower, Value upper) {
-_setColLowerBound(cols(id(c)),lower);
+_setColLowerBound(_cols(id(c)),lower);
-_setColUpperBound(cols(id(c)),upper);
+_setColUpperBound(_cols(id(c)),upper);
 }
 ///\brief Set the lower and the upper bound of several columns
 ///(i.e variables) at once
 ///
 /// The lower bound of a constraint (row) has to be given by an
 /// extended number of type Value, i.e. a finite number of type
 /// Value or -\ref INF.
 void rowLowerBound(Row r, Value value) {
-_setRowLowerBound(rows(id(r)),value);
+_setRowLowerBound(_rows(id(r)),value);
 }
 /// Get the lower bound of a row (i.e a constraint)
 /// This function returns the lower bound for row (constraint) \c c
 /// (this might be -\ref INF as well).
 ///\return The lower bound for row \c r
 Value rowLowerBound(Row r) const {
-return _getRowLowerBound(rows(id(r)));
+return _getRowLowerBound(_rows(id(r)));
 }
 /// Set the upper bound of a row (i.e a constraint)
 /// The upper bound of a constraint (row) has to be given by an
 /// extended number of type Value, i.e. a finite number of type
 /// Value or -\ref INF.
 void rowUpperBound(Row r, Value value) {
-_setRowUpperBound(rows(id(r)),value);
+_setRowUpperBound(_rows(id(r)),value);
 }
 /// Get the upper bound of a row (i.e a constraint)
 /// This function returns the upper bound for row (constraint) \c c
 /// (this might be -\ref INF as well).
 ///\return The upper bound for row \c r
 Value rowUpperBound(Row r) const {
-return _getRowUpperBound(rows(id(r)));
+return _getRowUpperBound(_rows(id(r)));
 }
 ///Set an element of the objective function
-void objCoeff(Col c, Value v) {_setObjCoeff(cols(id(c)),v); };
+void objCoeff(Col c, Value v) {_setObjCoeff(_cols(id(c)),v); };
 ///Get an element of the objective function
-Value objCoeff(Col c) const { return _getObjCoeff(cols(id(c))); };
+Value objCoeff(Col c) const { return _getObjCoeff(_cols(id(c))); };
 ///Set the objective function
 ///\param e is a linear expression of type \ref Expr.
 ///
 void obj(const Expr& e) {
-_setObjCoeffs(ExprIterator(e.comps.begin(), cols),
+_setObjCoeffs(ExprIterator(e.comps.begin(), _cols),
-ExprIterator(e.comps.end(), cols));
+ExprIterator(e.comps.end(), _cols));
 obj_const_comp = *e;
 }
 ///Get the objective function
 ///\return the objective function as a linear expression of type
 ///Expr.
 Expr obj() const {
 Expr e;
-_getObjCoeffs(InsertIterator(e.comps, cols));
+_getObjCoeffs(InsertIterator(e.comps, _cols));
 *e = obj_const_comp;
 return e;
 }
 ///Set the sense to maximization
 void min() { _setSense(MIN); }
 ///Clear the problem
-void clear() { _clear(); rows.clear(); cols.clear(); }
+void clear() { _clear(); _rows.clear(); _cols.clear(); }
 /// Set the message level of the solver
 void messageLevel(MessageLevel level) { _messageLevel(level); }
 /// Write the problem to a file in the given format
 /// Return the primal value of the column
 /// Return the primal value of the column.
 /// \pre The problem is solved.
-Value primal(Col c) const { return _getPrimal(cols(id(c))); }
+Value primal(Col c) const { return _getPrimal(_cols(id(c))); }
 /// Return the primal value of the expression
 /// Return the primal value of the expression, i.e. the dot
 /// product of the primal solution and the expression.
 /// primal problem.
 ///
 /// \pre The problem is solved and the dual problem is infeasible.
 /// \note Some solvers does not provide primal ray calculation
 /// functions.
-Value primalRay(Col c) const { return _getPrimalRay(cols(id(c))); }
+Value primalRay(Col c) const { return _getPrimalRay(_cols(id(c))); }
 /// Return the dual value of the row
 /// Return the dual value of the row.
 /// \pre The problem is solved.
-Value dual(Row r) const { return _getDual(rows(id(r))); }
+Value dual(Row r) const { return _getDual(_rows(id(r))); }
 /// Return the dual value of the dual expression
 /// Return the dual value of the dual expression, i.e. the dot
 /// product of the dual solution and the dual expression.
 /// dual problem.
 ///
 /// \pre The problem is solved and the primal problem is infeasible.
 /// \note Some solvers does not provide dual ray calculation
 /// functions.
-Value dualRay(Row r) const { return _getDualRay(rows(id(r))); }
+Value dualRay(Row r) const { return _getDualRay(_rows(id(r))); }
 /// Return the basis status of the column
 /// \see VarStatus
-VarStatus colStatus(Col c) const { return _getColStatus(cols(id(c))); }
+VarStatus colStatus(Col c) const { return _getColStatus(_cols(id(c))); }
 /// Return the basis status of the row
 /// \see VarStatus
-VarStatus rowStatus(Row r) const { return _getRowStatus(rows(id(r))); }
+VarStatus rowStatus(Row r) const { return _getRowStatus(_rows(id(r))); }
 ///The value of the objective function
 ///\return
 ///- \ref INF or -\ref INF means either infeasibility or unboundedness
 ///Sets the type of the given column to the given type
 ///Sets the type of the given column to the given type.
 ///
 void colType(Col c, ColTypes col_type) {
-_setColType(cols(id(c)),col_type);
+_setColType(_cols(id(c)),col_type);
 }
 ///Gives back the type of the column.
 ///Gives back the type of the column.
 ///
 ColTypes colType(Col c) const {
-return _getColType(cols(id(c)));
+return _getColType(_cols(id(c)));
 }
 ///@}
 ///\name Obtain the Solution
 /// Return the value of the row in the solution
 ///  Return the value of the row in the solution.
 /// \pre The problem is solved.
-Value sol(Col c) const { return _getSol(cols(id(c))); }
+Value sol(Col c) const { return _getSol(_cols(id(c))); }
 /// Return the value of the expression in the solution
 /// Return the value of the expression in the solution, i.e. the
 /// dot product of the solution and the expression.

changeset 1343	20f95cd51aba
parent 1270	dceba191c00d
child 1353	760a5f690163