Changeset 2363:2aabce558574 in lemon-0.x for lemon/lp_soplex.cc

Timestamp:

02/15/07 15:22:08 (17 years ago)

Author:

Balazs Dezso

Branch:

default

Phase:

public

Convert:

svn:c9d7d8f5-90d6-0310-b91f-818b3a526b0e/lemon/trunk@3174

Message:

Changes on the LP interface

_FixId => LpId?

• handling of not common ids soplex

LpGlpk? row and col erase bug fix

• calling lpx_std_basis before simplex

LpSoplex?

• added getter functions
• better m4 file
• integration to the tests
• better handling of unsolved lps

File:

• lemon/lp_soplex.cc (modified) (13 diffs)

lemon/lp_soplex.cc

@@ -28 +28 @@
   
   LpSoplex::LpSoplex() : LpSolverBase() {
+    rows.setIdHandler(relocateIdHandler);
+    cols.setIdHandler(relocateIdHandler);
     soplex = new soplex::SoPlex;
+    solved = false;
   }
   
@@ -48 +51 @@
   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;
@@ -58 +64 @@
   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;
@@ -68 +77 @@
   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;
   }
   
@@ -94 +107 @@
       soplex->changeElement(i, it->first, it->second);
     }
+    solved = false;
   }
   
@@ -103 +117 @@
       soplex->changeElement(it->first, j, it->second);
     }
-  }
-  
-  void LpSoplex::_setCoeff(int row, int col, Value value) {
-    soplex->changeElement(row, col, value);
+    solved = false;
+  }
+  
+  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);
   }
 
@@ -129 +174 @@
       soplex->changeObj(i, 0.0);
     }
+    solved = false;
   }
 
@@ -134 +180 @@
     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);
 
@@ -144 +190 @@
     case soplex::SPxSolver::INFEASIBLE:
     case soplex::SPxSolver::UNBOUNDED:
+      solved = true;
       return SOLVED;
     default:
@@ -151 +198 @@
 
   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];
   }
   
@@ -167 +214 @@
 
   LpSoplex::SolutionStatus LpSoplex::_getPrimalStatus() {
+    if (!solved) return UNDEFINED;
     switch (soplex->status()) {
     case soplex::SPxSolver::OPTIMAL:
@@ -180 +228 @@
 
   LpSoplex::SolutionStatus LpSoplex::_getDualStatus() {
-    switch (0) {
-    case 0:
+    if (!solved) return UNDEFINED;
+    switch (soplex->status()) {
+    case soplex::SPxSolver::OPTIMAL:
+      return OPTIMAL;
+    case soplex::SPxSolver::UNBOUNDED:
+      return INFEASIBLE;
+    default:
       return UNDEFINED;
-      return OPTIMAL;
-      return INFEASIBLE;
-      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;
     }
@@ -200 +253 @@
   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