bug fix for InterpDataOwned, implement into_owned

Author: kylecarow

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ninterp"
-version = "0.7.2"
+version = "0.7.3"
 edition = "2021"
 description = "Numerical interpolation for N-dimensional rectilinear grids"
 repository = "https://github.com/NREL/ninterp"

src/interpolator/data.rs

@@ -45,7 +45,7 @@ where
 /// [`InterpData`] that views data.
 pub type InterpDataViewed<T, const N: usize> = InterpData<ViewRepr<T>, N>;
 /// [`InterpData`] that owns data.
-pub type InterpDataOwned<T, const N: usize> = InterpData<ViewRepr<T>, N>;
+pub type InterpDataOwned<T, const N: usize> = InterpData<OwnedRepr<T>, N>;
 
 impl<D, const N: usize> PartialEq for InterpData<D, N>
 where
@@ -90,9 +90,21 @@ where
 
     /// View interpolator data.
     pub fn view(&self) -> InterpDataViewed<&D::Elem, N> {
-        InterpData {
+        InterpDataViewed {
             grid: std::array::from_fn(|i| self.grid[i].view()),
             values: self.values.view(),
         }
     }
+
+    /// Turn the data into an [`InterpDataOwned`], cloning the array elements if necessary.
+    pub fn into_owned(self) -> InterpDataOwned<D::Elem, N>
+    where
+        Dim<[Ix; N]>: Dimension,
+        D::Elem: Clone,
+    {
+        InterpDataOwned {
+            grid: self.grid.map(|arr| arr.into_owned()),
+            values: self.values.into_owned(),
+        }
+    }
 }

src/interpolator/enums.rs

@@ -189,6 +189,31 @@ where
             extrapolate,
         )?))
     }
+
+    /// Return an interpolator with viewed data.
+    pub fn view(&self) -> InterpolatorEnumViewed<&D::Elem> {
+        match self {
+            InterpolatorEnum::Interp0D(interp) => InterpolatorEnum::Interp0D(interp.clone()),
+            InterpolatorEnum::Interp1D(interp) => InterpolatorEnum::Interp1D(interp.view()),
+            InterpolatorEnum::Interp2D(interp) => InterpolatorEnum::Interp2D(interp.view()),
+            InterpolatorEnum::Interp3D(interp) => InterpolatorEnum::Interp3D(interp.view()),
+            InterpolatorEnum::InterpND(interp) => InterpolatorEnum::InterpND(interp.view()),
+        }
+    }
+
+    /// Turn the interpolator into an [`InterpolatorEnumOwned`], cloning the array elements if necessary.
+    pub fn into_owned(self) -> InterpolatorEnumOwned<D::Elem>
+    where
+        D::Elem: Clone,
+    {
+        match self {
+            InterpolatorEnum::Interp0D(interp) => InterpolatorEnum::Interp0D(interp.clone()),
+            InterpolatorEnum::Interp1D(interp) => InterpolatorEnum::Interp1D(interp.into_owned()),
+            InterpolatorEnum::Interp2D(interp) => InterpolatorEnum::Interp2D(interp.into_owned()),
+            InterpolatorEnum::Interp3D(interp) => InterpolatorEnum::Interp3D(interp.into_owned()),
+            InterpolatorEnum::InterpND(interp) => InterpolatorEnum::InterpND(interp.into_owned()),
+        }
+    }
 }
 
 impl<D> Interpolator<D::Elem> for InterpolatorEnum<D>

src/interpolator/n/mod.rs

@@ -111,11 +111,22 @@ where
 
     /// View interpolator data.
     pub fn view(&self) -> InterpDataNDViewed<&D::Elem> {
-        InterpDataND {
+        InterpDataNDViewed {
             grid: self.grid.iter().map(|g| g.view()).collect(),
             values: self.values.view(),
         }
     }
+
+    /// Turn the data into an [`InterpDataNDOwned`], cloning the array elements if necessary.
+    pub fn into_owned(self) -> InterpDataNDOwned<D::Elem>
+    where
+        D::Elem: Clone,
+    {
+        InterpDataNDOwned {
+            grid: self.grid.into_iter().map(|g| g.into_owned()).collect(),
+            values: self.values.into_owned(),
+        }
+    }
 }
 
 /// N-D interpolator
