Index: src/lemon/lp_base.h
===================================================================
--- src/lemon/lp_base.h	(revision 1359)
+++ src/lemon/lp_base.h	(revision 1364)
@@ -199,5 +199,5 @@
     ///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.
@@ -319,6 +319,27 @@
     ///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
     {
@@ -328,9 +349,7 @@
       typedef Expr::Value Value;
       
-      static const Value INF;
-      static const Value NaN;
-      //     static const Value INF=0;
-      //     static const Value NaN=1;
-      
+//       static const Value INF;
+//       static const Value NaN;
+
     protected:
       Expr _expr;
@@ -357,22 +376,33 @@
 	_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;
@@ -387,4 +417,7 @@
 
     //Abstract virtual functions
+    virtual LpSolverBase &_newLp() = 0;
+    virtual LpSolverBase &_copyLp() = 0;
+
     virtual int _addCol() = 0;
     virtual int _addRow() = 0;
@@ -427,4 +460,9 @@
     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
 
@@ -452,5 +490,5 @@
     ///like
     ///\code
-    ///std::map<AnyStatus,LpSolverBase::Col>
+    ///std::map<AnyType,LpSolverBase::Col>
     ///\endcode
     ///- an iterable lemon \ref concept::WriteMap "write map" like 
@@ -460,5 +498,4 @@
     ///\endcode
     ///\return The number of the created column.
-    ///\bug Iterable nodemap hasn't been implemented yet.
 #ifdef DOXYGEN
     template<class T>
@@ -669,5 +706,5 @@
     ///- \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;}
@@ -684,5 +721,5 @@
   {
     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;
   }
@@ -695,5 +732,5 @@
   {
     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;
   }
@@ -706,5 +743,5 @@
   {
     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;
   }
@@ -718,5 +755,5 @@
   {
     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;
   }
@@ -729,5 +766,5 @@
   {
     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;
   }
