Merge pull request #4 from NREL/clone

Make types Clone-able

Author: kylecarow

Cargo.toml

@@ -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]

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)]
+#[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/lib.rs

@@ -123,6 +123,7 @@ pub mod prelude {
     pub use crate::Interpolator;
 }
 
+pub mod data;
 pub mod error;
 pub mod strategy;
 
@@ -133,23 +134,27 @@ pub mod two;
 pub mod zero;
 
 pub mod interpolator {
-    pub use crate::n::InterpND;
-    pub use crate::one::Interp1D;
-    pub use crate::three::Interp3D;
-    pub use crate::two::Interp2D;
+    pub use crate::n::{InterpND, InterpNDOwned, InterpNDViewed};
+    pub use crate::one::{Interp1D, Interp1DOwned, Interp1DViewed};
+    pub use crate::three::{Interp3D, Interp3DOwned, Interp3DViewed};
+    pub use crate::two::{Interp2D, Interp2DOwned, Interp2DViewed};
     pub use crate::zero::Interp0D;
 }
 
+pub(crate) use data::*;
 pub(crate) use error::*;
 pub(crate) use strategy::*;
 
 pub(crate) use std::fmt::Debug;
 
+pub use ndarray;
 pub(crate) use ndarray::prelude::*;
-pub(crate) use ndarray::{Data, Ix};
+pub(crate) use ndarray::{Data, Ix, RawDataClone};
 
 pub(crate) use num_traits::{clamp, Num, One};
 
+pub(crate) use dyn_clone::*;
+
 #[cfg(feature = "serde")]
 pub(crate) use ndarray::DataOwned;
 #[cfg(feature = "serde")]
@@ -173,7 +178,7 @@ pub(crate) use assert_approx_eq;
 /// This trait is dyn-compatible, meaning you can use:
 /// `Box<dyn Interpolator<_>>`
 /// and swap the contained interpolator at runtime.
-pub trait Interpolator<T> {
+pub trait Interpolator<T>: DynClone {
     /// Interpolator dimensionality.
     fn ndim(&self) -> usize;
     /// Validate interpolator data.
@@ -182,6 +187,8 @@ pub trait Interpolator<T> {
     fn interpolate(&self, point: &[T]) -> Result<T, InterpolateError>;
 }
 
+clone_trait_object!(<T> Interpolator<T>);
+
 impl<T> Interpolator<T> for Box<dyn Interpolator<T>> {
     fn ndim(&self) -> usize {
         (**self).ndim()
@@ -194,54 +201,6 @@ impl<T> Interpolator<T> for Box<dyn Interpolator<T>> {
     }
 }
 
-#[derive(Debug)]
-#[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,
-    D::Elem: Num + PartialOrd + Copy + Debug,
-{
-    pub grid: [ArrayBase<D, Ix1>; N],
-    pub values: ArrayBase<D, Dim<[Ix; N]>>,
-}
-
-impl<D, const N: usize> InterpData<D, N>
-where
-    Dim<[Ix; N]>: Dimension,
-    D: Data,
-    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(())
-    }
-}
-
 /// Extrapolation strategy
 ///
 /// Controls what happens if supplied interpolant point
@@ -264,9 +223,9 @@ macro_rules! extrapolate_impl {
     ($InterpType:ident, $Strategy:ident) => {
         impl<D, S> $InterpType<D, S>
         where
-            D: Data,
+            D: Data + RawDataClone + Clone,
             D::Elem: Num + PartialOrd + Copy + Debug,
-            S: $Strategy<D>,
+            S: $Strategy<D> + Clone,
         {
             /// Set [`Extrapolate`] variant, checking validity.
             pub fn set_extrapolate(

src/n/mod.rs

@@ -6,7 +6,7 @@ use ndarray::prelude::*;
 
 mod strategies;
 /// Interpolator data where N is determined at runtime
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 #[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 #[cfg_attr(
     feature = "serde",
@@ -17,15 +17,20 @@ mod strategies;
 )]
 pub struct InterpDataND<D>
 where
-    D: Data,
+    D: Data + RawDataClone + Clone,
     D::Elem: Num + PartialOrd + Copy + Debug,
 {
     pub grid: Vec<ArrayBase<D, Ix1>>,
     pub values: ArrayBase<D, IxDyn>,
 }
+/// [`InterpDataND`] that views data.
+pub type InterpDataNDViewed<T> = InterpDataND<ndarray::ViewRepr<T>>;
+/// [`InterpDataND`] that owns data.
+pub type InterpDataNDOwned<T> = InterpDataND<ndarray::OwnedRepr<T>>;
+
 impl<D> InterpDataND<D>
 where
-    D: Data,
+    D: Data + RawDataClone + Clone,
     D::Elem: Num + PartialOrd + Copy + Debug,
 {
     pub fn ndim(&self) -> usize {
@@ -76,7 +81,7 @@ where
 }
 
 /// N-D interpolator
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 #[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 #[cfg_attr(
     feature = "serde",
@@ -88,9 +93,9 @@ where
 )]
 pub struct InterpND<D, S>
 where
-    D: Data,
+    D: Data + RawDataClone + Clone,
     D::Elem: Num + PartialOrd + Copy + Debug,
-    S: StrategyND<D>,
+    S: StrategyND<D> + Clone,
 {
     pub data: InterpDataND<D>,
     pub strategy: S,
@@ -101,14 +106,18 @@ where
     )]
     pub extrapolate: Extrapolate<D::Elem>,
 }
