impl WithTimeLimit for LpSolveProblem, CPLEXProblem, and lp-solvers Model<T> (#116)

* impl WithTimeLimit for LpSolveProblem, CPLEXProblem, and lp-solvers Model<T>

* cargo fmt

---------

Co-authored-by: Joonho Kim <[email protected]>

Author: jk2997

Cargo.toml

@@ -43,7 +43,7 @@ lpsolve = { version = "1.0.1", 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 }
+cplex-rs = { version = "0.1.9", optional = true }
 clarabel = { version = "0.11.0", optional = true, features = [] }
 fnv = "1.0.5"
 

src/solvers/cplex.rs

@@ -1,11 +1,13 @@
 //! A solver that uses the [CPLEX](https://www.ibm.com/products/ilog-cplex-optimization-studio/cplex-optimizer) solver.
 
 use std::collections::HashMap;
+use std::time::Duration;
 
 use crate::{
     constraint::ConstraintReference, variable::UnsolvedProblem, Constraint, ResolutionError,
-    Solution, SolutionStatus, SolverModel, Variable, VariableDefinition,
+    Solution, SolutionStatus, SolverModel, Variable, VariableDefinition, WithTimeLimit,
 };
+use cplex_rs::parameters::TimeLimit;
 use cplex_rs::{ConstraintType, Environment, Problem, ProblemType};
 
 use super::ObjectiveDirection;
@@ -157,6 +159,16 @@ impl SolverModel for CPLEXProblem {
     }
 }
 
+impl WithTimeLimit for CPLEXProblem {
+    fn with_time_limit<T: Into<f64>>(mut self, seconds: T) -> Self {
+        self.model
+            .env_mut()
+            .set_parameter(TimeLimit(Duration::from_secs_f64(seconds.into())))
+            .expect("Failed to set CPLEX time limit");
+        self
+    }
+}
+
 /// A wrapper to a solved SCIP problem
 pub struct CplexSolved {
     solution: cplex_rs::Solution,

src/solvers/lp_solvers.rs

@@ -10,7 +10,7 @@ pub use lp_solvers::solvers::*;
 use lp_solvers::util::UniqueNameGenerator;
 
 use crate::constraint::ConstraintReference;
-use crate::solvers::{MipGapError, ObjectiveDirection, SolutionStatus};
+use crate::solvers::{MipGapError, ObjectiveDirection, SolutionStatus, WithTimeLimit};
 use crate::variable::UnsolvedProblem;
 use crate::{
     Constraint, Expression, IntoAffineExpression, ResolutionError, Solution as GoodLpSolution,
@@ -135,6 +135,16 @@ impl<T: SolverTrait> SolverModel for Model<T> {
     }
 }
 
+impl<T> crate::solvers::WithTimeLimit for Model<T>
+where
+    T: lp_solvers::solvers::WithMaxSeconds<T>,
+{
+    fn with_time_limit<U: Into<f64>>(mut self, seconds: U) -> Self {
+        self.solver = self.solver.with_max_seconds(seconds.into() as u32);
+        self
+    }
+}
+
 fn linear_coefficients_str(
     expr: &Expression,
     variables: &[lp_solvers::problem::Variable],

src/solvers/lpsolve.rs

@@ -1,6 +1,8 @@
 //! lp_solve is a free ([LGPL](https://lpsolve.sourceforge.net/5.5/LGPL.htm)) linear (integer) programming solver written in C and based on the revised simplex method.
 //! good_lp uses the [lpsolve crate](https://docs.rs/lpsolve/) to call lpsolve. You will need a C compiler, but you won't have to install any additional library.
-use crate::solvers::{ObjectiveDirection, ResolutionError, Solution, SolutionStatus, SolverModel};
+use crate::solvers::{
+    ObjectiveDirection, ResolutionError, Solution, SolutionStatus, SolverModel, WithTimeLimit,
+};
 use crate::variable::UnsolvedProblem;
 use crate::{
     affine_expression_trait::IntoAffineExpression, constraint::ConstraintReference, ModelWithSOS1,
@@ -128,6 +130,13 @@ impl SolverModel for LpSolveProblem {
     }
 }
 
+impl WithTimeLimit for LpSolveProblem {
+    fn with_time_limit<T: Into<f64>>(mut self, seconds: T) -> Self {
+        self.0.set_timeout(seconds.into().ceil() as i64);
+        self
+    }
+}
+
 impl ModelWithSOS1 for LpSolveProblem {
     fn add_sos1<I: IntoAffineExpression>(&mut self, variables: I) {
         let iter = variables.linear_coefficients().into_iter();