Struct Interpolator 

pub struct Interpolator<P>(pub P);

Adapt a scalar optional-input stage to chunk output mode.

The inner processor is called with Some(x) once and then None N-1 times to synthesize one output chunk from one input sample.

This is convenient for polyphase interpolators and other stages whose natural scalar interface is Option<X> -> Y. Unlike crate::ChunkOut, this preserves stream phase and still runs the recursive inner stage once per output sample.

See also Decimator for the inverse direction.

Examples

use dsp_process::{FnSplitProcess, Interpolator, SplitProcess};

let proc = Interpolator(FnSplitProcess(|_: &mut (), x: Option<i32>| {
    x.unwrap_or_default()
}));
let mut state = ();
assert_eq!(proc.process(&mut state, 7), [7, 0, 0]);

Tuple Fields

0: P

Trait Implementations

impl<P: Clone> Clone for Interpolator<P>

fn clone(&self) -> Interpolator<P>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<P: Debug> Debug for Interpolator<P>

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

Formats the value using the given formatter.

impl<P: Default> Default for Interpolator<P>

fn default() -> Interpolator<P>

Returns the “default value” for a type.

impl<X: Copy, C, S> SplitInplace<X, S> for Interpolator<C>

where Self: SplitProcess<X, X, S>,

fn inplace(&self, state: &mut S, xy: &mut [X])

See also Inplace::inplace

impl<X: Copy, Y, C: SplitProcess<Option<X>, Y, S>, S, const N: usize> SplitProcess<X, [Y; N], S> for Interpolator<C>

fn process(&self, state: &mut S, x: X) -> [Y; N]

Process an input into an output

fn block(&self, state: &mut S, x: &[X], y: &mut [Y])

Process a block of inputs