lemon-0.x: comparison src/lemon/lp

equal deleted inserted replaced

-:eccf9d58a025
+:0cb95bdeef56
 ///(\ref Col "Col"s) and also has a constant component.
 ///
 ///There are several ways to access and modify the contents of this
 ///container.
 ///- Its it fully compatible with \c std::map<Col,double>, so for expamle
-///if \c e is an Expr and \c v and \c w are of type \ref Col then you can
+///if \c e is an Expr and \c v and \c w are of type \ref Col, then you can
 ///read and modify the coefficients like
 ///these.
 ///\code
 ///e[v]=5;
 ///e[v]+=12;
 }
 };
 ///Linear constraint
-///\todo document please
+///This data stucture represents a linear constraint in the LP.
-///
+///Basically it is a linear expression with a lower or an upper bound
+///(or both). These parts of the constraint can be obtained by the member
+///functions \ref expr(), \ref lowerBound() and \ref upperBound(),
+///respectively.
+///There are two ways to construct a constraint.
+///- You can set the linear expression and the bounds directly
+///  by the functions above.
+///- The operators <tt>\<=</tt>, <tt>==</tt> and  <tt>\>=</tt>
+///  are defined between expressions, or even between constraints whenever
+///  it makes sense. Therefore if \c e and \c f are linear expressions and
+///  \c s and \c t are numbers, then the followings are valid expressions
+///  and thus they can be used directly e.g. in \ref addRow() whenever
+///  it makes sense.
+///  \code
+///  e<=s
+///  e<=f
+///  s<=e<=t
+///  e>=t
+///  \endcode
+///\warning The validity of a constraint is checked only at run time, so
+///e.g. \ref addRow(<tt>x[1]\<=x[2]<=5</tt>) will compile, but will throw a
+///\ref LogicError exception.
 class Constr
 {
 public:
 typedef LpSolverBase::Expr Expr;
 typedef Expr::Key Key;
 typedef Expr::Value Value;
-static const Value INF;
+//       static const Value INF;
-static const Value NaN;
+//       static const Value NaN;
-//     static const Value INF=0;
-//     static const Value NaN=1;
 protected:
 Expr _expr;
 Value _lb,_ub;
 public:
 ///\e
 void clear()
 {
 	_expr.clear();
 	_lb=_ub=NaN;
 }
-///\e
+///Reference to the linear expression
 Expr &expr() { return _expr; }
-///\e
+///Cont reference to the linear expression
 const Expr &expr() const { return _expr; }
-///\e
+///Reference to the lower bound.
+///\return
+///- -\ref INF: the constraint is lower unbounded.
+///- -\ref NaN: lower bound has not been set.
+///- finite number: the lower bound
 Value &lowerBound() { return _lb; }
-///\e
+///The const version of \ref lowerBound()
 const Value &lowerBound() const { return _lb; }
-///\e
+///Reference to the upper bound.
+///\return
+///- -\ref INF: the constraint is upper unbounded.
+///- -\ref NaN: upper bound has not been set.
+///- finite number: the upper bound
 Value &upperBound() { return _ub; }
-///\e
+///The const version of \ref upperBound()
 const Value &upperBound() const { return _ub; }
-///\e
+///Is the constraint lower bounded?
 bool lowerBounded() const {
 	using namespace std;
 	return isfinite(_lb);
 }
-///\e
+///Is the constraint upper bounded?
 bool upperBounded() const {
 	using namespace std;
 	return isfinite(_ub);
 }
 };
 protected:
 _FixId rows;
 _FixId cols;
 //Abstract virtual functions
+virtual LpSolverBase &_newLp() = 0;
+virtual LpSolverBase &_copyLp() = 0;
 virtual int _addCol() = 0;
 virtual int _addRow() = 0;
 virtual void _setRowCoeffs(int i,
 			       int length,
 int  const * indices,
 LpSolverBase() : obj_const_comp(0) {}
 ///\e
 virtual ~LpSolverBase() {}
+///Creates a new LP problem
+LpSolverBase &newLp() {return _newLp();}
+///Make a copy of the LP problem
+LpSolverBase &copyLp() {return _copyLp();}
 ///\name Build up and modify of the LP
 ///@{
 ///Add a new empty column (i.e a new variable) to the LP
 ///\endcode
 ///- a standard STL compatible iterable container with
 ///\ref Col as its \c mapped_type
 ///like
 ///\code
-///std::map<AnyStatus,LpSolverBase::Col>
+///std::map<AnyType,LpSolverBase::Col>
 ///\endcode
 ///- an iterable lemon \ref concept::WriteMap "write map" like
 ///\code
 ///ListGraph::NodeMap<LpSolverBase::Col>
 ///ListGraph::EdgeMap<LpSolverBase::Col>
 ///\endcode
 ///\return The number of the created column.
-///\bug Iterable nodemap hasn't been implemented yet.
 #ifdef DOXYGEN
 template<class T>
 int addColSet(T &t) { return 0;}
 #else
 template<class T>
 ///\e
 ///\return
 ///- \ref INF or -\ref INF means either infeasibility or unboundedness
 /// of the primal problem, depending on whether we minimize or maximize.
-///- \ref NAN if no primal solution is found.
+///- \ref NaN if no primal solution is found.
 ///- The (finite) objective value if an optimal solution is found.
 Value primalValue() { return _getPrimalValue()+obj_const_comp;}
 ///@}
 };
 ///
 inline LpSolverBase::Expr operator+(const LpSolverBase::Expr &a,
 				      const LpSolverBase::Expr &b)
 {
 LpSolverBase::Expr tmp(a);
-tmp+=b; ///\todo Don't STL have some special 'merge' algorithm?
+tmp+=b; ///\todo Doesn't STL have some special 'merge' algorithm?
 return tmp;
 }
 ///\e
 ///\relates LpSolverBase::Expr
 ///
 inline LpSolverBase::Expr operator-(const LpSolverBase::Expr &a,
 				      const LpSolverBase::Expr &b)
 {
 LpSolverBase::Expr tmp(a);
-tmp-=b; ///\todo Don't STL have some special 'merge' algorithm?
+tmp-=b; ///\todo Doesn't STL have some special 'merge' algorithm?
 return tmp;
 }
 ///\e
 ///\relates LpSolverBase::Expr
 ///
 inline LpSolverBase::Expr operator*(const LpSolverBase::Expr &a,
 				      const LpSolverBase::Value &b)
 {
 LpSolverBase::Expr tmp(a);
-tmp*=b; ///\todo Don't STL have some special 'merge' algorithm?
+tmp*=b; ///\todo Doesn't STL have some special 'merge' algorithm?
 return tmp;
 }
 ///\e
 ///
 inline LpSolverBase::Expr operator*(const LpSolverBase::Value &a,
 				      const LpSolverBase::Expr &b)
 {
 LpSolverBase::Expr tmp(b);
-tmp*=a; ///\todo Don't STL have some special 'merge' algorithm?
+tmp*=a; ///\todo Doesn't STL have some special 'merge' algorithm?
 return tmp;
 }
 ///\e
 ///\relates LpSolverBase::Expr
 ///
 inline LpSolverBase::Expr operator/(const LpSolverBase::Expr &a,
 				      const LpSolverBase::Value &b)
 {
 LpSolverBase::Expr tmp(a);
-tmp/=b; ///\todo Don't STL have some special 'merge' algorithm?
+tmp/=b; ///\todo Doesn't STL have some special 'merge' algorithm?
 return tmp;
 }
 ///\e

changeset 1364	ee5959aa4410
parent 1359	1581f961cfaa
child 1376	8de0c1aeeb32