Struct signal_processing::Zpk

pub struct Zpk<T: ComplexFloat, Z: MaybeList<T> = (), P: MaybeList<T> = (), K: ComplexFloat<Real = T::Real> = T> {
    pub z: ProductSequence<T, Z>,
    pub p: ProductSequence<T, P>,
    pub k: K,
}

Fields

z: ProductSequence<T, Z>

p: ProductSequence<T, P>

k: K

Implementations

impl<T, Z, P, K> Zpk<T, Z, P, K>

where T: ComplexFloat, Z: MaybeList<T>, P: MaybeList<T>, K: ComplexFloat<Real = T::Real>,

pub fn new(z: Z, p: P, k: K) -> Self

pub type View<'a> = Zpk<T, <Z as MaybeContainer<T>>::View<'a>, <P as MaybeContainer<T>>::View<'a>, K> where Z: 'a, P: 'a, Z::View<'a>: MaybeList<T>, P::View<'a>: MaybeList<T>

pub type Owned = Zpk<T, <Z as MaybeContainer<T>>::Owned, <P as MaybeContainer<T>>::Owned, K> where Z::Owned: MaybeList<T>, P::Owned: MaybeList<T>

pub fn as_view<'a>(&'a self) -> Zpk<T, Z::View<'a>, P::View<'a>, K>

where Z::View<'a>: MaybeList<T>, P::View<'a>: MaybeList<T>,

pub fn to_owned(&self) -> Zpk<T, Z::Owned, P::Owned, K>

where Z::Owned: MaybeList<T>, P::Owned: MaybeList<T>,

pub fn into_owned(self) -> Zpk<T, Z::Owned, P::Owned, K>

where Z::Owned: MaybeList<T>, P::Owned: MaybeList<T>,

pub fn s() -> Self

where T: Zero, K: One, ProductSequence<T, [T; 1]>: Into<ProductSequence<T, Z>>, ProductSequence<T, ()>: Into<ProductSequence<T, P>>,

pub fn z() -> Self

where T: Zero, K: One, ProductSequence<T, [T; 1]>: Into<ProductSequence<T, Z>>, ProductSequence<T, ()>: Into<ProductSequence<T, P>>,

pub fn one() -> Self

where Self: Default,

pub fn zero() -> Self

where Self: Default,

pub fn is_one(&self) -> bool

pub fn is_zero(&self) -> bool

pub fn poles(&self) -> &[T]

pub fn zeros(&self) -> &[T]

pub fn complex_real<Tol>( self, tolerance: Tol ) -> Result<(Vec<[Complex<T::Real>; 2]>, Vec<[Complex<T::Real>; 2]>, Vec<T::Real>, Vec<T::Real>, K), ComplexRealError>

where Tol: Maybe<T::Real>, T: Into<Complex<T::Real>>, Self: ToZpk<T, Vec<T>, Vec<T>, K, (), ()>,

Trait Implementations

impl<T1, T2, T3, T4, Z1, Z2, Z3, Z4, P1, P2, P3, P4, K1, K2, K3, K4, K5, B1, B2, B3> Add<Zpk<T2, Z2, P2, K2>> for Zpk<T1, Z1, P1, K1>

where T1: ComplexFloat, T2: ComplexFloat, T3: ComplexFloat, T4: ComplexFloat<Real = T3::Real>, Z1: MaybeList<T1, MaybeSome: StaticMaybe<Z1::Some, Maybe<Vec<Complex<T1::Real>>>: MaybeList<Complex<T1::Real>, Some = B1>>>, Z2: MaybeList<T2, MaybeSome: StaticMaybe<Z2::Some, Maybe<Vec<Complex<T2::Real>>>: MaybeList<Complex<T2::Real>, Some = B2>>>, Z3: MaybeList<Complex<T3::Real>>, Z4: MaybeList<T4>, P1: MaybeList<T1>, P2: MaybeList<T2>, P3: MaybeList<T3>, P4: MaybeList<T4>, K1: ComplexFloat<Real = T1::Real>, K2: ComplexFloat<Real = T2::Real>, K3: ComplexFloat<Real = T3::Real>, K4: ComplexFloat<Real = T3::Real>, K5: ComplexFloat<Real = T3::Real>, B1: MaybeList<Complex<T1::Real>, MaybeSome: StaticMaybe<B1::Some, Maybe<Vec<Complex<T3::Real>>>: MaybeOr<Vec<Complex<T3::Real>>, <B2::MaybeSome as StaticMaybe<B2::Some>>::Maybe<Vec<Complex<T3::Real>>>, Output = Z3>>>, B2: MaybeList<Complex<T2::Real>>, B3: MaybeList<K3>, Self: SplitNumerDenom, Zpk<T2, Z2, P2, K2>: SplitNumerDenom, <Self as SplitNumerDenom>::OutputNum: ToTf<Complex<K1::Real>, B1, (), (), ()>, <Zpk<T2, Z2, P2, K2> as SplitNumerDenom>::OutputNum: ToTf<Complex<K2::Real>, B2, (), (), ()>, Tf<Complex<K1::Real>, B1, ()>: Add<Tf<Complex<K2::Real>, B2, ()>, Output = Tf<K3, B3, ()>>, Tf<K3, B3, ()>: ToZpk<Complex<T3::Real>, Z3, (), K3, (), ()>, <Self as SplitNumerDenom>::OutputDen: Mul<<Zpk<T2, Z2, P2, K2> as SplitNumerDenom>::OutputDen, Output = Zpk<T3, (), P3, K4>>, Zpk<Complex<T3::Real>, Z3, (), K3>: Mul<Zpk<T3, (), P3, K4>, Output = Zpk<T4, Z4, P4, K5>>,

type Output = Zpk<T4, Z4, P4, K5>

The resulting type after applying the + operator.

fn add(self, rhs: Zpk<T2, Z2, P2, K2>) -> Self::Output

Performs the + operation.

impl<T, const N: usize> BesselAP<()> for Zpk<Complex<T>, (), [Complex<T>; N], T>

where T: Float + FloatConst, Zpk<Complex<T>, (), Vec<Complex<T>>, T>: BesselAP<usize> + System<Domain = T>,

fn besselap((): ()) -> Self

