Struct ILPSolver 

pub struct ILPSolver {
    pub time_limit: Option<f64>,
}

An ILP solver using the HiGHS backend.

This solver solves Integer Linear Programming problems directly using the HiGHS solver.

Example

use problemreductions::models::algebraic::{ILP, LinearConstraint, ObjectiveSense};
use problemreductions::solvers::ILPSolver;

// Create a simple binary ILP: maximize x0 + 2*x1 subject to x0 + x1 <= 1
let ilp = ILP::<bool>::new(
    2,
    vec![LinearConstraint::le(vec![(0, 1.0), (1, 1.0)], 1.0)],
    vec![(0, 1.0), (1, 2.0)],
    ObjectiveSense::Maximize,
);

let solver = ILPSolver::new();
if let Some(solution) = solver.solve(&ilp) {
    println!("Solution: {:?}", solution);
}

Fields

time_limit: Option<f64>

Time limit in seconds (None = no limit).

Implementations

impl ILPSolver

pub fn new() -> Self

Create a new ILP solver with default settings.

pub fn with_time_limit(seconds: f64) -> Self

Create an ILP solver with a time limit.

pub fn solve<V: VariableDomain>(&self, problem: &ILP<V>) -> Option<Vec<usize>>

Solve an ILP problem directly.

Returns None if the problem is infeasible or the solver fails. The returned solution is a configuration vector where each element is the variable value (config index = value).

pub fn solve_reduced<P>(&self, problem: &P) -> Option<Vec<usize>>

where P: ReduceTo<ILP<bool>>,

Solve any problem that reduces to ILP<bool>.

This method first reduces the problem to a binary ILP, solves the ILP, and then extracts the solution back to the original problem space.

Example

use problemreductions::prelude::*;
use problemreductions::solvers::ILPSolver;

// Create a problem that reduces directly to ILP.
let problem = MaximumSetPacking::<i32>::new(vec![
    vec![0, 1],
    vec![1, 2],
    vec![3, 4],
]);

// Solve using ILP solver
let solver = ILPSolver::new();
if let Some(solution) = solver.solve_reduced(&problem) {
    println!("Solution: {:?}", solution);
}

pub fn solve_dyn(&self, any: &dyn Any) -> Option<Vec<usize>>

Solve a type-erased problem directly when a native solver hook exists.

Returns None if the input type has no direct solver or the solver finds no solution.

pub fn try_solve_via_reduction( &self, name: &str, variant: &BTreeMap<String, String>, instance: &dyn Any, ) -> Result<Vec<usize>, SolveViaReductionError>

pub fn solve_via_reduction( &self, name: &str, variant: &BTreeMap<String, String>, instance: &dyn Any, ) -> Option<Vec<usize>>

Solve a type-erased problem by finding a reduction path to ILP.

Tries all ILP variants, picks the cheapest path, reduces, solves, and extracts the solution back. Falls back to direct ILP solve if the problem is already an ILP type.

Returns None if no path to ILP exists or the solver finds no solution.

Trait Implementations

impl Clone for ILPSolver

fn clone(&self) -> ILPSolver

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ILPSolver

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for ILPSolver

fn default() -> ILPSolver

Returns the “default value” for a type.