Struct HighsOptions 

pub struct HighsOptions {
    pub universal: UniversalOptions,
    pub mip_gap: Option<f64>,
    pub presolve: Option<HighsPresolve>,
    pub method: Option<HighsMethod>,
    pub parallel: Option<bool>,
}

HiGHS-specific solver options.

Fields

universal: UniversalOptions

mip_gap: Option<f64>

presolve: Option<HighsPresolve>

method: Option<HighsMethod>

parallel: Option<bool>

Implementations

impl HighsOptions

pub fn mip_gap(self, gap: f64) -> HighsOptions

Examples found in repository

examples/lot_sizing.rs (line 100)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    const T: usize = 12;

    let demand: [f64; T] =
        [120.0, 90.0, 80.0, 140.0, 160.0, 200.0, 220.0, 190.0, 150.0, 130.0, 100.0, 170.0];
    let prod_cost: [f64; T] = [5.0, 5.0, 5.0, 5.5, 6.0, 6.5, 6.5, 6.0, 5.5, 5.0, 5.0, 5.5];
    let setup_cost = 500.0;
    let hold_cost = 2.0;
    let capacity = 300.0;
    let initial_inventory = 50.0;
    let safety_stock = 30.0;

    let m = Model::new("lot_sizing");
    let periods = Set::range(0..T);

    let x = m.indexed_var("x", &periods).lb(0.0).ub(capacity).build();
    let h = m.indexed_var("h", &periods).lb(0.0).build();
    let s = m.indexed_var("s", &periods).binary().build();

    m.constraint("inv_bal[0]", (h[0] - x[0]).eq(initial_inventory - demand[0]));
    m.add_constraints_over("inv_bal", &periods.filter(|k| k.as_i64().unwrap() > 0), |t: usize| {
        (h[t] - h[t - 1] - x[t]).eq(-demand[t])
    });
    m.add_constraints_over("setup", &periods, |t: usize| (x[t] - capacity * s[t]).le(0.0));
    m.constraint("safety_stock", h[T - 1].ge(safety_stock));

    let cost =
        sum_over(&periods, |t: usize| prod_cost[t] * x[t] + setup_cost * s[t] + hold_cost * h[t]);
    m.minimize(cost);

    #[cfg(feature = "gurobi")]
    let result = {
        let opts = GurobiOptions::default()
            .time_limit(std::time::Duration::from_secs(60))
            .mip_gap(1e-4)
            .verbose(true);
        Gurobi.solve(&m, &opts)?
    };

    #[cfg(all(feature = "highs", not(feature = "gurobi")))]
    let result = {
        let opts = HighsOptions::default()
            .time_limit(std::time::Duration::from_secs(60))
            .mip_gap(1e-4)
            .verbose(true);
        Highs.solve(&m, &opts)?
    };

    println!("\nLot-Sizing Result");
    println!("Status    : {:?}", result.status);
    if let Some(obj) = result.objective {
        println!("Total cost: {obj:.2}");
    }

    println!(
        "\n{:<8} {:>10} {:>10} {:>8} {:>12}",
        "Period", "Produce", "Inventory", "Active", "Period cost"
    );
    println!("{}", "-".repeat(55));

    let mut total_check = 0.0;
    for t in 0..T {
        let xt = result.value_of(x[t]).unwrap_or(0.0);
        let ht = result.value_of(h[t]).unwrap_or(0.0);
        let st = result.value_of(s[t]).unwrap_or(0.0);
        let period_cost = prod_cost[t] * xt + setup_cost * st + hold_cost * ht;
        total_check += period_cost;
        println!(
            "{:<8} {:>10.1} {:>10.1} {:>8} {:>12.2}",
            t + 1,
            xt,
            ht,
            if (st - 1.0).abs() < 1e-6 { "Yes" } else { "No" },
            period_cost
        );
    }
    println!("{}", "-".repeat(55));
    println!("{:<8} {:>10} {:>10} {:>8} {:>12.2}", "TOTAL", "", "", "", total_check);

    Ok(())
}

pub fn presolve(self, p: HighsPresolve) -> HighsOptions

pub fn method(self, m: HighsMethod) -> HighsOptions

pub fn parallel(self, on: bool) -> HighsOptions

Trait Implementations

impl Clone for HighsOptions

fn clone(&self) -> HighsOptions

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for HighsOptions

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

Formats the value using the given formatter.

impl Default for HighsOptions

fn default() -> HighsOptions

Returns the “default value” for a type.

impl HasUniversal for HighsOptions

fn universal(&self) -> &UniversalOptions

fn universal_mut(&mut self) -> &mut UniversalOptions