Struct ChunkInOut 

pub struct ChunkInOut<P, const Q: usize, const R: usize>(pub P);

General fixed-ratio regrouping adapter for chunked input and output.

Adapt a [X; Q] -> [Y; R] processor to [X; N = Q*I]->[Y; M = R*I] for any I by flattening and re-chunking input and output.

This is the most general fixed-ratio chunk adapter in the crate. It requires the input and output to represent the same number of inner chunks. Reach for it when neither plain Chunk, ChunkIn, nor ChunkOut captures the actual grouping relation.

Examples

use dsp_process::{ChunkInOut, FnSplitProcess, Process, Split};

let mut p = Split::stateless(ChunkInOut::<_, 2, 1>(FnSplitProcess(
    |_: &mut (), [a, b]: [i32; 2]| [a + b],
)));
assert_eq!(p.process([1, 2, 3, 4]), [3, 7]);

Tuple Fields

0: P

Trait Implementations

impl<P: Clone, const Q: usize, const R: usize> Clone for ChunkInOut<P, Q, R>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<P: Copy, const Q: usize, const R: usize> Copy for ChunkInOut<P, Q, R>

impl<P: Debug, const Q: usize, const R: usize> Debug for ChunkInOut<P, Q, R>

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

Formats the value using the given formatter.

impl<P: Default, const Q: usize, const R: usize> Default for ChunkInOut<P, Q, R>

fn default() -> Self

Returns the “default value” for a type.

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

where Self: SplitProcess<[X; N], [X; N], S>,

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

See also Inplace::inplace

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>,

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

Process an input into an output

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

Process a block of inputs