Enum BiquadRepr 

pub enum BiquadRepr<T, C = T, Y = T>
where
    Ba<T>: Default,
    Pid<T>: Default,
    BiquadClamp<C, Y>: Default,
    FilterRepr<T>: Default,
{
    Ba(Ba<T>),
    Raw(BiquadClamp<C, Y>),
    Pid(Pid<T>),
    Filter(FilterRepr<T>),
}

Representation of Biquad

miniconf::Tree can be used like this:

use miniconf::{Tree, str_leaf};
#[derive(Tree)]
struct Foo {
    #[tree(typ="&str", with=str_leaf, defer=self.repr)]
    typ: (),
    repr: idsp::iir::repr::BiquadRepr<f32>,
}

Variants

Ba(Ba<T>)

Normalized SI unit coefficients

Raw(BiquadClamp<C, Y>)

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, Y> BiquadRepr<T, C, Y>

where BiquadClamp<C, Y>: Default + Clone, Y: 'static + Copy, T: 'static + Float + FloatConst + Default + AsPrimitive<Y>, f32: AsPrimitive<T>, Pid<T>: Build<BiquadClamp<C, Y>, Context = Units<T>>, [[T; 3]; 2]: Into<BiquadClamp<C, Y>>,

pub fn build(&self, units: &Units<T>) -> BiquadClamp<C, Y>

Build a biquad

Trait Implementations

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

where Ba<T>: Default, Pid<T>: Default, BiquadClamp<C, Y>: Default, FilterRepr<T>: Default,

fn as_ref(&self) -> &str

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

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

where Ba<T>: Default, Pid<T>: Default, BiquadClamp<C, Y>: Default, FilterRepr<T>: Default,

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

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

where Ba<T>: Default, Pid<T>: Default, BiquadClamp<C, Y>: Default, FilterRepr<T>: Default,

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

Formats the value using the given formatter.

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

where Ba<T>: Default, Pid<T>: Default, BiquadClamp<C, Y>: Default, FilterRepr<T>: Default,

fn default() -> Self

Returns the “default value” for a type.

impl<'_derivative_strum, T, C, Y> From<&'_derivative_strum BiquadRepr<T, C, Y>> for &'static str

where Ba<T>: Default, Pid<T>: Default, BiquadClamp<C, Y>: Default, FilterRepr<T>: Default,

fn from(x: &'_derivative_strum BiquadRepr<T, C, Y>) -> &'static str

Converts to this type from the input type.

impl<'_enum, T, C, Y> From<&'_enum BiquadRepr<T, C, Y>> for BiquadReprDiscriminants

where Ba<T>: Default, Pid<T>: Default, BiquadClamp<C, Y>: Default, FilterRepr<T>: Default,

fn from(val: &'_enum BiquadRepr<T, C, Y>) -> BiquadReprDiscriminants

Converts to this type from the input type.

impl<T, C, Y> From<BiquadRepr<T, C, Y>> for &'static str

where Ba<T>: Default, Pid<T>: Default, BiquadClamp<C, Y>: Default, FilterRepr<T>: Default,

fn from(x: BiquadRepr<T, C, Y>) -> &'static str

Converts to this type from the input type.

impl<T, C, Y> From<BiquadRepr<T, C, Y>> for BiquadReprDiscriminants

where Ba<T>: Default, Pid<T>: Default, BiquadClamp<C, Y>: Default, FilterRepr<T>: Default,

fn from(val: BiquadRepr<T, C, Y>) -> BiquadReprDiscriminants

Converts to this type from the input type.

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

where Ba<T>: Default, Pid<T>: Default, BiquadClamp<C, Y>: Default, FilterRepr<T>: Default,

type Err = ParseError

The associated error which can be returned from parsing.

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

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

impl<T, C, Y> IntoDiscriminant for BiquadRepr<T, C, Y>

where Ba<T>: Default, Pid<T>: Default, BiquadClamp<C, Y>: Default, FilterRepr<T>: Default,

type Discriminant = BiquadReprDiscriminants

Enum listing the same variants as this enum but without any data fields

fn discriminant(&self) -> Self::Discriminant

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

where Ba<T>: Default + TreeAny, Pid<T>: Default + TreeAny, BiquadClamp<C, Y>: Default, FilterRepr<T>: Default + TreeAny, C: Any, Y: Any,

fn ref_any_by_key(&self, keys: impl Keys) -> Result<&dyn Any, ValueError>

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

fn mut_any_by_key( &mut self, keys: impl Keys, ) -> Result<&mut dyn Any, ValueError>

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

fn ref_by_key<T>(&self, keys: impl IntoKeys) -> Result<&T, ValueError>

where T: Any,

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

fn mut_by_key<T>(&mut self, keys: impl IntoKeys) -> Result<&mut T, ValueError>

where T: Any,

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

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

where Ba<T>: Default + TreeDeserialize<'de>, Pid<T>: Default + TreeDeserialize<'de>, BiquadClamp<C, Y>: Default, FilterRepr<T>: Default + TreeDeserialize<'de>, C: DeserializeOwned, Y: DeserializeOwned,

fn deserialize_by_key<D: Deserializer<'de>>( &mut self, keys: impl Keys, de: D, ) -> Result<(), SerdeError<D::Error>>

Deserialize a leaf node by its keys.

fn probe_by_key<D: Deserializer<'de>>( keys: impl Keys, de: D, ) -> Result<(), SerdeError<D::Error>>

Blind deserialize a leaf node by its keys.

impl<T, C, Y> TreeSchema for BiquadRepr<T, C, Y>

where Ba<T>: Default + TreeSchema, Pid<T>: Default + TreeSchema, BiquadClamp<C, Y>: Default, FilterRepr<T>: Default + TreeSchema,

const SCHEMA: &'static Schema

Schema for this tree level

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

Return an exact size iterator of all leaf nodes

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

where Ba<T>: Default + TreeSerialize, Pid<T>: Default + TreeSerialize, BiquadClamp<C, Y>: Default, FilterRepr<T>: Default + TreeSerialize, C: Serialize, Y: Serialize,

fn serialize_by_key<S: Serializer>( &self, keys: impl Keys, ser: S, ) -> Result<S::Ok, SerdeError<S::Error>>

Serialize a node by keys.

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

where Ba<T>: Default, Pid<T>: Default, BiquadClamp<C, Y>: Default, FilterRepr<T>: Default,

type Error = ParseError

The type returned in the event of a conversion error.

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

Performs the conversion.