Trait Process 

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

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

Processing block

Single-input processing with state held in self.

This is the simplest trait in the crate: one new sample goes in, one output value comes out. Override block() when a specialized loop can reuse scratch storage, reduce bounds checks, or better match the desired data layout.

SplitProcess is the corresponding trait when immutable configuration and mutable runtime state should be separated.

Examples

use dsp_process::Process;

#[derive(Default)]
struct Acc(i32);

impl Process<i32> for Acc {
    fn process(&mut self, x: i32) -> i32 {
        self.0 += x;
        self.0
    }
}

let mut acc = Acc::default();
assert_eq!(acc.process(2), 2);
assert_eq!(acc.process(3), 5);

Required Methods

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

Update the state with a new input and obtain an output

Provided Methods

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

Process a block of inputs into a block of outputs

Input and output must be of the same size.

For hot-path use this is treated as a caller precondition; the default implementation only checks it in debug builds.

Dyn Compatibility

This trait is dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementations on Foreign Types

impl<X: Copy, Y, T: Process<X, Y>> Process<X, Y> for &mut T

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

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

Implementors

impl<F: FnMut(X) -> Y, X: Copy, Y> Process<X, Y> for FnProcess<F>

impl<T: Copy + Neg<Output = T>> Process<T> for Neg

impl<T: Copy> Process<Option<T>, T> for Hold<T>

impl<T: Copy> Process<T> for Identity

impl<X0: Copy + Add<X1, Output = Y>, X1: Copy, Y> Process<(X0, X1), Y> for Add

impl<X0: Copy + Mul<X1, Output = Y>, X1: Copy, Y> Process<(X0, X1), Y> for Mul

impl<X0: Copy + Sub<X1, Output = Y>, X1: Copy, Y> Process<(X0, X1), Y> for Sub

impl<X: Copy + Add<Output = Y> + Sub<Output = Y>, Y> Process<[X; 2], [Y; 2]> for Butterfly

impl<X: Copy + Add<X, Output = Y>, Y, const N: usize> Process<X, Y> for Nyquist<[X; N]>

impl<X: Copy + Default, const I: usize, const N: usize> Process<X, [X; N]> for Rate<I>

impl<X: Copy + Sub<Output = Y>, Y> Process<[X; 2], Y> for Sub

impl<X: Copy + Sub<X, Output = Y>, Y, const N: usize> Process<X, Y> for Comb<[X; N]>

impl<X: Copy, Y, S, C: SplitProcess<X, Y, S>> Process<X, Y> for Split<C, S>

impl<X: Copy, Y: AddAssign<X> + Copy> Process<X, Y> for Integrator<Y>

impl<X: Copy, Y: Product<X>, const N: usize> Process<[X; N], Y> for Mul

impl<X: Copy, Y: Sum<X>, const N: usize> Process<[X; N], Y> for Add

impl<X: Copy, const I: usize, const N: usize> Process<[X; N], X> for Rate<I>

impl<X: Copy, const N: usize, const M: usize> Process<[X; M]> for Buffer<[X; N]>

impl<X: Copy, const N: usize> Process<Option<[X; N]>, X> for Buffer<[X; N]>

impl<X: Copy, const N: usize> Process<X, Option<[X; N]>> for Buffer<[X; N]>

Buffer into chunks

Returns Some(chunk) every N samples and None otherwise.

impl<X: Copy, const N: usize> Process<X, [X; N]> for Identity

Fan out

impl<X: Copy, const N: usize> Process<X> for Buffer<[X; N]>

Delay line

This is the simplest stateful FIFO in the crate.

impl<X: Copy> Process<X, (X, X)> for Identity

Fan out

impl<X: Copy> Process<[X; 1], X> for Identity

Flatten