oximo 0.6.0

A Rust algebraic modeling library for solving optimization problems
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

use criterion::Criterion;
use oximo_highs::benchmark_support;

use super::common::{pair, sizes};

#[expect(clippy::cast_precision_loss)]
/// Measure HiGHS row extraction and its rejected result-map candidate.
pub fn bench(criterion: &mut Criterion) {
    // Measures ordered linear row extraction before building the native model.
    let mut row_group = criterion.benchmark_group("preprocessing/highs_rows");
    for (size, rows) in sizes(benchmark_support::ROW_THRESHOLD) {
        let model = benchmark_support::row_model(rows);
        pair(&mut row_group, &format!("{size}/{rows}"), rows, &model, |model, parallel| {
            benchmark_support::rows(model, parallel).unwrap()
        });
    }
    row_group.finish();

    // Measures complete RowProblem construction, without solver setup or solve.
    let mut translation_group = criterion.benchmark_group("preprocessing/highs_translation");
    for (size, rows) in sizes(benchmark_support::ROW_THRESHOLD) {
        let model = benchmark_support::row_model(rows);
        translation_group.throughput(criterion::Throughput::Elements(rows as u64));
        translation_group.bench_with_input(
            criterion::BenchmarkId::new(format!("lp/{size}/{rows}"), "serial"),
            &model,
            |bencher, model| {
                bencher.iter(|| {
                    std::hint::black_box(
                        benchmark_support::translate(std::hint::black_box(model)).unwrap(),
                    )
                });
            },
        );
    }
    translation_group.finish();

    // Re-measures the parallel HashMap candidate rejected for result parsing.
    let mut map_group = criterion.benchmark_group("preprocessing/highs_solution_maps_rejected");
    for (size, rows) in sizes(2731) {
        let values: Vec<f64> = (0..rows).map(|i| i as f64).collect();
        pair(&mut map_group, &format!("{size}/{rows}"), rows * 3, &values, |values, parallel| {
            benchmark_support::solution_maps(values, parallel)
        });
    }
    map_group.finish();
}