Enum BiquadRepr

pub enum BiquadRepr<T, C>
where
    C: Coefficient,
    T: Float + FloatConst,
{
    Ba(Ba<T>),
    Raw(Leaf<Biquad<C>>),
    Pid(Pid<T>),
    Filter(FilterRepr<T>),
}

Representation of Biquad

Variants

Ba(Ba<T>)

Normalized SI unit coefficients

Raw(Leaf<Biquad<C>>)

Raw, unscaled, possibly fixed point machine unit coefficients

Pid(Pid<T>)

A PID

Filter(FilterRepr<T>)

Standard biquad filters: Notch, Lowpass, Highpass, Shelf etc

Implementations

impl<T, C> BiquadRepr<T, C>

where C: Coefficient + AsPrimitive<C> + AsPrimitive<T>, T: AsPrimitive<C> + Float + FloatConst,

pub fn build<I>(&self, period: T, b_scale: T, y_scale: T) -> Biquad<C>

where T: AsPrimitive<I>, I: Float + 'static + AsPrimitive<C>, C: AsPrimitive<I>, f32: AsPrimitive<T>,

Build a biquad

Args:

• period: The sample period in desired units (e.g. SI seconds)
• b_scale: The feed forward (b coefficient) conversion scale from desired units to machine units. An identity (gain=1) filter a x input in machine units will lead to a y=b_scale*x filter output in machine units.
• y_scale: The y output scale from desired units to machine units. E.g. a max setting will lead to a y=y_scale*max upper limit of the filter in machine units.

Trait Implementations

impl<T, C> AsRef<str> for BiquadRepr<T, C>

where C: Coefficient, T: Float + FloatConst,

fn as_ref(&self) -> &str

Converts this type into a shared reference of the (usually inferred) input type.

impl<T, C> Clone for BiquadRepr<T, C>

where C: Coefficient + Clone, T: Float + FloatConst + Clone,

fn clone(&self) -> BiquadRepr<T, C>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T, C> Debug for BiquadRepr<T, C>

where C: Coefficient + Debug, T: Float + FloatConst + Debug,

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

Formats the value using the given formatter.

impl<T, C> Default for BiquadRepr<T, C>

where C: Coefficient, T: Float + FloatConst,

fn default() -> Self

Returns the “default value” for a type.

impl<T, C> FromStr for BiquadRepr<T, C>

where C: Coefficient, T: Float + FloatConst,

type Err = ParseError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<BiquadRepr<T, C>, <Self as FromStr>::Err>

Parses a string s to return a value of this type.

impl<T, C> TreeAny for BiquadRepr<T, C>

where C: Coefficient, T: Float + FloatConst, Ba<T>: TreeAny, Leaf<Biquad<C>>: TreeAny, Pid<T>: TreeAny, FilterRepr<T>: TreeAny,

fn ref_any_by_key<K>(&self, keys: K) -> Result<&dyn Any, Traversal>

where K: Keys,

Obtain a reference to a dyn Any trait object for a leaf node.

fn mut_any_by_key<K>(&mut self, keys: K) -> Result<&mut dyn Any, Traversal>

where K: Keys,

Obtain a mutable reference to a dyn Any trait object for a leaf node.

fn ref_by_key<T, K>(&self, keys: K) -> Result<&T, Traversal>

where T: Any, K: IntoKeys,

Obtain a reference to a leaf of known type by key.

fn mut_by_key<T, K>(&mut self, keys: K) -> Result<&mut T, Traversal>

where T: Any, K: IntoKeys,

Obtain a mutable reference to a leaf of known type by key.

impl<'de, T, C> TreeDeserialize<'de> for BiquadRepr<T, C>

where C: Coefficient, T: Float + FloatConst, Ba<T>: TreeDeserialize<'de>, Leaf<Biquad<C>>: TreeDeserialize<'de>, Pid<T>: TreeDeserialize<'de>, FilterRepr<T>: TreeDeserialize<'de>,

fn deserialize_by_key<K, D>( &mut self, keys: K, de: D, ) -> Result<usize, Error<D::Error>>

where K: Keys, D: Deserializer<'de>,

Deserialize a leaf node by its keys.

impl<T, C> TreeKey for BiquadRepr<T, C>

where C: Coefficient, T: Float + FloatConst, Ba<T>: TreeKey, Leaf<Biquad<C>>: TreeKey, Pid<T>: TreeKey, FilterRepr<T>: TreeKey,

fn traverse_all<W: Walk>() -> Result<W, W::Error>

Walk metadata about all paths.

fn traverse_by_key<K, F, E>(keys: K, func: F) -> Result<usize, Error<E>>

where K: Keys, F: FnMut(usize, Option<&'static str>, NonZero<usize>) -> Result<(), E>,

Traverse from the root to a leaf and call a function for each node.

fn transcode<N, K>(keys: K) -> Result<(N, Node), Traversal>

where K: IntoKeys, N: Transcode + Default,

Transcode keys to a new keys type representation

fn nodes<N, const D: usize>() -> NodeIter<Self, N, D>

where N: Transcode + Default,

Return an iterator over nodes of a given type

impl<T, C> TreeSerialize for BiquadRepr<T, C>

where C: Coefficient, T: Float + FloatConst, Ba<T>: TreeSerialize, Leaf<Biquad<C>>: TreeSerialize, Pid<T>: TreeSerialize, FilterRepr<T>: TreeSerialize,

fn serialize_by_key<K, S>( &self, keys: K, ser: S, ) -> Result<usize, Error<S::Error>>

where K: Keys, S: Serializer,

Serialize a node by keys.

impl<T, C> TryFrom<&str> for BiquadRepr<T, C>

where C: Coefficient, T: Float + FloatConst,

type Error = ParseError

The type returned in the event of a conversion error.

fn try_from(s: &str) -> Result<BiquadRepr<T, C>, <Self as TryFrom<&str>>::Error>

Performs the conversion.