Struct EvenSymmetric 

#[repr(transparent)]
pub struct EvenSymmetric<C>(pub C);

Linear phase FIR taps for odd = false and symmetric = true

Tuple Fields

0: C

Implementations

impl<T, const M: usize> EvenSymmetric<[T; M]>

pub const LEN: usize

Response length/number of taps minus one

Trait Implementations

impl<C: Clone> Clone for EvenSymmetric<C>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<C: Debug> Debug for EvenSymmetric<C>

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

Formats the value using the given formatter.

impl<C: Default> Default for EvenSymmetric<C>

fn default() -> EvenSymmetric<C>

Returns the “default value” for a type.

impl<C: Copy, T: Copy + Default + Sub<T, Output = T> + Add<Output = T> + Mul<C, Output = T> + Sum, const M: usize, const N: usize> SplitInplace<T, [T; N]> for EvenSymmetric<[C; M]>

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

See also [Inplace::inplace]

impl<C: Copy, T: Copy + Default + Add<Output = T> + Sub<Output = T> + Mul<C, Output = T> + Sum, const M: usize, const N: usize> SplitProcess<[T; 2], T, HbfDec<[T; N]>> for EvenSymmetric<[C; M]>

fn block(&self, state: &mut HbfDec<[T; N]>, x: &[[T; 2]], y: &mut [T])

Process a block of inputs

fn process(&self, state: &mut HbfDec<[T; N]>, x: [T; 2]) -> T

Process an input into an output

impl<C: Copy, T: Copy + Default + Add<Output = T> + Sub<Output = T> + Mul<C, Output = T> + Sum, const M: usize, const N: usize> SplitProcess<T, [T; 2], HbfInt<[T; N]>> for EvenSymmetric<[C; M]>

fn block(&self, state: &mut HbfInt<[T; N]>, x: &[T], y: &mut [[T; 2]])

Process a block of inputs

fn process(&self, state: &mut HbfInt<[T; N]>, x: T) -> [T; 2]

Process an input into an output

impl<C: Copy, T: Copy + Default + Sub<T, Output = T> + Add<Output = T> + Mul<C, Output = T> + Sum, const M: usize, const N: usize> SplitProcess<T, T, [T; N]> for EvenSymmetric<[C; M]>

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

Process a block of inputs

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

Process an input into an output

impl<C: Copy> Copy for EvenSymmetric<C>