Struct enterpolation::TransformInput

pub struct TransformInput<G, A, M> { /* private fields */ }

Struct which transforms the input before sending it to the underlying generator.

Both addition and multiplication is done. In regards to math operation priorities, multiplication is done first.

Implementations

impl<G, A, M> TransformInput<G, A, M>

pub fn new(generator: G, addition: A, multiplication: M) -> Self

Create a generic TransformInput.

impl<G, R> TransformInput<G, R, R>where G: Curve<R>, R: Real,

pub fn normalized_to_domain(generator: G, start: R, end: R) -> Self

Transfrom an input such that the wrapped generator changes its domain from [0.0,1.0] to the domain wished for.

Trait Implementations

impl<G: Clone, A: Clone, M: Clone> Clone for TransformInput<G, A, M>

fn clone(&self) -> TransformInput<G, A, M>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<G, R> Curve<R> for TransformInput<G, R, R>where G: Curve<R>, 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<G: Debug, A: Debug, M: Debug> Debug for TransformInput<G, A, M>

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

Formats the value using the given formatter.

impl<G, A, M, I> Generator<I> for TransformInput<G, A, M>where I: Mul<M>, I::Output: Add<A>, A: Copy, M: Copy, G: Generator<<<I as Mul<M>>::Output as Add<A>>::Output>,

type Output = <G as Generator<<<I as Mul<M>>::Output as Add<A>>::Output>>::Output

The element outputted

fn gen(&self, input: I) -> 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<G: PartialEq, A: PartialEq, M: PartialEq> PartialEq<TransformInput<G, A, M>> for TransformInput<G, A, M>

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

impl<G, A, M> StructuralPartialEq for TransformInput<G, A, M>