diff -r eb37b9774ef6 -r 2aabce558574 lemon/lp_soplex.cc
--- a/lemon/lp_soplex.cc	Thu Feb 15 13:06:23 2007 +0000
+++ b/lemon/lp_soplex.cc	Thu Feb 15 14:22:08 2007 +0000
@@ -27,7 +27,10 @@
 namespace lemon {
   
   LpSoplex::LpSoplex() : LpSolverBase() {
+    rows.setIdHandler(relocateIdHandler);
+    cols.setIdHandler(relocateIdHandler);
     soplex = new soplex::SoPlex;
+    solved = false;
   }
   
   LpSoplex::~LpSoplex() {
@@ -47,19 +50,25 @@
 
   int LpSoplex::_addCol() {
     soplex::LPCol col;
+    col.setLower(-soplex::infinity);
+    col.setUpper(soplex::infinity);
     soplex->addCol(col);
 
     colNames.push_back(std::string());
-    primal.push_back(0.0);
+    primal_value.push_back(0.0);
+    solved = false;
 
     return soplex->nCols() - 1;
   }
 
   int LpSoplex::_addRow() {
     soplex::LPRow row;
+    row.setLhs(-soplex::infinity);
+    row.setRhs(soplex::infinity);
     soplex->addRow(row);
 
-    dual.push_back(0.0);
+    dual_value.push_back(0.0);
+    solved = false;
 
     return soplex->nRows() - 1;
   }
@@ -67,14 +76,18 @@
 
   void LpSoplex::_eraseCol(int i) {
     soplex->removeCol(i);
-    primal[i] = primal.back();
-    primal.pop_back();
+    colNames[i] = colNames.back();
+    colNames.pop_back();
+    primal_value[i] = primal_value.back();
+    primal_value.pop_back();
+    solved = false;
   }
   
   void LpSoplex::_eraseRow(int i) {
     soplex->removeRow(i);
-    dual[i] = dual.back();
-    dual.pop_back();
+    dual_value[i] = dual_value.back();
+    dual_value.pop_back();
+    solved = false;
   }
   
   void LpSoplex::_getColName(int col, std::string &name) {
@@ -93,6 +106,7 @@
     for(LpRowIterator it = b; it != e; ++it) {
       soplex->changeElement(i, it->first, it->second);
     }
+    solved = false;
   }
   
   void LpSoplex::_setColCoeffs(int j, LpColIterator b, LpColIterator e) {
@@ -102,47 +116,80 @@
     for(LpColIterator it = b; it != e; ++it) {
       soplex->changeElement(it->first, j, it->second);
     }
+    solved = false;
   }
   
-  void LpSoplex::_setCoeff(int row, int col, Value value) {
-    soplex->changeElement(row, col, value);
+  void LpSoplex::_setCoeff(int i, int j, Value value) {
+    soplex->changeElement(i, j, value);
+    solved = false;
+  }
+
+  LpSoplex::Value LpSoplex::_getCoeff(int i, int j) {
+    return soplex->rowVector(i)[j];
   }
 
   void LpSoplex::_setColLowerBound(int i, Value value) {
-    soplex->changeLower(i, value); 
+    soplex->changeLower(i, value != -INF ? value : -soplex::infinity); 
+    solved = false;
   }
   
+  LpSoplex::Value LpSoplex::_getColLowerBound(int i) {
+    double value = soplex->lower(i);
+    return value != -soplex::infinity ? value : -INF;
+  }
+
   void LpSoplex::_setColUpperBound(int i, Value value) {
-    soplex->changeUpper(i, value); 
+    soplex->changeUpper(i, value != INF ? value : soplex::infinity); 
+    solved = false;
+  }
+
+  LpSoplex::Value LpSoplex::_getColUpperBound(int i) {
+    double value = soplex->upper(i);
+    return value != soplex::infinity ? value : INF;
   }
 
   void LpSoplex::_setRowBounds(int i, Value lb, Value ub) {
-    soplex->changeRange(i, lb, ub);
+    soplex->changeRange(i, lb != -INF ? lb : -soplex::infinity,
+                        ub != INF ? ub : soplex::infinity);
+    solved = false;
+  }
+  void LpSoplex::_getRowBounds(int i, Value &lower, Value &upper) {
+    lower = soplex->lhs(i);
+    if (lower == -soplex::infinity) lower = -INF;
+    upper = soplex->rhs(i);
+    if (upper == -soplex::infinity) upper = INF;
   }
 
   void LpSoplex::_setObjCoeff(int i, Value obj_coef) {
     soplex->changeObj(i, obj_coef);
+    solved = false;
+  }
+
+  LpSoplex::Value LpSoplex::_getObjCoeff(int i) {
+    return soplex->obj(i);
   }
 
   void LpSoplex::_clearObj() {
     for (int i = 0; i < soplex->nCols(); ++i) {
       soplex->changeObj(i, 0.0);
     }
+    solved = false;
   }
 
   LpSoplex::SolveExitStatus LpSoplex::_solve() {
     soplex::SPxSolver::Status status = soplex->solve();
 
-    soplex::Vector pv(primal.size(), &primal[0]);
+    soplex::Vector pv(primal_value.size(), &primal_value[0]);
     soplex->getPrimal(pv);
 
-    soplex::Vector dv(dual.size(), &dual[0]);
+    soplex::Vector dv(dual_value.size(), &dual_value[0]);
     soplex->getDual(dv);
 
     switch (status) {
     case soplex::SPxSolver::OPTIMAL:
     case soplex::SPxSolver::INFEASIBLE:
     case soplex::SPxSolver::UNBOUNDED:
+      solved = true;
       return SOLVED;
     default:
       return UNSOLVED;
@@ -150,11 +197,11 @@
   }
 
   LpSoplex::Value LpSoplex::_getPrimal(int i) {
-    return primal[i];
+    return primal_value[i];
   }
 
   LpSoplex::Value LpSoplex::_getDual(int i) {
-    return dual[i];
+    return dual_value[i];
   }
   
   LpSoplex::Value LpSoplex::_getPrimalValue() {
@@ -166,6 +213,7 @@
   }  
 
   LpSoplex::SolutionStatus LpSoplex::_getPrimalStatus() {
+    if (!solved) return UNDEFINED;
     switch (soplex->status()) {
     case soplex::SPxSolver::OPTIMAL:
       return OPTIMAL;
@@ -179,30 +227,41 @@
   }
 
   LpSoplex::SolutionStatus LpSoplex::_getDualStatus() {
-    switch (0) {
-    case 0:
-      return UNDEFINED;
+    if (!solved) return UNDEFINED;
+    switch (soplex->status()) {
+    case soplex::SPxSolver::OPTIMAL:
       return OPTIMAL;
+    case soplex::SPxSolver::UNBOUNDED:
       return INFEASIBLE;
+    default:
       return UNDEFINED;
     }
   }
 
   LpSoplex::ProblemTypes LpSoplex::_getProblemType() {
-    switch (0) {
-    case 0:
+    if (!solved) return UNKNOWN;
+    switch (soplex->status()) {
+    case soplex::SPxSolver::OPTIMAL:
       return PRIMAL_DUAL_FEASIBLE;
+    case soplex::SPxSolver::UNBOUNDED:
       return PRIMAL_FEASIBLE_DUAL_INFEASIBLE;
+    default:
       return UNKNOWN;
     }
   }
 
   void LpSoplex::_setMax() {
     soplex->changeSense(soplex::SPxSolver::MAXIMIZE);
+    solved = false;
   }
   void LpSoplex::_setMin() {
     soplex->changeSense(soplex::SPxSolver::MINIMIZE);
+    solved = false;
   }
+  bool LpSoplex::_isMax() {
+    return soplex->spxSense() == soplex::SPxSolver::MAXIMIZE;
+  }
+
   
 } //namespace lemon