Struct WarmStart

Source

pub struct WarmStart {
    pub x: Vec<f64>,
    pub equality_dual: Option<Vec<f64>>,
    pub inequality_dual: Option<Vec<f64>>,
    pub bound_dual: Option<Vec<f64>>,
    pub l1_dual: Option<Vec<f64>>,
}

Expand description

Optional initial primal and dual iterates.

Missing multiplier blocks are initialized to zero. Warm starts reuse iterates; to also reuse the equilibration and the reduced factorization across solves, keep a Workspace.

Fields§

§x: Vec<f64>

Initial decision vector.

§equality_dual: Option<Vec<f64>>

Optional equality multipliers.

§inequality_dual: Option<Vec<f64>>

Optional inequality multipliers.

§bound_dual: Option<Vec<f64>>

Optional box normal-cone multipliers.

§l1_dual: Option<Vec<f64>>

Optional L1 subgradient multipliers (problems with an L1Term only).

Implementations§

Source §

impl WarmStart

Source

pub fn from_primal(x: Vec<f64>) -> WarmStart

Constructs a primal-only warm start.

Examples found in repository ?

examples/synthetic.rs (line 33)

9fn main() -> Result<(), Box<dyn Error>> {
10    let mut config = SyntheticConfig::default();
11    let mut settings = SolverSettings::default();
12    let arguments: Vec<String> = env::args().skip(1).collect();
13    let mut index = 0;
14    while index < arguments.len() {
15        let flag = &arguments[index];
16        let value = arguments
17            .get(index + 1)
18            .ok_or_else(|| format!("missing value after {flag}"))?;
19        match flag.as_str() {
20            "--n" => config.assets = value.parse()?,
21            "--k" => config.factors = value.parse()?,
22            "--seed" => config.seed = value.parse()?,
23            "--inequalities" => config.inequalities = value.parse()?,
24            "--alpha" => settings.over_relaxation = value.parse()?,
25            "--polish" => settings.polish = value.parse()?,
26            _ => return Err(format!("unknown argument: {flag}").into()),
27        }
28        index += 2;
29    }
30    config.max_weight = (10.0 / config.assets as f64).min(1.0);
31
32    let instance = generate_synthetic(config)?;
33    let warm_start = WarmStart::from_primal(instance.feasible_reference.clone());
34    let mut runner = BenchmarkRunner::new();
35    runner.add_solver(Box::new(Solver::new(settings)));
36
37    println!("{}", BenchmarkRunner::markdown_header());
38    for record in runner.run(&instance.name, &instance.problem, Some(&warm_start)) {
39        match record {
40            Ok(record) => println!("{}", record.markdown_row()),
41            Err(error) => eprintln!("{error}"),
42        }
43    }
44    Ok(())
45}