Struct Lanes 

pub struct Lanes<C>(/* private fields */);

Multiple lanes with one shared configuration and separate states.

Lanes is the main reason the split-state API exists: immutable configuration is stored once while each lane keeps its own mutable state. Scalar processing is lane-wise over [X; N].

For view processing, pair it with View<_, _, LaneMajor, _> when the natural memory layout is lane-major and the inner stage benefits from long contiguous per-lane slices. Prefer this over repeat() when all lanes should use exactly the same configuration.

Examples

use dsp_process::{LaneMajor, Offset, Split, View, ViewMut, ViewProcess};

let mut p = Split::stateless(Offset(3)).lanes::<2>();
let x = View::<_, LaneMajor, 2>::from_flat(&[1, 2, 3, 10, 20, 30], 3);
let mut y = [0; 6];
let yv = ViewMut::<_, LaneMajor, 2>::from_flat(&mut y, 3);
ViewProcess::process_view(&mut p, x, yv);
assert_eq!(y, [4, 5, 6, 13, 23, 33]);

Implementations

impl<C> Lanes<C>

pub const fn new(inner: C) -> Self

Create a Lanes wrapper around an existing composition.

pub fn into_inner(self) -> C

Consume the wrapper and return the inner composition.

Trait Implementations

impl<C: Clone> Clone for Lanes<C>

fn clone(&self) -> Lanes<C>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<C: Copy> Copy for Lanes<C>

impl<C: Debug> Debug for Lanes<C>

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

Formats the value using the given formatter.

impl<C: Default> Default for Lanes<C>

fn default() -> Lanes<C>

Returns the “default value” for a type.

impl<X, C, S> SplitInplace<X, S> for Lanes<C>

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

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

See also Inplace::inplace

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

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

Process data from multiple lanes with a common configuration.

For layout-sensitive view processing use View<_, _, LaneMajor, _>.

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

Process an input into an output

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

Process a block of inputs

impl<'a, X: Copy, C, S, const N: usize> SplitViewInplace<ViewMut<'a, X, LaneMajor, N>, [S; N]> for Lanes<C>

where C: SplitInplace<X, S>,

fn inplace_view(&self, state: &mut [S; N], xy: ViewMut<'a, X, LaneMajor, N>)

Process one typed view in place.

impl<'a, 'b, X: Copy, Y, C, S, const N: usize> SplitViewProcess<View<'a, X, LaneMajor, N>, ViewMut<'b, Y, LaneMajor, N>, [S; N]> for Lanes<C>

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

fn process_view( &self, state: &mut [S; N], x: View<'a, X, LaneMajor, N>, y: ViewMut<'b, Y, LaneMajor, N>, )

Process one typed input view into one typed output view.