impl<T> BesselAP<usize> for Zpk<Complex<T>, (), Vec<Complex<T>>, T>

where T: Float + FloatConst + AddAssign + MulAssign + Into<Complex<T>> + ComplexFloat<Real = T> + Lapack<Complex = Complex<T>>, Complex<T>: From<T> + AddAssign + SubAssign + MulAssign + DivAssign + DivAssign<T>,

fn besselap(order: usize) -> Self

impl<T, Z, P> BesselF<usize> for Zpk<Complex<T>, Z, P, T>

where T: Float + FloatConst, Z: MaybeList<Complex<T>>, P: MaybeList<Complex<T>>, Zpk<Complex<T>, (), P, T>: BesselAP<usize> + SfTrans<1, Output = Self> + SfTrans<2, Output = Self> + System<Domain = T>, Self: Bilinear<Output = Self> + System<Domain = T>,

fn besself<const F: usize>( order: usize, frequencies: [T; F], filter_type: FilterGenType, plane: FilterGenPlane<T> ) -> Result<Self, FilterGenError>

where [(); { _ }]:,

impl<'a, T, Z, P, K> Bilinear for Zpk<T, Z, P, K>

where T: ComplexFloat + Add<T::Real, Output = T> + Div<T::Real, Output = T> + Mul<T::Real, Output = T> + MulAssign + Product + 'static, K: ComplexFloat<Real = T::Real> + MulAssign<K::Real> + Mul<K::Real, Output = K> + Div<K::Real, Output = K> + 'static, Z: MaybeList<T>, P: MaybeList<T>, T::Real: Into<T>, Self: ToZpk<T, Vec<T>, Vec<T>, K, (), ()> + System<Domain = K>,

type Output = Zpk<T, Vec<T>, Vec<T>, K>

fn bilinear( self, sampling_frequency: K::Real ) -> Result<Self::Output, BilinearError>

impl<T, const N: usize> ButtAP<()> for Zpk<Complex<T>, (), [Complex<T>; N], T>

where T: Float + FloatConst, Zpk<Complex<T>, (), Vec<Complex<T>>, T>: ButtAP<usize> + System<Domain = T>,

fn buttap((): ()) -> Self

impl<T> ButtAP<usize> for Zpk<Complex<T>, (), Vec<Complex<T>>, T>

where T: Float + FloatConst,

fn buttap(order: usize) -> Self

impl<T> Butter<usize> for Zpk<Complex<T>, Vec<Complex<T>>, Vec<Complex<T>>, T>

where T: Float + FloatConst, Complex<T>: ComplexFloat<Real = T>, Zpk<Complex<T>, (), Vec<Complex<T>>, T>: ButtAP<usize> + SfTrans<1, Output = Self> + SfTrans<2, Output = Self> + System<Domain = T>, Self: Bilinear<Output = Self> + System<Domain = T>,

fn butter<const F: usize>( order: usize, frequencies: [T; F], filter_type: FilterGenType, plane: FilterGenPlane<T> ) -> Result<Self, FilterGenError>

where [(); { _ }]:,

impl<T, const N: usize> Cheb1AP<()> for Zpk<Complex<T>, (), [Complex<T>; N], T>

where T: Float + FloatConst, Zpk<Complex<T>, (), Vec<Complex<T>>, T>: Cheb1AP<usize> + System<Domain = T>,

fn cheb1ap((): (), ripple: T) -> Self

impl<T> Cheb1AP<usize> for Zpk<Complex<T>, (), Vec<Complex<T>>, T>

where T: Float + FloatConst + DivAssign,

fn cheb1ap(order: usize, ripple: T) -> Self

impl<T, const N: usize> Cheb2AP<()> for Zpk<Complex<T>, (), [Complex<T>; N], T>

where T: Float + FloatConst, Zpk<Complex<T>, (), Vec<Complex<T>>, T>: Cheb2AP<usize> + System<Domain = T>,

fn cheb2ap((): (), ripple: T) -> Self

impl<T> Cheb2AP<usize> for Zpk<Complex<T>, Vec<Complex<T>>, Vec<Complex<T>>, T>

where T: Float + FloatConst + DivAssign,

fn cheb2ap(order: usize, ripple: T) -> Self

impl<T> Cheby1<usize> for Zpk<Complex<T>, Vec<Complex<T>>, Vec<Complex<T>>, T>

where T: Float + FloatConst, Complex<T>: ComplexFloat<Real = T>, Zpk<Complex<T>, (), Vec<Complex<T>>, T>: Cheb1AP<usize> + SfTrans<1, Output = Self> + SfTrans<2, Output = Self> + System<Domain = T>, Self: Bilinear<Output = Self> + System<Domain = T>,

fn cheby1<const F: usize>( order: usize, ripple: T, frequencies: [T; F], filter_type: FilterGenType, plane: FilterGenPlane<T> ) -> Result<Self, FilterGenError>

where [(); { _ }]:,

impl<T> Cheby2<usize> for Zpk<Complex<T>, Vec<Complex<T>>, Vec<Complex<T>>, T>

where T: Float + FloatConst, Complex<T>: ComplexFloat<Real = T>, Zpk<Complex<T>, Vec<Complex<T>>, Vec<Complex<T>>, T>: Cheb2AP<usize> + SfTrans<1, Output = Self> + SfTrans<2, Output = Self> + System<Domain = T>, Self: Bilinear<Output = Self> + System<Domain = T>,

fn cheby2<const F: usize>( order: usize, ripple: T, frequencies: [T; F], filter_type: FilterGenType, plane: FilterGenPlane<T> ) -> Result<Self, FilterGenError>

where [(); { _ }]:,

impl<T: Clone + ComplexFloat, Z: Clone + MaybeList<T>, P: Clone + MaybeList<T>, K: Clone + ComplexFloat<Real = T::Real>> Clone for Zpk<T, Z, P, K>

fn clone(&self) -> Zpk<T, Z, P, K>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug + ComplexFloat, Z: Debug + MaybeList<T>, P: Debug + MaybeList<T>, K: Debug + ComplexFloat<Real = T::Real>> Debug for Zpk<T, Z, P, K>

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

Formats the value using the given formatter.

impl<T, Z, P, K> Default for Zpk<T, Z, P, K>

