Ticket #44: 9347462c3106.patch

lemon/config.h.in

@@ -5 +5 @@
 #undef HAVE_GLPK
 
 /* Define to 1 if you have SOPLEX */
-#undef HAVE_SOPLEX
- No newline at end of file
+#undef HAVE_SOPLEX
+
+/* Define to 1 if you have CLP */
+#undef HAVE_CLP

lemon/lp.h

@@ -28 +28 @@
 #include <lemon/lp_cplex.h>
 #elif HAVE_SOPLEX
 #include <lemon/lp_soplex.h>
+#elif HAVE_CLP
+#include <lemon/lp_clp.h>
 #endif
 
 ///\file
@@ -41 +43 @@
   ///The default LP solver identifier.
   ///\ingroup lp_group
   ///
-  ///Currently, the possible values are \c GLPK or \c CPLEX
-#define DEFAULT_LP SOLVER
+  ///Currently, the possible values are \c LP_GLPK, \c LP_CPLEX, \c
+  ///LP_SOPLEX or \c LP_CLP
+#define LEMON_DEFAULT_LP SOLVER
   ///The default LP solver
 
   ///The default LP solver.
   ///\ingroup lp_group
   ///
-  ///Currently, it is either \c LpGlpk or \c LpCplex
+  ///Currently, it is either \c LpGlpk, \c LpCplex, \c LpSoplex or \c LpClp
   typedef LpGlpk Lp;
-  ///The default LP solver identifier string
 
-  ///The default LP solver identifier string.
+  ///The default MIP solver identifier
+
+  ///The default MIP solver identifier.
   ///\ingroup lp_group
   ///
-  ///Currently, the possible values are "GLPK" or "CPLEX"
-  const char default_solver_name[]="SOLVER";
+  ///Currently, the possible values are \c MIP_GLPK or \c MIP_CPLEX
+#define LEMON_DEFAULT_MIP SOLVER
+  ///The default MIP solver.
 
-  ///The default ILP solver.
-
-  ///The default ILP solver.
+  ///The default MIP solver.
   ///\ingroup lp_group
   ///
-  ///Currently, it is either \c LpGlpk or \c LpCplex
+  ///Currently, it is either \c MipGlpk or \c MipCplex
   typedef MipGlpk Mip;
 #else
 #ifdef HAVE_GLPK
-#define DEFAULT_LP GLPK
+# define LEMON_DEFAULT_LP LP_GLPK
   typedef LpGlpk Lp;
+# define LEMON_DEFAULT_MIP MIP_GLPK
   typedef MipGlpk Mip;
-  const char default_solver_name[]="GLPK";
 #elif HAVE_CPLEX
-#define DEFAULT_LP CPLEX
+# define LEMON_DEFAULT_LP LP_CPLEX
   typedef LpCplex Lp;
+# define LEMON_DEFAULT_MIP MIP_CPLEX
   typedef MipCplex Mip;
-  const char default_solver_name[]="CPLEX";
 #elif HAVE_SOPLEX
-#define DEFAULT_LP SOPLEX
+# define DEFAULT_LP LP_SOPLEX
   typedef LpSoplex Lp;
-  const char default_solver_name[]="SOPLEX";
+#elif HAVE_CLP
+# define DEFAULT_LP LP_CLP
+  typedef LpClp Lp;  
 #endif
 #endif
 

lemon/lp_base.cc

@@ -22 +22 @@
 #include <lemon/lp_base.h>
 namespace lemon {
 
-  const LpBase::Value
-  SolverBase::INF = std::numeric_limits<Value>::infinity();
-  const LpBase::Value
-  SolverBase::NaN = std::numeric_limits<Value>::quiet_NaN();
-
-//   const LpBase::Constr::Value
-//   LpBase::Constr::INF = std::numeric_limits<Value>::infinity();
-//   const LpBase::Constr::Value
-//   LpBase::Constr::NaN = std::numeric_limits<Value>::quiet_NaN();
+  const LpBase::Value LpBase::INF = std::numeric_limits<Value>::infinity();
+  const LpBase::Value LpBase::NaN = std::numeric_limits<Value>::quiet_NaN();
 
 } //namespace lemon

lemon/lp_base.h

