Struct TransferFunctionBlock 

pub struct TransferFunctionBlock<const NUM_SIZE: usize, const DEN_SIZE: usize, F: Float, I>
where
    I: Default,
{
    pub data: BlockData,
    /* private fields */
}

Implements a transfer function H(z) = Y(z) / X(z) over the input signal.

The parameters for the block require an array of numerator and denominator coefficients used to compute the output of the block: y[n] = b[0] * x[n] + b[1] * x[n-1] + ... + b[n] * x[n-n] - a[1] * y[n-1] - a[2] * y[n-2] + ...

A transfer function that represents an decay of 1/2 each sample can be represented as: H(z) = Y(z) / X(z) = z / (z - 0.5)

The numerator would be [1] and the denominator would be [1, -0.5].

The numerator and denominator must have dimensions of at least 1 and the 0th value of the denominator will be skipped (but must still be present), as it represents the coefficient for y[n], the current output.

Fields

data: BlockData

Trait Implementations

impl<const NUM_SIZE: usize, const DEN_SIZE: usize, F, I> Default for TransferFunctionBlock<NUM_SIZE, DEN_SIZE, F, I>

where F: Float, I: Pass + Default, BlockData: FromPass<I>,

fn default() -> Self

Returns the “default value” for a type.

impl<const NUM_SIZE: usize, const DEN_SIZE: usize, const ROWS: usize, const COLS: usize> ProcessBlock for TransferFunctionBlock<NUM_SIZE, DEN_SIZE, f32, Matrix<ROWS, COLS, f32>>

where f32: Float, OldBlockData: FromPass<Matrix<ROWS, COLS, f32>>,

type Inputs = Matrix<ROWS, COLS, f32>

type Output = Matrix<ROWS, COLS, f32>

type Parameters = Parameters<f32, NUM_SIZE, DEN_SIZE>

fn process( &mut self, parameters: &Self::Parameters, _context: &dyn Context, input: PassBy<'_, Self::Inputs>, ) -> PassBy<'_, Self::Output>

impl<const NUM_SIZE: usize, const DEN_SIZE: usize> ProcessBlock for TransferFunctionBlock<NUM_SIZE, DEN_SIZE, f32, f32>

where OldBlockData: FromPass<f64>,

type Inputs = f32

type Output = f32

type Parameters = Parameters<f32, NUM_SIZE, DEN_SIZE>

fn process( &mut self, parameters: &Self::Parameters, _context: &dyn Context, input: PassBy<'_, Self::Inputs>, ) -> PassBy<'_, Self::Output>

impl<const NUM_SIZE: usize, const DEN_SIZE: usize, const ROWS: usize, const COLS: usize> ProcessBlock for TransferFunctionBlock<NUM_SIZE, DEN_SIZE, f64, Matrix<ROWS, COLS, f64>>

where f64: Float, OldBlockData: FromPass<Matrix<ROWS, COLS, f64>>,

type Inputs = Matrix<ROWS, COLS, f64>

type Output = Matrix<ROWS, COLS, f64>

type Parameters = Parameters<f64, NUM_SIZE, DEN_SIZE>

fn process( &mut self, parameters: &Self::Parameters, _context: &dyn Context, input: PassBy<'_, Self::Inputs>, ) -> PassBy<'_, Self::Output>

impl<const NUM_SIZE: usize, const DEN_SIZE: usize> ProcessBlock for TransferFunctionBlock<NUM_SIZE, DEN_SIZE, f64, f64>

where OldBlockData: FromPass<f64>,

type Inputs = f64

type Output = f64

type Parameters = Parameters<f64, NUM_SIZE, DEN_SIZE>

fn process( &mut self, parameters: &Self::Parameters, _context: &dyn Context, input: PassBy<'_, Self::Inputs>, ) -> PassBy<'_, Self::Output>