Struct enterpolation::bspline::BSpline

pub struct BSpline<K, E, S> { /* private fields */ }

BSpline curve.

See bspline module for more information.

Implementations

impl BSpline<Unknown, Unknown, Unknown>

pub fn builder() -> BSplineBuilder<Unknown, Unknown, Unknown, Unknown, Open>

Get a builder for bsplines.

The builder takes:

• a mode, either open(), which is default, clamped() or legacy()
• elements with elements() or elements_with_weights()
• knots with knots() or equidistant()
• the kind of workspace to use with dynamic(), constant() or workspace()

Examples

let bez = BSpline::builder()
    .clamped()
    .elements([20.0,100.0,0.0,200.0])
    .equidistant::<f64>()
    .degree(3)
    .normalized()
    .constant::<4>()    // degree + 1
    .build()?;
let mut iter = bez.take(5);
let expected = [20.0,53.75,65.0,98.75,200.0];
for i in 0..=4 {
    let val = iter.next().unwrap();
    assert_f64_near!(val, expected[i]);
}

impl<K, E, S> BSpline<K, E, S>where E: DiscreteGenerator, K: SortedGenerator, S: Space<E::Output>,

pub fn new(elements: E, knots: K, space: S) -> Result<Self, BSplineError>

Creates a bspline curve of elements and knots given.

The resulting degree of the curve is elements.len() - knots.len() +1. The domain for the curve with degree p is knots[p-1] and knots[knots.len() - p -2].

The knots have to be sorted.

Errors

TooFewElements if there are less than two elements. InvalidDegree if degree is not at least 1 and at most the number of elements - 1. TooSmallWorkspace if the workspace is not bigger than the degree of the curve. IncongruousElementsKnots either if the amount of knots is less than the amount of elements or if the anoumt of knots is more than double the amount of elements.

impl<K, E, S> BSpline<K, E, S>where E: DiscreteGenerator, K: SortedGenerator, S: Space<E::Output>,

pub fn new_unchecked(elements: E, knots: K, space: S) -> Self

Creates a bspline curve of elements and knots given.

The resulting degree of the curve is elements.len() - knots.len() + 1. The domain for the curve with degree p is knots[p-1] and knots[knots.len() - p -2]. The knots have to be sorted.

Panics

The degree has to be at least 1, otherwise the library may panic at any time.

Trait Implementations

impl<K: Clone, E: Clone, S: Clone> Clone for BSpline<K, E, S>

fn clone(&self) -> BSpline<K, E, S>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<K, E, S, R> Curve<R> for BSpline<K, E, S>where E: DiscreteGenerator, S: Space<E::Output>, E::Output: Merge<R> + Copy, R: Real + Debug, K: SortedGenerator<Output = R>,

fn domain(&self) -> [R; 2]

The domain in which the curve uses interpolation.

fn slice<B>(self, bounds: B) -> Slice<Self, R>where Self: Sized, B: RangeBounds<R>,

Take a slice of a curve.

fn clamp(self) -> Clamp<Self>where Self: Sized,

Clamp the input of a curve to its domain.

impl<K: Debug, E: Debug, S: Debug> Debug for BSpline<K, E, S>

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

Formats the value using the given formatter.

impl<K, E, S, R> Generator<R> for BSpline<K, E, S>where E: DiscreteGenerator, S: Space<E::Output>, E::Output: Merge<R> + Copy, R: Real + Debug, K: SortedGenerator<Output = R>,

type Output = <E as Generator<usize>>::Output

The element outputted

fn gen(&self, scalar: R) -> E::Output

Method to generate the element at the given input

fn extract<I, J>(self, iterator: I) -> Extract<Self, J> where Self: Sized, I: IntoIterator<IntoIter = J>, J: Iterator<Item = Input>,

Helper function if one wants to extract values from the interpolation.

fn stack<G>(self, gen: G) -> Stack<Self, G>where Self: Sized,

Stack two generators together

fn composite<G>(self, gen: G) -> Composite<Self, G>where Self: Sized,

Takes two generators and creates a new generator pipelining both generators.

fn by_ref(&self) -> &Self

Get a reference of the generator.

fn sample<I, J>(&self, iterator: I) -> Extract<&Self, J> where Self: Sized, I: IntoIterator<IntoIter = J>, J: Iterator<Item = Input>,

Helper function if one wants to sample values from the interpolation.

impl<K: PartialEq, E: PartialEq, S: PartialEq> PartialEq<BSpline<K, E, S>> for BSpline<K, E, S>

fn eq(&self, other: &BSpline<K, E, S>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<K: Copy, E: Copy, S: Copy> Copy for BSpline<K, E, S>

impl<K, E, S> StructuralPartialEq for BSpline<K, E, S>