@@ -36 +36 @@
 ///\ingroup lp_group
 namespace lemon {
 
-  ///Common base class for LP solvers
+  ///Common base class for LP and MIP solvers
 
   ///\todo Much more docs
   ///\ingroup lp_group
-  class SolverBase {
+  class LpBase {
 
   protected:
 
@@ -90 +90 @@
     ///\todo Document what can one do with a Col (INVALID, comparing,
     ///it is similar to Node/Edge)
     class Col {
-      friend class SolverBase;
+      friend class LpBase;
     protected:
       int _id;
       explicit Col(int id) : _id(id) {}
@@ -105 +105 @@
     };
 
     class ColIt : public Col {
-      const SolverBase *_solver;
+      const LpBase *_solver;
     public:
       ColIt() {}
-      ColIt(const SolverBase &solver) : _solver(&solver)
+      ColIt(const LpBase &solver) : _solver(&solver)
       {
         _solver->cols.firstItem(_id);
       }
@@ -133 +133 @@
     ///\todo Document what can one do with a Row (INVALID, comparing,
     ///it is similar to Node/Edge)
     class Row {
-      friend class SolverBase;
+      friend class LpBase;
     protected:
       int _id;
       explicit Row(int id) : _id(id) {}
@@ -149 +149 @@
     };
 
     class RowIt : public Row {
-      const SolverBase *_solver;
+      const LpBase *_solver;
     public:
       RowIt() {}
-      RowIt(const SolverBase &solver) : _solver(&solver)
+      RowIt(const LpBase &solver) : _solver(&solver)
       {
         _solver->rows.firstItem(_id);
       }
@@ -184 +184 @@
     ///or you can also iterate through its elements.
     ///\code
     ///double s=0;
-    ///for(SolverBase::Expr::ConstMapIt i(e);i!=INVALID;++i)
+    ///for(LpBase::Expr::ConstCoeffIt i(e);i!=INVALID;++i)
     ///  s+=*i * primal(i);
     ///\endcode
     ///(This code computes the primal value of the expression).
@@ -216 +216 @@
     ///\sa Constr
     ///
     class Expr {
-      friend class SolverBase;
+      friend class LpBase;
     public:
-      typedef SolverBase::Col Key;
-      typedef SolverBase::Value Value;
+      typedef LpBase::Col Key;
+      typedef LpBase::Value Value;
 
     protected:
       Value const_comp;
@@ -264 +264 @@
       ///\e
       const Value& operator*() const { return const_comp; }
 
-      ///Removes the coefficients closer to zero than \c tolerance.
-      void simplify(Value tolerance = 0.0) {
+      ///Removes the coefficients closer to zero than \c epsilon.
+      void simplify(Value epsilon = 0.0) {
         std::map<int, Value>::iterator it=comps.begin();
         while (it != comps.end()) {
           std::map<int, Value>::iterator jt=it;
           ++jt;
-          if (std::fabs((*it).second) <= tolerance) comps.erase(it);
+          if (std::fabs((*it).second) <= epsilon) comps.erase(it);
           it=jt;
         }
-        if (std::fabs(const_comp) <= tolerance) const_comp = 0;
+        if (std::fabs(const_comp) <= epsilon) const_comp = 0;
       }
 
-      void simplify(Value tolerance = 0.0) const {
-        const_cast<Expr*>(this)->simplify(tolerance);
+      void simplify(Value epsilon = 0.0) const {
+        const_cast<Expr*>(this)->simplify(epsilon);
       }
 
       ///Sets all coefficients and the constant component to 0.
@@ -319 +319 @@
         return *this;
       }
 
-      class MapIt {
+      class CoeffIt {
       private:
 
         std::map<int, Value>::iterator _it, _end;
 
       public:
 
-        MapIt(Expr& e)
+        CoeffIt(Expr& e)
           : _it(e.comps.begin()), _end(e.comps.end()){}
 
         operator Col() const {
@@ -336 +336 @@
         Value& operator*() { return _it->second; }
         const Value& operator*() const { return _it->second; }
 
-        MapIt& operator++() { ++_it; return *this; }
+        CoeffIt& operator++() { ++_it; return *this; }
 
         bool operator==(Invalid) const { return _it == _end; }
         bool operator!=(Invalid) const { return _it != _end; }
       };
 
-      class ConstMapIt {
+      class ConstCoeffIt {
       private:
 
         std::map<int, Value>::const_iterator _it, _end;
 
       public:
 
-        ConstMapIt(const Expr& e)
+        ConstCoeffIt(const Expr& e)
           : _it(e.comps.begin()), _end(e.comps.end()){}
 
         operator Col() const {
@@ -358 +358 @@
 
         const Value& operator*() const { return _it->second; }
 
-        ConstMapIt& operator++() { ++_it; return *this; }
+        ConstCoeffIt& operator++() { ++_it; return *this; }
 
         bool operator==(Invalid) const { return _it == _end; }
         bool operator!=(Invalid) const { return _it != _end; }
@@ -395 +395 @@
     class Constr
     {
     public:
-      typedef SolverBase::Expr Expr;
+      typedef LpBase::Expr Expr;
       typedef Expr::Key Key;
       typedef Expr::Value Value;
 
@@ -406 +406 @@
       ///\e
       Constr() : _expr(), _lb(NaN), _ub(NaN) {}
       ///\e
-      Constr(Value lb,const Expr &e,Value ub) :
+      Constr(Value lb, const Expr &e, Value ub) :
         _expr(e), _lb(lb), _ub(ub) {}
       Constr(const Expr &e) :
         _expr(e), _lb(NaN), _ub(NaN) {}
@@ -466 +466 @@
     ///or you can also iterate through its elements.
     ///\code
     ///double s=0;
-    ///for(SolverBase::DualExpr::ConstMapIt i(e);i!=INVALID;++i)
+    ///for(LpBase::DualExpr::ConstCoeffIt i(e);i!=INVALID;++i)
     ///  s+=*i;
     ///\endcode
     ///(This code computes the sum of all coefficients).
@@ -490 +490 @@
     ///\sa Expr
     ///
     class DualExpr {
-      friend class SolverBase;
+      friend class LpBase;
     public:
-      typedef SolverBase::Row Key;
-      typedef SolverBase::Value Value;
+      typedef LpBase::Row Key;
+      typedef LpBase::Value Value;
 
     protected:
       std::map<int, Value> comps;
@@ -530 +530 @@
         }
       }
 
-      ///Removes the coefficients closer to zero than \c tolerance.
-      void simplify(Value tolerance = 0.0) {
+      ///Removes the coefficients closer to zero than \c epsilon.
+      void simplify(Value epsilon = 0.0) {
         std::map<int, Value>::iterator it=comps.begin();
         while (it != comps.end()) {
           std::map<int, Value>::iterator jt=it;
           ++jt;
-          if (std::fabs((*it).second) <= tolerance) comps.erase(it);
+          if (std::fabs((*it).second) <= epsilon) comps.erase(it);
           it=jt;
         }
       }
 
-      void simplify(Value tolerance = 0.0) const {
-        const_cast<DualExpr*>(this)->simplify(tolerance);
+      void simplify(Value epsilon = 0.0) const {
+        const_cast<DualExpr*>(this)->simplify(epsilon);
       }
 
       ///Sets all coefficients to 0.
@@ -579 +579 @@
         return *this;
       }
 
-      class MapIt {
+      class CoeffIt {
       private:
 
         std::map<int, Value>::iterator _it, _end;
 
       public:
 
-        MapIt(DualExpr& e)
+        CoeffIt(DualExpr& e)
           : _it(e.comps.begin()), _end(e.comps.end()){}
 
         operator Row() const {
@@ -596 +596 @@
         Value& operator*() { return _it->second; }
         const Value& operator*() const { return _it->second; }
 
-        MapIt& operator++() { ++_it; return *this; }
+        CoeffIt& operator++() { ++_it; return *this; }
 
         bool operator==(Invalid) const { return _it == _end; }
         bool operator!=(Invalid) const { return _it != _end; }
       };
 
-      class ConstMapIt {
+      class ConstCoeffIt {
       private:
 
         std::map<int, Value>::const_iterator _it, _end;
 
       public:
 
-        ConstMapIt(const DualExpr& e)
+        ConstCoeffIt(const DualExpr& e)
           : _it(e.comps.begin()), _end(e.comps.end()){}
 
         operator Row() const {
@@ -618 +618 @@
 
         const Value& operator*() const { return _it->second; }
 
-        ConstMapIt& operator++() { ++_it; return *this; }
+        ConstCoeffIt& operator++() { ++_it; return *this; }
 
         bool operator==(Invalid) const { return _it == _end; }
         bool operator!=(Invalid) const { return _it != _end; }
@@ -712 +712 @@
   protected:
 
     //Abstract virtual functions
-    virtual SolverBase* _newSolver() const = 0;
-    virtual SolverBase* _cloneSolver() const = 0;
+    virtual LpBase* _newSolver() const = 0;
+    virtual LpBase* _cloneSolver() const = 0;
 
     virtual int _addColId(int col) { return cols.addIndex(col); }
     virtual int _addRowId(int row) { return rows.addIndex(row); }
@@ -767 +767 @@
 
     virtual void _clear() = 0;
 
+    virtual const char* _solverName() const = 0;
+
     //Own protected stuff
 
     //Constant component of the objective function
@@ -775 +777 @@
   public:
 
     ///\e
-    SolverBase() : rows(), cols(), obj_const_comp(0) {
+    LpBase() : rows(), cols(), obj_const_comp(0) {
     }
 
     ///\e
-    virtual ~SolverBase() {}
+    virtual ~LpBase() {}
 
     ///Creates a new LP problem
-    SolverBase* newSolver() {return _newSolver();}
+    LpBase* newSolver() {return _newSolver();}
     ///Makes a copy of the LP problem
-    SolverBase* cloneSolver() {return _cloneSolver();}
+    LpBase* cloneSolver() {return _cloneSolver();}
+
+    ///Gives back the name of the solver.
+    const char* solverName() const {return _solverName();}
 
     ///\name Build up and modify the LP
 
@@ -804 +809 @@
     ///\ref Col as its \c values_type
     ///like
     ///\code
-    ///std::vector<SolverBase::Col>
-    ///std::list<SolverBase::Col>
+    ///std::vector<LpBase::Col>
+    ///std::list<LpBase::Col>
     ///\endcode
     ///- a standard STL compatible iterable container with
     ///\ref Col as its \c mapped_type
     ///like
     ///\code
-    ///std::map<AnyType,SolverBase::Col>
+    ///std::map<AnyType,LpBase::Col>
     ///\endcode
     ///- an iterable lemon \ref concepts::WriteMap "write map" like
     ///\code
-    ///ListGraph::NodeMap<SolverBase::Col>
-    ///ListGraph::ArcMap<SolverBase::Col>
+    ///ListGraph::NodeMap<LpBase::Col>
+    ///ListGraph::ArcMap<LpBase::Col>
     ///\endcode
     ///\return The number of the created column.
 #ifdef DOXYGEN
@@ -906 +911 @@
     ///\ref Row as its \c values_type
     ///like
     ///\code
-    ///std::vector<SolverBase::Row>
-    ///std::list<SolverBase::Row>
+    ///std::vector<LpBase::Row>
+    ///std::list<LpBase::Row>
     ///\endcode
     ///- a standard STL compatible iterable container with
     ///\ref Row as its \c mapped_type
     ///like
     ///\code
-    ///std::map<AnyType,SolverBase::Row>
+    ///std::map<AnyType,LpBase::Row>
     ///\endcode
     ///- an iterable lemon \ref concepts::WriteMap "write map" like
     ///\code
-    ///ListGraph::NodeMap<SolverBase::Row>
-    ///ListGraph::ArcMap<SolverBase::Row>
+    ///ListGraph::NodeMap<LpBase::Row>
+    ///ListGraph::ArcMap<LpBase::Row>
     ///\endcode
     ///\return The number of rows created.
 #ifdef DOXYGEN
@@ -1341 +1346 @@
 
   };
 
-  ///\relates SolverBase::Expr
+  ///\relates LpBase::Expr
   ///
-  inline SolverBase::Expr operator+(const SolverBase::Expr &a,
-                                    const SolverBase::Expr &b) {
-    SolverBase::Expr tmp(a);
+  inline LpBase::Expr operator+(const LpBase::Expr &a,
+                                const LpBase::Expr &b) {
+    LpBase::Expr tmp(a);
     tmp+=b;
     return tmp;
   }
   ///\e
 
-  ///\relates SolverBase::Expr
+  ///\relates LpBase::Expr
   ///
-  inline SolverBase::Expr operator-(const SolverBase::Expr &a,
-                                    const SolverBase::Expr &b) {
-    SolverBase::Expr tmp(a);
+  inline LpBase::Expr operator-(const LpBase::Expr &a,
+                                const LpBase::Expr &b) {
+    LpBase::Expr tmp(a);
     tmp-=b;
     return tmp;
   }
   ///\e
 
-  ///\relates SolverBase::Expr
+  ///\relates LpBase::Expr
   ///
-  inline SolverBase::Expr operator*(const SolverBase::Expr &a,
-                                    const SolverBase::Value &b) {
-    SolverBase::Expr tmp(a);
+  inline LpBase::Expr operator*(const LpBase::Expr &a,
+                                const LpBase::Value &b) {
+    LpBase::Expr tmp(a);
     tmp*=b;
     return tmp;
   }
 
   ///\e
 
-  ///\relates SolverBase::Expr
+  ///\relates LpBase::Expr
   ///
-  inline SolverBase::Expr operator*(const SolverBase::Value &a,
-                                    const SolverBase::Expr &b) {
-    SolverBase::Expr tmp(b);
+  inline LpBase::Expr operator*(const LpBase::Value &a,
+                                const LpBase::Expr &b) {
+    LpBase::Expr tmp(b);
     tmp*=a;
     return tmp;
   }
   ///\e
 
-  ///\relates SolverBase::Expr
+  ///\relates LpBase::Expr
   ///
-  inline SolverBase::Expr operator/(const SolverBase::Expr &a,
-                                    const SolverBase::Value &b) {
-    SolverBase::Expr tmp(a);
+  inline LpBase::Expr operator/(const LpBase::Expr &a,
+                                const LpBase::Value &b) {
+    LpBase::Expr tmp(a);
     tmp/=b;
     return tmp;
   }
 
   ///\e
 
-  ///\relates SolverBase::Constr
+  ///\relates LpBase::Constr
   ///
-  inline SolverBase::Constr operator<=(const SolverBase::Expr &e,
-                                       const SolverBase::Expr &f) {
-    return SolverBase::Constr(0, f - e, SolverBase::INF);
+  inline LpBase::Constr operator<=(const LpBase::Expr &e,
+                                   const LpBase::Expr &f) {
+    return LpBase::Constr(0, f - e, LpBase::INF);
   }
 
   ///\e
 
-  ///\relates SolverBase::Constr
+  ///\relates LpBase::Constr
   ///
-  inline SolverBase::Constr operator<=(const SolverBase::Value &e,
-                                       const SolverBase::Expr &f) {
-    return SolverBase::Constr(e, f, SolverBase::NaN);
+  inline LpBase::Constr operator<=(const LpBase::Value &e,
+                                   const LpBase::Expr &f) {
+    return LpBase::Constr(e, f, LpBase::NaN);
   }
 
   ///\e
 
-  ///\relates SolverBase::Constr
+  ///\relates LpBase::Constr
   ///
-  inline SolverBase::Constr operator<=(const SolverBase::Expr &e,
-                                       const SolverBase::Value &f) {
-    return SolverBase::Constr(- SolverBase::INF, e, f);
+  inline LpBase::Constr operator<=(const LpBase::Expr &e,
+                                   const LpBase::Value &f) {
+    return LpBase::Constr(- LpBase::INF, e, f);
   }
 
   ///\e
 
-  ///\relates SolverBase::Constr
+  ///\relates LpBase::Constr
   ///
-  inline SolverBase::Constr operator>=(const SolverBase::Expr &e,
-                                       const SolverBase::Expr &f) {
-    return SolverBase::Constr(0, e - f, SolverBase::INF);
+  inline LpBase::Constr operator>=(const LpBase::Expr &e,
+                                   const LpBase::Expr &f) {
+    return LpBase::Constr(0, e - f, LpBase::INF);
   }
 
 
   ///\e
 
-  ///\relates SolverBase::Constr
+  ///\relates LpBase::Constr
   ///
-  inline SolverBase::Constr operator>=(const SolverBase::Value &e,
-                                       const SolverBase::Expr &f) {
-    return SolverBase::Constr(SolverBase::NaN, f, e);
+  inline LpBase::Constr operator>=(const LpBase::Value &e,
+                                   const LpBase::Expr &f) {
+    return LpBase::Constr(LpBase::NaN, f, e);
   }
 
 
   ///\e
 
-  ///\relates SolverBase::Constr
+  ///\relates LpBase::Constr
   ///
-  inline SolverBase::Constr operator>=(const SolverBase::Expr &e,
-                                       const SolverBase::Value &f) {
-    return SolverBase::Constr(f, e, SolverBase::INF);
+  inline LpBase::Constr operator>=(const LpBase::Expr &e,
+                                   const LpBase::Value &f) {
+    return LpBase::Constr(f, e, LpBase::INF);
   }
 
   ///\e
 
-  ///\relates SolverBase::Constr
+  ///\relates LpBase::Constr
   ///
-  inline SolverBase::Constr operator==(const SolverBase::Expr &e,
-                                       const SolverBase::Value &f) {
-    return SolverBase::Constr(f, e, f);
+  inline LpBase::Constr operator==(const LpBase::Expr &e,
+                                   const LpBase::Value &f) {
+    return LpBase::Constr(f, e, f);
   }
 
   ///\e
 
-  ///\relates SolverBase::Constr
+  ///\relates LpBase::Constr
   ///
-  inline SolverBase::Constr operator==(const SolverBase::Expr &e,
-                                       const SolverBase::Expr &f) {
-    return SolverBase::Constr(0, f - e, 0);
+  inline LpBase::Constr operator==(const LpBase::Expr &e,
+                                   const LpBase::Expr &f) {
+    return LpBase::Constr(0, f - e, 0);
   }
 
   ///\e
 
-  ///\relates SolverBase::Constr
+  ///\relates LpBase::Constr
   ///
-  inline SolverBase::Constr operator<=(const SolverBase::Value &n,
-                                       const SolverBase::Constr &c) {
-    SolverBase::Constr tmp(c);
+  inline LpBase::Constr operator<=(const LpBase::Value &n,
+                                   const LpBase::Constr &c) {
+    LpBase::Constr tmp(c);
     LEMON_ASSERT(std::isnan(tmp.lowerBound()), "Wrong LP constraint");
     tmp.lowerBound()=n;
     return tmp;
   }
   ///\e
 
-  ///\relates SolverBase::Constr
+  ///\relates LpBase::Constr
   ///
-  inline SolverBase::Constr operator<=(const SolverBase::Constr &c,
-                                       const SolverBase::Value &n)
+  inline LpBase::Constr operator<=(const LpBase::Constr &c,
+                                   const LpBase::Value &n)
   {
-    SolverBase::Constr tmp(c);
+    LpBase::Constr tmp(c);
     LEMON_ASSERT(std::isnan(tmp.upperBound()), "Wrong LP constraint");
     tmp.upperBound()=n;
     return tmp;
@@ -1491 +1496 @@
 
   ///\e
 
-  ///\relates SolverBase::Constr
+  ///\relates LpBase::Constr
   ///
-  inline SolverBase::Constr operator>=(const SolverBase::Value &n,
-                                       const SolverBase::Constr &c) {
-    SolverBase::Constr tmp(c);
+  inline LpBase::Constr operator>=(const LpBase::Value &n,
+                                   const LpBase::Constr &c) {
+    LpBase::Constr tmp(c);
     LEMON_ASSERT(std::isnan(tmp.upperBound()), "Wrong LP constraint");
     tmp.upperBound()=n;
     return tmp;
   }
   ///\e
 
-  ///\relates SolverBase::Constr
+  ///\relates LpBase::Constr
   ///
-  inline SolverBase::Constr operator>=(const SolverBase::Constr &c,
-                                       const SolverBase::Value &n)
+  inline LpBase::Constr operator>=(const LpBase::Constr &c,
+                                   const LpBase::Value &n)
   {
-    SolverBase::Constr tmp(c);
+    LpBase::Constr tmp(c);
     LEMON_ASSERT(std::isnan(tmp.lowerBound()), "Wrong LP constraint");
     tmp.lowerBound()=n;
     return tmp;
@@ -1515 +1520 @@
 
   ///\e
 
-  ///\relates SolverBase::DualExpr
+  ///\relates LpBase::DualExpr
   ///
-  inline SolverBase::DualExpr operator+(const SolverBase::DualExpr &a,
-                                        const SolverBase::DualExpr &b) {
-    SolverBase::DualExpr tmp(a);
+  inline LpBase::DualExpr operator+(const LpBase::DualExpr &a,
+                                    const LpBase::DualExpr &b) {
+    LpBase::DualExpr tmp(a);
     tmp+=b;
     return tmp;
   }
   ///\e
 
-  ///\relates SolverBase::DualExpr
+  ///\relates LpBase::DualExpr
   ///
-  inline SolverBase::DualExpr operator-(const SolverBase::DualExpr &a,
-                                        const SolverBase::DualExpr &b) {
-    SolverBase::DualExpr tmp(a);
+  inline LpBase::DualExpr operator-(const LpBase::DualExpr &a,
+                                    const LpBase::DualExpr &b) {
+    LpBase::DualExpr tmp(a);
     tmp-=b;
     return tmp;
   }
   ///\e
 
-  ///\relates SolverBase::DualExpr
+  ///\relates LpBase::DualExpr
   ///
-  inline SolverBase::DualExpr operator*(const SolverBase::DualExpr &a,
-                                        const SolverBase::Value &b) {
-    SolverBase::DualExpr tmp(a);
+  inline LpBase::DualExpr operator*(const LpBase::DualExpr &a,
+                                    const LpBase::Value &b) {
+    LpBase::DualExpr tmp(a);
     tmp*=b;
     return tmp;
   }
 
   ///\e
 
-  ///\relates SolverBase::DualExpr
+  ///\relates LpBase::DualExpr
   ///
-  inline SolverBase::DualExpr operator*(const SolverBase::Value &a,
-                                        const SolverBase::DualExpr &b) {
-    SolverBase::DualExpr tmp(b);
+  inline LpBase::DualExpr operator*(const LpBase::Value &a,
+                                    const LpBase::DualExpr &b) {
+    LpBase::DualExpr tmp(b);
     tmp*=a;
     return tmp;
   }
   ///\e
 
-  ///\relates SolverBase::DualExpr
+  ///\relates LpBase::DualExpr
   ///
-  inline SolverBase::DualExpr operator/(const SolverBase::DualExpr &a,
-                                        const SolverBase::Value &b) {
-    SolverBase::DualExpr tmp(a);
+  inline LpBase::DualExpr operator/(const LpBase::DualExpr &a,
+                                    const LpBase::Value &b) {
+    LpBase::DualExpr tmp(a);
     tmp/=b;
     return tmp;
   }
@@ -1569 +1574 @@
   ///
   /// \brief Common base class for LP solvers
   /// \todo Much more docs
-  class LpBase : virtual public SolverBase {
+  class LpSolver : virtual public LpBase {
   public:
 
     ///\e
@@ -1586 +1591 @@
       UNBOUNDED = 4
     };
 
+    ///\e
     enum VarStatus {
-      BASIC, FREE, LOWER, UPPER, FIXED
+      /// The variable is in the basis
+      BASIC, 
+      /// The variable is free, but not basic
+      FREE,
+      /// The variable has active lower bound 
+      LOWER,
+      /// The variable has active upper bound
+      UPPER,
+      /// The variable is non-basic and fixed
+      FIXED
     };
 
   protected:
@@ -1644 +1659 @@
     ///\e
     Value primal(const Expr& e) const {
       double res = *e;
-      for (Expr::ConstMapIt c(e); c != INVALID; ++c) {
+      for (Expr::ConstCoeffIt c(e); c != INVALID; ++c) {
         res += *c * primal(c);
       }
       return res;
@@ -1657 +1672 @@
     ///\e
     Value dual(const DualExpr& e) const {
       double res = 0.0;
-      for (DualExpr::ConstMapIt r(e); r != INVALID; ++r) {
+      for (DualExpr::ConstCoeffIt r(e); r != INVALID; ++r) {
         res += *r * dual(r);
       }
       return res;
@@ -1681 +1696 @@
     Value primal() const { return _getPrimalValue()+obj_const_comp;}
     ///@}
 
-    LpBase* newSolver() {return _newSolver();}
-    LpBase* cloneSolver() {return _cloneSolver();}
+    LpSolver* newSolver() {return _newSolver();}
+    LpSolver* cloneSolver() {return _cloneSolver();}
 
   protected:
 
-    virtual LpBase* _newSolver() const = 0;
-    virtual LpBase* _cloneSolver() const = 0;
+    virtual LpSolver* _newSolver() const = 0;
+    virtual LpSolver* _cloneSolver() const = 0;
   };
 
 
@@ -1695 +1710 @@
   ///
   /// \brief Common base class for MIP solvers
   /// \todo Much more docs
-  class MipBase : virtual public SolverBase {
+  class MipSolver : virtual public LpBase {
   public:
 
     ///\e
@@ -1799 +1814 @@
     ///\e
     Value sol(const Expr& e) const {
       double res = *e;
-      for (Expr::ConstMapIt c(e); c != INVALID; ++c) {
+      for (Expr::ConstCoeffIt c(e); c != INVALID; ++c) {
         res += *c * sol(c);
       }
       return res;
@@ -1823 +1838 @@
 
   public:
 
-    MipBase* newSolver() {return _newSolver();}
-    MipBase* cloneSolver() {return _cloneSolver();}
+    MipSolver* newSolver() {return _newSolver();}
+    MipSolver* cloneSolver() {return _cloneSolver();}
 
   protected:
 
-    virtual MipBase* _newSolver() const = 0;
-    virtual MipBase* _cloneSolver() const = 0;
+    virtual MipSolver* _newSolver() const = 0;
+    virtual MipSolver* _cloneSolver() const = 0;
   };
 
 

lemon/lp_clp.cc

@@ -65 +65 @@
     LpClp* copylp = new LpClp(*this);
     return copylp;
   }
+
+  const char* LpClp::_solverName() const { return "LpClp"; }
 
   int LpClp::_addCol() {
     _prob->addColumn(0, 0, 0, -COIN_DBL_MAX, COIN_DBL_MAX, 0.0);
@@ -311 +313 @@
     return _prob->primalColumnSolution()[i];
   }
   LpClp::Value LpClp::_getPrimalValue() const {
-    return _prob->rawObjectiveValue();
+    return _prob->objectiveValue();
   }
 
   LpClp::Value LpClp::_getDual(int i) const {
@@ -399 +401 @@
     }
   }
 
-  void LpClp::_setSense(SolverBase::Sense sense) {
+  void LpClp::_setSense(LpClp::Sense sense) {
     switch (sense) {
     case MIN:
       _prob->setOptimizationDirection(1);
@@ -410 +412 @@
     }
   }
 
-  SolverBase::Sense LpClp::_getSense() const {
+  LpClp::Sense LpClp::_getSense() const {
     double dir = _prob->optimizationDirection();
     if (dir > 0.0) {
       return MIN;

lemon/lp_clp.h

@@ -39 +39 @@
   /// Clp library is an object oriented lp solver library developed at
   /// the IBM. The CLP is part of the COIN-OR package and it can be
   /// used with Common Public License.
-  class LpClp : public LpBase {
+  class LpClp : public LpSolver {
   protected:
 
     ClpSimplex* _prob;
@@ -48 +48 @@
     std::map<std::string, int> _row_names_ref;
 
   public:
-
-    typedef LpBase Parent;
 
     /// \e
     LpClp();
@@ -69 +67 @@
   protected:
 
     virtual LpClp* _newSolver() const;
-    virtual LpClp* _cloneSolver() const ;
+    virtual LpClp* _cloneSolver() const;
+
+    virtual const char* _solverName() const;
 
     virtual int _addCol();
     virtual int _addRow();

lemon/lp_cplex.cc

@@ -69 +69 @@
     }
   }
 
-  CplexBase::CplexBase() : SolverBase() {
+  CplexBase::CplexBase() : LpBase() {
     int status;
     _prob = CPXcreateprob(cplexEnv(), &status, "Cplex problem");
   }
 
   CplexBase::CplexBase(const CplexEnv& env)
-    : SolverBase(), _env(env) {
+    : LpBase(), _env(env) {
     int status;
     _prob = CPXcreateprob(cplexEnv(), &status, "Cplex problem");
   }
 
   CplexBase::CplexBase(const CplexBase& cplex)
-    : SolverBase() {
+    : LpBase() {
     int status;
     _prob = CPXcloneprob(cplexEnv(), cplex._prob, &status);
     rows = cplex.rows;
@@ -395 +395 @@
     }
   }
 
-  void CplexBase::_setObjCoeff(int i, SolverBase::Value obj_coef)
+  void CplexBase::_setObjCoeff(int i, CplexBase::Value obj_coef)
   {
     CPXchgobj(cplexEnv(), _prob, 1, &i, &obj_coef);
   }
@@ -441 +441 @@
   // LpCplex members
 
   LpCplex::LpCplex()
-    : SolverBase(), CplexBase(), LpBase() {}
+    : LpBase(), CplexBase(), LpSolver() {}
 
   LpCplex::LpCplex(const CplexEnv& env)
-    : SolverBase(), CplexBase(env), LpBase() {}
+    : LpBase(), CplexBase(env), LpSolver() {}
 
   LpCplex::LpCplex(const LpCplex& other)
-    : SolverBase(), CplexBase(other), LpBase() {}
+    : LpBase(), CplexBase(other), LpSolver() {}
 
   LpCplex::~LpCplex() {}
 
   LpCplex* LpCplex::_newSolver() const { return new LpCplex; }
   LpCplex* LpCplex::_cloneSolver() const {return new LpCplex(*this); }
+
+  const char* LpCplex::_solverName() const { return "LpCplex"; }
 
   void LpCplex::_clear_temporals() {
     _col_status.clear();
@@ -796 +798 @@
   // MipCplex members
 
   MipCplex::MipCplex()
-    : SolverBase(), CplexBase(), MipBase() {
+    : LpBase(), CplexBase(), MipSolver() {
 
 #if CPX_VERSION < 800
     CPXchgprobtype(cplexEnv(),  _prob, CPXPROB_MIP);
@@ -806 +808 @@
   }
 
   MipCplex::MipCplex(const CplexEnv& env)
-    : SolverBase(), CplexBase(env), MipBase() {
+    : LpBase(), CplexBase(env), MipSolver() {
 
 #if CPX_VERSION < 800
     CPXchgprobtype(cplexEnv(),  _prob, CPXPROB_MIP);
@@ -817 +819 @@
   }
 
   MipCplex::MipCplex(const MipCplex& other)
-    : SolverBase(), CplexBase(other), MipBase() {}
+    : LpBase(), CplexBase(other), MipSolver() {}
 
   MipCplex::~MipCplex() {}
 
   MipCplex* MipCplex::_newSolver() const { return new MipCplex; }
   MipCplex* MipCplex::_cloneSolver() const {return new MipCplex(*this); }
+
+  const char* MipCplex::_solverName() const { return "MipCplex"; }
 
   void MipCplex::_setColType(int i, MipCplex::ColTypes col_type) {
 
@@ -843 +847 @@
     }
   }
 
-  MipBase::ColTypes MipCplex::_getColType(int i) const {
+  MipCplex::ColTypes MipCplex::_getColType(int i) const {
     char t;
     CPXgetctype (cplexEnv(), _prob, &t, i, i);
     switch (t) {

lemon/lp_cplex.h

@@ -77 +77 @@
 
   /// \brief Base interface for the CPLEX LP and MIP solver
   ///
-  /// This class implements the common interface of the CPLEX LP and MIP solver.
-  ///\ingroup lp_group
-  class CplexBase : virtual public SolverBase {
+  /// This class implements the common interface of the CPLEX LP and
+  /// MIP solvers.  
+  /// \ingroup lp_group
+  class CplexBase : virtual public LpBase {
   protected:
-
-    typedef SolverBase Parent;
 
     CplexEnv _env;
     cpxlp* _prob;
@@ -161 +160 @@
   ///
   /// This class implements an interface for the CPLEX LP solver.
   ///\ingroup lp_group
-  class LpCplex : public CplexBase, public LpBase {
+  class LpCplex : public CplexBase, public LpSolver {
   public:
     /// \e
     LpCplex();
@@ -189 +188 @@
 
     virtual LpCplex* _cloneSolver() const;
     virtual LpCplex* _newSolver() const;
+
+    virtual const char* _solverName() const;
 
     virtual SolveExitStatus _solve();
     virtual Value _getPrimal(int i) const;
@@ -221 +222 @@
   ///
   /// This class implements an interface for the CPLEX MIP solver.
   ///\ingroup lp_group
-  class MipCplex : public CplexBase, public MipBase {
+  class MipCplex : public CplexBase, public MipSolver {
   public:
     /// \e
     MipCplex();
@@ -237 +238 @@
     virtual MipCplex* _cloneSolver() const;
     virtual MipCplex* _newSolver() const;
 
+    virtual const char* _solverName() const;
+
     virtual ColTypes _getColType(int col) const;
     virtual void _setColType(int col, ColTypes col_type);
 

lemon/lp_glpk.cc

@@ -28 +28 @@
 
   // GlpkBase members
 
-  GlpkBase::GlpkBase() : SolverBase() {
+  GlpkBase::GlpkBase() : LpBase() {
     lp = glp_create_prob();
     glp_create_index(lp);
   }
 
-  GlpkBase::GlpkBase(const GlpkBase &other) : SolverBase() {
+  GlpkBase::GlpkBase(const GlpkBase &other) : LpBase() {
     lp = glp_create_prob();
     glp_copy_prob(lp, other.lp, GLP_ON);
     glp_create_index(lp);
@@ -232 +232 @@
 
   }
 
-  SolverBase::Value GlpkBase::_getCoeff(int ix, int jx) const {
+  GlpkBase::Value GlpkBase::_getCoeff(int ix, int jx) const {
 
     int length = glp_get_mat_row(lp, ix, 0, 0);
 
@@ -290 +290 @@
     }
   }
 
-  SolverBase::Value GlpkBase::_getColLowerBound(int i) const {
+  GlpkBase::Value GlpkBase::_getColLowerBound(int i) const {
     int b = glp_get_col_type(lp, i);
     switch (b) {
     case GLP_LO:
@@ -345 +345 @@
 
   }
 
-  SolverBase::Value GlpkBase::_getColUpperBound(int i) const {
+  GlpkBase::Value GlpkBase::_getColUpperBound(int i) const {
     int b = glp_get_col_type(lp, i);
       switch (b) {
       case GLP_UP:
@@ -398 +398 @@
 
   }
 
-  SolverBase::Value GlpkBase::_getRowLowerBound(int i) const {
+  GlpkBase::Value GlpkBase::_getRowLowerBound(int i) const {
     int b = glp_get_row_type(lp, i);
     switch (b) {
     case GLP_LO:
@@ -452 +452 @@
     }
   }
 
-  SolverBase::Value GlpkBase::_getRowUpperBound(int i) const {
+  GlpkBase::Value GlpkBase::_getRowUpperBound(int i) const {
     int b = glp_get_row_type(lp, i);
     switch (b) {
     case GLP_UP:
@@ -488 +488 @@
     glp_set_obj_coef(lp, i, obj_coef);
   }
 
-  SolverBase::Value GlpkBase::_getObjCoeff(int i) const {
+  GlpkBase::Value GlpkBase::_getObjCoeff(int i) const {
     //i = 0 means the constant term (shift)
     return glp_get_obj_coef(lp, i);
   }
 
-  void GlpkBase::_setSense(SolverBase::Sense sense) {
+  void GlpkBase::_setSense(GlpkBase::Sense sense) {
     switch (sense) {
     case MIN:
       glp_set_obj_dir(lp, GLP_MIN);
@@ -504 +504 @@
     }
   }
 
-  SolverBase::Sense GlpkBase::_getSense() const {
+  GlpkBase::Sense GlpkBase::_getSense() const {
     switch(glp_get_obj_dir(lp)) {
     case GLP_MIN:
       return MIN;
@@ -512 +512 @@
       return MAX;
     default:
       LEMON_ASSERT(false, "Wrong sense");
-      return SolverBase::Sense();
+      return GlpkBase::Sense();
     }
   }
 
@@ -525 +525 @@
   // LpGlpk members
 
   LpGlpk::LpGlpk()
-    : SolverBase(), GlpkBase(), LpBase() {
+    : LpBase(), GlpkBase(), LpSolver() {
     messageLevel(MESSAGE_NO_OUTPUT);
   }
 
   LpGlpk::LpGlpk(const LpGlpk& other)
-    : SolverBase(other), GlpkBase(other), LpBase(other) {
+    : LpBase(other), GlpkBase(other), LpSolver(other) {
     messageLevel(MESSAGE_NO_OUTPUT);
   }
 
   LpGlpk* LpGlpk::_newSolver() const { return new LpGlpk; }
-  LpGlpk* LpGlpk::_cloneSolver() const {return new LpGlpk(*this); }
+  LpGlpk* LpGlpk::_cloneSolver() const { return new LpGlpk(*this); }
+
+  const char* LpGlpk::_solverName() const { return "LpGlpk"; }
 
   void LpGlpk::_clear_temporals() {
     _primal_ray.clear();
@@ -822 +824 @@
   // MipGlpk members
 
   MipGlpk::MipGlpk()
-    : SolverBase(), GlpkBase(), MipBase() {
+    : LpBase(), GlpkBase(), MipSolver() {
     messageLevel(MESSAGE_NO_OUTPUT);
   }
 
   MipGlpk::MipGlpk(const MipGlpk& other)
-    : SolverBase(), GlpkBase(other), MipBase() {
+    : LpBase(), GlpkBase(other), MipSolver() {
     messageLevel(MESSAGE_NO_OUTPUT);
   }
 
@@ -941 +943 @@
   MipGlpk* MipGlpk::_newSolver() const { return new MipGlpk; }
   MipGlpk* MipGlpk::_cloneSolver() const {return new MipGlpk(*this); }
 
+  const char* MipGlpk::_solverName() const { return "MipGlpk"; }
+
   void MipGlpk::messageLevel(MessageLevel m) {
     _message_level = m;
   }

lemon/lp_glpk.h

@@ -39 +39 @@
   ///
   /// This class implements the common interface of the GLPK LP and MIP solver.
   /// \ingroup lp_group
-  class GlpkBase : virtual public SolverBase {
+  class GlpkBase : virtual public LpBase {
   protected:
 
     typedef glp_prob LPX;
     glp_prob* lp;
-
-    typedef LpBase Parent;
 
     GlpkBase();
     GlpkBase(const GlpkBase&);
@@ -121 +119 @@
   ///
   /// This class implements an interface for the GLPK LP solver.
   ///\ingroup lp_group
-  class LpGlpk : public GlpkBase, public LpBase {
+  class LpGlpk : public GlpkBase, public LpSolver {
   public:
 
     ///\e
@@ -141 +139 @@
     virtual LpGlpk* _cloneSolver() const;
     virtual LpGlpk* _newSolver() const;
 
-    ///\todo It should be clarified
-    ///
+    virtual const char* _solverName() const;
+
     virtual SolveExitStatus _solve();
     virtual Value _getPrimal(int i) const;
     virtual Value _getDual(int i) const;
@@ -205 +203 @@
   ///
   /// This class implements an interface for the GLPK MIP solver.
   ///\ingroup lp_group
-  class MipGlpk : public GlpkBase, public MipBase {
+  class MipGlpk : public GlpkBase, public MipSolver {
   public:
 
     ///\e
@@ -217 +215 @@
 
     virtual MipGlpk* _cloneSolver() const;
     virtual MipGlpk* _newSolver() const;
+
+    virtual const char* _solverName() const;
 
     virtual ColTypes _getColType(int col) const;
     virtual void _setColType(int col, ColTypes col_type);

lemon/lp_skeleton.cc

@@ -111 +111 @@
   LpSkeleton* LpSkeleton::_cloneSolver() const
   { return static_cast<LpSkeleton*>(0); }
 
+  const char* LpSkeleton::_solverName() const { return "LpSkeleton"; }
+
   MipSkeleton::SolveExitStatus MipSkeleton::_solve()
   { return SOLVED; }
 
@@ -126 +128 @@
   MipSkeleton* MipSkeleton::_cloneSolver() const
   { return static_cast<MipSkeleton*>(0); }
 
+  const char* MipSkeleton::_solverName() const { return "MipSkeleton"; }
+
 } //namespace lemon
 

lemon/lp_skeleton.h

@@ -26 +26 @@
 namespace lemon {
 
   ///A skeleton class to implement LP solver interfaces
-  class SkeletonSolverBase : public virtual SolverBase {
+  class SkeletonSolverBase : public virtual LpBase {
     int col_num,row_num;
 
   protected:
@@ -140 +140 @@
   ///
   /// This class implements an interface for a skeleton LP solver.
   ///\ingroup lp_group
-  class LpSkeleton : public SkeletonSolverBase, public LpBase {
+  class LpSkeleton : public SkeletonSolverBase, public LpSolver {
   public:
-    LpSkeleton() : SkeletonSolverBase(), LpBase() {}
+    LpSkeleton() : SkeletonSolverBase(), LpSolver() {}
 
   protected:
 
@@ -176 +176 @@
     virtual LpSkeleton* _newSolver() const;
     ///\e
     virtual LpSkeleton* _cloneSolver() const;
+    ///\e
+    virtual const char* _solverName() const;
 
   };
 
@@ -183 +185 @@
   ///
   /// This class implements an interface for a skeleton MIP solver.
   ///\ingroup lp_group
-  class MipSkeleton : public SkeletonSolverBase, public MipBase {
+  class MipSkeleton : public SkeletonSolverBase, public MipSolver {
   public:
-    MipSkeleton() : SkeletonSolverBase(), MipBase() {}
+    MipSkeleton() : SkeletonSolverBase(), MipSolver() {}
 
   protected:
     ///\e
@@ -217 +219 @@
 
     ///\e
     virtual MipSkeleton* _cloneSolver() const;
+    ///\e
+    virtual const char* _solverName() const;
 
   };
 

lemon/lp_soplex.cc

@@ -26 +26 @@
 ///\brief Implementation of the LEMON-SOPLEX lp solver interface.
 namespace lemon {
 
-  LpSoplex::LpSoplex()
-    : SolverBase(), LpBase() {
+  LpSoplex::LpSoplex() {
     soplex = new soplex::SoPlex;
   }
 
@@ -35 +34 @@
     delete soplex;
   }
 
-  LpSoplex::LpSoplex(const LpSoplex& lp)
-    : SolverBase(), LpBase() {
+  LpSoplex::LpSoplex(const LpSoplex& lp) {
     rows = lp.rows;
     cols = lp.cols;
 
@@ -65 +63 @@
     LpSoplex* newlp = new LpSoplex(*this);
     return newlp;
   }
+
+  const char* LpSoplex::_solverName() const { return "LpSoplex"; }
 
   int LpSoplex::_addCol() {
     soplex::LPCol c;

lemon/lp_soplex.h

@@ -43 +43 @@
   /// developed at the Konrad-Zuse-Zentrum für Informationstechnik
   /// Berlin (ZIB). You can find detailed information about it at the
   /// <tt>http://soplex.zib.de</tt> address.
-  class LpSoplex : public LpBase {
+  class LpSoplex : public LpSolver {
   private:
 
     soplex::SoPlex* soplex;
@@ -67 +67 @@
 
   public:
 
-    typedef LpBase Parent;
-
-
     /// \e
     LpSoplex();
     /// \e
@@ -80 +77 @@
   protected:
 
     virtual LpSoplex* _newSolver() const;
-    virtual LpSoplex* _cloneSolver() const ;
+    virtual LpSoplex* _cloneSolver() const;
+
+    virtual const char* _solverName() const;
 
     virtual int _addCol();
     virtual int _addRow();

test/lp_test.cc

@@ -43 +43 @@
 
 using namespace lemon;
 
-void lpTest(LpBase & lp)
+void lpTest(LpSolver& lp)
 {
 
-  typedef LpBase LP;
+  typedef LpSolver LP;
 
   std::vector<LP::Col> x(10);
   //  for(int i=0;i<10;i++) x.push_back(lp.addCol());
@@ -195 +195 @@
     tolerance=0.02;
     e.simplify(tolerance);
     buf << "Coeff. of p2 should be 0";
-    check(const_cast<const LpBase::Expr&>(e)[p2]==0, buf.str());
+    check(const_cast<const LpSolver::Expr&>(e)[p2]==0, buf.str());
 
 
   }
@@ -235 +235 @@
 
 }
 
-void solveAndCheck(LpBase& lp, LpBase::ProblemType stat,
+void solveAndCheck(LpSolver& lp, LpSolver::ProblemType stat,
                    double exp_opt) {
   using std::string;
   lp.solve();
@@ -245 +245 @@
 
   check(lp.primalType()==stat, buf.str());
 
-  if (stat ==  LpBase::OPTIMAL) {
+  if (stat ==  LpSolver::OPTIMAL) {
     std::ostringstream sbuf;
     sbuf << "Wrong optimal value: the right optimum is " << exp_opt;
     check(std::abs(lp.primal()-exp_opt) < 1e-3, sbuf.str());
   }
 }
 
-void aTest(LpBase & lp)
+void aTest(LpSolver & lp)
 {
-  typedef LpBase LP;
+  typedef LpSolver LP;
 
  //The following example is very simple
 
-  typedef LpBase::Row Row;
-  typedef LpBase::Col Col;
+  typedef LpSolver::Row Row;
+  typedef LpSolver::Col Col;
 
 
   Col x1 = lp.addCol();
@@ -285 +285 @@
   check(lp.coeff(upright,x1)==1,"The coefficient in question is 1!");
   check(lp.colLowerBound(x1)==0,
         "The lower bound for variable x1 should be 0.");
-  check(lp.colUpperBound(x1)==LpBase::INF,
+  check(lp.colUpperBound(x1)==LpSolver::INF,
         "The upper bound for variable x1 should be infty.");
-  check(lp.rowLowerBound(upright) == -LpBase::INF,
+  check(lp.rowLowerBound(upright) == -LpSolver::INF,
         "The lower bound for the first row should be -infty.");
   check(lp.rowUpperBound(upright)==1,
         "The upper bound for the first row should be 1.");
-  LpBase::Expr e = lp.row(upright);
+  LpSolver::Expr e = lp.row(upright);
   check(e[x1] == 1, "The first coefficient should 1.");
   check(e[x2] == 2, "The second coefficient should 1.");
 
@@ -300 +300 @@
   check(e[x1] == 1, "The first coefficient should 1.");
   check(e[x2] == 1, "The second coefficient should 1.");
 
-  LpBase::DualExpr de = lp.col(x1);
+  LpSolver::DualExpr de = lp.col(x1);
   check(  de[upright] == 1, "The first coefficient should 1.");
 
-  LpBase* clp = lp.cloneSolver();
+  LpSolver* clp = lp.cloneSolver();
 
   //Testing the problem retrieving routines
   check(clp->objCoeff(x1)==1,"First term should be 1 in the obj function!");
@@ -312 +312 @@
   //  std::cout<<lp.colLowerBound(x1)<<std::endl;
   check(clp->colLowerBound(x1)==0,
         "The lower bound for variable x1 should be 0.");
-  check(clp->colUpperBound(x1)==LpBase::INF,
+  check(clp->colUpperBound(x1)==LpSolver::INF,
         "The upper bound for variable x1 should be infty.");
 
-  check(lp.rowLowerBound(upright)==-LpBase::INF,
+  check(lp.rowLowerBound(upright)==-LpSolver::INF,
         "The lower bound for the first row should be -infty.");
   check(lp.rowUpperBound(upright)==1,
         "The upper bound for the first row should be 1.");
@@ -331 +331 @@
   //Maximization of x1+x2
   //over the triangle with vertices (0,0) (0,1) (1,0)
   double expected_opt=1;
-  solveAndCheck(lp, LpBase::OPTIMAL, expected_opt);
+  solveAndCheck(lp, LpSolver::OPTIMAL, expected_opt);
 
   //Minimization
   lp.sense(lp.MIN);
   expected_opt=0;
-  solveAndCheck(lp, LpBase::OPTIMAL, expected_opt);
+  solveAndCheck(lp, LpSolver::OPTIMAL, expected_opt);
 
   //Vertex (-1,0) instead of (0,0)
-  lp.colLowerBound(x1, -LpBase::INF);
+  lp.colLowerBound(x1, -LpSolver::INF);
   expected_opt=-1;
-  solveAndCheck(lp, LpBase::OPTIMAL, expected_opt);
+  solveAndCheck(lp, LpSolver::OPTIMAL, expected_opt);
 
   //Erase one constraint and return to maximization
   lp.erase(upright);
   lp.sense(lp.MAX);
-  expected_opt=LpBase::INF;
-  solveAndCheck(lp, LpBase::UNBOUNDED, expected_opt);
+  expected_opt=LpSolver::INF;
+  solveAndCheck(lp, LpSolver::UNBOUNDED, expected_opt);
 
   //Infeasibilty
   lp.addRow(x1+x2 <=-2);
-  solveAndCheck(lp, LpBase::INFEASIBLE, expected_opt);
+  solveAndCheck(lp, LpSolver::INFEASIBLE, expected_opt);
 
 }
 

test/mip_test.cc

@@ -34 +34 @@
 
 using namespace lemon;
 
-void solveAndCheck(MipBase& mip, MipBase::ProblemType stat,
+void solveAndCheck(MipSolver& mip, MipSolver::ProblemType stat,
                    double exp_opt) {
   using std::string;
 
@@ -47 +47 @@
   //  itoa(stat,buf1, 10);
   check(mip.type()==stat, buf.str());
 
-  if (stat ==  MipBase::OPTIMAL) {
+  if (stat ==  MipSolver::OPTIMAL) {
     std::ostringstream sbuf;
     buf << "Wrong optimal value: the right optimum is " << exp_opt;
     check(std::abs(mip.solValue()-exp_opt) < 1e-3, sbuf.str());
@@ -55 +55 @@
   }
 }
 
-void aTest(MipBase& mip)
+void aTest(MipSolver& mip)
 {
  //The following example is very simple
 
 
-  typedef MipBase::Row Row;
-  typedef MipBase::Col Col;
+  typedef MipSolver::Row Row;
+  typedef MipSolver::Col Col;
 
 
 
@@ -89 +89 @@
   //Maximization of x1
   //over the triangle with vertices (0,0),(4/5,2/5),(0,2)
   double expected_opt=4.0/5.0;
-  solveAndCheck(mip, MipBase::OPTIMAL, expected_opt);
+  solveAndCheck(mip, MipSolver::OPTIMAL, expected_opt);
 
   //Restrict x2 to integer
-  mip.colType(x2,MipBase::INTEGER);
+  mip.colType(x2,MipSolver::INTEGER);
   expected_opt=1.0/2.0;
-  solveAndCheck(mip, MipBase::OPTIMAL, expected_opt);
+  solveAndCheck(mip, MipSolver::OPTIMAL, expected_opt);
 
 
   //Restrict both to integer
-  mip.colType(x1,MipBase::INTEGER);
+  mip.colType(x1,MipSolver::INTEGER);
   expected_opt=0;
-  solveAndCheck(mip, MipBase::OPTIMAL, expected_opt);
+  solveAndCheck(mip, MipSolver::OPTIMAL, expected_opt);
 
 
 
@@ -111 +111 @@
 {
 
 #ifdef HAVE_GLPK
-  MipGlpk mip1;
-  aTest(mip1);
+  {
+    MipGlpk mip1;
+    aTest(mip1);
+  }
 #endif
 
 #ifdef HAVE_CPLEX
-  MipCplex mip2;
-  aTest(mip2);
+  try {
+    MipCplex mip2;
+    aTest(mip2);
+  } catch (CplexEnv::LicenseError& error) {
+#ifdef LEMON_FORCE_CPLEX_CHECK
+    check(false, error.what());
+#else
+    std::cerr << error.what() << std::endl;
+    std::cerr << "Cplex license check failed, lp check skipped" << std::endl;
+#endif
+  }
 #endif
 
   return 0;