Struct BenchmarkRecord 

pub struct BenchmarkRecord {
    pub instance: String,
    pub solver: String,
    pub status: SolveStatus,
    pub objective: f64,
    pub primal_residual: f64,
    pub dual_residual: f64,
    pub iterations: usize,
    pub duration: Duration,
}

One measured solver/instance result.

Fields

instance: String

Instance label.

solver: String

Solver label.

status: SolveStatus

Termination status.

objective: f64

Objective at the returned point.

primal_residual: f64

Primal KKT residual.

dual_residual: f64

Dual KKT residual.

iterations: usize

ADMM or adapter iteration count.

duration: Duration

Measured solver-reported duration.

Implementations

impl BenchmarkRecord

pub fn markdown_row(&self) -> String

Renders one Markdown table row.

Examples found in repository

examples/synthetic.rs (line 40)

fn main() -> Result<(), Box<dyn Error>> {
    let mut config = SyntheticConfig::default();
    let mut settings = SolverSettings::default();
    let arguments: Vec<String> = env::args().skip(1).collect();
    let mut index = 0;
    while index < arguments.len() {
        let flag = &arguments[index];
        let value = arguments
            .get(index + 1)
            .ok_or_else(|| format!("missing value after {flag}"))?;
        match flag.as_str() {
            "--n" => config.assets = value.parse()?,
            "--k" => config.factors = value.parse()?,
            "--seed" => config.seed = value.parse()?,
            "--inequalities" => config.inequalities = value.parse()?,
            "--alpha" => settings.over_relaxation = value.parse()?,
            "--polish" => settings.polish = value.parse()?,
            _ => return Err(format!("unknown argument: {flag}").into()),
        }
        index += 2;
    }
    config.max_weight = (10.0 / config.assets as f64).min(1.0);

    let instance = generate_synthetic(config)?;
    let warm_start = WarmStart::from_primal(instance.feasible_reference.clone());
    let mut runner = BenchmarkRunner::new();
    runner.add_solver(Box::new(Solver::new(settings)));

    println!("{}", BenchmarkRunner::markdown_header());
    for record in runner.run(&instance.name, &instance.problem, Some(&warm_start)) {
        match record {
            Ok(record) => println!("{}", record.markdown_row()),
            Err(error) => eprintln!("{error}"),
        }
    }
    Ok(())
}

Trait Implementations

impl Clone for BenchmarkRecord

fn clone(&self) -> BenchmarkRecord

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for BenchmarkRecord

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

Formats the value using the given formatter.

impl PartialEq for BenchmarkRecord

fn eq(&self, other: &BenchmarkRecord) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for BenchmarkRecord