Struct enterpolation::Composite

pub struct Composite<A, B>(_, _);

Struct which composite two generator together to act as one generator.

This struct is created by Generator::composite. See its documentation for more.

Implementations

impl<A, B> Composite<A, B>

pub fn new(first: A, second: B) -> Self

Creates a composite generator.

Trait Implementations

impl<A: Clone, B: Clone> Clone for Composite<A, B>

fn clone(&self) -> Composite<A, B>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<A, B, R> Curve<R> for Composite<A, B>where A: Curve<R>, B: Generator<A::Output>, R: Real,

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<A: Debug, B: Debug> Debug for Composite<A, B>

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

Formats the value using the given formatter.

impl<A, B, T> Generator<T> for Composite<A, B>where A: Generator<T>, B: Generator<A::Output>,

type Output = <B as Generator<<A as Generator<T>>::Output>>::Output

The element outputted

fn gen(&self, scalar: T) -> Self::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<A: PartialEq, B: PartialEq> PartialEq<Composite<A, B>> for Composite<A, B>

fn eq(&self, other: &Composite<A, B>) -> 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<A: Copy, B: Copy> Copy for Composite<A, B>

impl<A, B> StructuralPartialEq for Composite<A, B>