+/// [`InterpND`] that views data.
+pub type InterpNDViewed<T, S> = InterpND<ndarray::ViewRepr<T>, S>;
+/// [`InterpND`] that owns data.
+pub type InterpNDOwned<T, S> = InterpND<ndarray::OwnedRepr<T>, S>;
 
 extrapolate_impl!(InterpND, StrategyND);
 
 impl<D, S> InterpND<D, S>
 where
-    D: Data,
+    D: Data + RawDataClone + Clone,
     D::Elem: Num + PartialOrd + Copy + Debug,
-    S: StrategyND<D>,
+    S: StrategyND<D> + Clone,
 {
     /// Instantiate N-dimensional (any dimensionality) interpolator.
     ///
@@ -170,9 +179,9 @@ where
 
 impl<D, S> Interpolator<D::Elem> for InterpND<D, S>
 where
-    D: Data,
+    D: Data + RawDataClone + Clone,
     D::Elem: Num + PartialOrd + Copy + Debug,
-    S: StrategyND<D>,
+    S: StrategyND<D> + Clone,
 {
     fn ndim(&self) -> usize {
         self.data.ndim()
@@ -229,7 +238,7 @@ where
 
 impl<D> InterpND<D, Box<dyn StrategyND<D>>>
 where
-    D: Data,
+    D: Data + RawDataClone + Clone,
     D::Elem: Num + PartialOrd + Copy + Debug,
 {
     /// Update strategy dynamically.

src/n/strategies.rs

@@ -1,8 +1,6 @@
 use super::*;
 
 use itertools::Itertools;
-// TODO: any way to remove `RawDataClone`?
-use ndarray::RawDataClone;
 
 pub fn get_index_permutations(shape: &[usize]) -> Vec<Vec<usize>> {
     if shape.is_empty() {
@@ -17,8 +15,7 @@ pub fn get_index_permutations(shape: &[usize]) -> Vec<Vec<usize>> {
 
 impl<D> StrategyND<D> for Linear
 where
-    // TODO: any way to remove the `RawDataClone` bound?
-    D: Data + RawDataClone,
+    D: Data + RawDataClone + Clone,
     D::Elem: Num + PartialOrd + Copy + Debug,
 {
     fn interpolate(
@@ -120,8 +117,7 @@ where
 
 impl<D> StrategyND<D> for Nearest
 where
-    // TODO: any way to remove the `RawDataClone` bound?
-    D: Data + RawDataClone,
+    D: Data + RawDataClone + Clone,
     D::Elem: Num + PartialOrd + Copy + Debug,
 {
     fn interpolate(