Support early solver stop without solution in HiGHS (#114)

If you put a stopping option as `.set_option("mip_max_nodes", 10)`, the solver
might stop without finding a feasible solution. This modification handles this
case by checking that a feasible solution is available, returning
`Err(ResolutionError::Other("NoSolutionFound"))` if not.

depends on rust-or/highs#32

Author: TeXitoi

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "good_lp"
-version = "1.14.0"
+version = "1.14.1"
 authors = ["Ophir LOJKINE <[email protected]>"]
 edition = "2018"
 repository = "https://github.com/rust-or/good_lp"
@@ -40,7 +40,7 @@ minilp = [
 coin_cbc = { version = "0.1", optional = true, default-features = false }
 microlp = { version = "0.2.11", optional = true }
 lpsolve = { version = "1.0.1", optional = true }
-highs = { version = "1.11.0", optional = true }
+highs = { version = "2.0.0", optional = true }
 russcip = { version = "0.8.2", optional = true }
 lp-solvers = { version = "1.0.0", features = ["cplex"], optional = true }
 cplex-rs = { version = "0.1", optional = true }

src/solvers/highs.rs

@@ -10,7 +10,7 @@ use crate::{
     variable::{UnsolvedProblem, VariableDefinition},
 };
 use crate::{Constraint, IntoAffineExpression, Variable, WithInitialSolution};
-use highs::HighsModelStatus;
+use highs::{HighsModelStatus, HighsSolutionStatus};
 use std::collections::HashMap;
 use std::iter::FromIterator;
 
@@ -292,32 +292,43 @@ impl SolverModel for HighsProblem {
         }
 
         let solved = model.solve();
-        match solved.status() {
-            HighsModelStatus::NotSet => Err(ResolutionError::Other("NotSet")),
-            HighsModelStatus::LoadError => Err(ResolutionError::Other("LoadError")),
-            HighsModelStatus::ModelError => Err(ResolutionError::Other("ModelError")),
-            HighsModelStatus::PresolveError => Err(ResolutionError::Other("PresolveError")),
-            HighsModelStatus::SolveError => Err(ResolutionError::Other("SolveError")),
-            HighsModelStatus::PostsolveError => Err(ResolutionError::Other("PostsolveError")),
-            HighsModelStatus::ModelEmpty => Err(ResolutionError::Other("ModelEmpty")),
-            HighsModelStatus::Infeasible => Err(ResolutionError::Infeasible),
-            HighsModelStatus::Unbounded => Err(ResolutionError::Unbounded),
-            HighsModelStatus::UnboundedOrInfeasible => Err(ResolutionError::Infeasible),
-            HighsModelStatus::ReachedTimeLimit => Ok(HighsSolution {
-                status: SolutionStatus::TimeLimit,
-                solution: solved.get_solution(),
-            }),
-            _ok_status => {
+        let status = match solved.status() {
+            HighsModelStatus::NotSet => return Err(ResolutionError::Other("NotSet")),
+            HighsModelStatus::LoadError => return Err(ResolutionError::Other("LoadError")),
+            HighsModelStatus::ModelError => return Err(ResolutionError::Other("ModelError")),
+            HighsModelStatus::PresolveError => return Err(ResolutionError::Other("PresolveError")),
+            HighsModelStatus::SolveError => return Err(ResolutionError::Other("SolveError")),
+            HighsModelStatus::PostsolveError => {
+                return Err(ResolutionError::Other("PostsolveError"));
+            }
+            HighsModelStatus::ModelEmpty => return Err(ResolutionError::Other("ModelEmpty")),
+            HighsModelStatus::Infeasible => return Err(ResolutionError::Infeasible),
+            HighsModelStatus::Unbounded => return Err(ResolutionError::Unbounded),
+            HighsModelStatus::UnboundedOrInfeasible => return Err(ResolutionError::Infeasible),
+            HighsModelStatus::ReachedTimeLimit
+            | HighsModelStatus::ReachedSolutionLimit
+            | HighsModelStatus::ReachedInterrupt
+            | HighsModelStatus::ReachedIterationLimit
+            | HighsModelStatus::ReachedMemoryLimit => SolutionStatus::TimeLimit,
+            HighsModelStatus::Optimal
+            | HighsModelStatus::ObjectiveBound
+            | HighsModelStatus::ObjectiveTarget => {
                 let gap = solved.mip_gap();
-                Ok(HighsSolution {
-                    status: if gap.is_finite() && gap > 0.0 {
-                        SolutionStatus::GapLimit
-                    } else {
-                        SolutionStatus::Optimal
-                    },
-                    solution: solved.get_solution(),
-                })
+                if gap.is_finite() && gap > 0.0 {
+                    SolutionStatus::GapLimit
+                } else {
+                    SolutionStatus::Optimal
+                }
             }
+            _ => return Err(ResolutionError::Other("Unknown")),
+        };
+        if solved.primal_solution_status() == HighsSolutionStatus::Feasible {
+            Ok(HighsSolution {
+                status,
+                solution: solved.get_solution(),
+            })
+        } else {
+            Err(ResolutionError::Other("NoSolutionFound"))
         }
     }