Struct CubicSpline

pub struct CubicSpline { /* private fields */ }

Cubic Spline (Natural)

Description

Implement traits of Natural cubic splines, by Arne Morten Kvarving.

Type

(&[f64], &[f64]) -> Cubic Spline

Examples

#[macro_use]
extern crate peroxide;
use peroxide::fuga::*;

fn main() -> Result<(), Box<dyn Error>> {
    let x = c!(0.9, 1.3, 1.9, 2.1);
    let y = c!(1.3, 1.5, 1.85, 2.1);

    let s = cubic_spline(&x, &y)?;

    let new_x = c!(1, 1.5, 2.0);

    // Generate Cubic polynomial
    for t in new_x.iter() {
        s.polynomial_at(*t).print();
    }
    // -0.2347x^3 + 0.6338x^2 - 0.0329x + 0.9873
    // 0.9096x^3 - 3.8292x^2 + 5.7691x - 1.5268
    // -2.2594x^3 + 14.2342x^2 - 28.5513x + 20.2094

    // Evaluation
    for t in new_x.iter() {
        s.eval(*t).print();
    }

    Ok(())
}

Implementations

impl CubicSpline

pub fn from_nodes(node_x: &[f64], node_y: &[f64]) -> Result<Self>

Examples

#[macro_use]
extern crate peroxide;
use peroxide::fuga::*;

fn main() -> Result<(), Box<dyn Error>> {
    let x = c!(0.9, 1.3, 1.9, 2.1);
    let y = c!(1.3, 1.5, 1.85, 2.1);

    let s = CubicSpline::from_nodes(&x, &y)?;

    for i in 0 .. 4 {
        println!("{}", s.eval(i as f64 / 2.0));
    }

    Ok(())
}

pub fn extend_with_nodes( &mut self, node_x: Vec<f64>, node_y: Vec<f64>, ) -> Result<()>

Extends the spline with the given nodes.

Description

The method ensures that the transition between each polynomial is smooth and that the spline interpolation of the new nodes is calculated around x = 0 in order to avoid that successive spline extensions with large x values become inaccurate.

Trait Implementations

impl Archive for CubicSpline

where Vec<(Range<f64>, Polynomial)>: Archive,

const COPY_OPTIMIZATION: CopyOptimization<Self>

An optimization flag that allows the bytes of this type to be copied directly to a writer instead of calling serialize.

type Archived = ArchivedCubicSpline

The archived representation of this type.

type Resolver = CubicSplineResolver

The resolver for this type. It must contain all the additional information from serializing needed to make the archived type from the normal type.

fn resolve(&self, resolver: Self::Resolver, out: Place<Self::Archived>)

Creates the archived version of this value at the given position and writes it to the given output.

impl Calculus for CubicSpline

fn derivative(&self) -> Self

fn integral(&self) -> Self

fn integrate<T: Into<f64> + Copy>(&self, interval: (T, T)) -> f64

impl Clone for CubicSpline

fn clone(&self) -> CubicSpline

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for CubicSpline

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

Formats the value using the given formatter.

impl Default for CubicSpline

fn default() -> CubicSpline

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for CubicSpline

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<__D: Fallible + ?Sized> Deserialize<CubicSpline, __D> for Archived<CubicSpline>

where Vec<(Range<f64>, Polynomial)>: Archive, <Vec<(Range<f64>, Polynomial)> as Archive>::Archived: Deserialize<Vec<(Range<f64>, Polynomial)>, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<CubicSpline, <__D as Fallible>::Error>

Deserializes using the given deserializer

impl From<Vec<(Range<f64>, Polynomial)>> for CubicSpline

fn from(polynomials: Vec<(Range<f64>, Polynomial)>) -> Self

Converts to this type from the input type.

impl Index<usize> for CubicSpline

type Output = (Range<f64>, Polynomial)

The returned type after indexing.

fn index(&self, index: usize) -> &Self::Output

Performs the indexing (container[index]) operation.

impl Into<Vec<(Range<f64>, Polynomial)>> for CubicSpline

fn into(self) -> Vec<(Range<f64>, Polynomial)>

Converts this type into the (usually inferred) input type.

impl Into<Vec<Polynomial>> for CubicSpline

fn into(self) -> Vec<Polynomial>

Converts this type into the (usually inferred) input type.

impl PolynomialSpline for CubicSpline

fn get_ranged_polynomials(&self) -> &Vec<(Range<f64>, Polynomial)>

fn polynomial_at<T: Into<f64> + Copy>(&self, x: T) -> &Polynomial

fn number_of_polynomials(&self) -> usize

impl<__S: Fallible + ?Sized> Serialize<__S> for CubicSpline

where Vec<(Range<f64>, Polynomial)>: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<Self as Archive>::Resolver, <__S as Fallible>::Error>

Writes the dependencies for the object and returns a resolver that can create the archived type.

impl Serialize for CubicSpline

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.