Merge pull request #19 from Specy/dev

add time limit, fixes #14

Author: Specy

Cargo.toml

@@ -16,8 +16,9 @@ categories = ["mathematics", "science"]
 [dependencies]
 sprs = { version = "0.11.4", default-features = false }
 log = "0.4.11"
+web-time = "1.1.0"
 
 [dev-dependencies]
 rand = "0.8.5"
 rand_pcg = "0.3.1"
-env_logger = "0.11.5"
+env_logger = "0.11.5"

src/lib.rs

@@ -61,6 +61,9 @@ mod tests;
 use solver::Solver;
 use sprs::errors::StructureError;
 
+use core::time::Duration;
+use web_time::Instant;
+
 /// An enum indicating whether to minimize or maximize objective function.
 #[derive(Clone, Copy, Debug, PartialEq)]
 pub enum OptimizationDirection {
@@ -218,6 +221,7 @@ pub struct Problem {
     var_maxs: Vec<f64>,
     var_domains: Vec<VarDomain>,
     constraints: Vec<(CsVec, ComparisonOp, f64)>,
+    time_limit: Option<Duration>,
 }
 
 impl std::fmt::Debug for Problem {
@@ -254,9 +258,19 @@ impl Problem {
             var_maxs: vec![],
             var_domains: vec![],
             constraints: vec![],
+            time_limit: None,
         }
     }
 
+    /// Set a time limit for the solver. If the solver exceeds this duration,
+    /// it will return [`Error::Limit`].
+    ///
+    /// The implementation uses [`web_time::Instant`] under the hood, which works
+    /// on both native and WebAssembly targets.
+    pub fn set_time_limit(&mut self, duration: Duration) {
+        self.time_limit = Some(duration);
+    }
+
     /// Add a new real variable to the problem.
     ///
     /// `obj_coeff` is a coefficient of the term in the objective function corresponding to this
@@ -353,15 +367,18 @@ impl Problem {
     ///
     /// # Errors
     ///
-    /// Will return an error, if the problem is infeasible (constraints can't be satisfied)
-    /// or if the objective value is unbounded.
+    /// Will return an error, if the problem is infeasible (constraints can't be satisfied),
+    /// if the objective value is unbounded, or if a time limit was set and exceeded.
     pub fn solve(&self) -> Result<Solution, Error> {
+        let deadline = self.time_limit.map(|d| Instant::now() + d);
+
         let mut solver = Solver::try_new(
             &self.obj_coeffs,
             &self.var_mins,
             &self.var_maxs,
             &self.constraints,
             &self.var_domains,
+            deadline,
         )?;
         solver.initial_solve()?;
 

src/solver.rs

@@ -8,6 +8,10 @@ use crate::{
 };
 use sprs::CompressedStorage;
 
+use web_time::Instant;
+
+pub(crate) type Deadline = Option<Instant>;
+
 type CsMat = sprs::CsMatI<f64, usize>;
 
 pub(crate) const MACHINE_EPS: f64 = f64::EPSILON * 10.0;
@@ -25,9 +29,20 @@ pub(crate) fn float_ne(a: f64, b: f64) -> bool {
     !float_eq(a, b)
 }
 
+#[inline]
+fn check_deadline(deadline: &Deadline) -> Result<(), Error> {
+    if let Some(dl) = deadline {
+        if Instant::now() >= *dl {
+            return Err(Error::Limit);
+        }
+    }
+    Ok(())
+}
+
 #[derive(Clone)]
 pub(crate) struct Solver {
     pub(crate) num_vars: usize,
+    pub(crate) deadline: Deadline,
 
     orig_obj_coeffs: Vec<f64>,
     orig_var_mins: Vec<f64>,
@@ -138,6 +153,7 @@ impl Solver {
         var_maxs: &[f64],
         constraints: &[(CsVec, ComparisonOp, f64)],
         var_domains: &[VarDomain],
+        deadline: Deadline,
     ) -> Result<Self, Error> {
         let enable_steepest_edge = true; // TODO: make user-settable.
 
@@ -356,6 +372,7 @@ impl Solver {
             orig_constraints,
             orig_constraints_csc,
             orig_rhs,
+            deadline,
             orig_var_domains: var_domains.to_vec(),
             /*orig_int_vars: var_domains
             .to_vec()
@@ -505,6 +522,8 @@ impl Solver {
     }
 
     pub(crate) fn initial_solve(&mut self) -> Result<(), Error> {
+        check_deadline(&self.deadline)?;
+
         if !self.is_primal_feasible {
             self.restore_feasibility()?;
         }
@@ -549,6 +568,10 @@ impl Solver {
             };
 
         for iter in 0.. {
+            if iter % 100 == 0 {
+                check_deadline(&self.deadline)?;
+            }
+
             //guaranteed to have at an element
             let cur_step = match dfs_stack.pop() {
                 Some(step) => step,
@@ -622,6 +645,8 @@ impl Solver {
     fn optimize(&mut self) -> Result<(), Error> {
         for iter in 0.. {
             if iter % 1000 == 0 {
+                check_deadline(&self.deadline)?;
+
                 let (num_vars, infeasibility) = self.calc_dual_infeasibility();
                 debug!(
                     "optimize iter {}: obj.: {}, non-optimal coeffs: {} ({})",
@@ -654,6 +679,8 @@ impl Solver {
 
         for iter in 0.. {
             if iter % 1000 == 0 {
+                check_deadline(&self.deadline)?;
+
                 let (num_vars, infeasibility) = self.calc_primal_infeasibility();
                 debug!(
                     "restore feasibility iter {}: {}: {}, infeas. vars: {} ({})",
@@ -764,7 +791,6 @@ impl Solver {
             }
         }
 
-
         self.is_primal_feasible = false;
         self.restore_feasibility()
     }
@@ -1621,6 +1647,7 @@ mod tests {
                 (to_sparse(&[0.0, 1.0]), ComparisonOp::Eq, 3.0),
             ],
             &[VarDomain::Real, VarDomain::Real],
+            Default::default(),
         )
         .unwrap();
 
@@ -1719,6 +1746,7 @@ mod tests {
                 (to_sparse(&[-1.0, 4.0]), ComparisonOp::Le, 20.0),
             ],
             &[VarDomain::Real, VarDomain::Real],
+            Default::default(),
         )
         .unwrap();
         sol.initial_solve().unwrap();
@@ -1742,6 +1770,7 @@ mod tests {
                 (to_sparse(&[1.0, 1.0]), ComparisonOp::Le, 5.0),
             ],
             &[VarDomain::Real, VarDomain::Real],
+            Default::default(),
         )
         .unwrap()
         .initial_solve();

src/tests/general.rs

@@ -3,6 +3,8 @@ mod tests_general {
     use crate::solver::float_eq;
     use crate::*;
 
+    use core::time::Duration;
+
     fn init() {
         let _ = env_logger::builder().is_test(true).try_init();
     }
@@ -367,6 +369,61 @@ mod tests_general {
         );
     }
 
+    #[test]
+    fn time_limit_zero_returns_limit_error() {
+        init();
+        let mut problem = Problem::new(OptimizationDirection::Maximize);
+        let x = problem.add_var(1.0, (0.0, f64::INFINITY));
+        let y = problem.add_var(2.0, (0.0, 3.0));
+        problem.add_constraint(&[(x, 1.0), (y, 1.0)], ComparisonOp::Le, 4.0);
+        problem.add_constraint(&[(x, 2.0), (y, 1.0)], ComparisonOp::Ge, 2.0);
+
+        // A zero duration guarantees the deadline is already passed before solving starts.
+        problem.set_time_limit(Duration::ZERO);
+        let result = problem.solve();
+        assert_eq!(result.unwrap_err(), Error::Limit);
+    }
+
+    #[test]
+    fn time_limit_generous_succeeds() {
+        init();
+        let mut problem = Problem::new(OptimizationDirection::Maximize);
+        let x = problem.add_var(1.0, (0.0, f64::INFINITY));
+        let y = problem.add_var(2.0, (0.0, 3.0));
+        problem.add_constraint(&[(x, 1.0), (y, 1.0)], ComparisonOp::Le, 4.0);
+        problem.add_constraint(&[(x, 2.0), (y, 1.0)], ComparisonOp::Ge, 2.0);
+
+        // A generous time limit should let a small problem solve without issue.
+        problem.set_time_limit(Duration::from_secs(60));
+        let sol = problem.solve().unwrap();
+        assert_eq!(sol.objective(), 7.0);
+        assert_eq!(sol[x], 1.0);
+        assert_eq!(sol[y], 3.0);
+    }
+
+    #[test]
+    fn time_limit_zero_integer_returns_limit_error() {
+        init();
+        let mut problem = Problem::new(OptimizationDirection::Maximize);
+        let weights = [10, 60, 30, 40, 30, 20, 20, 2];
+        let values = [1, 10, 15, 40, 60, 90, 100, 15];
+        let capacity = 102;
+        let mut vars = vec![];
+        for i in 0..weights.len() {
+            let var = problem.add_binary_var(values[i] as f64);
+            vars.push(var);
+        }
+        let entries = vars
+            .iter()
+            .map(|v| (*v, weights[v.0] as f64))
+            .collect::<Vec<_>>();
+        problem.add_constraint(&entries, ComparisonOp::Le, capacity as f64);
+
+        problem.set_time_limit(Duration::ZERO);
+        let result = problem.solve();
+        assert_eq!(result.unwrap_err(), Error::Limit);
+    }
+
     #[test]
     fn solve_big_m() {
         init();