@@ -233,12 +244,25 @@ where
         S: for<'a> StrategyND<ViewRepr<&'a D::Elem>>,
         D::Elem: Clone,
     {
-        InterpND {
+        InterpNDViewed {
             data: self.data.view(),
             strategy: self.strategy.clone(),
             extrapolate: self.extrapolate.clone(),
         }
     }
+
+    /// Turn the interpolator into an [`InterpNDOwned`], cloning the array elements if necessary.
+    pub fn into_owned(self) -> InterpNDOwned<D::Elem, S>
+    where
+        S: StrategyND<OwnedRepr<D::Elem>>,
+        D::Elem: Clone,
+    {
+        InterpNDOwned {
+            data: self.data.into_owned(),
+            strategy: self.strategy.clone(),
+            extrapolate: self.extrapolate.clone(),
+        }
+    }
 }
 
 impl<D, S> Interpolator<D::Elem> for InterpND<D, S>

src/interpolator/one/mod.rs

@@ -129,12 +129,25 @@ where
         S: for<'a> Strategy1D<ViewRepr<&'a D::Elem>>,
         D::Elem: Clone,
     {
-        Interp1D {
+        Interp1DViewed {
             data: self.data.view(),
             strategy: self.strategy.clone(),
             extrapolate: self.extrapolate.clone(),
         }
     }
+
+    /// Turn the interpolator into an [`Interp1DOwned`], cloning the array elements if necessary.
+    pub fn into_owned(self) -> Interp1DOwned<D::Elem, S>
+    where
+        S: Strategy1D<OwnedRepr<D::Elem>>,
+        D::Elem: Clone,
+    {
+        Interp1DOwned {
+            data: self.data.into_owned(),
+            strategy: self.strategy.clone(),
+            extrapolate: self.extrapolate.clone(),
+        }
+    }
 }
 
 impl<D, S> Interpolator<D::Elem> for Interp1D<D, S>

src/interpolator/three/mod.rs

@@ -150,12 +150,25 @@ where
         S: for<'a> Strategy3D<ViewRepr<&'a D::Elem>>,
         D::Elem: Clone,
     {
-        Interp3D {
+        Interp3DViewed {
             data: self.data.view(),
             strategy: self.strategy.clone(),
             extrapolate: self.extrapolate.clone(),
         }
     }
+
+    /// Turn the interpolator into an [`Interp3DOwned`], cloning the array elements if necessary.
+    pub fn into_owned(self) -> Interp3DOwned<D::Elem, S>
+    where
+        S: Strategy3D<OwnedRepr<D::Elem>>,
+        D::Elem: Clone,
+    {
+        Interp3DOwned {
+            data: self.data.into_owned(),
+            strategy: self.strategy.clone(),
+            extrapolate: self.extrapolate.clone(),
+        }
+    }
 }
 
 impl<D, S> Interpolator<D::Elem> for Interp3D<D, S>

src/interpolator/two/mod.rs

@@ -138,12 +138,25 @@ where
         S: for<'a> Strategy2D<ViewRepr<&'a D::Elem>>,
         D::Elem: Clone,
     {
-        Interp2D {
+        Interp2DViewed {
             data: self.data.view(),
             strategy: self.strategy.clone(),
             extrapolate: self.extrapolate.clone(),
         }
     }
+
+    /// Turn the interpolator into an [`Interp2DOwned`], cloning the array elements if necessary.
+    pub fn into_owned(self) -> Interp2DOwned<D::Elem, S>
+    where
+        S: Strategy2D<OwnedRepr<D::Elem>>,
+        D::Elem: Clone,
+    {
+        Interp2DOwned {
+            data: self.data.into_owned(),
+            strategy: self.strategy.clone(),
+            extrapolate: self.extrapolate.clone(),
+        }
+    }
 }
 
 impl<D, S> Interpolator<D::Elem> for Interp2D<D, S>