Trait SplitProcess 

pub trait SplitProcess<X: Copy, Y = X, S: ?Sized = ()> {
    // Required method
    fn process(&self, state: &mut S, x: X) -> Y;

    // Provided method
    fn block(&self, state: &mut S, x: &[X], y: &mut [Y]) { ... }
}

Processing with split state

Splitting configuration (the part of the filter that is unaffected by processing inputs, e.g. “coefficients”), from state (the part that is modified by processing) allows:

• Separating mutable from immutable state guarantees consistency (configuration can not change state and processing can not change configuration)
• Reduces memory traffic when swapping configuration
• Allows the same filter to be applied to multiple states (e.g. IQ data, multiple channels) guaranteeing consistency, reducing memory usage, and improving caching.

Required Methods

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

Process an input into an output

See also Process::process

Provided Methods

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

Process a block of inputs

See also Process::block

Implementations on Foreign Types

impl<X: Copy, C, S> SplitProcess<X, X, [S]> for [C]

where C: SplitInplace<X, S>,

Chain of multiple large filters of the same type

X->X->X...

• Clice can be empty

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

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

impl<X: Copy, Y, P: Process<X, Y>> SplitProcess<X, Y, Unsplit<P>> for ()

Configuration-less filters

fn process(&self, state: &mut Unsplit<P>, x: X) -> Y

fn block(&self, state: &mut Unsplit<P>, x: &[X], y: &mut [Y])

impl<X: Copy, Y, S: ?Sized, T: SplitProcess<X, Y, S>> SplitProcess<X, Y, S> for &T

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

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

impl<X: Copy, Y, S: ?Sized, T: SplitProcess<X, Y, S>> SplitProcess<X, Y, S> for &mut T

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

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

impl<X: Copy, Y: Copy, C0, C1, S0, S1> SplitProcess<X, Y, (S0, S1)> for (C0, C1)

where C0: SplitProcess<X, Y, S0>, C1: SplitInplace<Y, S1>,

Chain of two different large filters

X->Y->Y

fn process(&self, state: &mut (S0, S1), x: X) -> Y

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

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

where C: SplitProcess<X, Y, S> + SplitInplace<Y, S>,

A chain of multiple large filters of the same type

X->Y->Y...

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

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

Implementors

impl<'a, X: Copy, Y, P> SplitProcess<X, Y> for Unsplit<&'a P>

where &'a P: Process<X, Y>,

Stateless filters

impl<C, S, X: Copy, Y: Default + Copy, const N: usize, const R: usize, const M: usize> SplitProcess<[X; N], [Y; M], S> for ChunkOut<C, R>

where C: SplitProcess<X, [Y; R], S>,

impl<C, S, X: Copy, Y: Default + Copy, const Q: usize, const N: usize, const R: usize, const M: usize> SplitProcess<[X; N], [Y; M], S> for ChunkInOut<C, Q, R>

where C: SplitProcess<[X; Q], [Y; R], S>,

impl<C: SplitProcess<[X; R], Y, S>, S, X: Copy, Y, const N: usize, const R: usize, const M: usize> SplitProcess<[X; N], [Y; M], S> for ChunkIn<C, R>

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

impl<X0: Copy, X1: Copy, Y0, Y1, C0, C1, S0, S1> SplitProcess<(X0, X1), (Y0, Y1), (S0, S1)> for Parallel<(C0, C1)>

where C0: SplitProcess<X0, Y0, S0>, C1: SplitProcess<X1, Y1, S1>,

impl<X: Copy, C, S> SplitProcess<X, X, [S]> for Minor<[C], X>

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

A chain of multiple small filters of the same type

impl<X: Copy, U: Copy + Default, Y, C0, C1, S0, S1, const N: usize> SplitProcess<X, Y, (S0, S1)> for Major<(C0, C1), [U; N]>

where C0: SplitProcess<X, U, S0>, C1: SplitProcess<U, Y, S1>,

impl<X: Copy, U: Copy, Y, C0, C1, S0, S1> SplitProcess<X, Y, (S0, S1)> for Minor<(C0, C1), U>

where C0: SplitProcess<X, U, S0>, C1: SplitProcess<U, Y, S1>,

impl<X: Copy, Y, C0, C1, S0, S1> SplitProcess<[X; 2], [Y; 2], (S0, S1)> for Parallel<(C0, C1)>

where C0: SplitProcess<X, Y, S0>, C1: SplitProcess<X, Y, S1>,

impl<X: Copy, Y, C0, C1, S0, S1> SplitProcess<[X; 2], [Y; 2], (S0, S1)> for Transpose<(C0, C1)>

where C0: SplitProcess<X, Y, S0>, C1: SplitProcess<X, Y, S1>,

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

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

impl<X: Copy, Y, C: SplitProcess<X, Y, S>, S> SplitProcess<Option<X>, Option<Y>, S> for Map<C>

impl<X: Copy, Y, C: SplitProcess<X, Y, S>, S, E: Copy> SplitProcess<Result<X, E>, Result<Y, E>, S> for Map<C>

impl<X: Copy, Y: Copy + Default, C, S, const N: usize> SplitProcess<[X; N], [Y; N], [S; N]> for Channels<C>

where C: SplitProcess<X, Y, S>,

Process data from multiple channels with a common configuration

Note that block() and inplace() reinterpret the data as Transpose: not as [[X; N]] but as [[X]; N]. Use x.as_flattened().chunks_exact(x.len())/x.as_chunks<N>().0 etc. to match that.

impl<X: Copy, Y: Copy + Default, C, S, const N: usize> SplitProcess<[X; N], [Y; N], [S; N]> for Parallel<[C; N]>

where C: SplitProcess<X, Y, S>,

impl<X: Copy, Y: Copy + Default, C, S, const N: usize> SplitProcess<[X; N], [Y; N], [S; N]> for Transpose<[C; N]>

where C: SplitProcess<X, Y, S>,

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

where C: SplitProcess<X, Y, S> + SplitProcess<Y, Y, S>,

A chain of multiple small filters of the same type