Struct Interp2D

pub struct Interp2D<D, S>
where
    D: Data + RawDataClone + Clone,
    D::Elem: PartialEq + Debug,
    S: Strategy2D<D> + Clone,
{
    pub data: InterpData2D<D>,
    pub strategy: S,
    pub extrapolate: Extrapolate<D::Elem>,
}

2-D interpolator

Fields

data: InterpData2D<D>

Interpolator data.

strategy: S

Interpolation strategy.

extrapolate: Extrapolate<D::Elem>

Extrapolation setting.

Implementations

impl<D, S> Interp2D<D, S>

where D: Data + RawDataClone + Clone, D::Elem: PartialEq + Debug, S: Strategy2D<D> + Clone,

pub fn check_extrapolate( &self, extrapolate: &Extrapolate<D::Elem>, ) -> Result<(), ValidateError>

Check applicability of strategy, data, and extrapolate setting.

impl<D, S> Interp2D<D, S>

where D: Data + RawDataClone + Clone, D::Elem: PartialOrd + Debug, S: Strategy2D<D> + Clone,

pub fn new( x: ArrayBase<D, Ix1>, y: ArrayBase<D, Ix1>, f_xy: ArrayBase<D, Ix2>, strategy: S, extrapolate: Extrapolate<D::Elem>, ) -> Result<Self, ValidateError>

Construct and validate a 2-D interpolator.

Applicable interpolation strategies:

• strategy::Linear
• strategy::Nearest

Extrapolate::Enable is valid for strategy::Linear

Example:

use ndarray::prelude::*;
use ninterp::prelude::*;
// f(x, y) = 0.2 * x + 0.4 * y
// type annotation for clarity
let interp: Interp2DOwned<f64, _> = Interp2D::new(
    // x
    array![0., 1., 2.], // x0, x1, x2
    // y
    array![0., 1., 2., 3.], // y0, y1, y2
    // f(x, y)
    array![
        [0.0, 0.4, 0.8, 1.2], // f(x0, y0), f(x0, y1), f(x0, y2), f(x0, y3)
        [0.2, 0.6, 1.0, 1.4], // f(x1, y0), f(x1, y1), f(x1, y2), f(x1, y3)
        [0.4, 0.8, 1.2, 1.6], // f(x2, y0), f(x2, y1), f(x2, y2), f(x2, y3)
    ],
    strategy::Linear, // strategy mod is exposed via `use ndarray::prelude::*;`
    Extrapolate::Clamp, // restrict point within grid bounds
)
.unwrap();
assert_eq!(interp.interpolate(&[1.5, 1.5]).unwrap(), 0.9);
assert_eq!(
    interp.interpolate(&[-1., 3.5]).unwrap(),
    interp.interpolate(&[0., 3.]).unwrap()
); // point is restricted to within grid bounds

pub fn view(&self) -> Interp2DViewed<&D::Elem, S>

where S: for<'a> Strategy2D<ViewRepr<&'a D::Elem>>, D::Elem: Clone,

Return an interpolator with viewed data.

pub fn into_owned(self) -> Interp2DOwned<D::Elem, S>

where S: Strategy2D<OwnedRepr<D::Elem>>, D::Elem: Clone,

Turn the interpolator into an Interp2DOwned, cloning the array elements if necessary.

impl<D> Interp2D<D, Box<dyn Strategy2D<D>>>

where D: Data + RawDataClone + Clone, D::Elem: PartialEq + Debug,

pub fn set_strategy( &mut self, strategy: Box<dyn Strategy2D<D>>, ) -> Result<(), ValidateError>

Update strategy dynamically.

impl<D> Interp2D<D, Strategy2DEnum>

where D: Data + RawDataClone + Clone, D::Elem: Num + PartialOrd + Copy + Debug,

pub fn set_strategy( &mut self, strategy: impl Into<Strategy2DEnum>, ) -> Result<(), ValidateError>

Update strategy dynamically.

Trait Implementations

impl<D, S> Clone for Interp2D<D, S>

where D: Data + RawDataClone + Clone + Clone, D::Elem: PartialEq + Debug + Clone, S: Strategy2D<D> + Clone + Clone,

fn clone(&self) -> Interp2D<D, S>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<D, S> Debug for Interp2D<D, S>

where D: Data + RawDataClone + Clone + Debug, D::Elem: PartialEq + Debug + Debug, S: Strategy2D<D> + Clone + Debug,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<D> From<Interp2D<D, Strategy2DEnum>> for InterpolatorEnum<D>

where D: Data + RawDataClone + Clone, D::Elem: Num + PartialOrd + Copy + Debug,

fn from(interpolator: Interp2D<D, Strategy2DEnum>) -> Self

Converts to this type from the input type.

impl<D, S> Interpolator<<D as RawData>::Elem> for Interp2D<D, S>

where D: Data + RawDataClone + Clone, D::Elem: Num + Euclid + PartialOrd + Debug + Copy, S: Strategy2D<D> + Clone,

fn ndim(&self) -> usize

Returns 2.

fn validate(&mut self) -> Result<(), ValidateError>

Validate interpolator data.

fn interpolate(&self, point: &[D::Elem]) -> Result<D::Elem, InterpolateError>

Interpolate at supplied point.

fn set_extrapolate( &mut self, extrapolate: Extrapolate<D::Elem>, ) -> Result<(), ValidateError>

Set Extrapolate variant, checking validity.

impl<D, S> PartialEq for Interp2D<D, S>

where D: Data + RawDataClone + Clone, D::Elem: PartialEq + Debug, S: Strategy2D<D> + Clone + PartialEq, InterpData2D<D>: PartialEq,

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.