Struct ZPKModel 

pub struct ZPKModel { /* private fields */ }

Analog zero-pole-gain model for real input to real output. Provides methods to generate analog filters of standard type, i.e. bandpass, lowpass and highpass. These can subsequentially be used to generate a digital filter.

Example: Create a digital second order Butterworth bandpass filter

use lasprs::filter::{FilterSpec, ZPKModel};
let fs = 48000.;

let butter = ZPKModel::butter(FilterSpec::Bandpass{fl: 10., fu: 100., order: 2});
let mut filt = butter.bilinear(fs);

It has a transfer function that can be described as a rational function of the form:

         Π_i (s-z_i)
H(s) = k ------------
         Π_i (s-p_i)

where Π denotes the product of a series, z_i are the zeros, and p_i are the poles. In order to have real output for a real input, the zeros and poles should either be real, or come in complex conjugate pairs. This is enforced by the way the poles and zero’s are internally stored.

Implementations

impl ZPKModel

pub fn new<T, U>(zeros: T, poles: U, k: Flt) -> ZPKModel

where T: Into<Vec<PoleOrZero>>, U: Into<Vec<PoleOrZero>>,

Creata a new ZPK model, with give list of poles and zeros, and gain

Args

• zeros - list like struct of zeros. Can be a Vec<ZeroOrPole> or an &[ZeroOrPole].
• poles - list like struct of poles. Can be a Vec<ZeroOrPole> or an &[ZeroOrPole].
• k - linear gain.

pub fn setWarpFreq(self, fcrit: Flt) -> ZPKModel

Set critical frequency in filter, used for bilinear transform.

Args

• fcrit - New critical frequency in [Hz].

pub fn setGainAt(self, freq: Flt, required_gain: Flt) -> ZPKModel

Change the gain value such that it matches val at frequency freq. Does not change the phase at the given frequency.

pub fn butter(spec: FilterSpec) -> ZPKModel

Create a Butterworth filter according to a certain specification in spec.

Panics

• If specified order == 0
• If order is larger than [BUTTER_MAX_ORDER].
• If for a bandpass filter fl>=fu.
• If fl, or fu < 0.

pub fn bilinear(&self, fs: Flt) -> SeriesBiquad

Apply bilinear transform to obtain series biquads from this ZPK model. Pre-warping is taken into account, based on settings stored in ZPKModel. Using ZPKModel::setWarpFreq, this can be overridden.

Args

• fs - Sampling frequency [Hz]

pub fn freqWeightingFilter(wt: FreqWeighting) -> ZPKModel

Create analog filter prototype for a frequency weighting as used in Sound Level Meters.

Args

• wt - [FreqWeighting] to use. i.e. A-weighting.

Examples

Get part of pulse response of digital A-filter at 48 kHz

use lasprs::filter::{ZPKModel, FreqWeighting, Filter};

// Sampling frequency in Hz
let fs = 48000.;

let mut afilter = ZPKModel::freqWeightingFilter(FreqWeighting::A).bilinear(fs);
let mut data = [0.; 1000];
data[0] = 1.0;
let out = afilter.filter(&data);

Trait Implementations

impl Clone for ZPKModel

fn clone(&self) -> ZPKModel

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ZPKModel

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

Formats the value using the given formatter.

impl Default for ZPKModel

fn default() -> Self

Returns the “default value” for a type.

impl<'py> IntoPyObject<'py> for ZPKModel

type Target = ZPKModel

The Python output type

type Output = Bound<'py, <ZPKModel as IntoPyObject<'py>>::Target>

The smart pointer type to use.

type Error = PyErr

The type returned in the event of a conversion error.

fn into_pyobject( self, py: Python<'py>, ) -> Result<<Self as IntoPyObject<'_>>::Output, <Self as IntoPyObject<'_>>::Error>

Performs the conversion.

impl Mul for ZPKModel

type Output = ZPKModel

The resulting type after applying the * operator.

fn mul(self, rhs: ZPKModel) -> Self

Performs the * operation.

impl PyClass for ZPKModel

type Frozen = False

Whether the pyclass is frozen.

impl PyClassImpl for ZPKModel

const IS_BASETYPE: bool = false

#[pyclass(subclass)]

const IS_SUBCLASS: bool = false

#[pyclass(extends=…)]

const IS_MAPPING: bool = false

#[pyclass(mapping)]

const IS_SEQUENCE: bool = false

#[pyclass(sequence)]

const IS_IMMUTABLE_TYPE: bool = false

#[pyclass(immutable_type)]

type BaseType = PyAny

Base class

type ThreadChecker = SendablePyClass<ZPKModel>

This handles following two situations:

type PyClassMutability = <<PyAny as PyClassBaseType>::PyClassMutability as PyClassMutability>::MutableChild

Immutable or mutable

type Dict = PyClassDummySlot

Specify this class has #[pyclass(dict)] or not.

type WeakRef = PyClassDummySlot

Specify this class has #[pyclass(weakref)] or not.

type BaseNativeType = PyAny

The closest native ancestor. This is PyAny by default, and when you declare #[pyclass(extends=PyDict)], it’s PyDict.

fn items_iter() -> PyClassItemsIter

fn doc(py: Python<'_>) -> PyResult<&'static CStr>

Rendered class doc

fn lazy_type_object() -> &'static LazyTypeObject<Self>

fn dict_offset() -> Option<isize>

fn weaklist_offset() -> Option<isize>

impl<'a, 'py> PyFunctionArgument<'a, 'py, false> for &'a ZPKModel

type Holder = Option<PyRef<'py, ZPKModel>>

fn extract( obj: &'a Bound<'py, PyAny>, holder: &'a mut Self::Holder, ) -> PyResult<Self>

impl<'a, 'py> PyFunctionArgument<'a, 'py, false> for &'a mut ZPKModel

type Holder = Option<PyRefMut<'py, ZPKModel>>

fn extract( obj: &'a Bound<'py, PyAny>, holder: &'a mut Self::Holder, ) -> PyResult<Self>

impl PyMethods<ZPKModel> for PyClassImplCollector<ZPKModel>

fn py_methods(self) -> &'static PyClassItems

impl PyTypeInfo for ZPKModel

const NAME: &'static str = "ZPKModel"

Class name.

const MODULE: Option<&'static str> = ::core::option::Option::None

Module name, if any.

fn type_object_raw(py: Python<'_>) -> *mut PyTypeObject

Returns the PyTypeObject instance for this type.

fn type_object(py: Python<'_>) -> Bound<'_, PyType>

Returns the safe abstraction over the type object.

fn is_type_of(object: &Bound<'_, PyAny>) -> bool

Checks if object is an instance of this type or a subclass of this type.

fn is_exact_type_of(object: &Bound<'_, PyAny>) -> bool

Checks if object is an instance of this type.

impl<'a, T: AsArray<'a, Flt>> TransferFunction<'a, T> for ZPKModel

fn tf(&self, _fs: Flt, freq: T) -> Array1<Complex<Flt>>

Compute frequency response (i.e. transfer function from input to output)

impl DerefToPyAny for ZPKModel