Struct Chunk 

pub struct Chunk<P>(pub P);

Elementwise fixed-size chunk lifting.

Adapt a X -> Y processor into a [X; N] -> [Y; N] processor by flattening input and output.

This is the simplest array-lifting adapter and is often the right choice when a scalar stage should run elementwise over fixed-size chunks with no rate change and no frame semantics beyond flattening.

Prefer the more specific adapters when the inner stage consumes or produces grouped samples (ChunkIn, ChunkOut, ChunkInOut) or when stream phase is part of the semantics (Interpolator, Decimator).

Examples

use dsp_process::{Chunk, Offset, Process, Split};

let mut p = Split::stateless(Chunk(Offset(3)));
assert_eq!(p.process([1, 2, 3]), [4, 5, 6]);

Tuple Fields

0: P

Trait Implementations

impl<P: Clone> Clone for Chunk<P>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<P: Copy> Copy for Chunk<P>

impl<P: Debug> Debug for Chunk<P>

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

Formats the value using the given formatter.

impl<P: Default> Default for Chunk<P>

fn default() -> Chunk<P>

Returns the “default value” for a type.

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

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

See also Inplace::inplace

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

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

Process an input into an output

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

Process a block of inputs