Ticket #44: 473d56c5aec8.patch

lemon/lp_base.h

@@ -38 +38 @@
 
   ///Common base class for LP and MIP solvers
 
-  ///\todo Much more docs
+  ///Usually this class is not used directly, please use one of the concrete
+  ///implementations of the solver interface.
   ///\ingroup lp_group
   class LpBase {
 
@@ -87 +88 @@
     ///Its value remains valid and correct even after the addition or erase of
     ///other columns.
     ///
-    ///\todo Document what can one do with a Col (INVALID, comparing,
-    ///it is similar to Node/Edge)
+    ///\note This class is similar to other Item types in LEMON, like
+    ///Node and Arc types in digraph.
     class Col {
       friend class LpBase;
     protected:
@@ -96 +97 @@
       explicit Col(int id) : _id(id) {}
     public:
       typedef Value ExprValue;
-      typedef True LpSolverCol;
+      typedef True LpCol;
+      /// Default constructor
+      
+      /// \warning The default constructor sets the Col to an
+      /// undefined value.
       Col() {}
+      /// Invalid constructor \& conversion.
+      
+      /// This constructor initializes the Col to be invalid.
+      /// \sa Invalid for more details.      
       Col(const Invalid&) : _id(-1) {}
+      /// Equality operator
+
+      /// Two \ref Col "Col"s are equal if and only if they point to
+      /// the same LP column or both are invalid.
+      bool operator==(Col c) const  {return _id == c._id;}
+      /// Inequality operator
+
+      /// \sa operator==(Col c)
+      ///
+      bool operator!=(Col c) const  {return _id != c._id;}
+      /// Artificial ordering operator.
+
+      /// To allow the use of this object in std::map or similar
+      /// associative container we require this.
+      ///
+      /// \note This operator only have to define some strict ordering of
+      /// the items; this order has nothing to do with the iteration
+      /// ordering of the items.
       bool operator<(Col c) const  {return _id < c._id;}
-      bool operator==(Col c) const  {return _id == c._id;}
-      bool operator!=(Col c) const  {return _id != c._id;}
     };
 
+    ///Iterator for iterate over the columns of an LP problem
+
+    /// Its usage is quite simple, for example you can count the number
+    /// of columns in an LP \c lp:
+    ///\code
+    /// int count=0;
+    /// for (LpBase::ColIt c(lp); c!=INVALID; ++c) ++count;
+    ///\endcode
     class ColIt : public Col {
       const LpBase *_solver;
     public:
+      /// Default constructor
+      
+      /// \warning The default constructor sets the iterator
+      /// to an undefined value.
       ColIt() {}
+      /// Sets the iterator to the first Col
+      
+      /// Sets the iterator to the first Col.
+      ///
       ColIt(const LpBase &solver) : _solver(&solver)
       {
         _solver->cols.firstItem(_id);
       }
+      /// Invalid constructor \& conversion
+      
+      /// Initialize the iterator to be invalid.
+      /// \sa Invalid for more details.
       ColIt(const Invalid&) : Col(INVALID) {}
+      /// Next column
+      
+      /// Assign the iterator to the next column.
+      ///
       ColIt &operator++()
       {
         _solver->cols.nextItem(_id);
@@ -120 +169 @@
       }
     };
 
+    /// \brief Returns the ID of the column.
     static int id(const Col& col) { return col._id; }
+    /// \brief Returns the column with the given ID.
+    ///
+    /// \pre The argument should be a valid column ID in the LP problem.
     static Col colFromId(int id) { return Col(id); }
 
     ///Refer to a row of the LP.
@@ -130 +183 @@
     ///Its value remains valid and correct even after the addition or erase of
     ///other rows.
     ///
-    ///\todo Document what can one do with a Row (INVALID, comparing,
-    ///it is similar to Node/Edge)
+    ///\note This class is similar to other Item types in LEMON, like
+    ///Node and Arc types in digraph.
     class Row {
       friend class LpBase;
     protected:
@@ -139 +192 @@
       explicit Row(int id) : _id(id) {}
     public:
       typedef Value ExprValue;
-      typedef True LpSolverRow;
+      typedef True LpRow;
+      /// Default constructor
+      
+      /// \warning The default constructor sets the Row to an
+      /// undefined value.
       Row() {}
+      /// Invalid constructor \& conversion.
+      
+      /// This constructor initializes the Row to be invalid.
+      /// \sa Invalid for more details.      
       Row(const Invalid&) : _id(-1) {}
+      /// Equality operator
 
-      bool operator<(Row c) const  {return _id < c._id;}
-      bool operator==(Row c) const  {return _id == c._id;}
-      bool operator!=(Row c) const  {return _id != c._id;}
+      /// Two \ref Row "Row"s are equal if and only if they point to
+      /// the same LP row or both are invalid.
+      bool operator==(Row r) const  {return _id == r._id;}
+      /// Inequality operator
+      
+      /// \sa operator==(Row r)
+      ///
+      bool operator!=(Row r) const  {return _id != r._id;}
+      /// Artificial ordering operator.
+
+      /// To allow the use of this object in std::map or similar
+      /// associative container we require this.
+      ///
+      /// \note This operator only have to define some strict ordering of
+      /// the items; this order has nothing to do with the iteration
+      /// ordering of the items.
+      bool operator<(Row r) const  {return _id < r._id;}
     };
 
+    ///Iterator for iterate over the rows of an LP problem
+
+    /// Its usage is quite simple, for example you can count the number
+    /// of rows in an LP \c lp:
+    ///\code
+    /// int count=0;
+    /// for (LpBase::RowIt c(lp); c!=INVALID; ++c) ++count;
+    ///\endcode
     class RowIt : public Row {
       const LpBase *_solver;
     public:
+      /// Default constructor
+      
+      /// \warning The default constructor sets the iterator
+      /// to an undefined value.
       RowIt() {}
+      /// Sets the iterator to the first Row
+      
+      /// Sets the iterator to the first Row.
+      ///
       RowIt(const LpBase &solver) : _solver(&solver)
       {
         _solver->rows.firstItem(_id);
       }
+      /// Invalid constructor \& conversion
+      
+      /// Initialize the iterator to be invalid.
+      /// \sa Invalid for more details.
       RowIt(const Invalid&) : Row(INVALID) {}
+      /// Next row
+      
+      /// Assign the iterator to the next row.
+      ///
       RowIt &operator++()
       {
         _solver->rows.nextItem(_id);
@@ -164 +264 @@
       }
     };
 
+    /// \brief Returns the ID of the row.
     static int id(const Row& row) { return row._id; }
+    /// \brief Returns the row with the given ID.
+    ///
+    /// \pre The argument should be a valid row ID in the LP problem.
     static Row rowFromId(int id) { return Row(id); }
 
   public:
@@ -196 +300 @@
     ///2*v-3.12*(v-w/2)+2
     ///v*2.1+(3*v+(v*12+w+6)*3)/2
     ///\endcode
-    ///are valid \ref Expr "Expr"essions.
+    ///are valid expressions.
     ///The usual assignment operations are also defined.
     ///\code
     ///e=v+w;
@@ -204 +308 @@
     ///e*=3.4;
     ///e/=5;
     ///\endcode
-    ///- The constant member can be set and read by \ref operator*()
+    ///- The constant member can be set and read by dereference
+    ///  operator (unary *)
+    ///
     ///\code
     ///*e=12;
     ///double c=*e;
     ///\endcode
     ///
-    ///\note \ref clear() not only sets all coefficients to 0 but also
-    ///clears the constant components.
-    ///
     ///\sa Constr
-    ///
     class Expr {
       friend class LpBase;
     public:
+      /// The key type of the expression
       typedef LpBase::Col Key;
+      /// The value type of the expression
       typedef LpBase::Value Value;
 
     protected:
@@ -227 +331 @@
 
     public:
       typedef True SolverExpr;
-      ///\e
+      /// Default constructor
+      
+      /// Construct an empty expression, the coefficients and
+      /// the constant component are initialized to zero.
       Expr() : const_comp(0) {}
-      ///\e
-      Expr(const Key &k) : const_comp(0) {
+      /// Construct an expression from a column
+
+      /// Construct an expression, which has a term with \c c variable
+      /// and 1.0 coefficient.
+      Expr(const Col &c) : const_comp(0) {
         typedef std::map<int, Value>::value_type pair_type;
-        comps.insert(pair_type(id(k), 1));
+        comps.insert(pair_type(id(c), 1));
       }
-      ///\e
+      /// Construct an expression from a constant
+
+      /// Construct an expression, which's constant component is \c v.
+      ///
       Expr(const Value &v) : const_comp(v) {}
-      ///\e
-      Value operator[](const Key& k) const {
-        std::map<int, Value>::const_iterator it=comps.find(id(k));
+      /// Returns the coefficient of the column
+      Value operator[](const Col& c) const {
+        std::map<int, Value>::const_iterator it=comps.find(id(c));
         if (it != comps.end()) {
           return it->second;
         } else {
           return 0;
         }
       }
-      ///\e
-      Value& operator[](const Key& k) {
-        return comps[id(k)];
+      /// Returns the coefficient of the column
+      Value& operator[](const Col& c) {
+        return comps[id(c)];
       }
-      ///\e
-      void set(const Key &k, const Value &v) {
+      /// Sets the coefficient of the column
+      void set(const Col &c, const Value &v) {
         if (v != 0.0) {
           typedef std::map<int, Value>::value_type pair_type;
-          comps.insert(pair_type(id(k), v));
+          comps.insert(pair_type(id(c), v));
         } else {
-          comps.erase(id(k));
+          comps.erase(id(c));
         }
       }
-
-      ///\e
+      /// Returns the constant component of the expression
       Value& operator*() { return const_comp; }
-      ///\e
+      /// Returns the constant component of the expression
       const Value& operator*() const { return const_comp; }
-
-      ///Removes the coefficients closer to zero than \c epsilon.
+      /// \brief Removes the coefficients which's absolute value does
+      /// not exceed \c epsilon. It also sets to zero the constant
+      /// component, if it does not exceed epsilon in absolute value.
       void simplify(Value epsilon = 0.0) {
         std::map<int, Value>::iterator it=comps.begin();
         while (it != comps.end()) {
@@ -286 +399 @@
         const_comp=0;
       }
 
-      ///\e
+      ///Compound assignment
       Expr &operator+=(const Expr &e) {
         for (std::map<int, Value>::const_iterator it=e.comps.begin();
              it!=e.comps.end(); ++it)
@@ -294 +407 @@
         const_comp+=e.const_comp;
         return *this;
       }
-      ///\e
+      ///Compound assignment
       Expr &operator-=(const Expr &e) {
         for (std::map<int, Value>::const_iterator it=e.comps.begin();
              it!=e.comps.end(); ++it)
@@ -302 +415 @@
         const_comp-=e.const_comp;
         return *this;
       }
-      ///\e
-      Expr &operator*=(const Value &c) {
+      ///Multiply with a constant
+      Expr &operator*=(const Value &v) {
         for (std::map<int, Value>::iterator it=comps.begin();
              it!=comps.end(); ++it)
-          it->second*=c;
-        const_comp*=c;
+          it->second*=v;
+        const_comp*=v;
         return *this;
       }
-      ///\e
+      ///Division with a constant
       Expr &operator/=(const Value &c) {
         for (std::map<int, Value>::iterator it=comps.begin();
              it!=comps.end(); ++it)
@@ -319 +432 @@
         return *this;
       }
 
+      ///Iterator over the expression
+      
+      ///The iterator iterates over the terms of the expression. 
+      /// 
+      ///\code
+      ///double s=0;
+      ///for(LpBase::Expr::CoeffIt i(e);i!=INVALID;++i)
+      ///  s+= *i * primal(i);
+      ///\endcode
       class CoeffIt {
       private:
 
@@ -326 +448 @@
 
       public:
 
+        /// Sets the iterator to the first term
+        
+        /// Sets the iterator to the first term of the expression.
+        ///
         CoeffIt(Expr& e)
           : _it(e.comps.begin()), _end(e.comps.end()){}
 
+        /// Convert the iterator to the column of the term
         operator Col() const {
           return colFromId(_it->first);
         }
 
+        /// Returns the coefficient of the term
         Value& operator*() { return _it->second; }
+
+        /// Returns the coefficient of the term
         const Value& operator*() const { return _it->second; }
-
+        /// Next term
+        
+        /// Assign the iterator to the next term.
+        ///
         CoeffIt& operator++() { ++_it; return *this; }
 
+        /// Equality operator
         bool operator==(Invalid) const { return _it == _end; }
+        /// Inequality operator
         bool operator!=(Invalid) const { return _it != _end; }
       };
 
+      /// Const iterator over the expression
+      
+      ///The iterator iterates over the terms of the expression. 
+      /// 
+      ///\code
+      ///double s=0;
+      ///for(LpBase::Expr::ConstCoeffIt i(e);i!=INVALID;++i)
+      ///  s+=*i * primal(i);
+      ///\endcode
       class ConstCoeffIt {
       private:
 
@@ -349 +493 @@
 
       public:
 
+        /// Sets the iterator to the first term
+        
+        /// Sets the iterator to the first term of the expression.
+        ///
         ConstCoeffIt(const Expr& e)
           : _it(e.comps.begin()), _end(e.comps.end()){}
 
+        /// Convert the iterator to the column of the term
         operator Col() const {
           return colFromId(_it->first);
         }
 
+        /// Returns the coefficient of the term
         const Value& operator*() const { return _it->second; }
 
+        /// Next term
+        
+        /// Assign the iterator to the next term.
+        ///
         ConstCoeffIt& operator++() { ++_it; return *this; }
 
+        /// Equality operator
         bool operator==(Invalid) const { return _it == _end; }
+        /// Inequality operator
         bool operator!=(Invalid) const { return _it != _end; }
       };
 
@@ -478 +634 @@
     ///2*v-3.12*(v-w/2)
     ///v*2.1+(3*v+(v*12+w)*3)/2
     ///\endcode
-    ///are valid \ref DualExpr "DualExpr"essions.
+    ///are valid \ref DualExpr dual expressions.
     ///The usual assignment operations are also defined.
     ///\code
     ///e=v+w;
@@ -488 +644 @@
     ///\endcode
     ///
     ///\sa Expr
-    ///
     class DualExpr {
       friend class LpBase;
     public:
+      /// The key type of the expression
       typedef LpBase::Row Key;
+      /// The value type of the expression
       typedef LpBase::Value Value;
 
     protected:
@@ -500 +657 @@
 
     public:
       typedef True SolverExpr;
-      ///\e
+      /// Default constructor
+      
+      /// Construct an empty expression, the coefficients are
+      /// initialized to zero.
       DualExpr() {}
-      ///\e
-      DualExpr(const Key &k) {
+      /// Construct an expression from a row
+
+      /// Construct an expression, which has a term with \c r dual
+      /// variable and 1.0 coefficient.
+      DualExpr(const Row &r) {
         typedef std::map<int, Value>::value_type pair_type;
-        comps.insert(pair_type(id(k), 1));
+        comps.insert(pair_type(id(r), 1));
       }
-      ///\e
-      Value operator[](const Key& k) const {
-        std::map<int, Value>::const_iterator it = comps.find(id(k));
+      /// Returns the coefficient of the row
+      Value operator[](const Row& r) const {
+        std::map<int, Value>::const_iterator it = comps.find(id(r));
         if (it != comps.end()) {
           return it->second;
         } else {
           return 0;
         }
       }
-      ///\e
-      Value& operator[](const Key& k) {
-        return comps[id(k)];
+      /// Returns the coefficient of the row
+      Value& operator[](const Row& r) {
+        return comps[id(r)];
       }
-      ///\e
-      void set(const Key &k, const Value &v) {
+      /// Sets the coefficient of the row
+      void set(const Row &r, const Value &v) {
         if (v != 0.0) {
           typedef std::map<int, Value>::value_type pair_type;
-          comps.insert(pair_type(id(k), v));
+          comps.insert(pair_type(id(r), v));
         } else {
-          comps.erase(id(k));
+          comps.erase(id(r));
         }
       }
-
-      ///Removes the coefficients closer to zero than \c epsilon.
+      /// \brief Removes the coefficients which's absolute value does
+      /// not exceed \c epsilon. 
       void simplify(Value epsilon = 0.0) {
         std::map<int, Value>::iterator it=comps.begin();
         while (it != comps.end()) {
@@ -549 +712 @@
       void clear() {
         comps.clear();
       }
-
-      ///\e
+      ///Compound assignment
       DualExpr &operator+=(const DualExpr &e) {
         for (std::map<int, Value>::const_iterator it=e.comps.begin();
              it!=e.comps.end(); ++it)
           comps[it->first]+=it->second;
         return *this;
       }
-      ///\e
+      ///Compound assignment
       DualExpr &operator-=(const DualExpr &e) {
         for (std::map<int, Value>::const_iterator it=e.comps.begin();
              it!=e.comps.end(); ++it)
           comps[it->first]-=it->second;
         return *this;
       }
-      ///\e
-      DualExpr &operator*=(const Value &c) {
+      ///Multiply with a constant
+      DualExpr &operator*=(const Value &v) {
         for (std::map<int, Value>::iterator it=comps.begin();
              it!=comps.end(); ++it)
-          it->second*=c;
+          it->second*=v;
         return *this;
       }
-      ///\e
-      DualExpr &operator/=(const Value &c) {
+      ///Division with a constant
+      DualExpr &operator/=(const Value &v) {
         for (std::map<int, Value>::iterator it=comps.begin();
              it!=comps.end(); ++it)
-          it->second/=c;
+          it->second/=v;
         return *this;
       }
 
+      ///Iterator over the expression
+      
+      ///The iterator iterates over the terms of the expression. 
+      /// 
+      ///\code
+      ///double s=0;
+      ///for(LpBase::DualExpr::CoeffIt i(e);i!=INVALID;++i)
+      ///  s+= *i * dual(i);
+      ///\endcode
       class CoeffIt {
       private:
 
@@ -586 +757 @@
 
       public:
 
+        /// Sets the iterator to the first term
+        
+        /// Sets the iterator to the first term of the expression.
+        ///
         CoeffIt(DualExpr& e)
           : _it(e.comps.begin()), _end(e.comps.end()){}
 
+        /// Convert the iterator to the row of the term
         operator Row() const {
           return rowFromId(_it->first);
         }
 
+        /// Returns the coefficient of the term
         Value& operator*() { return _it->second; }
+
+        /// Returns the coefficient of the term
         const Value& operator*() const { return _it->second; }
 
+        /// Next term
+        
+        /// Assign the iterator to the next term.
+        ///
         CoeffIt& operator++() { ++_it; return *this; }
 
+        /// Equality operator
         bool operator==(Invalid) const { return _it == _end; }
+        /// Inequality operator
         bool operator!=(Invalid) const { return _it != _end; }
       };
 
+      ///Iterator over the expression
+      
+      ///The iterator iterates over the terms of the expression. 
+      /// 
+      ///\code
+      ///double s=0;
+      ///for(LpBase::DualExpr::ConstCoeffIt i(e);i!=INVALID;++i)
+      ///  s+= *i * dual(i);
+      ///\endcode
       class ConstCoeffIt {
       private:
 
@@ -609 +803 @@
 
       public:
 
+        /// Sets the iterator to the first term
+        
+        /// Sets the iterator to the first term of the expression.
+        ///
         ConstCoeffIt(const DualExpr& e)
           : _it(e.comps.begin()), _end(e.comps.end()){}
 
+        /// Convert the iterator to the row of the term
         operator Row() const {
           return rowFromId(_it->first);
         }
 
+        /// Returns the coefficient of the term
         const Value& operator*() const { return _it->second; }
 
+        /// Next term
+        
+        /// Assign the iterator to the next term.
+        ///
         ConstCoeffIt& operator++() { ++_it; return *this; }
 
+        /// Equality operator
         bool operator==(Invalid) const { return _it == _end; }
+        /// Inequality operator
         bool operator!=(Invalid) const { return _it != _end; }
       };
     };
@@ -774 +980 @@
     //Constant component of the objective function
     Value obj_const_comp;
 
+    LpBase() : rows(), cols(), obj_const_comp(0) {}
+
   public:
 
-    ///\e
-    LpBase() : rows(), cols(), obj_const_comp(0) {
-    }
-
-    ///\e
+    /// Virtual destructor
     virtual ~LpBase() {}
 
     ///Creates a new LP problem
@@ -798 +1002 @@
     ///Add a new empty column (i.e a new variable) to the LP
     Col addCol() { Col c; c._id = _addColId(_addCol()); return c;}
 
-    ///\brief Adds several new columns
-    ///(i.e a variables) at once
+    ///\brief Adds several new columns (i.e variables) at once
     ///
-    ///This magic function takes a container as its argument
-    ///and fills its elements
-    ///with new columns (i.e. variables)
+    ///This magic function takes a container as its argument and fills
+    ///its elements with new columns (i.e. variables)
     ///\param t can be
     ///- a standard STL compatible iterable container with
-    ///\ref Col as its \c values_type
-    ///like
+    ///\ref Col as its \c values_type like
     ///\code
     ///std::vector<LpBase::Col>
     ///std::list<LpBase::Col>
     ///\endcode
     ///- a standard STL compatible iterable container with
-    ///\ref Col as its \c mapped_type
-    ///like
+    ///\ref Col as its \c mapped_type like
     ///\code
     ///std::map<AnyType,LpBase::Col>
     ///\endcode
@@ -829 +1029 @@
     int addColSet(T &t) { return 0;}
 #else
     template<class T>
-    typename enable_if<typename T::value_type::LpSolverCol,int>::type
+    typename enable_if<typename T::value_type::LpCol,int>::type
     addColSet(T &t,dummy<0> = 0) {
       int s=0;
       for(typename T::iterator i=t.begin();i!=t.end();++i) {*i=addCol();s++;}
       return s;
     }
     template<class T>
-    typename enable_if<typename T::value_type::second_type::LpSolverCol,
+    typename enable_if<typename T::value_type::second_type::LpCol,
                        int>::type
     addColSet(T &t,dummy<1> = 1) {
       int s=0;
@@ -847 +1047 @@
       return s;
     }
     template<class T>
-    typename enable_if<typename T::MapIt::Value::LpSolverCol,
+    typename enable_if<typename T::MapIt::Value::LpCol,
                        int>::type
     addColSet(T &t,dummy<2> = 2) {
       int s=0;
@@ -873 +1073 @@
 
     ///Get a column (i.e a dual constraint) of the LP
 
-    ///\param r is the column to get
+    ///\param c is the column to get
     ///\return the dual expression associated to the column
     DualExpr col(Col c) const {
       DualExpr e;
@@ -884 +1084 @@
     ///Add a new column to the LP
 
     ///\param e is a dual linear expression (see \ref DualExpr)
-    ///\param obj is the corresponding component of the objective
+    ///\param o is the corresponding component of the objective
     ///function. It is 0 by default.
     ///\return The created column.
     Col addCol(const DualExpr &e, Value o = 0) {
@@ -900 +1100 @@
     ///\return The created row
     Row addRow() { Row r; r._id = _addRowId(_addRow()); return r;}
 
-    ///\brief Add several new rows
-    ///(i.e a constraints) at once
+    ///\brief Add several new rows (i.e constraints) at once
     ///
-    ///This magic function takes a container as its argument
-    ///and fills its elements
-    ///with new row (i.e. variables)
+    ///This magic function takes a container as its argument and fills
+    ///its elements with new row (i.e. variables)
     ///\param t can be
     ///- a standard STL compatible iterable container with
-    ///\ref Row as its \c values_type
-    ///like
+    ///\ref Row as its \c values_type like
     ///\code
     ///std::vector<LpBase::Row>
     ///std::list<LpBase::Row>
     ///\endcode
     ///- a standard STL compatible iterable container with
-    ///\ref Row as its \c mapped_type
-    ///like
+    ///\ref Row as its \c mapped_type like
     ///\code
     ///std::map<AnyType,LpBase::Row>
     ///\endcode
@@ -931 +1127 @@
     int addRowSet(T &t) { return 0;}
 #else
     template<class T>
-    typename enable_if<typename T::value_type::LpSolverRow,int>::type
+    typename enable_if<typename T::value_type::LpRow,int>::type
     addRowSet(T &t, dummy<0> = 0) {
       int s=0;
       for(typename T::iterator i=t.begin();i!=t.end();++i) {*i=addRow();s++;}
       return s;
     }
     template<class T>
-    typename enable_if<typename T::value_type::second_type::LpSolverRow,
-                       int>::type
+    typename enable_if<typename T::value_type::second_type::LpRow, int>::type
     addRowSet(T &t, dummy<1> = 1) {
       int s=0;
       for(typename T::iterator i=t.begin();i!=t.end();++i) {
@@ -949 +1144 @@
       return s;
     }
     template<class T>
-    typename enable_if<typename T::MapIt::Value::LpSolverRow,
-                       int>::type
+    typename enable_if<typename T::MapIt::Value::LpRow, int>::type
     addRowSet(T &t, dummy<2> = 2) {
       int s=0;
       for(typename T::MapIt i(t); i!=INVALID; ++i)
@@ -1020 +1214 @@
     ///Erase a column (i.e a variable) from the LP
 
     ///\param c is the column to be deleted
-    ///\todo Please check this
     void erase(Col c) {
       _eraseCol(cols(id(c)));
       _eraseColId(cols(id(c)));
@@ -1028 +1221 @@
     ///Erase a row (i.e a constraint) from the LP
 
     ///\param r is the row to be deleted
-    ///\todo Please check this
     void erase(Row r) {
       _eraseRow(rows(id(r)));
       _eraseRowId(rows(id(r)));
@@ -1099 +1291 @@
 
     /// Get an element of the coefficient matrix of the LP
 
-    ///\param r is the row of the element in question
-    ///\param c is the column of the element in question
+    ///\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)));
@@ -1117 +1309 @@
 
     /// Get the lower bound of a column (i.e a variable)
 
-    /// This function returns the lower bound for column (variable) \t c
+    /// This function returns the lower bound for column (variable) \c c
     /// (this might be -\ref INF as well).
-    ///\return The lower bound for column \t c
+    ///\return The lower bound for column \c c
     Value colLowerBound(Col c) const {
       return _getColLowerBound(cols(id(c)));
     }
 
     ///\brief Set the lower bound of  several columns
-    ///(i.e a variables) at once
+    ///(i.e variables) at once
     ///
     ///This magic function takes a container as its argument
     ///and applies the function on all of its elements.
-    /// 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.
+    ///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.
 #ifdef DOXYGEN
     template<class T>
     void colLowerBound(T &t, Value value) { return 0;}
 #else
     template<class T>
-    typename enable_if<typename T::value_type::LpSolverCol,void>::type
+    typename enable_if<typename T::value_type::LpCol,void>::type
     colLowerBound(T &t, Value value,dummy<0> = 0) {
       for(typename T::iterator i=t.begin();i!=t.end();++i) {
         colLowerBound(*i, value);
       }
     }
     template<class T>
-    typename enable_if<typename T::value_type::second_type::LpSolverCol,
+    typename enable_if<typename T::value_type::second_type::LpCol,
                        void>::type
     colLowerBound(T &t, Value value,dummy<1> = 1) {
       for(typename T::iterator i=t.begin();i!=t.end();++i) {
@@ -1152 +1344 @@
       }
     }
     template<class T>
-    typename enable_if<typename T::MapIt::Value::LpSolverCol,
+    typename enable_if<typename T::MapIt::Value::LpCol,
                        void>::type
     colLowerBound(T &t, Value value,dummy<2> = 2) {
       for(typename T::MapIt i(t); i!=INVALID; ++i){
@@ -1172 +1364 @@
 
     /// Get the upper bound of a column (i.e a variable)
 
-    /// This function returns the upper bound for column (variable) \t c
+    /// This function returns the upper bound for column (variable) \c c
     /// (this might be \ref INF as well).
-    ///\return The upper bound for column \t c
+    /// \return The upper bound for column \c c
     Value colUpperBound(Col c) const {
       return _getColUpperBound(cols(id(c)));
     }
 
     ///\brief Set the upper bound of  several columns
-    ///(i.e a variables) at once
+    ///(i.e variables) at once
     ///
     ///This magic function takes a container as its argument
     ///and applies the function on all of its elements.
-    /// 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.
+    ///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.
 #ifdef DOXYGEN
     template<class T>
     void colUpperBound(T &t, Value value) { return 0;}
 #else
     template<class T>
-    typename enable_if<typename T::value_type::LpSolverCol,void>::type
+    typename enable_if<typename T::value_type::LpCol,void>::type
     colUpperBound(T &t, Value value,dummy<0> = 0) {
       for(typename T::iterator i=t.begin();i!=t.end();++i) {
         colUpperBound(*i, value);
       }
     }
     template<class T>
-    typename enable_if<typename T::value_type::second_type::LpSolverCol,
+    typename enable_if<typename T::value_type::second_type::LpCol,
                        void>::type
     colUpperBound(T &t, Value value,dummy<1> = 1) {
       for(typename T::iterator i=t.begin();i!=t.end();++i) {
@@ -1207 +1399 @@
       }
     }
     template<class T>
-    typename enable_if<typename T::MapIt::Value::LpSolverCol,
+    typename enable_if<typename T::MapIt::Value::LpCol,
                        void>::type
     colUpperBound(T &t, Value value,dummy<2> = 2) {
       for(typename T::MapIt i(t); i!=INVALID; ++i){
@@ -1228 +1420 @@
     }
 
     ///\brief Set the lower and the upper bound of several columns
-    ///(i.e a variables) at once
+    ///(i.e variables) at once
     ///
     ///This magic function takes a container as its argument
     ///and applies the function on all of its elements.
@@ -1241 +1433 @@
     void colBounds(T &t, Value lower, Value upper) { return 0;}
 #else
     template<class T>
-    typename enable_if<typename T::value_type::LpSolverCol,void>::type
+    typename enable_if<typename T::value_type::LpCol,void>::type
     colBounds(T &t, Value lower, Value upper,dummy<0> = 0) {
       for(typename T::iterator i=t.begin();i!=t.end();++i) {
         colBounds(*i, lower, upper);
       }
     }
     template<class T>
-    typename enable_if<typename T::value_type::second_type::LpSolverCol,
-                       void>::type
+    typename enable_if<typename T::value_type::second_type::LpCol, void>::type
     colBounds(T &t, Value lower, Value upper,dummy<1> = 1) {
       for(typename T::iterator i=t.begin();i!=t.end();++i) {
         colBounds(i->second, lower, upper);
       }
     }
     template<class T>
-    typename enable_if<typename T::MapIt::Value::LpSolverCol,
-                       void>::type
+    typename enable_if<typename T::MapIt::Value::LpCol, void>::type
     colBounds(T &t, Value lower, Value upper,dummy<2> = 2) {
       for(typename T::MapIt i(t); i!=INVALID; ++i){
         colBounds(*i, lower, upper);
@@ -1276 +1466 @@
 
     /// Get the lower bound of a row (i.e a constraint)
 
-    /// This function returns the lower bound for row (constraint) \t c
+    /// This function returns the lower bound for row (constraint) \c c
     /// (this might be -\ref INF as well).
-    ///\return The lower bound for row \t r
+    ///\return The lower bound for row \c r
     Value rowLowerBound(Row r) const {
       return _getRowLowerBound(rows(id(r)));
     }
@@ -1294 +1484 @@
 
     /// Get the upper bound of a row (i.e a constraint)
 
-    /// This function returns the upper bound for row (constraint) \t c
+    /// This function returns the upper bound for row (constraint) \c c
     /// (this might be -\ref INF as well).
-    ///\return The upper bound for row \t r
+    ///\return The upper bound for row \c r
     Value rowUpperBound(Row r) const {
       return _getRowUpperBound(rows(id(r)));
     }
@@ -1310 +1500 @@
     ///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),
                     ExprIterator(e.comps.end(), cols));
@@ -1318 +1509 @@
 
     ///Get the objective function
 
-    ///\return the objective function as a linear expression of type \ref Expr.
+    ///\return the objective function as a linear expression of type
+    ///Expr.
     Expr obj() const {
       Expr e;
       _getObjCoeffs(InsertIterator(e.comps, cols));
@@ -1346 +1538 @@
 
   };
 
+  /// Addition
+
   ///\relates LpBase::Expr
   ///
-  inline LpBase::Expr operator+(const LpBase::Expr &a,
-                                const LpBase::Expr &b) {
+  inline LpBase::Expr operator+(const LpBase::Expr &a, const LpBase::Expr &b) {
     LpBase::Expr tmp(a);
     tmp+=b;
     return tmp;
   }
-  ///\e
+  ///Substraction
 
   ///\relates LpBase::Expr
   ///
-  inline LpBase::Expr operator-(const LpBase::Expr &a,
-                                const LpBase::Expr &b) {
+  inline LpBase::Expr operator-(const LpBase::Expr &a, const LpBase::Expr &b) {
     LpBase::Expr tmp(a);
     tmp-=b;
     return tmp;
   }
-  ///\e
+  ///Multiply with constant
 
   ///\relates LpBase::Expr
   ///
-  inline LpBase::Expr operator*(const LpBase::Expr &a,
-                                const LpBase::Value &b) {
+  inline LpBase::Expr operator*(const LpBase::Expr &a, const LpBase::Value &b) {
     LpBase::Expr tmp(a);
     tmp*=b;
     return tmp;
   }
 
-  ///\e
+  ///Multiply with constant
 
   ///\relates LpBase::Expr
   ///
-  inline LpBase::Expr operator*(const LpBase::Value &a,
-                                const LpBase::Expr &b) {
+  inline LpBase::Expr operator*(const LpBase::Value &a, const LpBase::Expr &b) {
     LpBase::Expr tmp(b);
     tmp*=a;
     return tmp;
   }
-  ///\e
+  ///Divide with constant
 
   ///\relates LpBase::Expr
   ///
-  inline LpBase::Expr operator/(const LpBase::Expr &a,
-                                const LpBase::Value &b) {
+  inline LpBase::Expr operator/(const LpBase::Expr &a, const LpBase::Value &b) {
     LpBase::Expr tmp(a);
     tmp/=b;
     return tmp;
   }
 
-  ///\e
+  ///Create constraint
 
   ///\relates LpBase::Constr
   ///
@@ -1405 +1594 @@
     return LpBase::Constr(0, f - e, LpBase::INF);
   }
 
-  ///\e
+  ///Create constraint
 
   ///\relates LpBase::Constr
   ///
@@ -1414 +1603 @@
     return LpBase::Constr(e, f, LpBase::NaN);
   }
 
-  ///\e
+  ///Create constraint
 
   ///\relates LpBase::Constr
   ///
@@ -1423 +1612 @@
     return LpBase::Constr(- LpBase::INF, e, f);
   }
 
-  ///\e
+  ///Create constraint
 
   ///\relates LpBase::Constr
   ///
@@ -1433 +1622 @@
   }
 
 
-  ///\e
+  ///Create constraint
 
   ///\relates LpBase::Constr
   ///
@@ -1443 +1632 @@
   }
 
 
-  ///\e
+  ///Create constraint
 
   ///\relates LpBase::Constr
   ///
@@ -1452 +1641 @@
     return LpBase::Constr(f, e, LpBase::INF);
   }
 
-  ///\e
+  ///Create constraint
 
   ///\relates LpBase::Constr
   ///
@@ -1461 +1650 @@
     return LpBase::Constr(f, e, f);
   }
 
-  ///\e
+  ///Create constraint
 
   ///\relates LpBase::Constr
   ///
@@ -1470 +1659 @@
     return LpBase::Constr(0, f - e, 0);
   }
 
-  ///\e
+  ///Create constraint
 
   ///\relates LpBase::Constr
   ///
@@ -1481 +1670 @@
     tmp.lowerBound()=n;
     return tmp;
   }
-  ///\e
+  ///Create constraint
 
   ///\relates LpBase::Constr
   ///
@@ -1494 +1683 @@
     return tmp;
   }
 
-  ///\e
+  ///Create constraint
 
   ///\relates LpBase::Constr
   ///
@@ -1505 +1694 @@
     tmp.upperBound()=n;
     return tmp;
   }
-  ///\e
+  ///Create constraint
 
   ///\relates LpBase::Constr
   ///
@@ -1518 +1707 @@
     return tmp;
   }
 
-  ///\e
+  ///Addition
 
   ///\relates LpBase::DualExpr
   ///
@@ -1528 +1717 @@
     tmp+=b;
     return tmp;
   }
-  ///\e
+  ///Substraction
 
   ///\relates LpBase::DualExpr
   ///
@@ -1538 +1727 @@
     tmp-=b;
     return tmp;
   }
-  ///\e
+  ///Multiply with constant
 
   ///\relates LpBase::DualExpr
   ///
@@ -1549 +1738 @@
     return tmp;
   }
 
-  ///\e
+  ///Multiply with constant
 
   ///\relates LpBase::DualExpr
   ///
@@ -1559 +1748 @@
     tmp*=a;
     return tmp;
   }
-  ///\e
+  ///Divide with constant
 
   ///\relates LpBase::DualExpr
   ///
@@ -1573 +1762 @@
   /// \ingroup lp_group
   ///
   /// \brief Common base class for LP solvers
-  /// \todo Much more docs
+  ///
+  /// This class is an abstract base class for LP solvers. This class
+  /// provides a full interface for set and modify an LP problem,
+  /// solve it and retrieve the solution. You can use one of the
+  /// descendants as a concrete implementation, or the \c Lp
+  /// default LP solver. However, if you would like to handle LP
+  /// solvers as reference or pointer in a generic way, you can use
+  /// this class directly.
   class LpSolver : virtual public LpBase {
   public:
 
-    ///\e
+    /// The problem types for primal and dual problems
     enum ProblemType {
       ///Feasible solution hasn't been found (but may exist).
       UNDEFINED = 0,
@@ -1591 +1787 @@
       UNBOUNDED = 4
     };
 
-    ///\e
+    ///The basis status of variables
     enum VarStatus {
       /// The variable is in the basis
       BASIC, 
@@ -1634 +1830 @@
     ///\return The result of the optimization procedure. Possible
     ///values and their meanings can be found in the documentation of
     ///\ref SolveExitStatus.
-    ///
-    ///\todo Which method is used to solve the problem
     SolveExitStatus solve() { return _solve(); }
 
     ///@}
@@ -1654 +1848 @@
       return _getDualType();
     }
 
-    ///\e
+    /// 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))); }
-    ///\e
+
+    /// 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.
+    /// \pre The problem is solved.
     Value primal(const Expr& e) const {
       double res = *e;
       for (Expr::ConstCoeffIt c(e); c != INVALID; ++c) {
@@ -1664 +1866 @@
       }
       return res;
     }
-    ///\e
+    /// Returns a component of the primal ray
+    
+    /// The primal ray is solution of the modified primal problem,
+    /// where we change each finite bound to 0, and we looking for a
+    /// negative objective value in case of minimization, and positive
+    /// objective value for maximization. If there is such solution,
+    /// that proofs the unsolvability of the dual problem, and if a
+    /// feasible primal solution exists, then the unboundness of
+    /// 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))); }
 
-    ///\e
+    /// 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))); }
-    ///\e
+
+    /// 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.
+    /// \pre The problem is solved.
     Value dual(const DualExpr& e) const {
       double res = 0.0;
       for (DualExpr::ConstCoeffIt r(e); r != INVALID; ++r) {
@@ -1677 +1899 @@
       }
       return res;
     }
-    ///\e
+
+    /// Returns a component of the dual ray
+    
+    /// The dual ray is solution of the modified primal problem, where
+    /// we change each finite bound to 0 (i.e. the objective function
+    /// coefficients in the primal problem), and we looking for a
+    /// ositive objective value. If there is such solution, that
+    /// proofs the unsolvability of the primal problem, and if a
+    /// feasible dual solution exists, then the unboundness of
+    /// 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))); }
 
-    ///\e
+    /// Return the basis status of the column
+
+    /// \see VarStatus
     VarStatus colStatus(Col c) const { return _getColStatus(cols(id(c))); }
 
-    ///\e
-    VarStatus rowStatus(Col c) const { return _getRowStatus(cols(id(c))); }
+    /// Return the basis status of the row
 
-    ///\e
+    /// \see VarStatus
+    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
@@ -1709 +1948 @@
   /// \ingroup lp_group
   ///
   /// \brief Common base class for MIP solvers
-  /// \todo Much more docs
+  ///
+  /// This class is an abstract base class for MIP solvers. This class
+  /// provides a full interface for set and modify an MIP problem,
+  /// solve it and retrieve the solution. You can use one of the
+  /// descendants as a concrete implementation, or the \c Lp
+  /// default MIP solver. However, if you would like to handle MIP
+  /// solvers as reference or pointer in a generic way, you can use
+  /// this class directly.
   class MipSolver : virtual public LpBase {
   public:
 
-    ///\e
+    /// The problem types for MIP problems
     enum ProblemType {
       ///Feasible solution hasn't been found (but may exist).
       UNDEFINED = 0,
@@ -1733 +1979 @@
 
     ///@{
 
-    ///\e Solve the MIP problem at hand
+    /// Solve the MIP problem at hand
     ///
     ///\return The result of the optimization procedure. Possible
     ///values and their meanings can be found in the documentation of
     ///\ref SolveExitStatus.
-    ///
-    ///\todo Which method is used to solve the problem
     SolveExitStatus solve() { return _solve(); }
 
     ///@}
@@ -1756 +2000 @@
     };
 
     ///Sets the type of the given column to the given type
+
+    ///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);
     }
 
     ///Gives back the type of the column.
+
+    ///Gives back the type of the column.
     ///
-    ///Gives back the type of the column.
     ColTypes colType(Col c) const {
       return _getColType(cols(id(c)));
-    }
-
-    ///Sets the type of the given Col to integer.
-    ///
-    ///Sets the type of the given Col to integer.
-    void integer(Col c) {
-      colType(c, INTEGER);
-    }
-
-    ///Gives back whether the type of the column is integer or not.
-    ///
-    ///Gives back the type of the column.
-    ///\return true if the column has integer type and false if not.
-    bool integer(Col c) const {
-      return (colType(c) == INTEGER);
-    }
-
-    ///Sets the type of the given Col to continuous.
-    ///
-    ///Sets the type of the given Col to continuous.
-    void real(Col c) {
-      colType(c, REAL);
-    }
-
-    ///Gives back whether the type of the column is continuous or not.
-    ///
-    ///Gives back the type of the column.
-    ///\return true if the column has continuous type and false if not.
-    bool real(Col c) const {
-      return (colType(c) == REAL);
     }
     ///@}
 
@@ -1809 +2025 @@
       return _getType();
     }
 
-    ///\e
+    /// 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))); }
-    ///\e
+
+    /// 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.
+    /// \pre The problem is solved.
     Value sol(const Expr& e) const {
       double res = *e;
       for (Expr::ConstCoeffIt c(e); c != INVALID; ++c) {
@@ -1819 +2043 @@
       }
       return res;
     }
+    ///The value of the objective function
+    
     ///\return
     ///- \ref INF or -\ref INF means either infeasibility or unboundedness
     /// of the problem, depending on whether we minimize or maximize.

lemon/lp_clp.cc

@@ -91 +91 @@
 
   void LpClp::_eraseColId(int i) {
     cols.eraseIndex(i);
-    cols.shiftIndexes(i);
+    cols.shiftIndices(i);
   }
 
   void LpClp::_eraseRowId(int i) {
     rows.eraseIndex(i);
-    rows.shiftIndexes(i);
+    rows.shiftIndices(i);
   }
 
   void LpClp::_getColName(int c, std::string& name) const {

lemon/lp_cplex.cc

@@ -119 +119 @@
 
   void CplexBase::_eraseColId(int i) {
     cols.eraseIndex(i);
-    cols.shiftIndexes(i);
+    cols.shiftIndices(i);
   }
   void CplexBase::_eraseRowId(int i) {
     rows.eraseIndex(i);
-    rows.shiftIndexes(i);
+    rows.shiftIndices(i);
   }
 
   void CplexBase::_getColName(int col, std::string &name) const {
@@ -395 +395 @@
     }
   }
 
-  void CplexBase::_setObjCoeff(int i, CplexBase::Value obj_coef)
+  void CplexBase::_setObjCoeff(int i, Value obj_coef)
   {
     CPXchgobj(cplexEnv(), _prob, 1, &i, &obj_coef);
   }

lemon/lp_glpk.cc

@@ -71 +71 @@
 
   void GlpkBase::_eraseColId(int i) {
     cols.eraseIndex(i);
-    cols.shiftIndexes(i);
+    cols.shiftIndices(i);
   }
 
   void GlpkBase::_eraseRowId(int i) {
     rows.eraseIndex(i);
-    rows.shiftIndexes(i);
+    rows.shiftIndices(i);
   }
 
   void GlpkBase::_getColName(int c, std::string& name) const {