Index: lemon/clp.cc
===================================================================
--- lemon/clp.cc	(revision 461)
+++ lemon/clp.cc	(revision 462)
@@ -22,5 +22,5 @@
 namespace lemon {
 
-  LpClp::LpClp() {
+  ClpLp::ClpLp() {
     _prob = new ClpSimplex();
     _init_temporals();
@@ -28,5 +28,5 @@
   }
 
-  LpClp::LpClp(const LpClp& other) {
+  ClpLp::ClpLp(const ClpLp& other) {
     _prob = new ClpSimplex(*other._prob);
     rows = other.rows;
@@ -36,15 +36,15 @@
   }
 
-  LpClp::~LpClp() {
+  ClpLp::~ClpLp() {
     delete _prob;
     _clear_temporals();
   }
 
-  void LpClp::_init_temporals() {
+  void ClpLp::_init_temporals() {
     _primal_ray = 0;
     _dual_ray = 0;
   }
 
-  void LpClp::_clear_temporals() {
+  void ClpLp::_clear_temporals() {
     if (_primal_ray) {
       delete[] _primal_ray;
@@ -57,22 +57,22 @@
   }
 
-  LpClp* LpClp::_newSolver() const {
-    LpClp* newlp = new LpClp;
+  ClpLp* ClpLp::_newSolver() const {
+    ClpLp* newlp = new ClpLp;
     return newlp;
   }
 
-  LpClp* LpClp::_cloneSolver() const {
-    LpClp* copylp = new LpClp(*this);
+  ClpLp* ClpLp::_cloneSolver() const {
+    ClpLp* copylp = new ClpLp(*this);
     return copylp;
   }
 
-  const char* LpClp::_solverName() const { return "LpClp"; }
-
-  int LpClp::_addCol() {
+  const char* ClpLp::_solverName() const { return "ClpLp"; }
+
+  int ClpLp::_addCol() {
     _prob->addColumn(0, 0, 0, -COIN_DBL_MAX, COIN_DBL_MAX, 0.0);
     return _prob->numberColumns() - 1;
   }
 
-  int LpClp::_addRow() {
+  int ClpLp::_addRow() {
     _prob->addRow(0, 0, 0, -COIN_DBL_MAX, COIN_DBL_MAX);
     return _prob->numberRows() - 1;
@@ -80,48 +80,48 @@
 
 
-  void LpClp::_eraseCol(int c) {
+  void ClpLp::_eraseCol(int c) {
     _col_names_ref.erase(_prob->getColumnName(c));
     _prob->deleteColumns(1, &c);
   }
 
-  void LpClp::_eraseRow(int r) {
+  void ClpLp::_eraseRow(int r) {
     _row_names_ref.erase(_prob->getRowName(r));
     _prob->deleteRows(1, &r);
   }
 
-  void LpClp::_eraseColId(int i) {
+  void ClpLp::_eraseColId(int i) {
     cols.eraseIndex(i);
     cols.shiftIndices(i);
   }
 
-  void LpClp::_eraseRowId(int i) {
+  void ClpLp::_eraseRowId(int i) {
     rows.eraseIndex(i);
     rows.shiftIndices(i);
   }
 
-  void LpClp::_getColName(int c, std::string& name) const {
+  void ClpLp::_getColName(int c, std::string& name) const {
     name = _prob->getColumnName(c);
   }
 
-  void LpClp::_setColName(int c, const std::string& name) {
+  void ClpLp::_setColName(int c, const std::string& name) {
     _prob->setColumnName(c, const_cast<std::string&>(name));
     _col_names_ref[name] = c;
   }
 
-  int LpClp::_colByName(const std::string& name) const {
+  int ClpLp::_colByName(const std::string& name) const {
     std::map<std::string, int>::const_iterator it = _col_names_ref.find(name);
     return it != _col_names_ref.end() ? it->second : -1;
   }
 
-  void LpClp::_getRowName(int r, std::string& name) const {
+  void ClpLp::_getRowName(int r, std::string& name) const {
     name = _prob->getRowName(r);
   }
 
-  void LpClp::_setRowName(int r, const std::string& name) {
+  void ClpLp::_setRowName(int r, const std::string& name) {
     _prob->setRowName(r, const_cast<std::string&>(name));
     _row_names_ref[name] = r;
   }
 
-  int LpClp::_rowByName(const std::string& name) const {
+  int ClpLp::_rowByName(const std::string& name) const {
     std::map<std::string, int>::const_iterator it = _row_names_ref.find(name);
     return it != _row_names_ref.end() ? it->second : -1;
@@ -129,5 +129,5 @@
 
 
-  void LpClp::_setRowCoeffs(int ix, ExprIterator b, ExprIterator e) {
+  void ClpLp::_setRowCoeffs(int ix, ExprIterator b, ExprIterator e) {
     std::map<int, Value> coeffs;
 
@@ -157,5 +157,5 @@
   }
 
-  void LpClp::_getRowCoeffs(int ix, InsertIterator b) const {
+  void ClpLp::_getRowCoeffs(int ix, InsertIterator b) const {
     int n = _prob->clpMatrix()->getNumCols();
 
@@ -174,5 +174,5 @@
   }
 
-  void LpClp::_setColCoeffs(int ix, ExprIterator b, ExprIterator e) {
+  void ClpLp::_setColCoeffs(int ix, ExprIterator b, ExprIterator e) {
     std::map<int, Value> coeffs;
 
@@ -197,5 +197,5 @@
   }
 
-  void LpClp::_getColCoeffs(int ix, InsertIterator b) const {
+  void ClpLp::_getColCoeffs(int ix, InsertIterator b) const {
     CoinBigIndex begin = _prob->clpMatrix()->getVectorStarts()[ix];
     CoinBigIndex end = begin + _prob->clpMatrix()->getVectorLengths()[ix];
@@ -210,9 +210,9 @@
   }
 
-  void LpClp::_setCoeff(int ix, int jx, Value value) {
+  void ClpLp::_setCoeff(int ix, int jx, Value value) {
     _prob->modifyCoefficient(ix, jx, value);
   }
 
-  LpClp::Value LpClp::_getCoeff(int ix, int jx) const {
+  ClpLp::Value ClpLp::_getCoeff(int ix, int jx) const {
     CoinBigIndex begin = _prob->clpMatrix()->getVectorStarts()[ix];
     CoinBigIndex end = begin + _prob->clpMatrix()->getVectorLengths()[ix];
@@ -229,41 +229,41 @@
   }
 
-  void LpClp::_setColLowerBound(int i, Value lo) {
+  void ClpLp::_setColLowerBound(int i, Value lo) {
     _prob->setColumnLower(i, lo == - INF ? - COIN_DBL_MAX : lo);
   }
 
-  LpClp::Value LpClp::_getColLowerBound(int i) const {
+  ClpLp::Value ClpLp::_getColLowerBound(int i) const {
     double val = _prob->getColLower()[i];
     return val == - COIN_DBL_MAX ? - INF : val;
   }
 
-  void LpClp::_setColUpperBound(int i, Value up) {
+  void ClpLp::_setColUpperBound(int i, Value up) {
     _prob->setColumnUpper(i, up == INF ? COIN_DBL_MAX : up);
   }
 
-  LpClp::Value LpClp::_getColUpperBound(int i) const {
+  ClpLp::Value ClpLp::_getColUpperBound(int i) const {
     double val = _prob->getColUpper()[i];
     return val == COIN_DBL_MAX ? INF : val;
   }
 
-  void LpClp::_setRowLowerBound(int i, Value lo) {
+  void ClpLp::_setRowLowerBound(int i, Value lo) {
     _prob->setRowLower(i, lo == - INF ? - COIN_DBL_MAX : lo);
   }
 
-  LpClp::Value LpClp::_getRowLowerBound(int i) const {
+  ClpLp::Value ClpLp::_getRowLowerBound(int i) const {
     double val = _prob->getRowLower()[i];
     return val == - COIN_DBL_MAX ? - INF : val;
   }
 
-  void LpClp::_setRowUpperBound(int i, Value up) {
+  void ClpLp::_setRowUpperBound(int i, Value up) {
     _prob->setRowUpper(i, up == INF ? COIN_DBL_MAX : up);
   }
 
-  LpClp::Value LpClp::_getRowUpperBound(int i) const {
+  ClpLp::Value ClpLp::_getRowUpperBound(int i) const {
     double val = _prob->getRowUpper()[i];
     return val == COIN_DBL_MAX ? INF : val;
   }
 
-  void LpClp::_setObjCoeffs(ExprIterator b, ExprIterator e) {
+  void ClpLp::_setObjCoeffs(ExprIterator b, ExprIterator e) {
     int num = _prob->clpMatrix()->getNumCols();
     for (int i = 0; i < num; ++i) {
@@ -275,5 +275,5 @@
   }
 
-  void LpClp::_getObjCoeffs(InsertIterator b) const {
+  void ClpLp::_getObjCoeffs(InsertIterator b) const {
     int num = _prob->clpMatrix()->getNumCols();
     for (int i = 0; i < num; ++i) {
@@ -286,40 +286,40 @@
   }
 
-  void LpClp::_setObjCoeff(int i, Value obj_coef) {
+  void ClpLp::_setObjCoeff(int i, Value obj_coef) {
     _prob->setObjectiveCoefficient(i, obj_coef);
   }
 
-  LpClp::Value LpClp::_getObjCoeff(int i) const {
+  ClpLp::Value ClpLp::_getObjCoeff(int i) const {
     return _prob->getObjCoefficients()[i];
   }
 
-  LpClp::SolveExitStatus LpClp::_solve() {
+  ClpLp::SolveExitStatus ClpLp::_solve() {
     return _prob->primal() >= 0 ? SOLVED : UNSOLVED;
   }
 
-  LpClp::SolveExitStatus LpClp::solvePrimal() {
+  ClpLp::SolveExitStatus ClpLp::solvePrimal() {
     return _prob->primal() >= 0 ? SOLVED : UNSOLVED;
   }
 
-  LpClp::SolveExitStatus LpClp::solveDual() {
+  ClpLp::SolveExitStatus ClpLp::solveDual() {
     return _prob->dual() >= 0 ? SOLVED : UNSOLVED;
   }
 
-  LpClp::SolveExitStatus LpClp::solveBarrier() {
+  ClpLp::SolveExitStatus ClpLp::solveBarrier() {
     return _prob->barrier() >= 0 ? SOLVED : UNSOLVED;
   }
 
-  LpClp::Value LpClp::_getPrimal(int i) const {
+  ClpLp::Value ClpLp::_getPrimal(int i) const {
     return _prob->primalColumnSolution()[i];
   }
-  LpClp::Value LpClp::_getPrimalValue() const {
+  ClpLp::Value ClpLp::_getPrimalValue() const {
     return _prob->objectiveValue();
   }
 
-  LpClp::Value LpClp::_getDual(int i) const {
+  ClpLp::Value ClpLp::_getDual(int i) const {
     return _prob->dualRowSolution()[i];
   }
 
-  LpClp::Value LpClp::_getPrimalRay(int i) const {
+  ClpLp::Value ClpLp::_getPrimalRay(int i) const {
     if (!_primal_ray) {
       _primal_ray = _prob->unboundedRay();
@@ -329,5 +329,5 @@
   }
 
-  LpClp::Value LpClp::_getDualRay(int i) const {
+  ClpLp::Value ClpLp::_getDualRay(int i) const {
     if (!_dual_ray) {
       _dual_ray = _prob->infeasibilityRay();
@@ -337,5 +337,5 @@
   }
 
-  LpClp::VarStatus LpClp::_getColStatus(int i) const {
+  ClpLp::VarStatus ClpLp::_getColStatus(int i) const {
     switch (_prob->getColumnStatus(i)) {
     case ClpSimplex::basic:
@@ -357,5 +357,5 @@
   }
 
-  LpClp::VarStatus LpClp::_getRowStatus(int i) const {
+  ClpLp::VarStatus ClpLp::_getRowStatus(int i) const {
     switch (_prob->getColumnStatus(i)) {
     case ClpSimplex::basic:
@@ -378,5 +378,5 @@
 
 
-  LpClp::ProblemType LpClp::_getPrimalType() const {
+  ClpLp::ProblemType ClpLp::_getPrimalType() const {
     if (_prob->isProvenOptimal()) {
       return OPTIMAL;
@@ -390,5 +390,5 @@
   }
 
-  LpClp::ProblemType LpClp::_getDualType() const {
+  ClpLp::ProblemType ClpLp::_getDualType() const {
     if (_prob->isProvenOptimal()) {
       return OPTIMAL;
@@ -402,5 +402,5 @@
   }
 
-  void LpClp::_setSense(LpClp::Sense sense) {
+  void ClpLp::_setSense(ClpLp::Sense sense) {
     switch (sense) {
     case MIN:
@@ -413,5 +413,5 @@
   }
 
-  LpClp::Sense LpClp::_getSense() const {
+  ClpLp::Sense ClpLp::_getSense() const {
     double dir = _prob->optimizationDirection();
     if (dir > 0.0) {
@@ -422,5 +422,5 @@
   }
 
-  void LpClp::_clear() {
+  void ClpLp::_clear() {
     delete _prob;
     _prob = new ClpSimplex();
@@ -431,5 +431,5 @@
   }
 
-  void LpClp::messageLevel(MessageLevel m) {
+  void ClpLp::messageLevel(MessageLevel m) {
     _prob->setLogLevel(static_cast<int>(m));
   }
Index: lemon/clp.h
===================================================================
--- lemon/clp.h	(revision 461)
+++ lemon/clp.h	(revision 462)
@@ -40,5 +40,5 @@
   /// the IBM. The CLP is part of the COIN-OR package and it can be
   /// used with Common Public License.
-  class LpClp : public LpSolver {
+  class ClpLp : public LpSolver {
   protected:
 
@@ -51,9 +51,9 @@
 
     /// \e
-    LpClp();
+    ClpLp();
     /// \e
-    LpClp(const LpClp&);
+    ClpLp(const ClpLp&);
     /// \e
-    ~LpClp();
+    ~ClpLp();
 
   protected:
@@ -67,6 +67,6 @@
   protected:
 
-    virtual LpClp* _newSolver() const;
-    virtual LpClp* _cloneSolver() const;
+    virtual ClpLp* _newSolver() const;
+    virtual ClpLp* _cloneSolver() const;
 
     virtual const char* _solverName() const;
Index: lemon/cplex.cc
===================================================================
--- lemon/cplex.cc	(revision 461)
+++ lemon/cplex.cc	(revision 462)
@@ -439,23 +439,23 @@
   }
 
-  // LpCplex members
-
-  LpCplex::LpCplex()
+  // CplexLp members
+
+  CplexLp::CplexLp()
     : LpBase(), CplexBase(), LpSolver() {}
 
-  LpCplex::LpCplex(const CplexEnv& env)
+  CplexLp::CplexLp(const CplexEnv& env)
     : LpBase(), CplexBase(env), LpSolver() {}
 
-  LpCplex::LpCplex(const LpCplex& other)
+  CplexLp::CplexLp(const CplexLp& other)
     : 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() {
+  CplexLp::~CplexLp() {}
+
+  CplexLp* CplexLp::_newSolver() const { return new CplexLp; }
+  CplexLp* CplexLp::_cloneSolver() const {return new CplexLp(*this); }
+
+  const char* CplexLp::_solverName() const { return "CplexLp"; }
+
+  void CplexLp::_clear_temporals() {
     _col_status.clear();
     _row_status.clear();
@@ -473,5 +473,5 @@
   // routines CPXsolninfo, CPXgetstat, and CPXsolution to obtain
   // further information about the status of the optimization.
-  LpCplex::SolveExitStatus LpCplex::convertStatus(int status) {
+  CplexLp::SolveExitStatus CplexLp::convertStatus(int status) {
 #if CPX_VERSION >= 800
     if (status == 0) {
@@ -506,25 +506,25 @@
   }
 
-  LpCplex::SolveExitStatus LpCplex::_solve() {
+  CplexLp::SolveExitStatus CplexLp::_solve() {
     _clear_temporals();
     return convertStatus(CPXlpopt(cplexEnv(), _prob));
   }
 
-  LpCplex::SolveExitStatus LpCplex::solvePrimal() {
+  CplexLp::SolveExitStatus CplexLp::solvePrimal() {
     _clear_temporals();
     return convertStatus(CPXprimopt(cplexEnv(), _prob));
   }
 
-  LpCplex::SolveExitStatus LpCplex::solveDual() {
+  CplexLp::SolveExitStatus CplexLp::solveDual() {
     _clear_temporals();
     return convertStatus(CPXdualopt(cplexEnv(), _prob));
   }
 
-  LpCplex::SolveExitStatus LpCplex::solveBarrier() {
+  CplexLp::SolveExitStatus CplexLp::solveBarrier() {
     _clear_temporals();
     return convertStatus(CPXbaropt(cplexEnv(), _prob));
   }
 
-  LpCplex::Value LpCplex::_getPrimal(int i) const {
+  CplexLp::Value CplexLp::_getPrimal(int i) const {
     Value x;
     CPXgetx(cplexEnv(), _prob, &x, i, i);
@@ -532,5 +532,5 @@
   }
 
-  LpCplex::Value LpCplex::_getDual(int i) const {
+  CplexLp::Value CplexLp::_getDual(int i) const {
     Value y;
     CPXgetpi(cplexEnv(), _prob, &y, i, i);
@@ -538,5 +538,5 @@
   }
 
-  LpCplex::Value LpCplex::_getPrimalValue() const {
+  CplexLp::Value CplexLp::_getPrimalValue() const {
     Value objval;
     CPXgetobjval(cplexEnv(), _prob, &objval);
@@ -544,5 +544,5 @@
   }
 
-  LpCplex::VarStatus LpCplex::_getColStatus(int i) const {
+  CplexLp::VarStatus CplexLp::_getColStatus(int i) const {
     if (_col_status.empty()) {
       _col_status.resize(CPXgetnumcols(cplexEnv(), _prob));
@@ -560,9 +560,9 @@
     default:
       LEMON_ASSERT(false, "Wrong column status");
-      return LpCplex::VarStatus();
-    }
-  }
-
-  LpCplex::VarStatus LpCplex::_getRowStatus(int i) const {
+      return CplexLp::VarStatus();
+    }
+  }
+
+  CplexLp::VarStatus CplexLp::_getRowStatus(int i) const {
     if (_row_status.empty()) {
       _row_status.resize(CPXgetnumrows(cplexEnv(), _prob));
@@ -582,9 +582,9 @@
     default:
       LEMON_ASSERT(false, "Wrong row status");
-      return LpCplex::VarStatus();
-    }
-  }
-
-  LpCplex::Value LpCplex::_getPrimalRay(int i) const {
+      return CplexLp::VarStatus();
+    }
+  }
+
+  CplexLp::Value CplexLp::_getPrimalRay(int i) const {
     if (_primal_ray.empty()) {
       _primal_ray.resize(CPXgetnumcols(cplexEnv(), _prob));
@@ -594,5 +594,5 @@
   }
 
-  LpCplex::Value LpCplex::_getDualRay(int i) const {
+  CplexLp::Value CplexLp::_getDualRay(int i) const {
     if (_dual_ray.empty()) {
 
@@ -687,5 +687,5 @@
 #endif
 
-  LpCplex::ProblemType LpCplex::_getPrimalType() const {
+  CplexLp::ProblemType CplexLp::_getPrimalType() const {
     // Unboundedness not treated well: the following is from cplex 9.0 doc
     // About Unboundedness
@@ -769,5 +769,5 @@
   // CPX_STAT_UNBOUNDED
 
-  LpCplex::ProblemType LpCplex::_getDualType() const {
+  CplexLp::ProblemType CplexLp::_getDualType() const {
     int stat = CPXgetstat(cplexEnv(), _prob);
 #if CPX_VERSION >= 800
@@ -796,7 +796,7 @@
   }
 
-  // MipCplex members
-
-  MipCplex::MipCplex()
+  // CplexMip members
+
+  CplexMip::CplexMip()
     : LpBase(), CplexBase(), MipSolver() {
 
@@ -808,5 +808,5 @@
   }
 
-  MipCplex::MipCplex(const CplexEnv& env)
+  CplexMip::CplexMip(const CplexEnv& env)
     : LpBase(), CplexBase(env), MipSolver() {
 
@@ -819,15 +819,15 @@
   }
 
-  MipCplex::MipCplex(const MipCplex& other)
+  CplexMip::CplexMip(const CplexMip& other)
     : 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) {
+  CplexMip::~CplexMip() {}
+
+  CplexMip* CplexMip::_newSolver() const { return new CplexMip; }
+  CplexMip* CplexMip::_cloneSolver() const {return new CplexMip(*this); }
+
+  const char* CplexMip::_solverName() const { return "CplexMip"; }
+
+  void CplexMip::_setColType(int i, CplexMip::ColTypes col_type) {
 
     // Note If a variable is to be changed to binary, a call to CPXchgbds
@@ -848,5 +848,5 @@
   }
 
-  MipCplex::ColTypes MipCplex::_getColType(int i) const {
+  CplexMip::ColTypes CplexMip::_getColType(int i) const {
     char t;
     CPXgetctype (cplexEnv(), _prob, &t, i, i);
@@ -863,5 +863,5 @@
   }
 
-  MipCplex::SolveExitStatus MipCplex::_solve() {
+  CplexMip::SolveExitStatus CplexMip::_solve() {
     int status;
     status = CPXmipopt (cplexEnv(), _prob);
@@ -874,5 +874,5 @@
 
 
-  MipCplex::ProblemType MipCplex::_getType() const {
+  CplexMip::ProblemType CplexMip::_getType() const {
 
     int stat = CPXgetstat(cplexEnv(), _prob);
@@ -910,5 +910,5 @@
   }
 
-  MipCplex::Value MipCplex::_getSol(int i) const {
+  CplexMip::Value CplexMip::_getSol(int i) const {
     Value x;
     CPXgetmipx(cplexEnv(), _prob, &x, i, i);
@@ -916,5 +916,5 @@
   }
 
-  MipCplex::Value MipCplex::_getSolValue() const {
+  CplexMip::Value CplexMip::_getSolValue() const {
     Value objval;
     CPXgetmipobjval(cplexEnv(), _prob, &objval);
Index: lemon/cplex.h
===================================================================
--- lemon/cplex.h	(revision 461)
+++ lemon/cplex.h	(revision 462)
@@ -161,14 +161,14 @@
   /// This class implements an interface for the CPLEX LP solver.
   ///\ingroup lp_group
-  class LpCplex : public CplexBase, public LpSolver {
-  public:
-    /// \e
-    LpCplex();
-    /// \e
-    LpCplex(const CplexEnv&);
-    /// \e
-    LpCplex(const LpCplex&);
-    /// \e
-    virtual ~LpCplex();
+  class CplexLp : public CplexBase, public LpSolver {
+  public:
+    /// \e
+    CplexLp();
+    /// \e
+    CplexLp(const CplexEnv&);
+    /// \e
+    CplexLp(const CplexLp&);
+    /// \e
+    virtual ~CplexLp();
 
   private:
@@ -187,6 +187,6 @@
   protected:
 
-    virtual LpCplex* _cloneSolver() const;
-    virtual LpCplex* _newSolver() const;
+    virtual CplexLp* _cloneSolver() const;
+    virtual CplexLp* _newSolver() const;
 
     virtual const char* _solverName() const;
@@ -223,19 +223,19 @@
   /// This class implements an interface for the CPLEX MIP solver.
   ///\ingroup lp_group
-  class MipCplex : public CplexBase, public MipSolver {
-  public:
-    /// \e
-    MipCplex();
-    /// \e
-    MipCplex(const CplexEnv&);
-    /// \e
-    MipCplex(const MipCplex&);
-    /// \e
-    virtual ~MipCplex();
-
-  protected:
-
-    virtual MipCplex* _cloneSolver() const;
-    virtual MipCplex* _newSolver() const;
+  class CplexMip : public CplexBase, public MipSolver {
+  public:
+    /// \e
+    CplexMip();
+    /// \e
+    CplexMip(const CplexEnv&);
+    /// \e
+    CplexMip(const CplexMip&);
+    /// \e
+    virtual ~CplexMip();
+
+  protected:
+
+    virtual CplexMip* _cloneSolver() const;
+    virtual CplexMip* _newSolver() const;
 
     virtual const char* _solverName() const;
Index: lemon/glpk.cc
===================================================================
--- lemon/glpk.cc	(revision 461)
+++ lemon/glpk.cc	(revision 462)
@@ -523,31 +523,31 @@
   }
 
-  // LpGlpk members
-
-  LpGlpk::LpGlpk()
+  // GlpkLp members
+
+  GlpkLp::GlpkLp()
     : LpBase(), GlpkBase(), LpSolver() {
     messageLevel(MESSAGE_NO_OUTPUT);
   }
 
-  LpGlpk::LpGlpk(const LpGlpk& other)
+  GlpkLp::GlpkLp(const GlpkLp& 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); }
-
-  const char* LpGlpk::_solverName() const { return "LpGlpk"; }
-
-  void LpGlpk::_clear_temporals() {
+  GlpkLp* GlpkLp::_newSolver() const { return new GlpkLp; }
+  GlpkLp* GlpkLp::_cloneSolver() const { return new GlpkLp(*this); }
+
+  const char* GlpkLp::_solverName() const { return "GlpkLp"; }
+
+  void GlpkLp::_clear_temporals() {
     _primal_ray.clear();
     _dual_ray.clear();
   }
 
-  LpGlpk::SolveExitStatus LpGlpk::_solve() {
+  GlpkLp::SolveExitStatus GlpkLp::_solve() {
     return solvePrimal();
   }
 
-  LpGlpk::SolveExitStatus LpGlpk::solvePrimal() {
+  GlpkLp::SolveExitStatus GlpkLp::solvePrimal() {
     _clear_temporals();
 
@@ -574,5 +574,5 @@
   }
 
-  LpGlpk::SolveExitStatus LpGlpk::solveDual() {
+  GlpkLp::SolveExitStatus GlpkLp::solveDual() {
     _clear_temporals();
 
@@ -600,17 +600,17 @@
   }
 
-  LpGlpk::Value LpGlpk::_getPrimal(int i) const {
+  GlpkLp::Value GlpkLp::_getPrimal(int i) const {
     return glp_get_col_prim(lp, i);
   }
 
-  LpGlpk::Value LpGlpk::_getDual(int i) const {
+  GlpkLp::Value GlpkLp::_getDual(int i) const {
     return glp_get_row_dual(lp, i);
   }
 
-  LpGlpk::Value LpGlpk::_getPrimalValue() const {
+  GlpkLp::Value GlpkLp::_getPrimalValue() const {
     return glp_get_obj_val(lp);
   }
 
-  LpGlpk::VarStatus LpGlpk::_getColStatus(int i) const {
+  GlpkLp::VarStatus GlpkLp::_getColStatus(int i) const {
     switch (glp_get_col_stat(lp, i)) {
     case GLP_BS:
@@ -626,9 +626,9 @@
     default:
       LEMON_ASSERT(false, "Wrong column status");
-      return LpGlpk::VarStatus();
-    }
-  }
-
-  LpGlpk::VarStatus LpGlpk::_getRowStatus(int i) const {
+      return GlpkLp::VarStatus();
+    }
+  }
+
+  GlpkLp::VarStatus GlpkLp::_getRowStatus(int i) const {
     switch (glp_get_row_stat(lp, i)) {
     case GLP_BS:
@@ -644,9 +644,9 @@
     default:
       LEMON_ASSERT(false, "Wrong row status");
-      return LpGlpk::VarStatus();
-    }
-  }
-
-  LpGlpk::Value LpGlpk::_getPrimalRay(int i) const {
+      return GlpkLp::VarStatus();
+    }
+  }
+
+  GlpkLp::Value GlpkLp::_getPrimalRay(int i) const {
     if (_primal_ray.empty()) {
       int row_num = glp_get_num_rows(lp);
@@ -700,5 +700,5 @@
   }
 
-  LpGlpk::Value LpGlpk::_getDualRay(int i) const {
+  GlpkLp::Value GlpkLp::_getDualRay(int i) const {
     if (_dual_ray.empty()) {
       int row_num = glp_get_num_rows(lp);
@@ -772,5 +772,5 @@
   }
 
-  LpGlpk::ProblemType LpGlpk::_getPrimalType() const {
+  GlpkLp::ProblemType GlpkLp::_getPrimalType() const {
     if (glp_get_status(lp) == GLP_OPT)
       return OPTIMAL;
@@ -789,9 +789,9 @@
     default:
       LEMON_ASSERT(false, "Wrong primal type");
-      return  LpGlpk::ProblemType();
-    }
-  }
-
-  LpGlpk::ProblemType LpGlpk::_getDualType() const {
+      return  GlpkLp::ProblemType();
+    }
+  }
+
+  GlpkLp::ProblemType GlpkLp::_getDualType() const {
     if (glp_get_status(lp) == GLP_OPT)
       return OPTIMAL;
@@ -810,29 +810,29 @@
     default:
       LEMON_ASSERT(false, "Wrong primal type");
-      return  LpGlpk::ProblemType();
-    }
-  }
-
-  void LpGlpk::presolver(bool b) {
+      return  GlpkLp::ProblemType();
+    }
+  }
+
+  void GlpkLp::presolver(bool b) {
     lpx_set_int_parm(lp, LPX_K_PRESOL, b ? 1 : 0);
   }
 
-  void LpGlpk::messageLevel(MessageLevel m) {
+  void GlpkLp::messageLevel(MessageLevel m) {
     _message_level = m;
   }
 
-  // MipGlpk members
-
-  MipGlpk::MipGlpk()
+  // GlpkMip members
+
+  GlpkMip::GlpkMip()
     : LpBase(), GlpkBase(), MipSolver() {
     messageLevel(MESSAGE_NO_OUTPUT);
   }
 
-  MipGlpk::MipGlpk(const MipGlpk& other)
+  GlpkMip::GlpkMip(const GlpkMip& other)
     : LpBase(), GlpkBase(other), MipSolver() {
     messageLevel(MESSAGE_NO_OUTPUT);
   }
 
-  void MipGlpk::_setColType(int i, MipGlpk::ColTypes col_type) {
+  void GlpkMip::_setColType(int i, GlpkMip::ColTypes col_type) {
     switch (col_type) {
     case INTEGER:
@@ -845,5 +845,5 @@
   }
 
-  MipGlpk::ColTypes MipGlpk::_getColType(int i) const {
+  GlpkMip::ColTypes GlpkMip::_getColType(int i) const {
     switch (glp_get_col_kind(lp, i)) {
     case GLP_IV:
@@ -856,5 +856,5 @@
   }
 
-  MipGlpk::SolveExitStatus MipGlpk::_solve() {
+  GlpkMip::SolveExitStatus GlpkMip::_solve() {
     glp_smcp smcp;
     glp_init_smcp(&smcp);
@@ -902,5 +902,5 @@
 
 
-  MipGlpk::ProblemType MipGlpk::_getType() const {
+  GlpkMip::ProblemType GlpkMip::_getType() const {
     switch (glp_get_status(lp)) {
     case GLP_OPT:
@@ -916,5 +916,5 @@
       default:
         LEMON_ASSERT(false, "Wrong problem type.");
-        return MipGlpk::ProblemType();
+        return GlpkMip::ProblemType();
       }
     case GLP_NOFEAS:
@@ -929,22 +929,22 @@
     default:
       LEMON_ASSERT(false, "Wrong problem type.");
-      return MipGlpk::ProblemType();
-    }
-  }
-
-  MipGlpk::Value MipGlpk::_getSol(int i) const {
+      return GlpkMip::ProblemType();
+    }
+  }
+
+  GlpkMip::Value GlpkMip::_getSol(int i) const {
     return glp_mip_col_val(lp, i);
   }
 
-  MipGlpk::Value MipGlpk::_getSolValue() const {
+  GlpkMip::Value GlpkMip::_getSolValue() const {
     return glp_mip_obj_val(lp);
   }
 
-  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) {
+  GlpkMip* GlpkMip::_newSolver() const { return new GlpkMip; }
+  GlpkMip* GlpkMip::_cloneSolver() const {return new GlpkMip(*this); }
+
+  const char* GlpkMip::_solverName() const { return "GlpkMip"; }
+
+  void GlpkMip::messageLevel(MessageLevel m) {
     _message_level = m;
   }
Index: lemon/glpk.h
===================================================================
--- lemon/glpk.h	(revision 461)
+++ lemon/glpk.h	(revision 462)
@@ -120,11 +120,11 @@
   /// This class implements an interface for the GLPK LP solver.
   ///\ingroup lp_group
-  class LpGlpk : public GlpkBase, public LpSolver {
-  public:
-
-    ///\e
-    LpGlpk();
-    ///\e
-    LpGlpk(const LpGlpk&);
+  class GlpkLp : public GlpkBase, public LpSolver {
+  public:
+
+    ///\e
+    GlpkLp();
+    ///\e
+    GlpkLp(const GlpkLp&);
 
   private:
@@ -137,6 +137,6 @@
   protected:
 
-    virtual LpGlpk* _cloneSolver() const;
-    virtual LpGlpk* _newSolver() const;
+    virtual GlpkLp* _cloneSolver() const;
+    virtual GlpkLp* _newSolver() const;
 
     virtual const char* _solverName() const;
@@ -204,16 +204,16 @@
   /// This class implements an interface for the GLPK MIP solver.
   ///\ingroup lp_group
-  class MipGlpk : public GlpkBase, public MipSolver {
-  public:
-
-    ///\e
-    MipGlpk();
-    ///\e
-    MipGlpk(const MipGlpk&);
-
-  protected:
-
-    virtual MipGlpk* _cloneSolver() const;
-    virtual MipGlpk* _newSolver() const;
+  class GlpkMip : public GlpkBase, public MipSolver {
+  public:
+
+    ///\e
+    GlpkMip();
+    ///\e
+    GlpkMip(const GlpkMip&);
+
+  protected:
+
+    virtual GlpkMip* _cloneSolver() const;
+    virtual GlpkMip* _newSolver() const;
 
     virtual const char* _solverName() const;
Index: lemon/lp.h
===================================================================
--- lemon/lp.h	(revision 461)
+++ lemon/lp.h	(revision 462)
@@ -52,6 +52,6 @@
   ///\ingroup lp_group
   ///
-  ///Currently, it is either \c LpGlpk, \c LpCplex, \c LpSoplex or \c LpClp
-  typedef LpGlpk Lp;
+  ///Currently, it is either \c GlpkLp, \c CplexLp, \c SoplexLp or \c ClpLp
+  typedef GlpkLp Lp;
 
   ///The default MIP solver identifier
@@ -67,23 +67,23 @@
   ///\ingroup lp_group
   ///
-  ///Currently, it is either \c MipGlpk or \c MipCplex
-  typedef MipGlpk Mip;
+  ///Currently, it is either \c GlpkMip or \c CplexMip
+  typedef GlpkMip Mip;
 #else
 #ifdef HAVE_GLPK
 # define LEMON_DEFAULT_LP GLPK
-  typedef LpGlpk Lp;
+  typedef GlpkLp Lp;
 # define LEMON_DEFAULT_MIP GLPK
-  typedef MipGlpk Mip;
+  typedef GlpkMip Mip;
 #elif HAVE_CPLEX
 # define LEMON_DEFAULT_LP CPLEX
-  typedef LpCplex Lp;
+  typedef CplexLp Lp;
 # define LEMON_DEFAULT_MIP CPLEX
-  typedef MipCplex Mip;
+  typedef CplexMip Mip;
 #elif HAVE_SOPLEX
 # define DEFAULT_LP SOPLEX
-  typedef LpSoplex Lp;
+  typedef SoplexLp Lp;
 #elif HAVE_CLP
 # define DEFAULT_LP CLP
-  typedef LpClp Lp;  
+  typedef ClpLp Lp;  
 #endif
 #endif
Index: lemon/soplex.cc
===================================================================
--- lemon/soplex.cc	(revision 461)
+++ lemon/soplex.cc	(revision 462)
@@ -27,13 +27,13 @@
 namespace lemon {
 
-  LpSoplex::LpSoplex() {
+  SoplexLp::SoplexLp() {
     soplex = new soplex::SoPlex;
   }
 
-  LpSoplex::~LpSoplex() {
+  SoplexLp::~SoplexLp() {
     delete soplex;
   }
 
-  LpSoplex::LpSoplex(const LpSoplex& lp) {
+  SoplexLp::SoplexLp(const SoplexLp& lp) {
     rows = lp.rows;
     cols = lp.cols;
@@ -50,22 +50,22 @@
   }
 
-  void LpSoplex::_clear_temporals() {
+  void SoplexLp::_clear_temporals() {
     _primal_values.clear();
     _dual_values.clear();
   }
 
-  LpSoplex* LpSoplex::_newSolver() const {
-    LpSoplex* newlp = new LpSoplex();
+  SoplexLp* SoplexLp::_newSolver() const {
+    SoplexLp* newlp = new SoplexLp();
     return newlp;
   }
 
-  LpSoplex* LpSoplex::_cloneSolver() const {
-    LpSoplex* newlp = new LpSoplex(*this);
+  SoplexLp* SoplexLp::_cloneSolver() const {
+    SoplexLp* newlp = new SoplexLp(*this);
     return newlp;
   }
 
-  const char* LpSoplex::_solverName() const { return "LpSoplex"; }
-
-  int LpSoplex::_addCol() {
+  const char* SoplexLp::_solverName() const { return "SoplexLp"; }
+
+  int SoplexLp::_addCol() {
     soplex::LPCol c;
     c.setLower(-soplex::infinity);
@@ -78,5 +78,5 @@
   }
 
-  int LpSoplex::_addRow() {
+  int SoplexLp::_addRow() {
     soplex::LPRow r;
     r.setLhs(-soplex::infinity);
@@ -90,5 +90,5 @@
 
 
-  void LpSoplex::_eraseCol(int i) {
+  void SoplexLp::_eraseCol(int i) {
     soplex->removeCol(i);
     _col_names_ref.erase(_col_names[i]);
@@ -98,5 +98,5 @@
   }
 
-  void LpSoplex::_eraseRow(int i) {
+  void SoplexLp::_eraseRow(int i) {
     soplex->removeRow(i);
     _row_names_ref.erase(_row_names[i]);
@@ -106,18 +106,18 @@
   }
 
-  void LpSoplex::_eraseColId(int i) {
+  void SoplexLp::_eraseColId(int i) {
     cols.eraseIndex(i);
     cols.relocateIndex(i, cols.maxIndex());
   }
-  void LpSoplex::_eraseRowId(int i) {
+  void SoplexLp::_eraseRowId(int i) {
     rows.eraseIndex(i);
     rows.relocateIndex(i, rows.maxIndex());
   }
 
-  void LpSoplex::_getColName(int c, std::string &name) const {
+  void SoplexLp::_getColName(int c, std::string &name) const {
     name = _col_names[c];
   }
 
-  void LpSoplex::_setColName(int c, const std::string &name) {
+  void SoplexLp::_setColName(int c, const std::string &name) {
     _col_names_ref.erase(_col_names[c]);
     _col_names[c] = name;
@@ -127,5 +127,5 @@
   }
 
-  int LpSoplex::_colByName(const std::string& name) const {
+  int SoplexLp::_colByName(const std::string& name) const {
     std::map<std::string, int>::const_iterator it =
       _col_names_ref.find(name);
@@ -137,9 +137,9 @@
   }
 
-  void LpSoplex::_getRowName(int r, std::string &name) const {
+  void SoplexLp::_getRowName(int r, std::string &name) const {
     name = _row_names[r];
   }
 
-  void LpSoplex::_setRowName(int r, const std::string &name) {
+  void SoplexLp::_setRowName(int r, const std::string &name) {
     _row_names_ref.erase(_row_names[r]);
     _row_names[r] = name;
@@ -149,5 +149,5 @@
   }
 
-  int LpSoplex::_rowByName(const std::string& name) const {
+  int SoplexLp::_rowByName(const std::string& name) const {
     std::map<std::string, int>::const_iterator it =
       _row_names_ref.find(name);
@@ -160,5 +160,5 @@
 
 
-  void LpSoplex::_setRowCoeffs(int i, ExprIterator b, ExprIterator e) {
+  void SoplexLp::_setRowCoeffs(int i, ExprIterator b, ExprIterator e) {
     for (int j = 0; j < soplex->nCols(); ++j) {
       soplex->changeElement(i, j, 0.0);
@@ -169,5 +169,5 @@
   }
 
-  void LpSoplex::_getRowCoeffs(int i, InsertIterator b) const {
+  void SoplexLp::_getRowCoeffs(int i, InsertIterator b) const {
     const soplex::SVector& vec = soplex->rowVector(i);
     for (int k = 0; k < vec.size(); ++k) {
@@ -177,5 +177,5 @@
   }
 
-  void LpSoplex::_setColCoeffs(int j, ExprIterator b, ExprIterator e) {
+  void SoplexLp::_setColCoeffs(int j, ExprIterator b, ExprIterator e) {
     for (int i = 0; i < soplex->nRows(); ++i) {
       soplex->changeElement(i, j, 0.0);
@@ -186,5 +186,5 @@
   }
 
-  void LpSoplex::_getColCoeffs(int i, InsertIterator b) const {
+  void SoplexLp::_getColCoeffs(int i, InsertIterator b) const {
     const soplex::SVector& vec = soplex->colVector(i);
     for (int k = 0; k < vec.size(); ++k) {
@@ -194,53 +194,53 @@
   }
 
-  void LpSoplex::_setCoeff(int i, int j, Value value) {
+  void SoplexLp::_setCoeff(int i, int j, Value value) {
     soplex->changeElement(i, j, value);
   }
 
-  LpSoplex::Value LpSoplex::_getCoeff(int i, int j) const {
+  SoplexLp::Value SoplexLp::_getCoeff(int i, int j) const {
     return soplex->rowVector(i)[j];
   }
 
-  void LpSoplex::_setColLowerBound(int i, Value value) {
+  void SoplexLp::_setColLowerBound(int i, Value value) {
     LEMON_ASSERT(value != INF, "Invalid bound");
     soplex->changeLower(i, value != -INF ? value : -soplex::infinity);
   }
 
-  LpSoplex::Value LpSoplex::_getColLowerBound(int i) const {
+  SoplexLp::Value SoplexLp::_getColLowerBound(int i) const {
     double value = soplex->lower(i);
     return value != -soplex::infinity ? value : -INF;
   }
 
-  void LpSoplex::_setColUpperBound(int i, Value value) {
+  void SoplexLp::_setColUpperBound(int i, Value value) {
     LEMON_ASSERT(value != -INF, "Invalid bound");
     soplex->changeUpper(i, value != INF ? value : soplex::infinity);
   }
 
-  LpSoplex::Value LpSoplex::_getColUpperBound(int i) const {
+  SoplexLp::Value SoplexLp::_getColUpperBound(int i) const {
     double value = soplex->upper(i);
     return value != soplex::infinity ? value : INF;
   }
 
-  void LpSoplex::_setRowLowerBound(int i, Value lb) {
+  void SoplexLp::_setRowLowerBound(int i, Value lb) {
     LEMON_ASSERT(lb != INF, "Invalid bound");
     soplex->changeRange(i, lb != -INF ? lb : -soplex::infinity, soplex->rhs(i));
   }
 
-  LpSoplex::Value LpSoplex::_getRowLowerBound(int i) const {
+  SoplexLp::Value SoplexLp::_getRowLowerBound(int i) const {
     double res = soplex->lhs(i);
     return res == -soplex::infinity ? -INF : res;
   }
 
-  void LpSoplex::_setRowUpperBound(int i, Value ub) {
+  void SoplexLp::_setRowUpperBound(int i, Value ub) {
     LEMON_ASSERT(ub != -INF, "Invalid bound");
     soplex->changeRange(i, soplex->lhs(i), ub != INF ? ub : soplex::infinity);
   }
 
-  LpSoplex::Value LpSoplex::_getRowUpperBound(int i) const {
+  SoplexLp::Value SoplexLp::_getRowUpperBound(int i) const {
     double res = soplex->rhs(i);
     return res == soplex::infinity ? INF : res;
   }
 
-  void LpSoplex::_setObjCoeffs(ExprIterator b, ExprIterator e) {
+  void SoplexLp::_setObjCoeffs(ExprIterator b, ExprIterator e) {
     for (int j = 0; j < soplex->nCols(); ++j) {
       soplex->changeObj(j, 0.0);
@@ -251,5 +251,5 @@
   }
 
-  void LpSoplex::_getObjCoeffs(InsertIterator b) const {
+  void SoplexLp::_getObjCoeffs(InsertIterator b) const {
     for (int j = 0; j < soplex->nCols(); ++j) {
       Value coef = soplex->obj(j);
@@ -261,13 +261,13 @@
   }
 
-  void LpSoplex::_setObjCoeff(int i, Value obj_coef) {
+  void SoplexLp::_setObjCoeff(int i, Value obj_coef) {
     soplex->changeObj(i, obj_coef);
   }
 
-  LpSoplex::Value LpSoplex::_getObjCoeff(int i) const {
+  SoplexLp::Value SoplexLp::_getObjCoeff(int i) const {
     return soplex->obj(i);
   }
 
-  LpSoplex::SolveExitStatus LpSoplex::_solve() {
+  SoplexLp::SolveExitStatus SoplexLp::_solve() {
 
     _clear_temporals();
@@ -285,5 +285,5 @@
   }
 
-  LpSoplex::Value LpSoplex::_getPrimal(int i) const {
+  SoplexLp::Value SoplexLp::_getPrimal(int i) const {
     if (_primal_values.empty()) {
       _primal_values.resize(soplex->nCols());
@@ -294,5 +294,5 @@
   }
 
-  LpSoplex::Value LpSoplex::_getDual(int i) const {
+  SoplexLp::Value SoplexLp::_getDual(int i) const {
     if (_dual_values.empty()) {
       _dual_values.resize(soplex->nRows());
@@ -303,9 +303,9 @@
   }
 
-  LpSoplex::Value LpSoplex::_getPrimalValue() const {
+  SoplexLp::Value SoplexLp::_getPrimalValue() const {
     return soplex->objValue();
   }
 
-  LpSoplex::VarStatus LpSoplex::_getColStatus(int i) const {
+  SoplexLp::VarStatus SoplexLp::_getColStatus(int i) const {
     switch (soplex->getBasisColStatus(i)) {
     case soplex::SPxSolver::BASIC:
@@ -325,5 +325,5 @@
   }
 
-  LpSoplex::VarStatus LpSoplex::_getRowStatus(int i) const {
+  SoplexLp::VarStatus SoplexLp::_getRowStatus(int i) const {
     switch (soplex->getBasisRowStatus(i)) {
     case soplex::SPxSolver::BASIC:
@@ -343,5 +343,5 @@
   }
 
-  LpSoplex::Value LpSoplex::_getPrimalRay(int i) const {
+  SoplexLp::Value SoplexLp::_getPrimalRay(int i) const {
     if (_primal_ray.empty()) {
       _primal_ray.resize(soplex->nCols());
@@ -352,5 +352,5 @@
   }
 
-  LpSoplex::Value LpSoplex::_getDualRay(int i) const {
+  SoplexLp::Value SoplexLp::_getDualRay(int i) const {
     if (_dual_ray.empty()) {
       _dual_ray.resize(soplex->nRows());
@@ -361,5 +361,5 @@
   }
 
-  LpSoplex::ProblemType LpSoplex::_getPrimalType() const {
+  SoplexLp::ProblemType SoplexLp::_getPrimalType() const {
     switch (soplex->status()) {
     case soplex::SPxSolver::OPTIMAL:
@@ -374,5 +374,5 @@
   }
 
-  LpSoplex::ProblemType LpSoplex::_getDualType() const {
+  SoplexLp::ProblemType SoplexLp::_getDualType() const {
     switch (soplex->status()) {
     case soplex::SPxSolver::OPTIMAL:
@@ -387,5 +387,5 @@
   }
 
-  void LpSoplex::_setSense(Sense sense) {
+  void SoplexLp::_setSense(Sense sense) {
     switch (sense) {
     case MIN:
@@ -397,5 +397,5 @@
   }
 
-  LpSoplex::Sense LpSoplex::_getSense() const {
+  SoplexLp::Sense SoplexLp::_getSense() const {
     switch (soplex->spxSense()) {
     case soplex::SPxSolver::MAXIMIZE:
@@ -405,9 +405,9 @@
     default:
       LEMON_ASSERT(false, "Wrong sense.");
-      return LpSoplex::Sense();
-    }
-  }
-
-  void LpSoplex::_clear() {
+      return SoplexLp::Sense();
+    }
+  }
+
+  void SoplexLp::_clear() {
     soplex->clear();
     _col_names.clear();
Index: lemon/soplex.h
===================================================================
--- lemon/soplex.h	(revision 461)
+++ lemon/soplex.h	(revision 462)
@@ -44,5 +44,5 @@
   /// Berlin (ZIB). You can find detailed information about it at the
   /// <tt>http://soplex.zib.de</tt> address.
-  class LpSoplex : public LpSolver {
+  class SoplexLp : public LpSolver {
   private:
 
@@ -69,14 +69,14 @@
 
     /// \e
-    LpSoplex();
+    SoplexLp();
     /// \e
-    LpSoplex(const LpSoplex&);
+    SoplexLp(const SoplexLp&);
     /// \e
-    ~LpSoplex();
+    ~SoplexLp();
 
   protected:
 
-    virtual LpSoplex* _newSolver() const;
-    virtual LpSoplex* _cloneSolver() const;
+    virtual SoplexLp* _newSolver() const;
+    virtual SoplexLp* _cloneSolver() const;
 
     virtual const char* _solverName() const;
