la-stack 0.5.2

Fast, stack-allocated linear algebra for fixed dimensions
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
48
49
50
51
52
53
54
55
56
57
58

#![forbid(unsafe_code)]

//! Focused structure-sensitive exact solve measurements, outside release reports.

use criterion::Criterion;
use std::hint::black_box;

#[path = "common/bench_utils.rs"]
mod bench_utils;
#[path = "common/rational_solve.rs"]
pub mod rational_solve;

use bench_utils::OrAbort;
use rational_solve::{Structure, solve_input};

fn bench_dimension<const D: usize>(criterion: &mut Criterion) {
    for structure in Structure::ALL {
        for dyadic in [false, true] {
            let input = solve_input::<D>(structure, dyadic);
            let coefficients = if dyadic { "dyadic" } else { "rational" };
            let mut group = criterion.benchmark_group(format!(
                "rational_solve/{}/{coefficients}_d{D}",
                structure.name()
            ));
            group.bench_function("legacy", |b| {
                b.iter(|| black_box(black_box(&input).legacy().or_abort("legacy solve")));
            });
            group.bench_function("construct", |b| {
                b.iter(|| black_box(black_box(&input).construct().or_abort("input construction")));
            });
            group.bench_function("prepared", |b| {
                b.iter(|| {
                    black_box(
                        black_box(input.matrix())
                            .solve(black_box(input.rhs()))
                            .or_abort("prepared solve"),
                    )
                });
            });
            group.bench_function("adapter", |b| {
                b.iter(|| black_box(black_box(&input).adapter().or_abort("adapter solve")));
            });
            group.finish();
        }
    }
}

fn main() {
    let mut criterion = Criterion::default().configure_from_args();
    bench_dimension::<2>(&mut criterion);
    bench_dimension::<3>(&mut criterion);
    bench_dimension::<4>(&mut criterion);
    bench_dimension::<5>(&mut criterion);
    bench_dimension::<6>(&mut criterion);
    bench_dimension::<7>(&mut criterion);
    bench_dimension::<8>(&mut criterion);
    criterion.final_summary();
}