interpn 0.6.3__tar.gz → 0.6.4__tar.gz

{interpn-0.6.3 → interpn-0.6.4}/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## 0.6.4 2025-10-24
+
+Implement N-dimensional nearest-neighbor interpolation on regular and rectilinear grids.
+
+### Added
+
+* Rust
+  * Add `nearest` module with regular- and rectilinear- grid methods in up to 6 dimensions
+  * Reduce code duplication for fixed-dim array indexing
+  * Update pyo3 and numpy rust deps
+* Python
+  * Add bindings, tests, benchmarks, and quality-of-fit plots for `NearestRegular` and `NearestRectilinear`
+  * Update PGO profile data to include new functions
+
 ## 0.6.3 2025-10-22
 
 Unpin max supported python version due to use of stable ABI3,

{interpn-0.6.3 → interpn-0.6.4}/Cargo.lock

@@ -221,7 +221,7 @@ checksum = "b248f5224d1d606005e02c97f5aa4e88eeb230488bcc03bc9ca4d7991399f2b5"
 
 [[package]]
 name = "interpn"
-version = "0.6.2"
+version = "0.6.4"
 dependencies = [
  "criterion",
  "crunchy",
@@ -355,9 +355,9 @@ dependencies = [
 
 [[package]]
 name = "numpy"
-version = "0.26.0"
+version = "0.27.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9b2dba356160b54f5371b550575b78130a54718b4c6e46b3f33a6da74a27e78b"
+checksum = "0fa24ffc88cf9d43f7269d6b6a0d0a00010924a8cc90604a21ef9c433b66998d"
 dependencies = [
  "libc",
  "ndarray",
@@ -444,9 +444,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3"
-version = "0.26.0"
+version = "0.27.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7ba0117f4212101ee6544044dae45abe1083d30ce7b29c4b5cbdfa2354e07383"
+checksum = "37a6df7eab65fc7bee654a421404947e10a0f7085b6951bf2ea395f4659fb0cf"
 dependencies = [
  "indoc",
  "libc",
@@ -461,9 +461,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-build-config"
-version = "0.26.0"
+version = "0.27.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4fc6ddaf24947d12a9aa31ac65431fb1b851b8f4365426e182901eabfb87df5f"
+checksum = "f77d387774f6f6eec64a004eac0ed525aab7fa1966d94b42f743797b3e395afb"
 dependencies = [
  "python3-dll-a",
  "target-lexicon",
@@ -471,9 +471,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-ffi"
-version = "0.26.0"
+version = "0.27.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "025474d3928738efb38ac36d4744a74a400c901c7596199e20e45d98eb194105"
+checksum = "2dd13844a4242793e02df3e2ec093f540d948299a6a77ea9ce7afd8623f542be"
 dependencies = [
  "libc",
  "pyo3-build-config",
@@ -481,9 +481,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-macros"
-version = "0.26.0"
+version = "0.27.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2e64eb489f22fe1c95911b77c44cc41e7c19f3082fc81cce90f657cdc42ffded"
+checksum = "eaf8f9f1108270b90d3676b8679586385430e5c0bb78bb5f043f95499c821a71"
 dependencies = [
  "proc-macro2",
  "pyo3-macros-backend",
@@ -493,9 +493,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-macros-backend"
-version = "0.26.0"
+version = "0.27.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "100246c0ecf400b475341b8455a9213344569af29a3c841d29270e53102e0fcf"
+checksum = "70a3b2274450ba5288bc9b8c1b69ff569d1d61189d4bff38f8d22e03d17f932b"
 dependencies = [
  "heck",
  "proc-macro2",

{interpn-0.6.3 → interpn-0.6.4}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "interpn"
-version = "0.6.2"
+version = "0.6.4"
 edition = "2024"
 authors = ["James Logan <jlogan03@gmail.com>"]
 license = "MIT OR Apache-2.0"
@@ -20,8 +20,8 @@ num-traits = { version = "0.2.19", default-features = false, features = ["libm"]
 crunchy = { version = "0.2.4", default-features = false, features = ["limit_256"] }
 
 # Python bindings
-pyo3 = { version = "0.26.0", features = ["extension-module", "abi3-py39", "generate-import-lib"], optional = true }
-numpy = { version = "0.26.0", optional = true }
+pyo3 = { version = "0.27.1", features = ["extension-module", "abi3-py39", "generate-import-lib"], optional = true }
+numpy = { version = "0.27.0", optional = true }
 
 # Test-only utils
 itertools = { version = "0.14.0", optional = true }

{interpn-0.6.3 → interpn-0.6.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: interpn
-Version: 0.6.3
+Version: 0.6.4
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy

{interpn-0.6.3 → interpn-0.6.4}/benches/bench.rs

@@ -3,8 +3,8 @@
 use criterion::*;
 use gridgen::*;
 use interpn::{
-    Linear1D, LinearHoldLast1D, MultilinearRegular, RectilinearGrid1D, RegularGrid1D, multicubic,
-    multilinear,
+    Linear1D, LinearHoldLast1D, MultilinearRegular, NearestRectilinear, NearestRegular,
+    RectilinearGrid1D, RegularGrid1D, multicubic, multilinear, nearest,
     one_dim::{
         Interp1D,
         hold::{Left1D, Nearest1D},
@@ -135,6 +135,70 @@ macro_rules! bench_interp_specific {
             },
         );
 
+        $group.bench_with_input(
+            BenchmarkId::new(
+                format!(
+                    "Nearest Regular {}x{}D, {}",
+                    $gridsize, $ndims, scan_or_shuffle
+                ),
+                $size,
+            ),
+            $size,
+            |b, &size| {
+                let (grids, z) = gen_grid($ndims, $gridsize, 0.0);
+                let m: usize = ((size as f64).powf(1.0 / ($ndims as f64)) + 2.0) as usize;
+                let gridobs_t = match $kind {
+                    Kind::Interp => gen_interp_obs_grid(&grids, m, true),
+                    Kind::Extrap => gen_extrap_obs_grid(&grids, m, true),
+                };
+                let obs: Vec<&[f64]> = gridobs_t.iter().map(|x| &x[..size]).collect();
+                let mut out = vec![0.0; size];
+
+                let dims = [$gridsize; $ndims];
+                let mut starts = [0.0; $ndims];
+                let mut steps = [0.0; $ndims];
+                (0..$ndims).for_each(|i| starts[i] = grids[i][0]);
+                (0..$ndims).for_each(|i| steps[i] = grids[i][1] - grids[i][0]);
+
+                b.iter(|| {
+                    black_box({
+                        nearest::regular::interpn(&dims, &starts, &steps, &z, &obs[..], &mut out)
+                            .unwrap()
+                    })
+                });
+            },
+        );
+
+        $group.bench_with_input(
+            BenchmarkId::new(
+                format!(
+                    "Nearest Rectilinear {}x{}D, {}",
+                    $gridsize, $ndims, scan_or_shuffle
+                ),
+                $size,
+            ),
+            $size,
+            |b, &size| {
+                let (grids, z) = gen_grid($ndims, $gridsize, 1e-3);
+
+                let m: usize = ((size as f64).powf(1.0 / ($ndims as f64)) + 2.0) as usize;
+                let gridobs_t = match $kind {
+                    Kind::Interp => gen_interp_obs_grid(&grids, m, true),
+                    Kind::Extrap => gen_extrap_obs_grid(&grids, m, true),
+                };
+                let obs: Vec<&[f64]> = gridobs_t.iter().map(|x| &x[..size]).collect();
+                let mut out = vec![0.0; size];
+
+                let gridslice: Vec<&[f64]> = grids.iter().map(|x| &x[..]).collect();
+
+                b.iter(|| {
+                    black_box(
+                        nearest::rectilinear::interpn(&gridslice, &z, &obs, &mut out).unwrap(),
+                    )
+                });
+            },
+        );
+
         $group.bench_with_input(
             BenchmarkId::new(
                 format!(
@@ -426,41 +490,8 @@ fn bench_interp(c: &mut Criterion) {
     }
 }
 
-fn bench_extrap(c: &mut Criterion) {
-    //
-    // Shuffled (un-ordered observation points)
-    //
-    for gridsize in [10] {
-        let mut group = c.benchmark_group(format!("Extrap_1D_Shuffled_{gridsize}-grid"));
-        for size in [1, 100, 1_000_000].iter() {
-            group.throughput(Throughput::Elements(*size as u64));
-            bench_interp_specific!(group, 1, gridsize, size, Kind::Extrap);
-        }
-        group.finish();
-    }
-
-    for gridsize in [10] {
-        let mut group = c.benchmark_group(format!("Extrap_2D_Shuffled_{gridsize}-grid"));
-        for size in [1, 100, 1_000_000].iter() {
-            group.throughput(Throughput::Elements(*size as u64));
-            bench_interp_specific!(group, 2, gridsize, size, Kind::Extrap);
-        }
-        group.finish();
-    }
-
-    for gridsize in [10] {
-        let mut group = c.benchmark_group(format!("Extrap_3D_Shuffled_{gridsize}-grid"));
-        for size in [1, 100, 1_000_000].iter() {
-            group.throughput(Throughput::Elements(*size as u64));
-            bench_interp_specific!(group, 3, gridsize, size, Kind::Extrap);
-        }
-        group.finish();
-    }
-}
-
 criterion_group!(benches_interp, bench_interp);
-criterion_group!(benches_extrap, bench_extrap);
-criterion_main!(benches_interp, benches_extrap,);
+criterion_main!(benches_interp);
 
 mod randn {
     use rand::Rng;

{interpn-0.6.3 → interpn-0.6.4}/benches/bench_cpu.py

@@ -14,6 +14,8 @@ from interpn import (
     MultilinearRegular,
     MulticubicRegular,
     MulticubicRectilinear,
+    NearestRegular,
+    NearestRectilinear,
 )
 
 # Toggle SciPy/NumPy baselines via environment for PGO workloads.
@@ -85,6 +87,8 @@ def bench_4_dims_1_obs():
     cubic_rectilinear_interpn = MulticubicRectilinear.new(
         grids, zgrid, linearize_extrapolation=True
     )
+    nearest_regular_interpn = NearestRegular.new(dims, starts, steps, zgrid)
+    nearest_rectilinear_interpn = NearestRectilinear.new(grids, zgrid)
 
     # Preallocate output for potential perf advantage
     # Allocate at eval for 1:1 comparison with Scipy
@@ -98,6 +102,10 @@ def bench_4_dims_1_obs():
         "InterpN MulticubicRectilinear": lambda p: cubic_rectilinear_interpn.eval(
             p, out
         ),
+        "InterpN NearestRegular": lambda p: nearest_regular_interpn.eval(p, out),
+        "InterpN NearestRectilinear": lambda p: nearest_rectilinear_interpn.eval(
+            p, out
+        ),
         "numpy interp": lambda p: np.interp(p[0], grids[0], zgrid),  # 1D only
     }
 
@@ -111,6 +119,8 @@ def bench_4_dims_1_obs():
         "InterpN MultilinearRectilinear": points_interpn,
         "InterpN MulticubicRegular": points_interpn,
         "InterpN MulticubicRectilinear": points_interpn,
+        "InterpN NearestRegular": points_interpn,
+        "InterpN NearestRectilinear": points_interpn,
         "numpy interp": points_interpn,
     }
 
@@ -139,6 +149,8 @@ def bench_4_dims_1_obs():
         "InterpN MultilinearRectilinear": points_interpn1,
         "InterpN MulticubicRegular": points_interpn1,
         "InterpN MulticubicRectilinear": points_interpn1,
+        "InterpN NearestRegular": points_interpn1,
+        "InterpN NearestRectilinear": points_interpn1,
         "numpy interp": points_interpn1,
     }
 
@@ -167,6 +179,8 @@ def bench_4_dims_1_obs():
         "InterpN MultilinearRectilinear": points_interpn2,
         "InterpN MulticubicRegular": points_interpn2,
         "InterpN MulticubicRectilinear": points_interpn2,
+        "InterpN NearestRegular": points_interpn2,
+        "InterpN NearestRectilinear": points_interpn2,
         "numpy interp": points_interpn2,
     }
 
@@ -198,6 +212,8 @@ def bench_4_dims_1_obs():
         "InterpN MultilinearRectilinear": points_interpn3,
         "InterpN MulticubicRegular": points_interpn3,
         "InterpN MulticubicRectilinear": points_interpn3,
+        "InterpN NearestRegular": points_interpn3,
+        "InterpN NearestRectilinear": points_interpn3,
         "numpy interp": points_interpn3,
     }
 
@@ -245,6 +261,8 @@ def bench_3_dims_n_obs_unordered():
         cubic_rectilinear_interpn = MulticubicRectilinear.new(
             grids, zgrid, linearize_extrapolation=True
         )
+        nearest_regular_interpn = NearestRegular.new(dims, starts, steps, zgrid)
+        nearest_rectilinear_interpn = NearestRectilinear.new(grids, zgrid)
 
         throughputs = {
             "Scipy RegularGridInterpolator Linear": [],
@@ -253,6 +271,8 @@ def bench_3_dims_n_obs_unordered():
             "InterpN MultilinearRectilinear": [],
             "InterpN MulticubicRegular": [],
             "InterpN MulticubicRectilinear": [],
+            "InterpN NearestRegular": [],
+            "InterpN NearestRectilinear": [],
         }
         # ns = np.logspace(0, 5, 10, base=10)
         # ns = [int(x) for x in ns]
@@ -291,6 +311,12 @@ def bench_3_dims_n_obs_unordered():
                 "InterpN MulticubicRectilinear": lambda p: cubic_rectilinear_interpn.eval(
                     p, out
                 ),
+                "InterpN NearestRegular": lambda p: nearest_regular_interpn.eval(
+                    p, out
+                ),
+                "InterpN NearestRectilinear": lambda p: nearest_rectilinear_interpn.eval(
+                    p, out
+                ),
             }
 
             # Interpolation in random order
@@ -303,6 +329,8 @@ def bench_3_dims_n_obs_unordered():
                 "InterpN MultilinearRectilinear": points_interpn,
                 "InterpN MulticubicRegular": points_interpn,
                 "InterpN MulticubicRectilinear": points_interpn,
+                "InterpN NearestRegular": points_interpn,
+                "InterpN NearestRectilinear": points_interpn,
             }
 
             for name, func in interps.items():
@@ -322,6 +350,8 @@ def bench_3_dims_n_obs_unordered():
             "InterpN MultilinearRectilinear": "Linear",
             "InterpN MulticubicRegular": "Cubic",
             "InterpN MulticubicRectilinear": "Cubic",
+            "InterpN NearestRegular": "Linear",
+            "InterpN NearestRectilinear": "Linear",
         }
 
         linestyles = ["dotted", "-", "--", "-.", (0, (3, 1, 1, 1, 1, 1))]
@@ -394,6 +424,8 @@ def bench_4_dims_n_obs_unordered():
         cubic_rectilinear_interpn = MulticubicRectilinear.new(
             grids, zgrid, linearize_extrapolation=True
         )
+        nearest_regular_interpn = NearestRegular.new(dims, starts, steps, zgrid)
+        nearest_rectilinear_interpn = NearestRectilinear.new(grids, zgrid)
 
         throughputs = {
             "Scipy RegularGridInterpolator Linear": [],
@@ -402,6 +434,8 @@ def bench_4_dims_n_obs_unordered():
             "InterpN MultilinearRectilinear": [],
             "InterpN MulticubicRegular": [],
             "InterpN MulticubicRectilinear": [],
+            "InterpN NearestRegular": [],
+            "InterpN NearestRectilinear": [],
         }
         # ns = np.logspace(0, 4, 40, base=10)
         # ns = [int(x) for x in ns]
@@ -438,6 +472,12 @@ def bench_4_dims_n_obs_unordered():
                 "InterpN MulticubicRectilinear": lambda p: cubic_rectilinear_interpn.eval(
                     p, out
                 ),
+                "InterpN NearestRegular": lambda p: nearest_regular_interpn.eval(
+                    p, out
+                ),
+                "InterpN NearestRectilinear": lambda p: nearest_rectilinear_interpn.eval(
+                    p, out
+                ),
             }
 
             # Interpolation in random order
@@ -450,6 +490,8 @@ def bench_4_dims_n_obs_unordered():
                 "InterpN MultilinearRectilinear": points_interpn,
                 "InterpN MulticubicRegular": points_interpn,
                 "InterpN MulticubicRectilinear": points_interpn,
+                "InterpN NearestRegular": points_interpn,
+                "InterpN NearestRectilinear": points_interpn,
             }
 
             for name, func in interps.items():
@@ -467,6 +509,8 @@ def bench_4_dims_n_obs_unordered():
             "InterpN MultilinearRectilinear": "Linear",
             "InterpN MulticubicRegular": "Cubic",
             "InterpN MulticubicRectilinear": "Cubic",
+            "InterpN NearestRegular": "Linear",
+            "InterpN NearestRectilinear": "Linear",
         }
 
         linestyles = ["dotted", "-", "--", "-.", (0, (3, 1, 1, 1, 1, 1))]
@@ -518,6 +562,8 @@ def bench_throughput_vs_dims():
             "InterpN MultilinearRectilinear": [],
             "InterpN MulticubicRegular": [],
             "InterpN MulticubicRectilinear": [],
+            "InterpN NearestRegular": [],
+            "InterpN NearestRectilinear": [],
             "Scipy RectBivariateSpline Cubic": [],  # Move to end to order plots
             "Numpy Interp": [],
         }
@@ -548,6 +594,8 @@ def bench_throughput_vs_dims():
             cubic_rectilinear_interpn = MulticubicRectilinear.new(
                 grids, zgrid, linearize_extrapolation=True
             )
+            nearest_regular_interpn = NearestRegular.new(dims, starts, steps, zgrid)
+            nearest_rectilinear_interpn = NearestRectilinear.new(grids, zgrid)
 
             m = max(int(float(nobs) ** (1.0 / ndims) + 2), 2)
 
@@ -570,6 +618,8 @@ def bench_throughput_vs_dims():
                 "InterpN MultilinearRectilinear": rectilinear_interpn.eval,
                 "InterpN MulticubicRegular": cubic_regular_interpn.eval,
                 "InterpN MulticubicRectilinear": cubic_rectilinear_interpn.eval,
+                "InterpN NearestRegular": nearest_regular_interpn.eval,
+                "InterpN NearestRectilinear": nearest_rectilinear_interpn.eval,
             }
 
             if ndims == 1:
@@ -594,6 +644,8 @@ def bench_throughput_vs_dims():
                 "InterpN MultilinearRectilinear": points_interpn,
                 "InterpN MulticubicRegular": points_interpn,
                 "InterpN MulticubicRectilinear": points_interpn,
+                "InterpN NearestRegular": points_interpn,
+                "InterpN NearestRectilinear": points_interpn,
                 "Numpy Interp": points_interpn,
             }
 
