interpn 0.6.2__tar.gz → 0.6.4__tar.gz

{interpn-0.6.2 → interpn-0.6.4}/.github/workflows/release-python.yml

@@ -6,18 +6,14 @@
 name: release-python
 
 on:
-  push:
-    branches:
-      - main
   workflow_dispatch:
 
 permissions:
   contents: read
 
 jobs:
-  release_rust:
-    uses: ./.github/workflows/release-rust.yml
-    secrets: inherit
+  test_python:
+    uses: ./.github/workflows/test-python.yml
 
   linux:
     runs-on: ${{ matrix.platform.runner }}
@@ -124,7 +120,7 @@ jobs:
     strategy:
       matrix:
         platform:
-          - runner: macos-13
+          - runner: macos-15-intel
             target: x86_64
           - runner: macos-14
             target: aarch64
@@ -163,7 +159,7 @@ jobs:
     name: Release
     runs-on: ubuntu-latest
     # if: ${{ startsWith(github.ref, 'refs/tags/') || github.event_name == 'workflow_dispatch' }}
-    needs: [release_rust, linux, musllinux, windows, macos, sdist]
+    needs: [test_python, linux, musllinux, windows, macos, sdist]
     permissions:
       # Use to sign the release artifacts
       id-token: write

{interpn-0.6.2 → interpn-0.6.4}/.github/workflows/release-rust.yml

@@ -4,7 +4,6 @@ permissions:
   contents: read
 
 on:
-  workflow_call:
   workflow_dispatch:
 
 jobs:

{interpn-0.6.2 → interpn-0.6.4}/.github/workflows/test-python.yml

@@ -11,7 +11,13 @@ jobs:
     strategy:
       matrix:
         target: [x86_64]
-        python-version: ["3.9", "3.10", "3.11", "3.12", "3.13"]
+        python-version:
+          - "3.9"
+          - "3.10"
+          - "3.11"
+          - "3.12"
+          - "3.13"
+          - "3.14"
     steps:
     - uses: actions/checkout@v3
     - name: Install uv
@@ -42,7 +48,7 @@ jobs:
           - runner: windows-latest
           - runner: ubuntu-latest
           - runner: ubuntu-24.04-arm  # aarch64
-          - runner: macos-13  # x86_64
+          - runner: macos-15-intel  # x86_64
           - runner: macos-14  # aarch64
         python-version: ["3.9"]
     steps:

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

@@ -1,5 +1,39 @@
 # 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,
