Struct Interp1D

pub struct Interp1D<D, S>
where
    D: Data + RawDataClone + Clone,
    D::Elem: Num + PartialOrd + Copy + Debug,
    S: Strategy1D<D> + Clone,
{
    pub data: InterpData1D<D>,
    pub strategy: S,
    pub extrapolate: Extrapolate<D::Elem>,
}

1-D interpolator

Fields

data: InterpData1D<D>

strategy: S

extrapolate: Extrapolate<D::Elem>

Implementations

impl<D, S> Interp1D<D, S>

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

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

Set Extrapolate variant, checking validity.

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

impl<D, S> Interp1D<D, S>

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

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

Instantiate one-dimensional interpolator.

Applicable interpolation strategies:

• Linear
• Nearest
• LeftNearest
• RightNearest

Extrapolate::Enable is valid for Linear

Example:

use ndarray::prelude::*;
use ninterp::prelude::*;
// f(x) = 0.4 * x
let interp = Interp1D::new(
    // x
    array![0., 1., 2.], // x0, x1, x2
    // f(x)
    array![0.0, 0.4, 0.8], // f(x0), f(x1), f(x2)
    Linear,
    Extrapolate::Enable,
)
.unwrap();
assert_eq!(interp.interpolate(&[1.4]).unwrap(), 0.56);
assert_eq!(
    interp.interpolate(&[3.6]).unwrap(),
    1.44
);

impl<D> Interp1D<D, Box<dyn Strategy1D<D>>>

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

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

Update strategy dynamically.

Trait Implementations

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

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

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

Returns a copy of the value.

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

Performs copy-assignment from source.

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

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

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

Formats the value using the given formatter.

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

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

fn ndim(&self) -> usize

Returns 1.

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

Validate interpolator data.

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

Interpolate at supplied point.

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

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

fn eq(&self, other: &Interp1D<D, S>) -> 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.

impl<D, S> StructuralPartialEq for Interp1D<D, S>

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