diff -r 08d495d48089 -r 9b082b3fb33f lemon/clp.cc
--- a/lemon/clp.cc	Mon Jan 12 12:26:01 2009 +0000
+++ b/lemon/clp.cc	Mon Jan 12 12:26:02 2009 +0000
@@ -21,13 +21,13 @@
 
 namespace lemon {
 
-  LpClp::LpClp() {
+  ClpLp::ClpLp() {
     _prob = new ClpSimplex();
     _init_temporals();
     messageLevel(MESSAGE_NO_OUTPUT);
   }
 
-  LpClp::LpClp(const LpClp& other) {
+  ClpLp::ClpLp(const ClpLp& other) {
     _prob = new ClpSimplex(*other._prob);
     rows = other.rows;
     cols = other.cols;
@@ -35,17 +35,17 @@
     messageLevel(MESSAGE_NO_OUTPUT);
   }
 
-  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;
       _primal_ray = 0;
@@ -56,79 +56,79 @@
     }
   }
 
-  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"; }
+  const char* ClpLp::_solverName() const { return "ClpLp"; }
 
-  int LpClp::_addCol() {
+  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;
   }
 
 
-  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;
   }
 
 
-  void LpClp::_setRowCoeffs(int ix, ExprIterator b, ExprIterator e) {
+  void ClpLp::_setRowCoeffs(int ix, ExprIterator b, ExprIterator e) {
     std::map<int, Value> coeffs;
 
     int n = _prob->clpMatrix()->getNumCols();
@@ -156,7 +156,7 @@
     }
   }
 
-  void LpClp::_getRowCoeffs(int ix, InsertIterator b) const {
+  void ClpLp::_getRowCoeffs(int ix, InsertIterator b) const {
     int n = _prob->clpMatrix()->getNumCols();
 
     const int* indices = _prob->clpMatrix()->getIndices();
@@ -173,7 +173,7 @@
     }
   }
 
-  void LpClp::_setColCoeffs(int ix, ExprIterator b, ExprIterator e) {
+  void ClpLp::_setColCoeffs(int ix, ExprIterator b, ExprIterator e) {
     std::map<int, Value> coeffs;
 
     CoinBigIndex begin = _prob->clpMatrix()->getVectorStarts()[ix];
@@ -196,7 +196,7 @@
     }
   }
 
-  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];
 
@@ -209,11 +209,11 @@
     }
   }
 
-  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];
 
@@ -228,43 +228,43 @@
     }
   }
 
-  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) {
       _prob->setObjectiveCoefficient(i, 0.0);
@@ -274,7 +274,7 @@
     }
   }
 
-  void LpClp::_getObjCoeffs(InsertIterator b) const {
+  void ClpLp::_getObjCoeffs(InsertIterator b) const {
     int num = _prob->clpMatrix()->getNumCols();
     for (int i = 0; i < num; ++i) {
       Value coef = _prob->getObjCoefficients()[i];
@@ -285,42 +285,42 @@
     }
   }
 
-  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();
       LEMON_ASSERT(_primal_ray != 0, "Primal ray is not provided");
@@ -328,7 +328,7 @@
     return _primal_ray[i];
   }
 
-  LpClp::Value LpClp::_getDualRay(int i) const {
+  ClpLp::Value ClpLp::_getDualRay(int i) const {
     if (!_dual_ray) {
       _dual_ray = _prob->infeasibilityRay();
       LEMON_ASSERT(_dual_ray != 0, "Dual ray is not provided");
@@ -336,7 +336,7 @@
     return _dual_ray[i];
   }
 
-  LpClp::VarStatus LpClp::_getColStatus(int i) const {
+  ClpLp::VarStatus ClpLp::_getColStatus(int i) const {
     switch (_prob->getColumnStatus(i)) {
     case ClpSimplex::basic:
       return BASIC;
@@ -356,7 +356,7 @@
     }
   }
 
-  LpClp::VarStatus LpClp::_getRowStatus(int i) const {
+  ClpLp::VarStatus ClpLp::_getRowStatus(int i) const {
     switch (_prob->getColumnStatus(i)) {
     case ClpSimplex::basic:
       return BASIC;
@@ -377,7 +377,7 @@
   }
 
 
-  LpClp::ProblemType LpClp::_getPrimalType() const {
+  ClpLp::ProblemType ClpLp::_getPrimalType() const {
     if (_prob->isProvenOptimal()) {
       return OPTIMAL;
     } else if (_prob->isProvenPrimalInfeasible()) {
@@ -389,7 +389,7 @@
     }
   }
 
-  LpClp::ProblemType LpClp::_getDualType() const {
+  ClpLp::ProblemType ClpLp::_getDualType() const {
     if (_prob->isProvenOptimal()) {
       return OPTIMAL;
     } else if (_prob->isProvenDualInfeasible()) {
@@ -401,7 +401,7 @@
     }
   }
 
-  void LpClp::_setSense(LpClp::Sense sense) {
+  void ClpLp::_setSense(ClpLp::Sense sense) {
     switch (sense) {
     case MIN:
       _prob->setOptimizationDirection(1);
@@ -412,7 +412,7 @@
     }
   }
 
-  LpClp::Sense LpClp::_getSense() const {
+  ClpLp::Sense ClpLp::_getSense() const {
     double dir = _prob->optimizationDirection();
     if (dir > 0.0) {
       return MIN;
@@ -421,7 +421,7 @@
     }
   }
 
-  void LpClp::_clear() {
+  void ClpLp::_clear() {
     delete _prob;
     _prob = new ClpSimplex();
     rows.clear();
@@ -430,7 +430,7 @@
     _clear_temporals();
   }
 
-  void LpClp::messageLevel(MessageLevel m) {
+  void ClpLp::messageLevel(MessageLevel m) {
     _prob->setLogLevel(static_cast<int>(m));
   }