Add StepLower and StepUpper marker strategies with enum wiring and legacy alias compatibility

README.md

@@ -125,7 +125,10 @@ An interpolation strategy (for example
 [`Linear`](https://docs.rs/ninterp/latest/ninterp/strategy/struct.Linear.html),
 [`LinearUniform`](https://docs.rs/ninterp/latest/ninterp/strategy/struct.LinearUniform.html),
 [`Nearest`](https://docs.rs/ninterp/latest/ninterp/strategy/struct.Nearest.html),
-[`Step`](https://docs.rs/ninterp/latest/ninterp/strategy/struct.Step.html)) must be specified.
+[`Step`](https://docs.rs/ninterp/latest/ninterp/strategy/struct.Step.html),
+[`StepLower`](https://docs.rs/ninterp/latest/ninterp/strategy/struct.StepLower.html),
+[`StepUpper`](https://docs.rs/ninterp/latest/ninterp/strategy/struct.StepUpper.html),
+must be specified.
 
 To change the interpolation strategy, supply a `Strategy1DEnum`/etc. or `Box<dyn Strategy1D>`/etc. at instantiation and call `set_strategy`.
 Custom strategies can be defined. See [`examples/custom_strategy.rs`](https://github.com/NatLabRockies/ninterp/blob/main/examples/custom_strategy.rs).

src/interpolator/n/strategies.rs

@@ -225,3 +225,49 @@ where
         false
     }
 }
+
+impl<D> StrategyND<D> for StepLower
+where
+    D: Data + RawDataClone + Clone,
+    D::Elem: Num + PartialOrd + Copy + Debug,
+{
+    fn interpolate(
+        &self,
+        data: &InterpDataND<D>,
+        point: &[D::Elem],
+    ) -> Result<D::Elem, InterpolateError> {
+        let n = data.values.ndim();
+        let mut idx = vec![0usize; n];
+        for dim in 0..n {
+            idx[dim] = step_index(StepDirection::Lower, data.grid[dim].view(), &point[dim]);
+        }
+        Ok(data.values.view()[idx.as_slice()])
+    }
+
+    fn allow_extrapolate(&self) -> bool {
+        false
+    }
+}
+
+impl<D> StrategyND<D> for StepUpper
+where
+    D: Data + RawDataClone + Clone,
+    D::Elem: Num + PartialOrd + Copy + Debug,
+{
+    fn interpolate(
+        &self,
+        data: &InterpDataND<D>,
+        point: &[D::Elem],
+    ) -> Result<D::Elem, InterpolateError> {
+        let n = data.values.ndim();
+        let mut idx = vec![0usize; n];
+        for dim in 0..n {
+            idx[dim] = step_index(StepDirection::Upper, data.grid[dim].view(), &point[dim]);
+        }
+        Ok(data.values.view()[idx.as_slice()])
+    }
+
+    fn allow_extrapolate(&self) -> bool {
+        false
+    }
+}

src/interpolator/n/tests.rs

@@ -297,6 +297,15 @@ fn test_step() {
     assert_eq!(interp.interpolate(&[0.3, 0.7, 0.6]).unwrap(), 0.); // floor→[0,0,0]
     assert_eq!(interp.interpolate(&[0.9, 0.9, 0.9]).unwrap(), 0.); // floor→[0,0,0]
 
+    let interp_lower = InterpND::new(
+        vec![array![0., 1.], array![0., 1.], array![0., 1.]],
+        array![[[0., 1.], [2., 3.]], [[4., 5.], [6., 7.]],].into_dyn(),
+        strategy::StepLower,
+        Extrapolate::Error,
+    )
+    .unwrap();
+    assert_eq!(interp_lower.interpolate(&[0.3, 0.7, 0.6]).unwrap(), 0.);
+
     // Uniform Upper (ceiling)
     let interp_upper = InterpND::new(
         vec![array![0., 1.], array![0., 1.], array![0., 1.]],
@@ -307,6 +316,18 @@ fn test_step() {
     .unwrap();
     assert_eq!(interp_upper.interpolate(&[0.3, 0.7, 0.6]).unwrap(), 7.); // ceil→[1,1,1]
 
+    let interp_marker_upper = InterpND::new(
+        vec![array![0., 1.], array![0., 1.], array![0., 1.]],
+        array![[[0., 1.], [2., 3.]], [[4., 5.], [6., 7.]],].into_dyn(),
+        strategy::StepUpper,
+        Extrapolate::Error,
+    )
+    .unwrap();
+    assert_eq!(
+        interp_marker_upper.interpolate(&[0.3, 0.7, 0.6]).unwrap(),
+        7.
+    );
+
     // Per-dimension: Lower in x, Upper in y, Lower in z
     let interp_mixed = InterpND::new(
         vec![array![0., 1.], array![0., 1.], array![0., 1.]],

src/interpolator/one/strategies.rs

@@ -114,3 +114,41 @@ where
         false
     }
 }
+
+impl<D> Strategy1D<D> for StepLower
+where
+    D: Data + RawDataClone + Clone,
+    D::Elem: Num + PartialOrd + Copy + Debug,
+{
+    fn interpolate(
+        &self,
+        data: &InterpData1D<D>,
+        point: &[D::Elem; 1],
+    ) -> Result<D::Elem, InterpolateError> {
+        Ok(data.values[step_index(StepDirection::Lower, data.grid[0].view(), &point[0])])
+    }
+
+    /// Returns `false`.
+    fn allow_extrapolate(&self) -> bool {
+        false
+    }
+}
+
+impl<D> Strategy1D<D> for StepUpper
+where
+    D: Data + RawDataClone + Clone,
+    D::Elem: Num + PartialOrd + Copy + Debug,
+{
+    fn interpolate(
+        &self,
+        data: &InterpData1D<D>,
+        point: &[D::Elem; 1],
+    ) -> Result<D::Elem, InterpolateError> {
+        Ok(data.values[step_index(StepDirection::Upper, data.grid[0].view(), &point[0])])
+    }
+
+    /// Returns `false`.
+    fn allow_extrapolate(&self) -> bool {
+        false
+    }
+}

src/interpolator/one/tests.rs

@@ -75,6 +75,29 @@ fn test_right_nearest() {
     assert_eq!(interp.interpolate(&[4.00]).unwrap(), 1.0);
 }
 
+#[test]
+fn test_step_markers() {
+    let lower = Interp1D::new(
+        array![0., 1., 2., 3., 4.],
+        array![0.2, 0.4, 0.6, 0.8, 1.0],
+        strategy::StepLower,
+        Extrapolate::Error,
+    )
+    .unwrap();
+    assert_eq!(lower.interpolate(&[3.75]).unwrap(), 0.8);
+    assert_eq!(lower.interpolate(&[4.00]).unwrap(), 1.0);
+
+    let upper = Interp1D::new(
+        array![0., 1., 2., 3., 4.],
+        array![0.2, 0.4, 0.6, 0.8, 1.0],
+        strategy::StepUpper,
+        Extrapolate::Error,
+    )
+    .unwrap();
+    assert_eq!(upper.interpolate(&[3.25]).unwrap(), 1.0);
+    assert_eq!(upper.interpolate(&[3.00]).unwrap(), 0.8);
+}
+
 #[test]
 fn test_nearest() {
     let interp = Interp1D::new(

src/interpolator/three/strategies.rs

@@ -241,3 +241,45 @@ where
         false
     }
 }
+
+impl<D> Strategy3D<D> for StepLower
+where
+    D: Data + RawDataClone + Clone,
+    D::Elem: Num + PartialOrd + Copy + Debug,
+{
+    fn interpolate(
+        &self,
+        data: &InterpData3D<D>,
+        point: &[D::Elem; 3],
+    ) -> Result<D::Elem, InterpolateError> {
+        let i = step_index(StepDirection::Lower, data.grid[0].view(), &point[0]);
+        let j = step_index(StepDirection::Lower, data.grid[1].view(), &point[1]);
+        let k = step_index(StepDirection::Lower, data.grid[2].view(), &point[2]);
+        Ok(data.values[[i, j, k]])
+    }
+
+    fn allow_extrapolate(&self) -> bool {
+        false
+    }
+}
+
+impl<D> Strategy3D<D> for StepUpper
+where
+    D: Data + RawDataClone + Clone,
+    D::Elem: Num + PartialOrd + Copy + Debug,
+{
+    fn interpolate(
+        &self,
+        data: &InterpData3D<D>,
+        point: &[D::Elem; 3],
+    ) -> Result<D::Elem, InterpolateError> {
+        let i = step_index(StepDirection::Upper, data.grid[0].view(), &point[0]);
+        let j = step_index(StepDirection::Upper, data.grid[1].view(), &point[1]);
+        let k = step_index(StepDirection::Upper, data.grid[2].view(), &point[2]);
+        Ok(data.values[[i, j, k]])
+    }
+
+    fn allow_extrapolate(&self) -> bool {
+        false
+    }
+}

src/interpolator/three/tests.rs

@@ -155,6 +155,17 @@ fn test_step() {
     assert_eq!(interp.interpolate(&[0.3, 0.7, 0.6]).unwrap(), 0.); // floor→[0,0,0]
     assert_eq!(interp.interpolate(&[0.9, 0.4, 0.1]).unwrap(), 0.); // floor→[0,0,0]
 
+    let interp_lower = Interp3D::new(
+        array![0., 1.],
+        array![0., 1.],
+        array![0., 1.],
+        array![[[0., 1.], [2., 3.]], [[4., 5.], [6., 7.]]],
+        strategy::StepLower,
+        Extrapolate::Error,
+    )
+    .unwrap();
+    assert_eq!(interp_lower.interpolate(&[0.3, 0.7, 0.6]).unwrap(), 0.);
+
     // Uniform Upper (ceiling)
     let interp_upper = Interp3D::new(
         array![0., 1.],
@@ -167,6 +178,20 @@ fn test_step() {
     .unwrap();
     assert_eq!(interp_upper.interpolate(&[0.3, 0.7, 0.6]).unwrap(), 7.); // ceil→[1,1,1]
 
+    let interp_marker_upper = Interp3D::new(
+        array![0., 1.],
+        array![0., 1.],
+        array![0., 1.],
+        array![[[0., 1.], [2., 3.]], [[4., 5.], [6., 7.]]],
+        strategy::StepUpper,
+        Extrapolate::Error,
+    )
+    .unwrap();
+    assert_eq!(
+        interp_marker_upper.interpolate(&[0.3, 0.7, 0.6]).unwrap(),
+        7.
+    );
+
     // Per-dimension: Lower in x, Upper in y, Lower in z
     let interp_mixed = Interp3D::new(
         array![0., 1.],

src/interpolator/two/strategies.rs

@@ -172,3 +172,43 @@ where
         false
     }
 }
+
+impl<D> Strategy2D<D> for StepLower
+where
+    D: Data + RawDataClone + Clone,
+    D::Elem: Num + PartialOrd + Copy + Debug,
+{
+    fn interpolate(
+        &self,
+        data: &InterpData2D<D>,
+        point: &[D::Elem; 2],
+    ) -> Result<D::Elem, InterpolateError> {
+        let i = step_index(StepDirection::Lower, data.grid[0].view(), &point[0]);
+        let j = step_index(StepDirection::Lower, data.grid[1].view(), &point[1]);
+        Ok(data.values[[i, j]])
+    }
+
+    fn allow_extrapolate(&self) -> bool {
+        false
+    }
+}
+
+impl<D> Strategy2D<D> for StepUpper
+where
+    D: Data + RawDataClone + Clone,
+    D::Elem: Num + PartialOrd + Copy + Debug,
+{
+    fn interpolate(
+        &self,
+        data: &InterpData2D<D>,
+        point: &[D::Elem; 2],
+    ) -> Result<D::Elem, InterpolateError> {
+        let i = step_index(StepDirection::Upper, data.grid[0].view(), &point[0]);
+        let j = step_index(StepDirection::Upper, data.grid[1].view(), &point[1]);
+        Ok(data.values[[i, j]])
+    }
+
+    fn allow_extrapolate(&self) -> bool {
+        false
+    }
+}

src/interpolator/two/tests.rs

@@ -119,6 +119,26 @@ fn test_step() {
     assert_eq!(interp.interpolate(&[0.7, 1.4]).unwrap(), f[[0, 1]]); // floor x→0, floor y→1
     assert_eq!(interp.interpolate(&[1.9, 0.1]).unwrap(), f[[1, 0]]); // floor x→1, floor y→0
 
+    let interp_lower = Interp2D::new(
+        grid_x.view(),
+        grid_y.view(),
+        values.view(),
+        strategy::StepLower,
+        Extrapolate::Error,
+    )
+    .unwrap();
+    assert_eq!(interp_lower.interpolate(&[0.7, 1.4]).unwrap(), f[[0, 1]]);
+
+    let interp_upper = Interp2D::new(
+        grid_x.view(),
+        grid_y.view(),
+        values.view(),
+        strategy::StepUpper,
+        Extrapolate::Error,
+    )
+    .unwrap();
+    assert_eq!(interp_upper.interpolate(&[0.7, 1.4]).unwrap(), f[[1, 2]]);
+
     // Per-dimension: Lower in x, Upper in y
     let interp_mixed = Interp2D::new(
         grid_x.view(),

src/lib.rs

@@ -15,7 +15,8 @@
 ///   - [`strategy::Linear`]
 ///   - [`strategy::LinearUniform`]
 ///   - [`strategy::Nearest`]
-///   - [`strategy::Step`] (replaces the former `LeftNearest`/`RightNearest`)
+///   - [`strategy::Step`] (per-dimension and/or runtime-selected step directions)
+///   - [`strategy::StepLower`] / [`strategy::StepUpper`]
 ///   - `serde`-compatible strategy enums: [`strategy::enums::Strategy1DEnum`]/etc.
 /// - The extrapolation setting enum: [`Extrapolate`]
 pub mod prelude {

src/strategy/enums/mod.rs

@@ -1,4 +1,6 @@
 //! This module provides enums that allow mutable strategy swapping.
+//! The enum variants and `From` impls here are hand-maintained per strategy type.
+//! Adding a new strategy requires explicit wiring in each of the 1-D/2-D/3-D/N-D enum modules.
 //!
 //! This is an alternative to using a `Box<dyn Strategy1D>`/etc. with a few key differences:
 //! - Better runtime performance
@@ -34,10 +36,8 @@
 //! assert_eq!(interp.interpolate(&[3.75]).unwrap(), 0.95);
 //! assert_eq!(interp.interpolate(&[4.00]).unwrap(), 1.0);
 //!
-//! // Piecewise-constant: return value at nearest lower grid point
-//! interp
-//!     .set_strategy(strategy::Step::from(strategy::StepDirection::Lower))
-//!     .unwrap();
+//! // Piecewise-constant: fixed lower direction (zero-allocation marker strategy)
+//! interp.set_strategy(strategy::StepLower).unwrap();
 //! assert_eq!(interp.interpolate(&[3.75]).unwrap(), 0.8);
 //! assert_eq!(interp.interpolate(&[4.00]).unwrap(), 1.0);
 //! ```
@@ -85,9 +85,7 @@ mod tests {
         assert_eq!(interp.interpolate(&[3.75]).unwrap(), 1.0);
         assert_eq!(interp.interpolate(&[4.00]).unwrap(), 1.0);
 
-        interp
-            .set_strategy(strategy::Step::from(strategy::StepDirection::Lower))
-            .unwrap();
+        interp.set_strategy(strategy::StepLower).unwrap();
         assert_eq!(interp.interpolate(&[3.00]).unwrap(), 0.8);
         assert_eq!(interp.interpolate(&[3.75]).unwrap(), 0.8);
         assert_eq!(interp.interpolate(&[4.00]).unwrap(), 1.0);