Fix for unbounded LP

Author: apete

CHANGELOG.md

@@ -23,6 +23,12 @@ Added / Changed / Deprecated / Fixed / Removed / Security
 
 - Refactored `SampleSet` (internally) to be better aligned with recent changes to other parts of the library. Primarily the class now uses `int` indices for all internal calculations. Also added a new `java.util.stream.Collector` implementation to simplify `SampleSet` creation from streams.
 
+### Fixed
+
+#### org.ojalgo.optimisation
+
+- Fixed a bug where the (new) LP solver would fail to recognise unbounded problems and instead return a solution with infinite values, stating it to be optimal.
+
 ## [55.0.0] – 2024-09-28
 
 ### Changed

src/main/java/org/ojalgo/optimisation/ExpressionsBasedModel.java

@@ -239,7 +239,8 @@ public static interface EntityMap extends ProblemStructure {
 
     public enum FileFormat {
 
-        EBM, MPS;
+        EBM,
+        MPS;
 
         /**
          * Apart from the "native" EBM file format, currently only supports the MPS file format, but with some
@@ -692,12 +693,12 @@ public static ExpressionsBasedModel parse(final File file) {
 
     public static ExpressionsBasedModel parse(final InputStream input, final FileFormat format) {
         switch (format) {
-        case MPS:
-            return FileFormatMPS.read(input);
-        case EBM:
-            return FileFormatEBM.read(input);
-        default:
-            throw new IllegalArgumentException();
+            case MPS:
+                return FileFormatMPS.read(input);
+            case EBM:
+                return FileFormatEBM.read(input);
+            default:
+                throw new IllegalArgumentException();
         }
     }
 
@@ -1420,7 +1421,7 @@ public void setKnownSolution(final Optimisation.Result knownSolution) {
 
     /**
      * For test/validation during solver development.
-     * 
+     *
      * @param knownSolution The optimal solution
      * @param handler What to do if validation fails
      */
@@ -1599,16 +1600,20 @@ private Optimisation.Result optimise() {
 
         Optimisation.Result result = prepared.solve(null);
 
-        for (int i = 0, limit = myVariables.size(); i < limit; i++) {
-            Variable tmpVariable = myVariables.get(i);
-            if (!tmpVariable.isFixed()) {
-                tmpVariable.setValue(options.solution.toBigDecimal(result.doubleValue(i)));
+        Optimisation.State retState = result.getState();
+
+        if (retState.isApproximate()) {
+            for (int i = 0, limit = myVariables.size(); i < limit; i++) {
+                Variable tmpVariable = myVariables.get(i);
+                if (!tmpVariable.isFixed()) {
+                    tmpVariable.setValue(options.solution.toBigDecimal(result.doubleValue(i)));
+                }
             }
         }
-
         Result retSolution = this.getVariableValues();
+
         double retValue = this.objective().evaluate(retSolution).doubleValue();
-        Optimisation.State retState = result.getState();
+
         List<KeyedPrimitive<EntryPair<ModelEntity<?>, ConstraintType>>> matchedMultipliers = result.getMatchedMultipliers();
 
         prepared.dispose();

src/main/java/org/ojalgo/optimisation/linear/SimplexSolver.java

@@ -55,7 +55,9 @@
 abstract class SimplexSolver extends LinearSolver {
 
     enum Direction {
-        DECREASE, INCREASE, STAY;
+        DECREASE,
+        INCREASE,
+        STAY;
     }
 
     /**
@@ -942,7 +944,7 @@ private boolean testPrimalExitRatio(final IterDescr iteration) {
             }
         }
 
-        if (iteration.ratioPrimal >= range) {
+        if (iteration.ratioPrimal >= range && Double.isFinite(iteration.ratioPrimal)) {
 
             if (this.isLogDebug()) {
                 this.log("Bound switch!");

src/test/java/org/ojalgo/optimisation/linear/LinearProblems.java

@@ -252,6 +252,33 @@ public void testMath286() {
         TestUtils.assertEquals(0, claimedValue.compareTo(tmpFullValue));
     }
 
+    /**
+     * https://github.com/vagmcs/Optimus/issues/43
+     * <p>
+     * The problem is unbounded (not infeasible). A feasible solution is x=120 and y=80.
+     * <p>
+     * In this case ojAlgo finds a feasible solution, but then somehow fails to identify that it's unbounded
+     * and instead returns a solution with an infinite value.
+     */
+    @Test
+    public void testOptimus43() {
+
+        ExpressionsBasedModel model = new ExpressionsBasedModel();
+
+        if (DEBUG) {
+            model.options.debug(LinearSolver.class);
+        }
+
+        Variable x = model.newVariable("x").weight(-2);
+        Variable y = model.newVariable("y").lower(80).upper(170).weight(5);
+
+        model.addExpression().set(x, 1).set(y, 1).lower(200);
+
+        Result result = model.minimise();
+
+        TestUtils.assertEquals(State.UNBOUNDED, result.getState());
+    }
+
     /**
      * Didn't recognise this as an infeasible problem.
      */

src/test/java/org/ojalgo/optimisation/service/OptimisationServiceTest.java

@@ -11,7 +11,7 @@
 @Tag("network")
 public class OptimisationServiceTest {
 
-    private static final String HOST = "http://13.60.238.155:8080";
+    private static final String HOST = "http://16.16.99.66:8080";
     // private static final String HOST = "http://localhost:8080";
     // private static final String HOST = "http://test-service.optimatika.se:8080";