+along with a host of other improvements to packaging and actions workflows.
+
+### New Contributors
+
+* [Clément Robert](https://github.com/neutrinoceros) contributed PRs 30,32,33,36 making up all the substantial changes in this release. Thanks, Clément!
+
+### Changed
+
+* Python
+  * Unpin max python version
+  * Roll forward pydantic version for python 3.14 compatibility
+  * Update package metadata
+  * Add python 3.14 to test matrix
+* Workflows
+  * Reconfigure from single-contributor to commons-project by segmenting release workflows to be dispatched manually only
+  * Update python release workflow to depend on test-python instead of release-rust to support separate releases
+
 ## 0.6.2 2025-10-20
 
 Add optional use of fused multiply-add, enabled for python distributions.

{interpn-0.6.2 → 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.2 → 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.4/PKG-INFO

@@ -0,0 +1,227 @@
+Metadata-Version: 2.4
+Name: interpn
+Version: 0.6.4
+Classifier: Programming Language :: Rust
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Requires-Dist: numpy>=2
+Requires-Dist: pydantic>=2.12
+Requires-Dist: pytest>=8.4.2 ; extra == 'test'
+Requires-Dist: pytest-cov>=7.0.0 ; extra == 'test'
+Requires-Dist: ruff>=0.13.3 ; extra == 'test'
+Requires-Dist: pyright==1.1.337 ; extra == 'test'
+Requires-Dist: mktestdocs>=0.2.1 ; extra == 'test'
+Requires-Dist: scipy>=1.11.4 ; extra == 'test'
+Requires-Dist: matplotlib>=3.8 ; extra == 'test'
+Requires-Dist: scipy>=1.11.4 ; extra == 'bench'
+Requires-Dist: matplotlib>=3.8 ; extra == 'bench'
+Requires-Dist: memory-profiler>=0.61.0 ; extra == 'bench'
+Requires-Dist: mkdocs>=1.5.3 ; extra == 'doc'
+Requires-Dist: mkdocstrings-python>=1.7.5 ; extra == 'doc'
+Requires-Dist: mkdocs-material>=9.4.10 ; extra == 'doc'
+Provides-Extra: test
+Provides-Extra: bench
+Provides-Extra: doc
+License-File: LICENSE-MIT
+License-File: LICENSE-APACHE
+Summary: N-dimensional interpolation/extrapolation methods
+Home-Page: https://github.com/jlogan03/interpn/
+Author-email: James Logan <jlogan03@gmail.com>
+License-Expression: MIT OR Apache-2.0
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+Project-URL: repository, https://github.com/jlogan03/interpn
+Project-URL: documentation, https://interpn.readthedocs.io/
+
+# InterpN
+
+[Repo](https://github.com/jlogan03/interpn) |
+[Python Docs](https://interpnpy.readthedocs.io/en/latest/) |
+[Rust Docs](https://docs.rs/interpn/latest/interpn/)
+
+N-dimensional interpolation/extrapolation methods, no-std and no-alloc compatible,
+prioritizing correctness, performance, and compatiblity with memory-constrained environments.
+
+Available as a rust crate and python library.
+
+These methods perform zero allocation when evaluated (except, optionally, for the output).
+Because of this, they have minimal per-call overhead, and are particularly
+effective when examining small numbers of observation points. See the
+[performance](https://interpnpy.readthedocs.io/en/latest/perf/) page for detailed benchmarks.
+
+## Features
+
+| Feature →<br>↓ Interpolant Method | Regular<br>Grid | Rectilinear<br>Grid | Json<br>Serialization |
+|-----------------------------------|-----------------|---------------------|-----------------------|
+| Linear                            |   ✅            |     ✅              | ✅                    |
+| Cubic                             |   ✅            |     ✅              | ✅                    |
+
+The methods provided here, while more limited in scope than scipy's,
+
+* are significantly faster under most conditions
+* use almost no RAM (and perform no heap allocations at all)
+* produce significantly improved floating-point error (by several orders of magnitude)
+* are json-serializable using Pydantic
+* can also be used easily in web and embedded applications via the Rust library
+* are permissively licensed
+
+![ND throughput 1000 obs](./docs/throughput_vs_dims_1000_obs.svg)
+
+See [here](https://interpnpy.readthedocs.io/en/latest/perf/) for more info about quality-of-fit, throughput, and memory usage.
+
+## Installation
+
+```bash
+pip install interpn
+```
+
+## Profile-Guided Optimization
+
+To build the extension with profile-guided optimization using pre-built profiles, do `sh ./scripts/pgo_install.sh`.
+You can also generate your own PGO profiles like `sh ./scripts/pgo_profile.sh`.
+after installing these extra compiler dependencies:
+
+```bash
+rustup component add llvm-tools-preview
+```
+
+## Rust Examples
+
+### Regular Grid
+```rust
+use interpn::{multilinear, multicubic};
+
+// Define a grid
+let x = [1.0_f64, 2.0, 3.0, 4.0];
+let y = [0.0_f64, 1.0, 2.0, 3.0];
+
+// Grid input for rectilinear method
+let grids = &[&x[..], &y[..]];
+
+// Grid input for regular grid method
+let dims = [x.len(), y.len()];
+let starts = [x[0], y[0]];
+let steps = [x[1] - x[0], y[1] - y[0]];
+
+// Values at grid points
+let z = [2.0; 16];
+
+// Observation points to interpolate/extrapolate
+let xobs = [0.0_f64, 5.0];
+let yobs = [-1.0, 3.0];
+let obs = [&xobs[..], &yobs[..]];
+
+// Storage for output
+let mut out = [0.0; 2];
+
+// Do interpolation
+multilinear::regular::interpn(&dims, &starts, &steps, &z, &obs, &mut out);
+multicubic::regular::interpn(&dims, &starts, &steps, &z, false, &obs, &mut out);
+```
+
+### Rectilinear Grid
+```rust
+use interpn::{multilinear, multicubic};
+
+// Define a grid
+let x = [1.0_f64, 2.0, 3.0, 4.0];
+let y = [0.0_f64, 1.0, 2.0, 3.0];
+
+// Grid input for rectilinear method
+let grids = &[&x[..], &y[..]];
+
+// Values at grid points
+let z = [2.0; 16];
+
+// Points to interpolate/extrapolate
+let xobs = [0.0_f64, 5.0];
+let yobs = [-1.0, 3.0];
+let obs = [&xobs[..], &yobs[..]];
+
+// Storage for output
+let mut out = [0.0; 2];
+
+// Do interpolation
+multilinear::rectilinear::interpn(grids, &z, &obs, &mut out).unwrap();
+multicubic::rectilinear::interpn(grids, &z, false, &obs, &mut out).unwrap();
+```
+
+## Python Examples
+
+### Available Methods
+
+```python
+import interpn
+import numpy as np
+
+# Build grid
+x = np.linspace(0.0, 10.0, 5)
+y = np.linspace(20.0, 30.0, 4)
+grids = [x, y]
+
+xgrid, ygrid = np.meshgrid(x, y, indexing="ij")
+zgrid = (xgrid + 2.0 * ygrid)  # Values at grid points
+
+# Grid inputs for true regular grid
+dims = [x.size, y.size]
+starts = np.array([x[0], y[0]])
+steps = np.array([x[1] - x[0], y[1] - y[0]])
+
+# Initialize different interpolators
+# Call like `linear_regular.eval([xs, ys])`
+linear_regular = interpn.MultilinearRegular.new(dims, starts, steps, zgrid)
+cubic_regular = interpn.MulticubicRegular.new(dims, starts, steps, zgrid)
+linear_rectilinear = interpn.MultilinearRectilinear.new(grids, zgrid)
+cubic_rectilinear = interpn.MulticubicRectilinear.new(grids, zgrid)
+```
+
+### Multilinear Interpolation
+
+```python
+import interpn
+import numpy as np
+
+# Build grid
+x = np.linspace(0.0, 10.0, 5)
+y = np.linspace(20.0, 30.0, 4)
+
+xgrid, ygrid = np.meshgrid(x, y, indexing="ij")
+zgrid = (xgrid + 2.0 * ygrid)  # Values at grid points
+
+# Grid inputs for true regular grid
+dims = [x.size, y.size]
+starts = np.array([x[0], y[0]])
+steps = np.array([x[1] - x[0], y[1] - y[0]])
+
+# Observation points pointed back at the grid
+obs = [xgrid.flatten(), ygrid.flatten()]
+
+# Initialize
+interpolator = interpn.MultilinearRegular.new(dims, starts, steps, zgrid.flatten())
+
+# Interpolate
+out = interpolator.eval(obs)
+
+# Check result
+assert np.allclose(out, zgrid.flatten(), rtol=1e-13)
+
+# Serialize and deserialize
+roundtrip_interpolator = interpn.MultilinearRegular.model_validate_json(
+    interpolator.model_dump_json()
+)
+out2 = roundtrip_interpolator.eval(obs)
+
+# Check result from roundtrip serialized/deserialized interpolator
+assert np.all(out == out2)
+```
+
+
+# License
+
+Licensed under either of
+
+- Apache License, Version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or http://www.apache.org/licenses/LICENSE-2.0)
+- MIT license ([LICENSE-MIT](LICENSE-MIT) or http://opensource.org/licenses/MIT)
+
+at your option.
+

{interpn-0.6.2 → 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;