Struct BenchmarkRunner 

pub struct BenchmarkRunner { /* private fields */ }

Executes the same generated instance through registered adapters.

Implementations

impl BenchmarkRunner

pub const fn new() -> BenchmarkRunner

Creates an empty runner.

Examples found in repository

examples/synthetic.rs (line 34)

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(())
}

pub fn add_solver(&mut self, solver: Box<dyn ComparisonSolver>)

Registers a solver adapter.

Examples found in repository

examples/synthetic.rs (line 35)

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(())
}

pub fn run( &mut self, instance_name: &str, problem: &QpProblem, warm_start: Option<&WarmStart>, ) -> Vec<Result<BenchmarkRecord, String>>

Runs all adapters and returns records or labeled failures.

Examples found in repository

examples/synthetic.rs (line 38)

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(())
}

pub const fn markdown_header() -> &'static str

Markdown header matching BenchmarkRecord::markdown_row.

Examples found in repository

examples/synthetic.rs (line 37)

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 Default for BenchmarkRunner

fn default() -> BenchmarkRunner

Returns the “default value” for a type.