Merge branch 'main' into cubic

Author: kylecarow

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ninterp"
-version = "0.5.1"
+version = "0.5.2"
 edition = "2021"
 description = "Numerical interpolation for N-dimensional rectilinear grids"
 repository = "https://github.com/NREL/ninterp"
@@ -15,10 +15,11 @@ keywords = [
 categories = ["mathematics"]
 
 [dependencies]
+dyn-clone = "1.0.19"
 itertools = "0.13.0"
-ndarray = "0.16.1"
+ndarray = ">=0.15, <0.17"
 num-traits = "0.2.19"
-serde = { version = "1.0.210", optional = true, features = ["derive"] }
+serde = { version = "1", optional = true, features = ["derive"] }
 thiserror = "1.0.64"
 
 [dev-dependencies]

README.md

@@ -15,7 +15,7 @@ cargo add ninterp
 ```
 
 #### Cargo Features
-- `serde`: support for serde
+- `serde`: support for serde ([caveat](https://github.com/NREL/ninterp/issues/5))
   ```
   cargo add ninterp --features serde
   ```
@@ -28,8 +28,8 @@ See examples in `new` method documentation:
 - [`Interp3D::new`](https://docs.rs/ninterp/latest/ninterp/three/struct.Interp3D.html#method.new)
 - [`InterpND::new`](https://docs.rs/ninterp/latest/ninterp/n/struct.InterpND.html#method.new)
 
-Also see the [`examples`](https://github.com/NREL/ninterp/tree/62a62ccd2b3c285919baae609089dee287dc3842/examples) directory for advanced examples:
-- Strategy dynamic dispatch: [`dynamic_strategy.rs`](https://github.com/NREL/ninterp/blob/62a62ccd2b3c285919baae609089dee287dc3842/examples/dynamic_strategy.rs)
+Also see the [`examples`](examples) directory for advanced examples:
+- Strategy dynamic dispatch: [`dynamic_strategy.rs`](examples/dynamic_strategy.rs)
 
   By default, construction of interpolators uses *static dispatch*,
   meaning strategy concrete types are determined at compilation.
@@ -38,9 +38,11 @@ Also see the [`examples`](https://github.com/NREL/ninterp/tree/62a62ccd2b3c28591
   use *dynamic dispatch* by providing a boxed trait object
   `Box<dyn Strategy1D>`/etc. to the `new` method.
 
-- Interpolator dynamic dispatch using `Box<dyn Interpolator>`: [`dynamic_interpolator.rs`](https://github.com/NREL/ninterp/blob/62a62ccd2b3c285919baae609089dee287dc3842/examples/dynamic_interpolator.rs)
+- Interpolator dynamic dispatch using `Box<dyn Interpolator>`: [`dynamic_interpolator.rs`](examples/dynamic_interpolator.rs)
 
-- Defining custom strategies: [`custom_strategy.rs`](https://github.com/NREL/ninterp/blob/62a62ccd2b3c285919baae609089dee287dc3842/examples/custom_strategy.rs)
+- Defining custom strategies: [`custom_strategy.rs`](examples/custom_strategy.rs)
+
+- Using transmutable (transparent) types, such as `uom::si::Quantity`: [`uom.rs`](examples/uom.rs)
 
 - Using transmutable (transparent) types, such as `uom::si::Quantity`: [`uom.rs`](https://github.com/NREL/ninterp/blob/de2c770dc3614ba43af9e015481fecdc20538380/examples/uom.rs)
 
@@ -63,7 +65,9 @@ This is useful when working with a `Box<dyn Interpolator>`
 Instantiation is done by calling an interpolator's `new` method.
 For dimensionalities N ≥ 1, this executes a validation step, preventing runtime panics.
 After editing interpolator data,
-call [`Interpolator::validate`](https://docs.rs/ninterp/latest/ninterp/trait.Interpolator.html#tymethod.validate) to rerun these checks.
+call the InterpData's `validate` method
+or [`Interpolator::validate`](https://docs.rs/ninterp/latest/ninterp/trait.Interpolator.html#tymethod.validate)
+to rerun these checks.
 
 To change the extrapolation setting, call `set_extrapolate`.
 
@@ -82,19 +86,19 @@ Not all interpolation strategies are implemented for every dimensionality.
 `Linear` and `Nearest` are implemented for all dimensionalities.
 
 Custom strategies can be defined. See
-[`examples/custom_strategy.rs`](https://github.com/NREL/ninterp/blob/62a62ccd2b3c285919baae609089dee287dc3842/examples/custom_strategy.rs)
+[`examples/custom_strategy.rs`](examples/custom_strategy.rs)
 for an example.
 
 ### Extrapolation
 An [`Extrapolate`](https://docs.rs/ninterp/latest/ninterp/enum.Extrapolate.html)
 setting must be provided in the `new` method.
 This controls what happens when a point is beyond the range of supplied coordinates.
-The following setttings are applicable for all interpolators:
+The following settings are applicable for all interpolators:
 - `Extrapolate::Fill(T)`
 - `Extrapolate::Clamp`
 - `Extrapolate::Error`
 
-`Extrapolate::Enable` is valid for `Linear` in all dimensionalities.
+`Extrapolate::Enable` is valid for `Linear` for all dimensionalities.
 
 If you are unsure which variant to choose, `Extrapolate::Error` is likely what you want.
 

examples/custom_strategy.rs

@@ -1,10 +1,14 @@
-use ndarray::prelude::*;
-
+use ninterp::data::InterpData2D;
 use ninterp::prelude::*;
 use ninterp::strategy::*;
 
+// Note: ninterp also re-exposes the internally used `ndarray` crate
+// `use ninterp::ndarray;`
+use ndarray::prelude::*;
+use ndarray::{Data, RawDataClone};
+
 // Debug must be derived for custom strategies
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 struct CustomStrategy;
 
 // Implement strategy for 2-D f32 interpolation
@@ -14,7 +18,7 @@ where
     // e.g. `Array2<f32>`, `ArrayView2<f32>`, `CowArray<<'a, f32>, Ix2>`, etc.
     // For a more generic bound, consider introducing a bound for D::Elem
     // e.g. D::Elem: num_traits::Num + PartialOrd
-    D: ndarray::Data<Elem = f32>,
+    D: Data<Elem = f32> + RawDataClone + Clone,
 {
     fn interpolate(
         &self,

examples/dynamic_interpolator.rs

@@ -25,5 +25,5 @@ fn main() {
         )
         .unwrap(),
     );
-    assert_eq!(boxed.interpolate(&[1.75]).unwrap(), 8.)
+    assert_eq!(boxed.interpolate(&[1.75]).unwrap(), 8.);
 }

examples/uom.rs

@@ -12,7 +12,7 @@ fn main() {
     let f_x = array![Power::new::<kilowatt>(0.25), Power::new::<kilowatt>(0.75)];
     // `uom::si::Quantity` is repr(transparent), meaning it has the same memory layout as its contained type.
     // This means we can get the contained type via transmuting.
-    let interp: Interp1D<ndarray::OwnedRepr<f64>, _> = unsafe {
+    let interp: ninterp::one::Interp1DOwned<f64, _> = unsafe {
         Interp1D::new(
             std::mem::transmute(x),
             std::mem::transmute(f_x),

src/data.rs

@@ -0,0 +1,56 @@
+use super::*;
+
+pub use crate::n::{InterpDataND, InterpDataNDOwned, InterpDataNDViewed};
+pub use crate::one::{InterpData1D, InterpData1DOwned, InterpData1DViewed};
+pub use crate::three::{InterpData3D, InterpData3DOwned, InterpData3DViewed};
+pub use crate::two::{InterpData2D, InterpData2DOwned, InterpData2DViewed};
+
+#[derive(Debug, Clone, PartialEq)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
+#[cfg_attr(
+    feature = "serde",
+    serde(bound = "
+        D: DataOwned,
+        D::Elem: Serialize + DeserializeOwned,
+        Dim<[usize; N]>: Serialize + DeserializeOwned,
+        [ArrayBase<D, Ix1>; N]: Serialize + DeserializeOwned,
+    ")
+)]
+pub struct InterpData<D, const N: usize>
+where
+    Dim<[Ix; N]>: Dimension,
+    D: Data + RawDataClone + Clone,
+    D::Elem: Num + PartialOrd + Copy + Debug,
+{
+    pub grid: [ArrayBase<D, Ix1>; N],
+    pub values: ArrayBase<D, Dim<[Ix; N]>>,
+}
+pub type InterpDataViewed<T, const N: usize> = InterpData<ndarray::ViewRepr<T>, N>;
+pub type InterpDataOwned<T, const N: usize> = InterpData<ndarray::ViewRepr<T>, N>;
+
+impl<D, const N: usize> InterpData<D, N>
+where
+    Dim<[Ix; N]>: Dimension,
+    D: Data + RawDataClone + Clone,
+    D::Elem: Num + PartialOrd + Copy + Debug,
+{
+    pub fn validate(&self) -> Result<(), ValidateError> {
+        for i in 0..N {
+            let i_grid_len = self.grid[i].len();
+            // Check that each grid dimension has elements
+            // Indexing `grid` directly is okay because empty dimensions are caught at compilation
+            if i_grid_len == 0 {
+                return Err(ValidateError::EmptyGrid(i));
+            }
+            // Check that grid points are monotonically increasing
+            if !self.grid[i].windows(2).into_iter().all(|w| w[0] <= w[1]) {
+                return Err(ValidateError::Monotonicity(i));
+            }
+            // Check that grid and values are compatible shapes
+            if i_grid_len != self.values.shape()[i] {
+                return Err(ValidateError::IncompatibleShapes(i));
+            }
+        }
+        Ok(())
+    }
+}

src/error.rs

@@ -3,7 +3,7 @@
 use thiserror::Error;
 
 /// Error in interpolator data validation
-#[derive(Error, Debug, Clone)]
+#[derive(Error, Debug, Clone, PartialEq)]
 pub enum ValidateError {
     #[error("selected `Strategy` ({0}) is unimplemented/inapplicable for interpolator")]
     StrategySelection(&'static str),
@@ -20,7 +20,7 @@ pub enum ValidateError {
 }
 
 /// Error in interpolation call
-#[derive(Error, Debug, Clone)]
+#[derive(Error, Debug, Clone, PartialEq)]
 pub enum InterpolateError {
     #[error("attempted to interpolate at point beyond grid data: {0}")]
     ExtrapolateError(String),