Struct Split 

pub struct Split<C, S> {
    pub config: C,
    pub state: S,
}

A stateful processor with split state

Fields

config: C

Processor configuration

state: S

Processor state

Implementations

impl<C, S> Split<C, S>

pub const fn new(config: C, state: S) -> Self

Create a new Split

pub const fn assert_process<X: Copy, Y>(&self)

where Self: Process<X, Y>,

Statically assert that this implements Process<X, Y>

pub fn as_mut(&mut self) -> Split<&C, &mut S>

Obtain a borrowing Split

Stateful Process is implemented on the borrowing Split

impl<C> Split<Unsplit<C>, ()>

pub fn stateless(config: C) -> Self

Create a stateless processor

impl<S> Split<(), Unsplit<S>>

pub fn stateful(state: S) -> Self

Create a state-only processor

impl<C, S> Split<C, S>

pub fn minor<U>(self) -> Split<Minor<C, U>, S>

Convert to a configuration-minor split

pub fn major<U>(self) -> Split<Major<C, U>, S>

Convert to intermediate buffered processor-major

pub fn parallel(self) -> Split<Parallel<C>, S>

Convert to parallel (MIMO)

pub fn repeat<const N: usize>(self) -> Split<[C; N], [S; N]>

where C: Clone, S: Clone,

Repeat by cloning configuration and current (!) state

pub fn channels<const N: usize>(self) -> Split<Channels<C>, [S; N]>

where S: Clone,

Apply to multiple states by cloning the current (!) state

pub fn transpose(self) -> Split<Transpose<C>, S>

Convert to parallel transpose operation on blocks/inplace of [[x]; N] instead of [[x; N]]

impl<C, S, U> Split<Minor<C, U>, S>

pub fn inter(self) -> Split<C, S>

Strip minor

impl<C, S> Split<Parallel<C>, S>

pub fn inter(self) -> Split<C, S>

Convert to serial

impl<C, S> Split<Transpose<C>, S>

pub fn inter(self) -> Split<C, S>

Convert to non-transposing

impl<C, S, B> Split<Major<C, B>, S>

pub fn inter(self) -> Split<C, S>

Remove major intermediate buffering

impl<C0, C1, S0, S1> Split<(C0, C1), (S0, S1)>

pub fn zip(self) -> (Split<C0, S0>, Split<C1, S1>)

Zip up a split

impl<C, S, const N: usize> Split<[C; N], [S; N]>

pub fn zip(self) -> [Split<C, S>; N]

Zip up a split

Trait Implementations

impl<C0, C1, S0, S1> Add<Split<C1, S1>> for Split<C0, S0>

Unzip two splits into one parallel

type Output = Split<Parallel<(C0, C1)>, (S0, S1)>

The resulting type after applying the + operator.

fn add(self, rhs: Split<C1, S1>) -> Self::Output

Performs the + operation.

impl<C: Clone, S: Clone> Clone for Split<C, S>

fn clone(&self) -> Split<C, S>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<C: Debug, S: Debug> Debug for Split<C, S>

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

Formats the value using the given formatter.

impl<C: Default, S: Default> Default for Split<C, S>

fn default() -> Split<C, S>

Returns the “default value” for a type.

impl<C, S, const N: usize> From<[Split<C, S>; N]> for Split<[C; N], [S; N]>

Unzip multiple splits

fn from(splits: [Split<C, S>; N]) -> Self

Converts to this type from the input type.

impl<C0, C1, S0, S1> From<(Split<C0, S0>, Split<C1, S1>)> for Split<(C0, C1), (S0, S1)>

Unzip two splits

fn from(value: (Split<C0, S0>, Split<C1, S1>)) -> Self

Converts to this type from the input type.

impl<X: Copy, S: ?Sized, C: SplitInplace<X, S> + ?Sized> Inplace<X> for Split<&C, &mut S>

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

Process an input block into the same data as output

impl<C0, C1, S0, S1> Mul<Split<C1, S1>> for Split<C0, S0>

Unzip two splits into one

type Output = Split<(C0, C1), (S0, S1)>

The resulting type after applying the * operator.

fn mul(self, rhs: Split<C1, S1>) -> Self::Output

Performs the * operation.

impl<X: Copy, Y, S: ?Sized, C: SplitProcess<X, Y, S> + ?Sized> Process<X, Y> for Split<&C, &mut S>

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

Update the state with a new input and obtain an output

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

Process a block of inputs into a block of outputs

impl<C: Copy, S: Copy> Copy for Split<C, S>