where T: ComplexFloat, Z: MaybeList<T>, P: MaybeList<T>, K: ComplexFloat<Real = T::Real>, ProductSequence<T, Z>: Default, ProductSequence<T, P>: Default,

fn default() -> Self

Returns the “default value” for a type.

impl<'a, 'b, T1, T2, Z1, Z2, P1, P2, K1, K2, O> Div<&'b Zpk<T2, Z2, P2, K2>> for &'a Zpk<T1, Z1, P1, K1>

where T1: ComplexFloat, T2: ComplexFloat, Z1: MaybeList<T1>, Z2: MaybeList<T2>, P1: MaybeList<T1>, P2: MaybeList<T2>, K1: ComplexFloat<Real = T1::Real>, K2: ComplexFloat<Real = T2::Real>, Z1::View<'a>: MaybeList<T1>, P1::View<'a>: MaybeList<T1>, Z2::View<'b>: MaybeList<T2>, P2::View<'b>: MaybeList<T2>, Zpk<T1, Z1::View<'a>, P1::View<'a>, K1>: Div<Zpk<T2, Z2::View<'b>, P2::View<'b>, K2>, Output = O>,

type Output = O

The resulting type after applying the / operator.

fn div(self, rhs: &'b Zpk<T2, Z2, P2, K2>) -> Self::Output

Performs the / operation.

impl<'b, T1, T2, Z1, Z2, P1, P2, K1, K2, O> Div<&'b Zpk<T2, Z2, P2, K2>> for Zpk<T1, Z1, P1, K1>

where T1: ComplexFloat, T2: ComplexFloat, Z1: MaybeList<T1>, Z2: MaybeList<T2>, P1: MaybeList<T1>, P2: MaybeList<T2>, K1: ComplexFloat<Real = T1::Real>, K2: ComplexFloat<Real = T2::Real>, Z2::View<'b>: MaybeList<T2>, P2::View<'b>: MaybeList<T2>, Zpk<T1, Z1, P1, K1>: Div<Zpk<T2, Z2::View<'b>, P2::View<'b>, K2>, Output = O>,

type Output = O

The resulting type after applying the / operator.

fn div(self, rhs: &'b Zpk<T2, Z2, P2, K2>) -> Self::Output

Performs the / operation.

impl<'b, T, Z, P, K, O> Div<K> for &'b Zpk<T, Z, P, K>

where T: ComplexFloat, Z: MaybeList<T>, P: MaybeList<T>, K: ComplexFloat<Real = T::Real>, Self: Div<Zpk<T, (), (), K>, Output = O>,

type Output = O

The resulting type after applying the / operator.

fn div(self, rhs: K) -> Self::Output

Performs the / operation.

impl<T, Z, P, K, O> Div<K> for Zpk<T, Z, P, K>

where T: ComplexFloat, Z: MaybeList<T>, P: MaybeList<T>, K: ComplexFloat<Real = T::Real>, Self: Div<Zpk<T, (), (), K>, Output = O>,

type Output = O

The resulting type after applying the / operator.

fn div(self, rhs: K) -> Self::Output

Performs the / operation.

impl<'a, T1, T2, Z1, Z2, P1, P2, K1, K2, O> Div<Zpk<T2, Z2, P2, K2>> for &'a Zpk<T1, Z1, P1, K1>

where T1: ComplexFloat, T2: ComplexFloat, Z1: MaybeList<T1>, Z2: MaybeList<T2>, P1: MaybeList<T1>, P2: MaybeList<T2>, K1: ComplexFloat<Real = T1::Real>, K2: ComplexFloat<Real = T2::Real>, Z1::View<'a>: MaybeList<T1>, P1::View<'a>: MaybeList<T1>, Zpk<T1, Z1::View<'a>, P1::View<'a>, K1>: Div<Zpk<T2, Z2, P2, K2>, Output = O>,

type Output = O

The resulting type after applying the / operator.

fn div(self, rhs: Zpk<T2, Z2, P2, K2>) -> Self::Output

Performs the / operation.

impl<T1, T2, T3, Z1, Z2, Z3, P1, P2, P3, K1, K2, K3> Div<Zpk<T2, Z2, P2, K2>> for Zpk<T1, Z1, P1, K1>

where T1: ComplexFloat + ComplexOp<T2, Output = T3>, T2: ComplexFloat + Into<T3>, T3: ComplexFloat, K1: ComplexFloat<Real = T1::Real> + ComplexOp<K2, Output = K3>, K2: ComplexFloat<Real = T2::Real> + Into<K3>, K3: ComplexFloat<Real = T3::Real> + Div<Output = K3>, Z1: MaybeList<T1>, Z2: MaybeList<T2>, Z3: MaybeList<T3>, P1: MaybeList<T1>, P2: MaybeList<T2>, P3: MaybeList<T3>, Z1::MaybeMapped<T3>: MaybeList<T3>, Z2::MaybeMapped<T3>: MaybeList<T3>, P1::MaybeMapped<T3>: MaybeList<T3>, P2::MaybeMapped<T3>: MaybeList<T3>, ProductSequence<T3, Z1::MaybeMapped<T3>>: Mul<ProductSequence<T3, P2::MaybeMapped<T3>>, Output = ProductSequence<T3, Z3>>, ProductSequence<T3, P1::MaybeMapped<T3>>: Mul<ProductSequence<T3, Z2::MaybeMapped<T3>>, Output = ProductSequence<T3, P3>>, Zpk<T3, Z3, P3, K3>: Normalize,

type Output = <Zpk<T3, Z3, P3, K3> as Normalize>::Output

The resulting type after applying the / operator.

fn div(self, rhs: Zpk<T2, Z2, P2, K2>) -> Self::Output

Performs the / operation.

impl<T> Ellip<usize> for Zpk<Complex<T>, Vec<Complex<T>>, Vec<Complex<T>>, T>

where T: Float + FloatConst, Complex<T>: ComplexFloat<Real = T>, Zpk<Complex<T>, Vec<Complex<T>>, Vec<Complex<T>>, T>: EllipAP<usize> + SfTrans<1, Output = Self> + SfTrans<2, Output = Self> + System<Domain = T>, Self: Bilinear<Output = Self> + System<Domain = T>,

fn ellip<const F: usize>( order: usize, passband_ripple: T, stopband_ripple: T, frequencies: [T; F], filter_type: FilterGenType, plane: FilterGenPlane<T> ) -> Result<Self, FilterGenError>

where [(); { _ }]:,

impl<T, const N: usize> EllipAP<()> for Zpk<Complex<T>, Vec<Complex<T>>, [Complex<T>; N], T>

where T: Float + FloatConst, Zpk<Complex<T>, Vec<Complex<T>>, Vec<Complex<T>>, T>: EllipAP<usize> + System<Domain = T>,

fn ellipap((): (), passband_ripple: T, stopband_ripple: T) -> Self

impl<T> EllipAP<usize> for Zpk<Complex<T>, Vec<Complex<T>>, Vec<Complex<T>>, T>

where T: Float + FloatConst + DivAssign + Sum + SubAssign + MulAssign + AddAssign, Complex<T>: MulAssign<T>,

fn ellipap(order: usize, passband_ripple: T, stopband_ripple: T) -> Self

impl<T, Z, P, K> FiltOrd for Zpk<T, Z, P, K>

where T: ComplexFloat, Z: MaybeList<T>, P: MaybeList<T>, K: ComplexFloat<Real = T::Real>,

type Output = usize

fn filtord(&self) -> Self::Output

impl<T> FirGr<usize> for Zpk<Complex<T>, Vec<Complex<T>>, Vec<Complex<T>>, T>

where T: Float + FloatConst, Complex<T>: ComplexFloat<Real = T>, Tf<T, Vec<T>, ()>: FirGr<usize> + ToZpk<Complex<T>, Vec<Complex<T>>, Vec<Complex<T>>, T, (), ()> + System<Domain = T>,

fn firgr<FS, MI, GD, const B: usize>( order: usize, bands: [T; { _ }], response: [T; B], weight: [T; B], filter_type: FilterClassType, sampling_frequency: FS, max_iter: MI, grid_density: GD ) -> Result<Self, FirGrError>

where FS: Maybe<T>, MI: Maybe<usize>, GD: Maybe<usize>,

impl<T> FirPm for Zpk<Complex<T>, Vec<Complex<T>>, Vec<Complex<T>>, T>

where T: Float + FloatConst, Complex<T>: ComplexFloat<Real = T>, Tf<T, Vec<T>, ()>: FirPm + ToZpk<Complex<T>, Vec<Complex<T>>, Vec<Complex<T>>, T, (), ()> + System<Domain = T>,

fn firpm<FS, RES, const B2: usize, const R: usize, const W: usize>( order: usize, bands: [Self::Domain; B2], response: [Self::Domain; R], weight: [Self::Domain; W], filter_type: FirPmType, sampling_frequency: FS, accuracy: Self::Domain, persistence: Self::Domain, robustness: Self::Domain, target: Self::Domain ) -> Result<(Self, Self::Domain, RES), FirPmError>

where FS: Maybe<Self::Domain>, RES: StaticMaybe<FirPmReport<Self::Domain>>, [(); { _ }]:,

impl<'a, T, Z, P, K, S, SS> FreqS<'a, S, SS> for Zpk<T, Z, P, K>

where T: ComplexFloat, Z: MaybeList<T> + 'a, P: MaybeList<T> + 'a, K: ComplexFloat<Real = T::Real>, S: ComplexFloat<Real = T::Real>, SS: Lists<S> + 'a, Z::View<'a>: MaybeList<T>, P::View<'a>: MaybeList<T>, Zpk<T, Z::View<'a>, P::View<'a>, K>: ToSos<K, [K; 3], [K; 3], Vec<Tf<K, [K; 3], [K; 3]>>, (), ()> + 'a + System<Domain = K>, Sos<K, [K; 3], [K; 3], Vec<Tf<K, [K; 3], [K; 3]>>>: for<'b> FreqS<'b, S, SS> + System<Domain = K>,

fn freqs( &'a self, s: SS ) -> SS::Mapped<Complex<<Self::Domain as ComplexFloat>::Real>>

impl<'a, T, Z, P, K, H, W, N> FreqZ<'a, H, W, N> for Zpk<T, Z, P, K>

where T: ComplexFloat, Z: MaybeList<T> + 'a, P: MaybeList<T> + 'a, K: ComplexFloat<Real = T::Real>, H: Lists<Complex<K::Real>>, W: List<K::Real>, N: Maybe<usize>, Z::View<'a>: MaybeList<T>, P::View<'a>: MaybeList<T>, Zpk<T, Z::View<'a>, P::View<'a>, K>: ToSos<K, [K; 3], [K; 3], Vec<Tf<K, [K; 3], [K; 3]>>, (), ()> + System<Domain = K>, Sos<K, [K; 3], [K; 3], Vec<Tf<K, [K; 3], [K; 3]>>>: for<'b> FreqZ<'b, H, W, N> + System<Domain = K>,

fn freqz(&'a self, n: N, shift: bool) -> (H, W)

impl<'a, T1, T2, K1, K2, Z1, Z2, P1, P2> From<&'a Zpk<T1, Z1, P1, K1>> for Zpk<T2, Z2, P2, K2>

where T1: ComplexFloat, T2: ComplexFloat, K1: ComplexFloat<Real = T1::Real> + Into<K2>, K2: ComplexFloat<Real = T2::Real>, Z1: MaybeList<T1>, P1: MaybeList<T1>, Z2: MaybeList<T2>, P2: MaybeList<T2>, Z1::View<'a>: MaybeList<T1>, P1::View<'a>: MaybeList<T1>, ProductSequence<T1, Z1::View<'a>>: Into<ProductSequence<T2, Z2>>, ProductSequence<T1, P1::View<'a>>: Into<ProductSequence<T2, P2>>,

fn from(zpk: &'a Zpk<T1, Z1, P1, K1>) -> Self

Converts to this type from the input type.

impl<'a, T, Z, P, K, O> Inv for &'a Zpk<T, Z, P, K>

where T: ComplexFloat, Z: MaybeList<T>, P: MaybeList<T>, K: ComplexFloat<Real = T::Real>, Z::View<'a>: MaybeList<T>, P::View<'a>: MaybeList<T>, Zpk<T, Z::View<'a>, P::View<'a>, K>: Inv<Output = O>,

type Output = O

The result after applying the operator.

fn inv(self) -> Self::Output

Returns the multiplicative inverse of self.

impl<T, Z, P, K> Inv for Zpk<T, Z, P, K>

where T: ComplexFloat, K: ComplexFloat<Real = T::Real> + Inv<Output: ComplexFloat<Real = T::Real>>, Z: MaybeList<T>, P: MaybeList<T>,

type Output = Zpk<T, P, Z, <K as Inv>::Output>

The result after applying the operator.

fn inv(self) -> Self::Output

Returns the multiplicative inverse of self.

impl<'a, T, Z, P, K> IsAllPass<'a> for Zpk<T, Z, P, K>

where T: ComplexFloat, Z: MaybeList<T>, P: MaybeList<T>, K: ComplexFloat<Real = T::Real>,

type Output = bool

fn is_allpass<TOL>(&'a self, tol: TOL) -> Self::Output

where TOL: Maybe<T::Real>,

impl<'a, T, Z, P, K> IsLinPhase<'a> for Zpk<T, Z, P, K>

where T: ComplexFloat, Z: MaybeList<T>, P: MaybeList<T>, K: ComplexFloat<Real = T::Real>,

type Output = bool

fn is_linphase<TOL>(&'a self, tol: TOL, generalized: bool) -> Self::Output

where TOL: Maybe<T::Real>,

impl<'a, T, Z, P, K> IsMaxPhase<'a> for Zpk<T, Z, P, K>

where T: ComplexFloat, Z: MaybeList<T>, P: MaybeList<T>, K: ComplexFloat<Real = T::Real>,

type Output = bool

fn is_maxphase<TOL>(&'a self, tol: TOL) -> Self::Output

where TOL: Maybe<T::Real>,

impl<'a, T, Z, P, K> IsStable<'a> for Zpk<T, Z, P, K>

where T: ComplexFloat, Z: MaybeList<T>, P: MaybeList<T>, K: ComplexFloat<Real = T::Real>,

type Output = bool

fn is_stable<TOL>(&'a self, tol: TOL, plane: Plane) -> Self::Output

where TOL: Maybe<T::Real>,

impl<T, Z, P, K> MaxPhase for Zpk<T, Z, P, K>

where T: ComplexFloat, Z: MaybeList<T, Owned: MaybeOwnedList<T>>, P: MaybeList<T, Owned: MaybeOwnedList<T>>, K: ComplexFloat<Real = T::Real> + MulAssign<T::Real>,

type OutputMax = Zpk<T, <Z as MaybeContainer<T>>::Owned, <P as MaybeContainer<T>>::Owned, K>

type OutputAp = Zpk<T, Vec<T>, Vec<T>, <K as ComplexFloat>::Real>

fn maxphase(self) -> (Self::OutputMax, Self::OutputAp)

impl<T, Z, P, K> MinPhase for Zpk<T, Z, P, K>

where T: ComplexFloat, Z: MaybeList<T, Owned: MaybeOwnedList<T>>, P: MaybeList<T, Owned: MaybeOwnedList<T>>, K: ComplexFloat<Real = T::Real> + MulAssign<T::Real>,

type OutputMin = Zpk<T, <Z as MaybeContainer<T>>::Owned, <P as MaybeContainer<T>>::Owned, K>

type OutputAp = Zpk<T, Vec<T>, Vec<T>, <K as ComplexFloat>::Real>

fn minphase(self) -> (Self::OutputMin, Self::OutputAp)

impl<'a, 'b, T1, T2, Z1, Z2, P1, P2, K1, K2, O> Mul<&'b Zpk<T2, Z2, P2, K2>> for &'a Zpk<T1, Z1, P1, K1>

where T1: ComplexFloat, T2: ComplexFloat, Z1: MaybeList<T1>, Z2: MaybeList<T2>, P1: MaybeList<T1>, P2: MaybeList<T2>, K1: ComplexFloat<Real = T1::Real>, K2: ComplexFloat<Real = T2::Real>, Z1::View<'a>: MaybeList<T1>, P1::View<'a>: MaybeList<T1>, Z2::View<'b>: MaybeList<T2>, P2::View<'b>: MaybeList<T2>, Zpk<T1, Z1::View<'a>, P1::View<'a>, K1>: Mul<Zpk<T2, Z2::View<'b>, P2::View<'b>, K2>, Output = O>,

type Output = O

The resulting type after applying the * operator.

fn mul(self, rhs: &'b Zpk<T2, Z2, P2, K2>) -> Self::Output

Performs the * operation.

impl<'b, T1, T2, Z1, Z2, P1, P2, K1, K2, O> Mul<&'b Zpk<T2, Z2, P2, K2>> for Zpk<T1, Z1, P1, K1>

where T1: ComplexFloat, T2: ComplexFloat, Z1: MaybeList<T1>, Z2: MaybeList<T2>, P1: MaybeList<T1>, P2: MaybeList<T2>, K1: ComplexFloat<Real = T1::Real>, K2: ComplexFloat<Real = T2::Real>, Z2::View<'b>: MaybeList<T2>, P2::View<'b>: MaybeList<T2>, Zpk<T1, Z1, P1, K1>: Mul<Zpk<T2, Z2::View<'b>, P2::View<'b>, K2>, Output = O>,

type Output = O

The resulting type after applying the * operator.

fn mul(self, rhs: &'b Zpk<T2, Z2, P2, K2>) -> Self::Output

Performs the * operation.

impl<'b, T, Z, P, K, O> Mul<K> for &'b Zpk<T, Z, P, K>

where T: ComplexFloat, Z: MaybeList<T>, P: MaybeList<T>, K: ComplexFloat<Real = T::Real>, Self: Mul<Zpk<T, (), (), K>, Output = O>,

type Output = O

The resulting type after applying the * operator.

fn mul(self, rhs: K) -> Self::Output

Performs the * operation.

impl<T, Z, P, K, O> Mul<K> for Zpk<T, Z, P, K>

where T: ComplexFloat, Z: MaybeList<T>, P: MaybeList<T>, K: ComplexFloat<Real = T::Real>, Self: Mul<Zpk<T, (), (), K>, Output = O>,

type Output = O

The resulting type after applying the * operator.

fn mul(self, rhs: K) -> Self::Output

Performs the * operation.

impl<'a, T1, T2, Z1, Z2, P1, P2, K1, K2, O> Mul<Zpk<T2, Z2, P2, K2>> for &'a Zpk<T1, Z1, P1, K1>

where T1: ComplexFloat, T2: ComplexFloat, Z1: MaybeList<T1>, Z2: MaybeList<T2>, P1: MaybeList<T1>, P2: MaybeList<T2>, K1: ComplexFloat<Real = T1::Real>, K2: ComplexFloat<Real = T2::Real>, Z1::View<'a>: MaybeList<T1>, P1::View<'a>: MaybeList<T1>, Zpk<T1, Z1::View<'a>, P1::View<'a>, K1>: Mul<Zpk<T2, Z2, P2, K2>, Output = O>,

type Output = O

The resulting type after applying the * operator.

fn mul(self, rhs: Zpk<T2, Z2, P2, K2>) -> Self::Output

Performs the * operation.

impl<T1, T2, T3, T4, Z1, Z2, Z3, P1, P2, P3, K1, K2, K3> Mul<Zpk<T2, Z2, P2, K2>> for Zpk<T1, Z1, P1, K1>

where T1: ComplexFloat + ComplexOp<T2, Output = T3>, T2: ComplexFloat + Into<T3>, T3: ComplexFloat, T4: ComplexFloat<Real = T3::Real>, K1: ComplexFloat<Real = T1::Real> + ComplexOp<K2, Output = K3>, K2: ComplexFloat<Real = T2::Real> + Into<K3>, K3: ComplexFloat<Real = T3::Real> + Mul<Output = K3>, Z1: MaybeList<T1>, Z2: MaybeList<T2>, Z3: MaybeList<T4>, P1: MaybeList<T1>, P2: MaybeList<T2>, P3: MaybeList<T4>, Z1::MaybeMapped<T3>: MaybeList<T3>, Z2::MaybeMapped<T3>: MaybeList<T3>, P1::MaybeMapped<T3>: MaybeList<T3>, P2::MaybeMapped<T3>: MaybeList<T3>, ProductSequence<T3, Z1::MaybeMapped<T3>>: Mul<ProductSequence<T3, Z2::MaybeMapped<T3>>, Output = ProductSequence<T4, Z3>>, ProductSequence<T3, P1::MaybeMapped<T3>>: Mul<ProductSequence<T3, P2::MaybeMapped<T3>>, Output = ProductSequence<T4, P3>>, Zpk<T4, Z3, P3, K3>: Normalize,

type Output = <Zpk<T4, Z3, P3, K3> as Normalize>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: Zpk<T2, Z2, P2, K2>) -> Self::Output

Performs the * operation.

impl<'a, T, Z, P, K, O> Neg for &'a Zpk<T, Z, P, K>

where T: ComplexFloat, Z: MaybeList<T>, P: MaybeList<T>, K: ComplexFloat<Real = T::Real>, Z::View<'a>: MaybeList<T>, P::View<'a>: MaybeList<T>, Zpk<T, Z::View<'a>, P::View<'a>, K>: Neg<Output = O>,

type Output = O

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<T, Z, P, K> Neg for Zpk<T, Z, P, K>

where T: ComplexFloat, K: ComplexFloat<Real = T::Real>, Z: MaybeList<T>, P: MaybeList<T>,

type Output = Zpk<T, Z, P, K>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<T, Z, P, Z2, P2, K> Normalize for Zpk<T, Z, P, K>

where T: ComplexFloat, Z: MaybeList<T, MaybeSome: StaticMaybe<Z::Some, Maybe<Vec<T>> = Z2>>, P: MaybeList<T, MaybeSome: StaticMaybe<Z::Some, Maybe<Vec<T>> = P2>>, K: ComplexFloat<Real = T::Real>, ProductSequence<T, Z>: Into<ProductSequence<T, Z2>>, ProductSequence<T, P>: Into<ProductSequence<T, P2>>, Z2: MaybeList<T> + Maybe<Vec<T>>, P2: MaybeList<T> + Maybe<Vec<T>>,

type Output = Zpk<T, Z2, P2, K>

fn normalize(self) -> Self::Output

impl<T, Z, P, K> One for Zpk<T, Z, P, K>

where T: ComplexFloat, K: ComplexFloat<Real = T::Real>, Z: List<T>, P: List<T>, Self: Default + Mul<Output = Self>,

fn one() -> Self

Returns the multiplicative identity element of Self, 1.

fn is_one(&self) -> bool

Returns true if self is equal to the multiplicative identity.

fn set_one(&mut self)

Sets self to the multiplicative identity element of Self, 1.

impl<T, Z, P, K, I> Pow<I> for Zpk<T, Z, P, K>

where T: ComplexFloat + ComplexOp<T, Output = T>, Z: MaybeList<T>, P: MaybeList<T>, K: ComplexFloat<Real = T::Real> + ComplexOp<K, Output = K>, I: Integer + BitAnd<I, Output = I> + Shr<usize, Output = I> + Copy, Self: ToZpk<T, Vec<T>, Vec<T>, K, (), ()> + Inv<Output: ToZpk<T, Vec<T>, Vec<T>, K, (), ()>>,

type Output = Zpk<T, Vec<T>, Vec<T>, K>

The result after applying the operator.

fn pow(self, n: I) -> Self::Output

Returns self to the power rhs.

impl<'a, T1, T2, Z1, Z2, P1, P2, K1, K2> Product<&'a Zpk<T1, Z1, P1, K1>> for Zpk<T2, Z2, P2, K2>

where T1: ComplexFloat, T2: ComplexFloat, K1: ComplexFloat<Real = T1::Real>, K2: ComplexFloat<Real = T2::Real>, Z1: List<T1>, P1: List<T1>, Z2: List<T2>, P2: List<T2>, &'a Zpk<T1, Z1, P1, K1>: Into<Self>, Self: One + 'a,

fn product<I: Iterator<Item = &'a Zpk<T1, Z1, P1, K1>>>(iter: I) -> Self

Method which takes an iterator and generates Self from the elements by multiplying the items.

impl<'a, T, Z, P, K, H, W, N> RealFreqZ<'a, H, W, N> for Zpk<T, Z, P, K>

where T: ComplexFloat<Real = K>, Z: MaybeList<T> + 'a, P: MaybeList<T> + 'a, K: Float + FloatConst, H: Lists<Complex<K>>, W: List<K>, N: Maybe<usize>, Z::View<'a>: MaybeList<T>, P::View<'a>: MaybeList<T>, Zpk<T, Z::View<'a>, P::View<'a>, K>: ToSos<K, [K; 3], [K; 3], Vec<Tf<K, [K; 3], [K; 3]>>, (), ()> + System<Domain = K>, Sos<K, [K; 3], [K; 3], Vec<Tf<K, [K; 3], [K; 3]>>>: for<'b> RealFreqZ<'b, H, W, N> + System<Domain = K>,

fn real_freqz(&'a self, n: N) -> (H, W)

impl<T, Z, P, K, R> RtfOrSystem for Zpk<T, Z, P, K>

where T: ComplexFloat<Real = R>, K: ComplexFloat<Real = R>, Z: MaybeList<T>, P: MaybeList<T>,

type Domain = K

impl<T, Z, P, K, const W: usize> SfTrans<W> for Zpk<T, Z, P, K>

where T: ComplexFloat + Mul<T::Real, Output = T> + Div<T::Real, Output = T> + Sub<T::Real, Output = T> + Into<Complex<T::Real>>, K: ComplexFloat<Real = T::Real> + DivAssign<T::Real> + MulAssign<T::Real>, T::Real: Into<T>, Complex<T::Real>: Add<T, Output = Complex<T::Real>>, Z: MaybeList<T>, P: MaybeList<T>, Self: ToZpk<T, Vec<T>, Vec<T>, K, (), ()> + System<Domain = K>, [(); { _ }]:,

type Output = Zpk<Complex<<T as ComplexFloat>::Real>, Vec<Complex<<T as ComplexFloat>::Real>>, Vec<Complex<<T as ComplexFloat>::Real>>, K>

fn sftrans( self, wo: <Self::Domain as ComplexFloat>::Real, w: [T::Real; W], stop: bool ) -> Result<Self::Output, SfTransError>

impl<T, Z, P, K> SplitNumerDenom for Zpk<T, Z, P, K>

where T: ComplexFloat, Z: MaybeList<T>, P: MaybeList<T>, K: ComplexFloat<Real = T::Real>,

type OutputNum = Zpk<T, Z, (), K>

type OutputDen = Zpk<T, (), P, <K as ComplexFloat>::Real>

fn split_numer_denom(self) -> (Self::OutputNum, Self::OutputDen)

impl<T, Z, P, K> Stabilize for Zpk<T, Z, P, K>

where T: ComplexFloat, Z: MaybeList<T, Owned: MaybeOwnedList<T>>, P: MaybeList<T, Owned: MaybeOwnedList<T>>, K: ComplexFloat<Real = T::Real>,

type Output = Zpk<T, <Z as MaybeContainer<T>>::Owned, <P as MaybeContainer<T>>::Owned, K>

fn stabilize(self, plane: Plane) -> Self::Output

impl<T1, T2, T3, T4, Z1, Z2, Z3, Z4, P1, P2, P3, P4, K1, K2, K3, K4, K5, B1, B2, B3> Sub<Zpk<T2, Z2, P2, K2>> for Zpk<T1, Z1, P1, K1>

where T1: ComplexFloat, T2: ComplexFloat, T3: ComplexFloat, T4: ComplexFloat<Real = T3::Real>, Z1: MaybeList<T1, MaybeSome: StaticMaybe<Z1::Some, Maybe<Vec<Complex<T1::Real>>>: MaybeList<Complex<T1::Real>, Some = B1>>>, Z2: MaybeList<T2, MaybeSome: StaticMaybe<Z2::Some, Maybe<Vec<Complex<T2::Real>>>: MaybeList<Complex<T2::Real>, Some = B2>>>, Z3: MaybeList<Complex<T3::Real>>, Z4: MaybeList<T4>, P1: MaybeList<T1>, P2: MaybeList<T2>, P3: MaybeList<T3>, P4: MaybeList<T4>, K1: ComplexFloat<Real = T1::Real>, K2: ComplexFloat<Real = T2::Real>, K3: ComplexFloat<Real = T3::Real>, K4: ComplexFloat<Real = T3::Real>, K5: ComplexFloat<Real = T3::Real>, B1: MaybeList<Complex<T1::Real>, MaybeSome: StaticMaybe<B1::Some, Maybe<Vec<Complex<T3::Real>>>: MaybeOr<Vec<Complex<T3::Real>>, <B2::MaybeSome as StaticMaybe<B2::Some>>::Maybe<Vec<Complex<T3::Real>>>, Output = Z3>>>, B2: MaybeList<Complex<T2::Real>>, B3: MaybeList<K3>, Self: SplitNumerDenom, Zpk<T2, Z2, P2, K2>: SplitNumerDenom, <Self as SplitNumerDenom>::OutputNum: ToTf<Complex<K1::Real>, B1, (), (), ()>, <Zpk<T2, Z2, P2, K2> as SplitNumerDenom>::OutputNum: ToTf<Complex<K2::Real>, B2, (), (), ()>, Tf<Complex<K1::Real>, B1, ()>: Sub<Tf<Complex<K2::Real>, B2, ()>, Output = Tf<K3, B3, ()>>, Tf<K3, B3, ()>: ToZpk<Complex<T3::Real>, Z3, (), K3, (), ()>, <Self as SplitNumerDenom>::OutputDen: Mul<<Zpk<T2, Z2, P2, K2> as SplitNumerDenom>::OutputDen, Output = Zpk<T3, (), P3, K4>>, Zpk<Complex<T3::Real>, Z3, (), K3>: Mul<Zpk<T3, (), P3, K4>, Output = Zpk<T4, Z4, P4, K5>>,

type Output = Zpk<T4, Z4, P4, K5>

The resulting type after applying the - operator.

fn sub(self, rhs: Zpk<T2, Z2, P2, K2>) -> Self::Output

Performs the - operation.

impl<T1, T2, Z, P, K, B, A, S> ToSos<T2, B, A, S, (), ()> for Zpk<T1, Z, P, K>

where T1: ComplexFloat + Into<Complex<T1::Real>>, T2: ComplexFloat + Into<Complex<T2::Real>> + AddAssign + MulAssign + 'static, K: ComplexFloat<Real = T1::Real> + Into<T2>, Z: MaybeList<T1, MaybeSome: StaticMaybe<Z::Some, Maybe<[T2; 3]>: MaybeOr<[T2; 3], B, Output = B>>>, P: MaybeList<T1, MaybeSome: StaticMaybe<P::Some, Maybe<[T2; 3]>: MaybeOr<[T2; 3], A, Output = A>>>, B: StaticMaybe<[T2; 3]> + MaybeOwnedList<T2> + MaybeOr<[T2; 3], A, Output: StaticMaybe<[T2; 3], Maybe<Vec<Tf<T2, B, A>>>: MaybeOr<Vec<Tf<T2, B, A>>, S, Output = S>>>, A: StaticMaybe<[T2; 3]> + MaybeOwnedList<T2>, S: StaticMaybe<Vec<Tf<T2, B, A>>> + MaybeList<Tf<T2, B, A>>, Complex<T1::Real>: Into<Complex<T2::Real>>, Complex<T2::Real>: AddAssign, T1::Real: Into<T2> + NotVoid, T2::Real: Into<T2>, Self: ToZpk<T1, Vec<T1>, Vec<T1>, K, (), ()>,

fn to_sos(self, (): (), (): ()) -> Sos<T2, B, A, S>

impl<T1, T2, Z, P, K> ToSs<T2, ArrayBase<OwnedRepr<T2>, Dim<[usize; 2]>>, ArrayBase<OwnedRepr<T2>, Dim<[usize; 2]>>, ArrayBase<OwnedRepr<T2>, Dim<[usize; 2]>>, ArrayBase<OwnedRepr<T2>, Dim<[usize; 2]>>> for Zpk<T1, Z, P, K>

where T1: ComplexFloat, T2: ComplexFloat, K: ComplexFloat<Real = T1::Real>, Z: MaybeList<T1>, P: MaybeList<T1>, Self: ToTf<T2, Vec<T2>, Vec<T2>, (), ()>, Tf<T2, Vec<T2>, Vec<T2>>: ToSs<T2, Array2<T2>, Array2<T2>, Array2<T2>, Array2<T2>>, Array2<T2>: SsAMatrix<T2, Array2<T2>, Array2<T2>, Array2<T2>> + SsBMatrix<T2, Array2<T2>, Array2<T2>, Array2<T2>> + SsCMatrix<T2, Array2<T2>, Array2<T2>, Array2<T2>> + SsDMatrix<T2, Array2<T2>, Array2<T2>, Array2<T2>>,

fn to_ss( self ) -> Result<Ss<T2, Array2<T2>, Array2<T2>, Array2<T2>, Array2<T2>>, ToSsError>

impl<'a, T1, T2, Z, Z2, P, P2, K, BB, B, A> ToTf<T2, B, A, (), ()> for Zpk<T1, Z, P, K>

where T1: ComplexFloat, T2: ComplexFloat<Real = T1::Real> + 'static, Polynomial<Complex<T2::Real>, Vec<Complex<T2::Real>>>: One, Polynomial<T2, Vec<T2>>: Mul<Polynomial<T2, [T2; 1]>, Output = Polynomial<T2, Vec<T2>>>, T1::Real: Into<T2> + 'static, K: ComplexFloat<Real = T1::Real>, Z: MaybeList<T1, MaybeSome: StaticMaybe<Z::Some, Maybe<Vec<Complex<T1::Real>>> = Z2>>, P: MaybeList<T1, MaybeSome: StaticMaybe<P::Some, Maybe<Vec<Complex<T1::Real>>> = P2>>, B: MaybeList<T2>, A: MaybeList<T2> + StaticMaybe<Vec<T2>>, Z2: MaybeList<Complex<T1::Real>, MaybeSome: StaticMaybe<Z2::Some, Maybe<Vec<T2>> = BB>> + Maybe<Vec<Complex<T2::Real>>>, P2: MaybeList<Complex<T1::Real>, MaybeSome: StaticMaybe<P2::Some, Maybe<Vec<T2>>: MaybeOr<Vec<T2>, A, Output = A>>> + Maybe<Vec<Complex<T2::Real>>>, BB: MaybeList<T2, Some: List<T2> + Sized, MaybeSome: Sized> + StaticMaybe<Vec<T2>>, Polynomial<T2, <BB as MaybeContainer<T2>>::Some>: Into<Polynomial<T2, B>>, Polynomial<T2, [T2; 1]>: Into<Polynomial<T2, B>>, Self: ToZpk<Complex<T2::Real>, Z2, P2, T2, (), ()>,

fn to_tf(self, (): (), (): ()) -> Tf<T2, B, A>

impl<T1, Z1, P1, K1, T2, Z2, P2, K2> ToZpk<T2, Z2, P2, K2, (), ()> for Zpk<T1, Z1, P1, K1>

where T1: ComplexFloat + Into<T2>, T2: ComplexFloat, K1: ComplexFloat<Real = T1::Real> + Into<K2>, K2: ComplexFloat<Real = T2::Real>, Z1: MaybeList<T1>, P1: MaybeList<T1>, Z2: MaybeList<T2>, P2: MaybeList<T2>, Z1::MaybeMapped<T2>: MaybeList<T2>, P1::MaybeMapped<T2>: MaybeList<T2>, ProductSequence<T2, Z1::MaybeMapped<T2>>: Into<ProductSequence<T2, Z2>>, ProductSequence<T2, P1::MaybeMapped<T2>>: Into<ProductSequence<T2, P2>>,

fn to_zpk(self, (): (), (): ()) -> Zpk<T2, Z2, P2, K2>

impl<T: Copy + ComplexFloat, Z: Copy + MaybeList<T>, P: Copy + MaybeList<T>, K: Copy + ComplexFloat<Real = T::Real>> Copy for Zpk<T, Z, P, K>

impl<T, Z, P, K, R> System for Zpk<T, Z, P, K>

where T: ComplexFloat<Real = R>, K: ComplexFloat<Real = R>, Z: MaybeList<T>, P: MaybeList<T>,