@@ -617,11 +669,13 @@ def bench_throughput_vs_dims():
             "InterpN MultilinearRectilinear": "Linear",
             "InterpN MulticubicRegular": "Cubic",
             "InterpN MulticubicRectilinear": "Cubic",
+            "InterpN NearestRegular": "Linear",
+            "InterpN NearestRectilinear": "Linear",
             "Numpy Interp": "Linear",
         }
 
-        linestyles = ["dotted", "-", "--", "-.", (0, (3, 1, 1, 1, 1, 1))]
-        alpha = [0.5, 1.0, 1.0, 1.0, 1.0]
+        linestyles = ["dotted", "-", "--", "-.", (0, (3, 1, 1, 1, 1, 1)), ":"]
+        alpha = [0.5, 1.0, 1.0, 1.0, 1.0, 1.0]
 
         _fig, axes = plt.subplots(1, 2, figsize=(12, 4.5), sharey=True)
         plt.suptitle(

{interpn-0.6.3 → interpn-0.6.4}/benches/bench_mem.py

@@ -16,6 +16,8 @@ from interpn import (
     MultilinearRegular,
     MulticubicRegular,
     MulticubicRectilinear,
+    NearestRegular,
+    NearestRectilinear,
 )
 
 
@@ -27,6 +29,8 @@ def bench_eval_mem_vs_dims():
         "InterpN MultilinearRectilinear": [],
         "InterpN MulticubicRegular": [],
         "InterpN MulticubicRectilinear": [],
+        "InterpN NearestRegular": [],
+        "InterpN NearestRectilinear": [],
     }
     ndims_to_test = [x for x in range(1, 9)]
     for ndims in ndims_to_test:
@@ -97,14 +101,14 @@ def bench_eval_mem_vs_dims():
             mems = memory_usage((func, (p,), {}), interval=1e-9, backend="psutil")
             usages[name].append(max(mems))
 
-    kinds = {
-        "Scipy RegularGridInterpolator Linear": "Linear",
-        "Scipy RegularGridInterpolator Cubic": "Cubic",
-        "InterpN MultilinearRegular": "Linear",
-        "InterpN MultilinearRectilinear": "Linear",
-        "InterpN MulticubicRegular": "Cubic",
-        "InterpN MulticubicRectilinear": "Cubic",
-    }
+        kinds = {
+            "Scipy RegularGridInterpolator Linear": "Linear",
+            "Scipy RegularGridInterpolator Cubic": "Cubic",
+            "InterpN MultilinearRegular": "Linear",
+            "InterpN MultilinearRectilinear": "Linear",
+            "InterpN MulticubicRegular": "Cubic",
+            "InterpN MulticubicRectilinear": "Cubic",
+        }
 
     linestyles = ["dotted", "-", "--", "-.", (0, (3, 1, 1, 1, 1, 1))]
     alpha = [0.5, 1.0, 1.0, 1.0, 1.0]