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
93
94
95
96
97
98
99
100

use criterion::{black_box, criterion_group, criterion_main, Criterion};
use ndarray::{Array, Array1, Axis};
use ndarray_interp::interp2d::{Bilinear, Interp2D, Interp2DScalar};

use rand_extensions::RandArray;

mod rand_extensions;

fn setup() -> (Interp2DScalar<f64, Bilinear>, Array1<f64>, Array1<f64>) {
    let data = Array::from_rand(10_000, (0.0, 1.0), 42)
        .into_shape_with_order((100, 100))
        .unwrap();
    let interp = Interp2D::builder(data).build().unwrap();
    let query_x = Array::from_rand(10_000, (0.0, 99.0), 123);
    let query_y = Array::from_rand(10_000, (0.0, 99.0), 96);
    (interp, query_x, query_y)
}

fn bench_scalar_data_1d_query(c: &mut Criterion) {
    let (interp, query_x, query_y) = black_box(setup());
    let query_x = query_x.into_shape_with_order((2500, 4)).unwrap();
    let query_y = query_y.into_shape_with_order((2500, 4)).unwrap();
    let query_arrx: Vec<_> = query_x.axis_iter(Axis(0)).collect();
    let query_arry: Vec<_> = query_y.axis_iter(Axis(0)).collect();

    c.bench_function("2D scalar `interp_array`", |b| {
        b.iter(|| {
            query_arrx.iter().zip(query_arry.iter()).for_each(|(x, y)| {
                interp.interp_array(x, y).unwrap();
            });
        })
    });

    let mut buffer = Array::zeros(4);
    c.bench_function("2D scalar `interp_array_into`", |b| {
        b.iter(|| {
            query_arrx.iter().zip(query_arry.iter()).for_each(|(x, y)| {
                interp.interp_array_into(x, y, buffer.view_mut()).unwrap();
            });
        })
    });
}

fn bench_scalar_data_2d_query(c: &mut Criterion) {
    let (interp, query_x, query_y) = black_box(setup());
    let query_x = query_x.into_shape_with_order((625, 4, 4)).unwrap();
    let query_y = query_y.into_shape_with_order((625, 4, 4)).unwrap();
    let query_arrx: Vec<_> = query_x.axis_iter(Axis(0)).collect();
    let query_arry: Vec<_> = query_y.axis_iter(Axis(0)).collect();

    c.bench_function("2D scalar `interp_array` 2D-query", |b| {
        b.iter(|| {
            query_arrx.iter().zip(query_arry.iter()).for_each(|(x, y)| {
                interp.interp_array(x, y).unwrap();
            });
        })
    });

    let mut buffer = Array::zeros((4, 4));
    c.bench_function("2D scalar `interp_array_into` 2D-query", |b| {
        b.iter(|| {
            query_arrx.iter().zip(query_arry.iter()).for_each(|(x, y)| {
                interp.interp_array_into(x, y, buffer.view_mut()).unwrap();
            });
        })
    });
}

fn bench_scalar_data_3d_query(c: &mut Criterion) {
    let (interp, query_x, query_y) = black_box(setup());
    let query_x = query_x.into_shape_with_order((125, 5, 4, 4)).unwrap();
    let query_y = query_y.into_shape_with_order((125, 5, 4, 4)).unwrap();
    let query_arrx: Vec<_> = query_x.axis_iter(Axis(0)).collect();
    let query_arry: Vec<_> = query_y.axis_iter(Axis(0)).collect();

    c.bench_function("2D scalar `interp_array` 3D-query", |b| {
        b.iter(|| {
            query_arrx.iter().zip(query_arry.iter()).for_each(|(x, y)| {
                interp.interp_array(x, y).unwrap();
            });
        })
    });

    let mut buffer = Array::zeros((5, 4, 4));
    c.bench_function("2D scalar `interp_array_into` 3D-query", |b| {
        b.iter(|| {
            query_arrx.iter().zip(query_arry.iter()).for_each(|(x, y)| {
                interp.interp_array_into(x, y, 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);