ndarray-interp 0.6.0

Interpolation package for ndarray
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
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92

//! Benchmarks for the [`Interp1D::interp_array`] method with different qeury dimensions

use criterion::{criterion_group, criterion_main, Criterion};
use ndarray::{Array, Axis};
use ndarray_interp::interp1d::Interp1D;

use rand_extensions::RandArray;

mod rand_extensions;

fn bench_scalar_data_1d_query(c: &mut Criterion) {
    let data = Array::from_rand(100, (0.0, 1.0), 42);
    let interp = Interp1D::builder(data).build().unwrap();
    let query = Array::from_rand(10_000, (0.0, 99.0), 123);

    let query = query.into_shape_with_order((2500, 4)).unwrap();
    let query_arr: Vec<_> = query.axis_iter(Axis(0)).collect();
    c.bench_function("1D scalar `interp_array`", |b| {
        b.iter(|| {
            for x in &query_arr {
                interp.interp_array(x).unwrap();
            }
        })
    });

    let mut buffer = Array::zeros(4);
    c.bench_function("1D scalar `interp_array_into`", |b| {
        b.iter(|| {
            for x in &query_arr {
                interp.interp_array_into(x, buffer.view_mut()).unwrap();
            }
        })
    });
}

fn bench_scalar_data_2d_query(c: &mut Criterion) {
    let data = Array::from_rand(100, (0.0, 1.0), 42);
    let interp = Interp1D::builder(data).build().unwrap();
    let query = Array::from_rand(10_000, (0.0, 99.0), 123);

    let query = query.into_shape_with_order((625, 4, 4)).unwrap();
    let query_arr: Vec<_> = query.axis_iter(Axis(0)).collect();
    c.bench_function("1D scalar `interp_array` 2D-query", |b| {
        b.iter(|| {
            for x in &query_arr {
                interp.interp_array(x).unwrap();
            }
        })
    });

    let mut buffer = Array::zeros((4, 4));
    c.bench_function("1D scalar `interp_array_into` 2D-query", |b| {
        b.iter(|| {
            for x in &query_arr {
                interp.interp_array_into(x, buffer.view_mut()).unwrap();
            }
        })
    });
}

fn bench_scalar_data_3d_query(c: &mut Criterion) {
    let data = Array::from_rand(100, (0.0, 1.0), 42);
    let interp = Interp1D::builder(data).build().unwrap();
    let query = Array::from_rand(10_000, (0.0, 99.0), 123);

    let query = query.into_shape_with_order((125, 5, 4, 4)).unwrap();
    let query_arr: Vec<_> = query.axis_iter(Axis(0)).collect();
    c.bench_function("1D scalar `interp_array` 3D-query", |b| {
        b.iter(|| {
            for x in &query_arr {
                interp.interp_array(x).unwrap();
            }
        })
    });

    let mut buffer = Array::zeros((5, 4, 4));
    c.bench_function("1D scalar `interp_array_into` 3D-query", |b| {
        b.iter(|| {
            for x in &query_arr {
                interp.interp_array_into(x, buffer.view_mut()).unwrap();
            }
        })
    });
}

criterion_group!(
    benches,
    bench_scalar_data_1d_query,
    bench_scalar_data_2d_query,
    bench_scalar_data_3d_query,
);
criterion_main!(benches);