Struct signal_processing::Tf

pub struct Tf<T: ComplexFloat, B: MaybeLists<T> = (), A: MaybeList<T> = ()> {
    pub b: Polynomial<T, B>,
    pub a: Polynomial<T, A>,
}

Fields

b: Polynomial<T, B>

a: Polynomial<T, A>

Implementations

impl<T: ComplexFloat, B: MaybeLists<T>, A: MaybeList<T>> Tf<T, B, A>

pub type View<'a> = Tf<T, <B as MaybeContainer<T>>::View<'a>, <A as MaybeContainer<T>>::View<'a>> where B::View<'a>: MaybeLists<T>, A::View<'a>: MaybeList<T>, B: 'a, A: 'a

pub type Owned = Tf<T, <B as MaybeContainer<T>>::Owned, <A as MaybeContainer<T>>::Owned> where B::Owned: MaybeLists<T>, A::Owned: MaybeList<T>

pub fn as_view<'a>(&'a self) -> Tf<T, B::View<'a>, A::View<'a>>

where B::View<'a>: MaybeLists<T>, A::View<'a>: MaybeList<T>,

pub fn to_owned(&self) -> Tf<T, B::Owned, A::Owned>

where B::Owned: MaybeLists<T>, A::Owned: MaybeList<T>,

pub fn into_owned(self) -> Tf<T, B::Owned, A::Owned>

where B::Owned: MaybeLists<T>, A::Owned: MaybeList<T>,

pub fn new(b: B, a: A) -> Self

pub fn one() -> Self

where Self: Default,

pub fn zero() -> Self

where Polynomial<T, [T; 0]>: Into<Polynomial<T, B>>, Polynomial<T, ()>: Into<Polynomial<T, A>>,

pub fn is_one(&self) -> bool

where B: MaybeList<T>,

pub fn is_zero(&self) -> bool

where B: MaybeLists<T>,

pub fn s() -> Self

where for<'a> &'a Tf<T, [T; 2], ()>: Into<Self>,

pub fn z() -> Self

where for<'a> &'a Tf<T, [T; 2], ()>: Into<Self>,

pub fn truncate<'a, const N: usize, const M: usize>( &'a self ) -> Tf<T, [T; N], [T; M]>

where B::View<'a>: MaybeLists<T>, A::View<'a>: MaybeLists<T>, Polynomial<T, B::View<'a>>: Into<Polynomial<T, Vec<T>>>, Polynomial<T, A::View<'a>>: Into<Polynomial<T, Vec<T>>>,

Trait Implementations

impl<'a, 'b, T, B, A, O> Add<&'b T> for &'a Tf<T, B, A>

where T: ComplexFloat, B: MaybeLists<T>, A: MaybeList<T>, Self: Add<Tf<T, &'b [T; 1], ()>, Output = O>,

type Output = O

The resulting type after applying the + operator.

fn add(self, rhs: &'b T) -> Self::Output

Performs the + operation.

impl<'b, T, B, A, O> Add<&'b T> for Tf<T, B, A>

where T: ComplexFloat, B: MaybeLists<T>, A: MaybeList<T>, Self: Add<Tf<T, &'b [T; 1], ()>, Output = O>,

type Output = O

The resulting type after applying the + operator.

fn add(self, rhs: &'b T) -> Self::Output

Performs the + operation.

impl<'a, 'b, T1, B1, A1, T2, B2, A2, O> Add<&'b Tf<T2, B2, A2>> for &'a Tf<T1, B1, A1>

where T1: ComplexFloat, T2: ComplexFloat, B1: MaybeLists<T1>, A1: MaybeList<T1>, B2: MaybeLists<T2>, A2: MaybeList<T2>, B1::View<'a>: MaybeLists<T1>, A1::View<'a>: MaybeList<T1>, B2::View<'b>: MaybeLists<T2>, A2::View<'b>: MaybeList<T2>, Tf<T1, B1::View<'a>, A1::View<'a>>: Add<Tf<T2, B2::View<'b>, A2::View<'b>>, Output = O>,

type Output = O

The resulting type after applying the + operator.

fn add(self, rhs: &'b Tf<T2, B2, A2>) -> Self::Output

Performs the + operation.

impl<'b, T1, B1, A1, T2, B2, A2, O> Add<&'b Tf<T2, B2, A2>> for Tf<T1, B1, A1>

where T1: ComplexFloat, T2: ComplexFloat, B1: MaybeLists<T1>, A1: MaybeList<T1>, B2: MaybeLists<T2>, A2: MaybeList<T2>, B2::View<'b>: MaybeLists<T2>, A2::View<'b>: MaybeList<T2>, Tf<T1, B1, A1>: Add<Tf<T2, B2::View<'b>, A2::View<'b>>, Output = O>,

type Output = O

The resulting type after applying the + operator.

fn add(self, rhs: &'b Tf<T2, B2, A2>) -> Self::Output

Performs the + operation.

impl<'a, T, B, A, O> Add<T> for &'a Tf<T, B, A>

where T: ComplexFloat, B: MaybeLists<T>, A: MaybeList<T>, Self: Add<Tf<T, [T; 1], ()>, Output = O>,

type Output = O

The resulting type after applying the + operator.

fn add(self, rhs: T) -> Self::Output

Performs the + operation.

impl<T, B, A, O> Add<T> for Tf<T, B, A>

where T: ComplexFloat, B: MaybeLists<T>, A: MaybeList<T>, Self: Add<Tf<T, [T; 1], ()>, Output = O>,

type Output = O

The resulting type after applying the + operator.

fn add(self, rhs: T) -> Self::Output

Performs the + operation.

impl<'a, T1, B1, A1, T2, B2, A2, O> Add<Tf<T2, B2, A2>> for &'a Tf<T1, B1, A1>

where T1: ComplexFloat, T2: ComplexFloat, B1: MaybeLists<T1>, A1: MaybeList<T1>, B2: MaybeLists<T2>, A2: MaybeList<T2>, B1::View<'a>: MaybeLists<T1>, A1::View<'a>: MaybeList<T1>, Tf<T1, B1::View<'a>, A1::View<'a>>: Add<Tf<T2, B2, A2>, Output = O>,

type Output = O

The resulting type after applying the + operator.

fn add(self, rhs: Tf<T2, B2, A2>) -> Self::Output

Performs the + operation.

impl<T1, B1, A1, T2, B2, A2, T3, B3, A3> Add<Tf<T2, B2, A2>> for Tf<T1, B1, A1>

where T1: ComplexFloat, T2: ComplexFloat, T3: ComplexFloat, B1: MaybeLists<T1>, A1: MaybeList<T1> + Clone, B2: MaybeLists<T2>, A2: MaybeList<T2> + Clone, B3: MaybeLists<T3>, A3: MaybeList<T3>, Polynomial<T1, A1>: Mul<Polynomial<T2, A2>, Output = Polynomial<T3, A3>>, Polynomial<T1, B1>: Mul<Polynomial<T2, A2>, Output: Add<<Polynomial<T2, B2> as Mul<Polynomial<T1, A1>>>::Output, Output = Polynomial<T3, B3>>>, Polynomial<T2, B2>: Mul<Polynomial<T1, A1>>, Tf<T3, B3, A3>: Normalize,

type Output = <Tf<T3, B3, A3> as Normalize>::Output

The resulting type after applying the + operator.

fn add(self, rhs: Tf<T2, B2, A2>) -> Self::Output

Performs the + operation.

impl<T, const N: usize> BesselF<()> for Tf<T, [T; N], [T; N]>

where [(); { _ }]:, T: Float + FloatConst, Tf<T, Vec<T>, Vec<T>>: BesselF<usize> + System<Domain = T>,

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

where [(); { _ }]:,

impl<T> BesselF<usize> for Tf<T, Vec<T>, Vec<T>>

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

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

where [(); { _ }]:,

impl<T, B, A> Bilinear for Tf<T, B, A>

where T: ComplexFloat, B: MaybeList<T>, A: MaybeList<T>, Self: ToZpk<Complex<T::Real>, Vec<Complex<T::Real>>, Vec<Complex<T::Real>>, T, (), ()> + System<Domain = T>, Zpk<Complex<T::Real>, Vec<Complex<T::Real>>, Vec<Complex<T::Real>>, T>: Bilinear<Output: ToTf<T, Vec<T>, Vec<T>, (), ()>> + System<Domain = T>,

type Output = Tf<T, Vec<T>, Vec<T>>

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

impl<T, const N: usize> Butter<()> for Tf<T, [T; N], [T; N]>

where [(); { _ }]:, T: Float + FloatConst, Tf<T, Vec<T>, Vec<T>>: Butter<usize> + System<Domain = T>,

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

where [(); { _ }]:,

impl<T> Butter<usize> for Tf<T, Vec<T>, Vec<T>>

where T: Float + FloatConst, Zpk<Complex<T>, Vec<Complex<T>>, Vec<Complex<T>>, T>: Butter<usize> + ToTf<T, Vec<T>, Vec<T>, (), ()> + 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> Cheby1<()> for Tf<T, [T; N], [T; N]>

where [(); { _ }]:, T: Float + FloatConst, Tf<T, Vec<T>, Vec<T>>: Cheby1<usize> + System<Domain = T>,

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

where [(); { _ }]:,

impl<T> Cheby1<usize> for Tf<T, Vec<T>, Vec<T>>

where T: Float + FloatConst, Zpk<Complex<T>, Vec<Complex<T>>, Vec<Complex<T>>, T>: Cheby1<usize> + ToTf<T, Vec<T>, Vec<T>, (), ()> + 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, const N: usize> Cheby2<()> for Tf<T, [T; N], [T; N]>

where [(); { _ }]:, T: Float + FloatConst, Tf<T, Vec<T>, Vec<T>>: Cheby2<usize> + System<Domain = T>,

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

where [(); { _ }]:,

impl<T> Cheby2<usize> for Tf<T, Vec<T>, Vec<T>>

where T: Float + FloatConst, Zpk<Complex<T>, Vec<Complex<T>>, Vec<Complex<T>>, T>: Cheby2<usize> + ToTf<T, Vec<T>, Vec<T>, (), ()> + 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, B: Clone + MaybeLists<T>, A: Clone + MaybeList<T>> Clone for Tf<T, B, A>

fn clone(&self) -> Tf<T, B, A>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug + ComplexFloat, B: Debug + MaybeLists<T>, A: Debug + MaybeList<T>> Debug for Tf<T, B, A>

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

Formats the value using the given formatter.

impl<T, B, A> Default for Tf<T, B, A>

where T: ComplexFloat, B: MaybeLists<T>, A: MaybeList<T>, Polynomial<T, B>: From<Polynomial<T, ()>>, Polynomial<T, A>: From<Polynomial<T, ()>>,

fn default() -> Self

Returns the “default value” for a type.

impl<'a, 'b, T, B, A, O> Div<&'b T> for &'a Tf<T, B, A>

where T: ComplexFloat, B: MaybeLists<T>, A: MaybeList<T>, Self: Div<Tf<T, &'b [T; 1], ()>, Output = O>,

type Output = O

The resulting type after applying the / operator.

fn div(self, rhs: &'b T) -> Self::Output

Performs the / operation.

impl<'b, T, B, A, O> Div<&'b T> for Tf<T, B, A>

where T: ComplexFloat, B: MaybeLists<T>, A: MaybeList<T>, Self: Div<Tf<T, &'b [T; 1], ()>, Output = O>,

type Output = O

The resulting type after applying the / operator.

fn div(self, rhs: &'b T) -> Self::Output

Performs the / operation.

impl<'a, 'b, T1, B1, A1, T2, B2, A2, O> Div<&'b Tf<T2, B2, A2>> for &'a Tf<T1, B1, A1>

where T1: ComplexFloat, T2: ComplexFloat, B1: MaybeLists<T1>, A1: MaybeList<T1>, B2: MaybeLists<T2>, A2: MaybeList<T2>, B1::View<'a>: MaybeLists<T1>, A1::View<'a>: MaybeList<T1>, B2::View<'b>: MaybeLists<T2>, A2::View<'b>: MaybeList<T2>, Tf<T1, B1::View<'a>, A1::View<'a>>: Div<Tf<T2, B2::View<'b>, A2::View<'b>>, Output = O>,

type Output = O

The resulting type after applying the / operator.

fn div(self, rhs: &'b Tf<T2, B2, A2>) -> Self::Output

Performs the / operation.

impl<'b, T1, B1, A1, T2, B2, A2, O> Div<&'b Tf<T2, B2, A2>> for Tf<T1, B1, A1>

where T1: ComplexFloat, T2: ComplexFloat, B1: MaybeLists<T1>, A1: MaybeList<T1>, B2: MaybeLists<T2>, A2: MaybeList<T2>, B2::View<'b>: MaybeLists<T2>, A2::View<'b>: MaybeList<T2>, Tf<T1, B1, A1>: Div<Tf<T2, B2::View<'b>, A2::View<'b>>, Output = O>,

type Output = O

The resulting type after applying the / operator.

fn div(self, rhs: &'b Tf<T2, B2, A2>) -> Self::Output

Performs the / operation.

impl<'a, T, B, A, O> Div<T> for &'a Tf<T, B, A>

where T: ComplexFloat, B: MaybeLists<T>, A: MaybeList<T>, Self: Div<Tf<T, [T; 1], ()>, Output = O>,

type Output = O

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T, B, A, O> Div<T> for Tf<T, B, A>

where T: ComplexFloat, B: MaybeLists<T>, A: MaybeList<T>, Self: Div<Tf<T, [T; 1], ()>, Output = O>,

type Output = O

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'a, T1, B1, A1, T2, B2, A2, O> Div<Tf<T2, B2, A2>> for &'a Tf<T1, B1, A1>

where T1: ComplexFloat, T2: ComplexFloat, B1: MaybeLists<T1>, A1: MaybeList<T1>, B2: MaybeLists<T2>, A2: MaybeList<T2>, B1::View<'a>: MaybeLists<T1>, A1::View<'a>: MaybeList<T1>, Tf<T1, B1::View<'a>, A1::View<'a>>: Div<Tf<T2, B2, A2>, Output = O>,

type Output = O

The resulting type after applying the / operator.

fn div(self, rhs: Tf<T2, B2, A2>) -> Self::Output

Performs the / operation.

impl<T1, T2, T3, B1, B2, B3, A1, A2, A3> Div<Tf<T2, B2, A2>> for Tf<T1, B1, A1>

where T1: ComplexFloat, T2: ComplexFloat, T3: ComplexFloat, B1: MaybeLists<T1>, A1: MaybeList<T1>, B2: MaybeLists<T2>, A2: MaybeList<T2>, B3: MaybeLists<T3>, A3: MaybeList<T3>, Polynomial<T1, B1>: Mul<Polynomial<T2, A2>, Output = Polynomial<T3, B3>>, Polynomial<T1, A1>: Mul<Polynomial<T2, B2>, Output = Polynomial<T3, A3>>, Tf<T3, B3, A3>: Normalize,

type Output = <Tf<T3, B3, A3> as Normalize>::Output

The resulting type after applying the / operator.

fn div(self, rhs: Tf<T2, B2, A2>) -> Self::Output

Performs the / operation.

impl<T, const N: usize> Ellip<()> for Tf<T, [T; N], [T; N]>

where [(); { _ }]:, T: Float + FloatConst, Tf<T, Vec<T>, Vec<T>>: Ellip<usize> + System<Domain = T>,

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

where [(); { _ }]:,

impl<T> Ellip<usize> for Tf<T, Vec<T>, Vec<T>>

where T: Float + FloatConst, Zpk<Complex<T>, Vec<Complex<T>>, Vec<Complex<T>>, T>: Ellip<usize> + ToTf<T, Vec<T>, Vec<T>, (), ()> + 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<'a, T, B, A, X, Y, XX, XXX> FftFilt<'a, X, XX> for Tf<T, B, A>

where T: ComplexFloat<Real: Into<Y> + 'static> + ComplexOp<X, Output = Y> + Into<Complex<T::Real>> + 'a, A: MaybeList<T, MaybeMapped<Complex<T::Real>>: MaybeList<Complex<T::Real>>>, B: MaybeLists<T, RowView<'a>: MaybeList<T, MaybeMapped<Complex<T::Real>>: MaybeList<Complex<T::Real>>>> + 'a, X: ComplexFloat<Real = T::Real> + Into<Y> + Into<Complex<T::Real>>, XX: Lists<X, Mapped<Complex<T::Real>>: Clone + Lists<Complex<T::Real>, RowOwned = XXX, RowsMapped<XXX::Mapped<Y>>: Into<XX::Mapped<Y>>>>, XXX: List<Complex<T::Real>>, Y: ComplexFloat<Real = T::Real> + 'static, Complex<T::Real>: Clone + AddAssign + MulAssign + DivAssign + MulAssign<T::Real>,

type Output = <B as MaybeLists<T>>::RowsMapped<<XX as Container<X>>::Mapped<Y>>

fn fftfilt<N>(&'a self, x: XX, n: N) -> Self::Output

where N: Maybe<usize>,

impl<'a, T, B, A, X, XX> FiltFilt<'a, X, XX> for Tf<T, B, A>

where T: ComplexOp<X> + ComplexOp<T, Output = T> + Sum + AddAssign, X: Into<<T as ComplexOp<X>>::Output> + ComplexFloat<Real = T::Real>, <T as ComplexOp<X>>::Output: ComplexOp<T, Real = T::Real, Output = <T as ComplexOp<X>>::Output> + ComplexOp<X, Output = <T as ComplexOp<X>>::Output> + ComplexOp<<T as ComplexOp<X>>::Output, Output = <T as ComplexOp<X>>::Output>, B: MaybeLists<T>, A: MaybeList<T>, XX: Lists<X>, Self: 'a, &'a Self: Into<Tf<T, Vec<Vec<T>>, Vec<T>>>, for<'b> Tf<T, &'b [T], &'b [T]>: System<Domain = T>, for<'b> Rtf<'b, <T as ComplexOp<X>>::Output, Tf<T, &'b [T], &'b [T]>>: FilterMut<X, Vec<X>, Output = Vec<<T as ComplexOp<X>>::Output>> + FilterMut<<T as ComplexOp<X>>::Output, Vec<<T as ComplexOp<X>>::Output>, Output = Vec<<T as ComplexOp<X>>::Output>> + RtfOrSystem<Domain = <T as ComplexOp<X>>::Output>,

type Output = <B as MaybeLists<T>>::RowsMapped<<XX as Container<X>>::Mapped<<<Tf<T, B, A> as RtfOrSystem>::Domain as ComplexOp<X>>::Output>>

fn filtfilt(&'a self, x: XX) -> Self::Output

impl<'a, T, B, A, X, XX, Y> FiltIC<'a, X, XX, <B as MaybeLists<T>>::RowsMapped<<XX as Container<X>>::Mapped<Y>>> for Tf<T, B, A>

where T: ComplexOp<X, Output = Y>, B: MaybeLists<T>, A: MaybeList<T>, X: ComplexFloat + Into<Y>, Y: ComplexFloat + DivAssign, XX: List<X>, XX::Mapped<Y>: List<Y>, B::RowsMapped<XX::Mapped<Y>>: Lists<Y>, Self: 'a, &'a Self: Into<Tf<T, Vec<Vec<T>>, Vec<T>>>,

fn filtic(&'a self, y: B::RowsMapped<XX::Mapped<Y>>, x: XX) -> Vec<Y>

impl<T, B, A> FiltOrd for Tf<T, B, A>

where T: ComplexFloat, B: MaybeLists<T>, A: MaybeList<T>,

type Output = <B as MaybeLists<T>>::RowsMapped<usize>

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

impl<'a, T, B, A> FilterNorm<'a> for Tf<T, B, A>

where T: ComplexFloat<Real: Sum>, B: MaybeLists<T>, A: MaybeList<T>, B::RowsMapped<Vec<T>>: for<'b> Lists<T, RowView<'b>: List<T>, RowsMapped<T::Real> = B::RowsMapped<T::Real>>, B::RowsMapped<[Complex<T::Real>; 1024]>: for<'b> Lists<Complex<T::Real>, RowView<'b>: List<Complex<T::Real>>, RowsMapped<T::Real> = B::RowsMapped<T::Real>>, Self: ImpZ<'a, B::RowsMapped<Vec<T>>, Vec<T::Real>, ()> + FreqZ<'a, B::RowsMapped<[Complex<T::Real>; 1024]>, [T::Real; 1024], ()> + System<Domain = T>,

type Output = <B as MaybeLists<T>>::RowsMapped<<T as ComplexFloat>::Real>

fn filternorm(&'a self, p: T::Real) -> Self::Output

impl<T, F, const N: usize> Fir1<(), F, <T as ComplexFloat>::Real> for Tf<T, [T; N], ()>

where T: ComplexFloat, F: List<T::Real>, T::Real: Into<T>, Self: Fir1<(), F, T::Real, [T::Real; N], true> + System<Domain = T>,

fn fir1<FS>( (): (), frequencies: F, filter_type: Fir1Type, (): (), scale: bool, sampling_frequency: FS ) -> Result<Self, FilterGenError>

where FS: Maybe<T::Real>,

impl<T, F, W, WW> Fir1<(), F, W, WW, true> for Tf<T, WW::Mapped<T>, ()>

where T: ComplexFloat + Into<Complex<T::Real>> + Mul<T::Real, Output = T>, T::Real: Into<T>, Complex<T::Real>: AddAssign + MulAssign, WW: List<W>, F: List<T::Real>, W: ComplexFloat<Real = T::Real> + Into<T>, WW::Mapped<T>: List<T, Mapped<T> = WW::Mapped<T>>, Self: Fir2<(), Vec<T::Real>, Vec<T>, W, WW, true> + System<Domain = T>,

fn fir1<FS>( (): (), frequencies: F, filter_type: Fir1Type, window: WW, scale: bool, sampling_frequency: FS ) -> Result<Self, FilterGenError>

where FS: Maybe<T::Real>,

impl<T, F> Fir1<usize, F, <T as ComplexFloat>::Real> for Tf<T, Vec<T>, ()>

where T: ComplexFloat, F: List<T::Real>, T::Real: Into<T>, Self: Fir1<(), F, T::Real, Vec<T::Real>, true> + System<Domain = T>,

fn fir1<FS>( order: usize, frequencies: F, filter_type: Fir1Type, (): (), scale: bool, sampling_frequency: FS ) -> Result<Self, FilterGenError>

where FS: Maybe<T::Real>,

impl<T, F, M, const N: usize> Fir2<(), F, M, <T as ComplexFloat>::Real> for Tf<T, [T; N], ()>

where T: ComplexFloat, T::Real: Into<T>, F: List<T::Real>, M: List<T, Length = F::Length>, Self: Fir2<(), F, M, T::Real, [T::Real; N], true> + System<Domain = T>, [(); { _ }]:,

fn fir2<NPT, LAP, FS>( (): (), frequencies: F, magnitudes: M, npt: NPT, lap: LAP, (): (), sampling_frequency: FS ) -> Result<Self, FilterGenError>

where NPT: Maybe<usize>, LAP: Maybe<usize>, FS: Maybe<<Self::Domain as ComplexFloat>::Real>,

impl<T, F, M, W, WW> Fir2<(), F, M, W, WW, true> for Tf<T, WW::Mapped<T>, ()>

where T: ComplexFloat<Real: TotalOrder + MulAssign + AddAssign + SubAssign> + Div<T::Real, Output = T> + Mul<T::Real, Output = T> + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, T::Real: Into<T>, F: List<T::Real>, M: List<T, Length = F::Length>, W: ComplexFloat<Real = T::Real> + Into<T>, WW: List<W>, WW::Mapped<T>: List<T>, [(); { _ }]:,

fn fir2<NPT, LAP, FS>( (): (), frequencies: F, magnitudes: M, npt: NPT, lap: LAP, window: WW, sampling_frequency: FS ) -> Result<Self, FilterGenError>

where NPT: Maybe<usize>, LAP: Maybe<usize>, FS: Maybe<T::Real>,

impl<T, F, M> Fir2<usize, F, M, <T as ComplexFloat>::Real> for Tf<T, Vec<T>, ()>

where T: ComplexFloat, T::Real: Into<T>, F: List<T::Real>, M: List<T, Length = F::Length>, Self: Fir2<(), F, M, T::Real, Vec<T::Real>, true> + System<Domain = T>, [(); { _ }]:,

fn fir2<NPT, LAP, FS>( order: usize, frequencies: F, magnitudes: M, npt: NPT, lap: LAP, (): (), sampling_frequency: FS ) -> Result<Self, FilterGenError>

where NPT: Maybe<usize>, LAP: Maybe<usize>, FS: Maybe<<Self::Domain as ComplexFloat>::Real>,

impl<T, const N: usize> FirGr<()> for Tf<T, [T; N], ()>

where T: Float + FloatConst + AddAssign + MulAssign + DivAssign,

fn firgr<FS, MI, GD, const B: 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> FirGr<usize> for Tf<T, Vec<T>, ()>

where T: Float + FloatConst + AddAssign + MulAssign + DivAssign,

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, const N: usize> FirLS<()> for Tf<T, [T; N], ()>

where T: ComplexFloat, Tf<T, Vec<T>, ()>: FirLS<usize> + System<Domain = T>,

fn firls<const B2: usize, const M: usize, FS, W>( (): (), frequencies: [<Self::Domain as ComplexFloat>::Real; B2], magnitudes: [Self::Domain; M], weights: W, sampling_frequency: FS ) -> Result<Self, FilterGenError>

where FS: Maybe<<Self::Domain as ComplexFloat>::Real>, W: Maybe<[Self::Domain; { _ }]>, [(); { _ }]:,

impl<T> FirLS<usize> for Tf<T, Vec<T>, ()>

where T: ComplexFloat + Lapack + Sub<<T as ComplexFloat>::Real, Output = T> + Mul<<T as ComplexFloat>::Real, Output = T> + Div<<T as ComplexFloat>::Real, Output = T>, <T as ComplexFloat>::Real: MulAssign + Into<T>,

fn firls<const B2: usize, const M: usize, FS, W>( order: usize, frequencies: [<Self::Domain as ComplexFloat>::Real; B2], magnitudes: [Self::Domain; M], weights: W, sampling_frequency: FS ) -> Result<Self, FilterGenError>

where FS: Maybe<<T as ComplexFloat>::Real>, W: Maybe<[T; { _ }]>, [(); { _ }]:,

impl<T> FirPm for Tf<T, Vec<T>, ()>

where T: Float + FloatConst + AddAssign + SubAssign + MulAssign + DivAssign + Default + SampleUniform + 'static, Complex<T>: MulAssign + AddAssign + MulAssign<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, S, SS, B, A> FreqS<'a, S, SS> for Tf<T, B, A>

where S: ComplexFloat<Real = T::Real> + 'a, SS: Lists<S> + 'a, T: ComplexFloat + Into<Complex<T::Real>>, Complex<T::Real>: MulAssign<S> + AddAssign, B: MaybeList<T>, A: MaybeList<T>, Self: 'a,

fn freqs(&'a self, s: SS) -> SS::Mapped<Complex<T::Real>>

impl<'a, T, B, A, const N: usize> FreqZ<'a, <B as MaybeLists<T>>::RowsMapped<[Complex<<T as ComplexFloat>::Real>; N]>, [<T as ComplexFloat>::Real; N], ()> for Tf<T, B, A>

where T: ComplexFloat, B: MaybeLists<T>, A: MaybeList<T>, B::RowsMapped<[Complex<T::Real>; N]>: Lists<Complex<T::Real>>, Complex<T::Real>: AddAssign + MulAssign + Mul<T::Real, Output = Complex<T::Real>>, Self: 'a, &'a Self: Into<Tf<Complex<T::Real>, Vec<Vec<Complex<T::Real>>>, Vec<Complex<T::Real>>>>,

fn freqz( &'a self, (): (), shift: bool ) -> (B::RowsMapped<[Complex<T::Real>; N]>, [T::Real; N])

impl<'a, T, B, A> FreqZ<'a, <B as MaybeLists<T>>::RowsMapped<Vec<Complex<<T as ComplexFloat>::Real>>>, Vec<<T as ComplexFloat>::Real>, usize> for Tf<T, B, A>

where T: ComplexFloat, B: MaybeLists<T>, A: MaybeList<T>, B::RowsMapped<Vec<Complex<T::Real>>>: Lists<Complex<T::Real>>, Complex<T::Real>: AddAssign + MulAssign + Mul<T::Real, Output = Complex<T::Real>>, Self: 'a, &'a Self: Into<Tf<Complex<T::Real>, Vec<Vec<Complex<T::Real>>>, Vec<Complex<T::Real>>>>,

fn freqz( &'a self, n: usize, shift: bool ) -> (B::RowsMapped<Vec<Complex<T::Real>>>, Vec<T::Real>)

impl<'a, T1, B1, A1, T2, B2, A2> From<&'a Tf<T1, B1, A1>> for Tf<T2, B2, A2>

where T1: ComplexFloat, T2: ComplexFloat, B1: MaybeLists<T1>, A1: MaybeList<T1>, B2: MaybeLists<T2>, A2: MaybeList<T2>, B1::View<'a>: MaybeLists<T1>, A1::View<'a>: MaybeLists<T1>, Polynomial<T1, B1::View<'a>>: Into<Polynomial<T2, B2>>, Polynomial<T1, A1::View<'a>>: Into<Polynomial<T2, A2>>,

fn from(tf: &'a Tf<T1, B1, A1>) -> Self

Converts to this type from the input type.

impl<'a, T, B, A, const N: usize> GrpDelay<'a, <B as MaybeLists<T>>::RowsMapped<[<T as ComplexFloat>::Real; N]>, [<T as ComplexFloat>::Real; N], ()> for Tf<T, B, A>

where T: ComplexFloat, B: MaybeLists<T>, A: MaybeList<T>, B::RowsMapped<[T::Real; N]>: Lists<T::Real>, Vec<Complex<T::Real>>: for<'b> Conv<Complex<T::Real>, Complex<T::Real>, &'b [Complex<T::Real>], Output = Vec<Complex<T::Real>>>, Complex<T::Real>: AddAssign + MulAssign + Mul<T::Real, Output = Complex<T::Real>>, Self: 'a, &'a Self: Into<Tf<Complex<T::Real>, Vec<Vec<Complex<T::Real>>>, Vec<Complex<T::Real>>>>,

fn grpdelay<FS>( &'a self, (): (), sampling_rate: FS ) -> (B::RowsMapped<[T::Real; N]>, [T::Real; N])

where FS: Maybe<<Self::Domain as ComplexFloat>::Real>,

impl<T, T2, B, B2, A, A2, R, R2, P, RP, K> ImpInvar for Tf<T, B, A>

where T: ComplexFloat<Real: Into<T> + NotPolynomial> + 'static, B: MaybeLists<T>, A: MaybeList<T>, Self: Residue<Output = Rpk<T, R, P, RP, K>> + System<Domain = T>, Rpk<R, R2, P, Vec<(R2, P)>, [R; 1]>: Residue<Output = Tf<T2, B2, A2>> + System<Domain: ComplexFloat<Real = T::Real>>, T2: ComplexFloat<Real = T::Real> + 'static, B2: MaybeLists<T2>, A2: MaybeList<T2>, B2::MaybeMapped<T>: MaybeLists<T, RowsMapped<Vec<T>>: MaybeLists<T>, RowOwned: MaybeList<T>>, Polynomial<T, <B2::MaybeMapped<T> as MaybeLists<T>>::RowOwned>: Into<Polynomial<T, Vec<T>>>, A2::MaybeMapped<T>: MaybeList<T>, R: ComplexFloat<Real = T::Real> + Mul<T::Real, Output = R> + ComplexOp<P, Output = R2> + AddAssign, P: ComplexFloat<Real = T::Real> + Mul<T::Real, Output = P> + Into<R2> + MulAssign + Add<T::Real, Output = P>, R2: ComplexFloat<Real = T::Real> + NotPolynomial, RP: MaybeList<(R, P)>, K: MaybeList<T>, SumSequence<(R, P), RP>: Into<SumSequence<(R, P), Vec<(R, P)>>>,

type Output = Tf<T, <<B2 as MaybeContainer<T2>>::MaybeMapped<T> as MaybeLists<T>>::RowsMapped<Vec<T>>, <A2 as MaybeContainer<T2>>::MaybeMapped<T>>

fn impinvar<FS, TOL>( self, sampling_frequency: FS, tol: TOL ) -> Result<Self::Output, ImpInvarError>

where FS: Maybe<T::Real>, TOL: Maybe<T::Real>,

impl<'a, T, B, A, const N: usize> ImpZ<'a, <B as MaybeLists<T>>::RowsMapped<[T; N]>, [<T as ComplexFloat>::Real; N], ()> for Tf<T, B, A>

where T: ComplexFloat, B: MaybeLists<T>, A: MaybeList<T>, B::RowsMapped<Vec<T>>: Lists<T, RowsMapped<[T; N]> = B::RowsMapped<[T; N]>>, B::RowsMapped<[T; N]>: Lists<T>, Self: ImpZ<'a, B::RowsMapped<Vec<T>>, Vec<T::Real>, usize> + System<Domain = T> + 'a,

fn impz( &'a self, (): (), sampling_frequency: Option<<T as ComplexFloat>::Real> ) -> (B::RowsMapped<[T; N]>, [T::Real; N])

impl<'a, T, B, A> ImpZ<'a, <B as MaybeLists<T>>::RowsMapped<Vec<T>>, Vec<<T as ComplexFloat>::Real>, ()> for Tf<T, B, A>

where Complex<<T as ComplexFloat>::Real>: From<T> + AddAssign + SubAssign + MulAssign + DivAssign + DivAssign<<T as ComplexFloat>::Real>, T: ComplexFloat + Lapack<Complex = Complex<<T as ComplexFloat>::Real>>, B: MaybeLists<T>, A: MaybeList<T>, B::RowsMapped<Vec<T>>: Lists<T>, Self: ImpZ<'a, B::RowsMapped<Vec<T>>, Vec<<T as ComplexFloat>::Real>, usize> + System<Domain = T>,

fn impz( &'a self, (): (), sampling_frequency: Option<<T as ComplexFloat>::Real> ) -> (B::RowsMapped<Vec<T>>, Vec<<T as ComplexFloat>::Real>)

impl<'a, T, B, A> ImpZ<'a, <B as MaybeLists<T>>::RowsMapped<Vec<T>>, Vec<<T as ComplexFloat>::Real>, usize> for Tf<T, B, A>

where T: ComplexFloat + ComplexOp<T, Output = T>, B: MaybeLists<T>, A: MaybeList<T>, B::RowsMapped<Vec<T>>: for<'b> Lists<T, RowsMapped<Vec<T>> = B::RowsMapped<Vec<T>>, RowView<'b>: List<T, Mapped<T::Real> = Vec<T::Real>>> + 'a, Self: 'a + Filter<'a, T, Vec<T>, Output = B::RowsMapped<Vec<T>>> + System<Domain = T>, &'a Self: Into<Tf<T, B::RowsMapped<Vec<T>>, Vec<T>>>, Vec<T>: for<'b> Conv<T, T, &'b [T], Output = Vec<T>>, T::Real: Into<T>, (): Maybe<Vec<T>>,

fn impz( &'a self, n: usize, sampling_frequency: Option<<T as ComplexFloat>::Real> ) -> (B::RowsMapped<Vec<T>>, Vec<T::Real>)

impl<'a, T, B, A, O> Inv for &'a Tf<T, B, A>

where T: ComplexFloat, B: MaybeLists<T>, A: MaybeList<T>, B::View<'a>: MaybeLists<T>, A::View<'a>: MaybeList<T>, Tf<T, B::View<'a>, A::View<'a>>: 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, B, A> Inv for Tf<T, B, A>

where T: ComplexFloat, B: MaybeList<T>, A: MaybeList<T>,

type Output = Tf<T, A, B>

The result after applying the operator.

fn inv(self) -> Self::Output

Returns the multiplicative inverse of self.

impl<T, B, A, H, S, W, HFW> InvFreqS<H, S, W, HFW, <<B as MaybeLists<T>>::Width as StaticMaybe<usize>>::Opposite, <<A as MaybeLists<T>>::Width as StaticMaybe<usize>>::Opposite> for Tf<T, B, A>

where T: Float + FloatConst + Lapack<Real = T> + AddAssign + 'static, B: List<T>, A: MaybeList<T>, H: ComplexFloat<Real = T>, S: ComplexFloat<Real = T> + Into<Complex<T>>, HFW: List<(H, S, W)>, W: Maybe<T> + Clone, Complex<T>: Mul<T, Output = Complex<T>> + Mul<H, Output = Complex<T>> + Mul<Output = Complex<T>> + MulAssign, <B::Width as StaticMaybe<usize>>::Opposite: Sized, <A::Width as StaticMaybe<usize>>::Opposite: Sized, Vec<T>: TryInto<B> + TryInto<A>, [(); { _ }]:,

fn invfreqs<ZB>( hfw: HFW, nb: <B::Width as StaticMaybe<usize>>::Opposite, na: <A::Width as StaticMaybe<usize>>::Opposite, zb: ZB, norm: bool, method: InvFreqMethod ) -> (Self, T)

where ZB: Maybe<<B::Width as StaticMaybe<usize>>::Opposite>,

impl<T, B, A, H, W, HFW> InvFreqZ<H, W, HFW, <<B as MaybeLists<T>>::Width as StaticMaybe<usize>>::Opposite, <<A as MaybeLists<T>>::Width as StaticMaybe<usize>>::Opposite> for Tf<T, B, A>

where T: Float + FloatConst + Lapack<Real = T> + AddAssign + 'static, B: List<T>, A: MaybeList<T>, H: ComplexFloat<Real = T>, HFW: List<(H, T, W)>, W: Maybe<T> + Clone, Complex<T>: Mul<T, Output = Complex<T>> + Mul<H, Output = Complex<T>> + Mul<Output = Complex<T>> + MulAssign, <B::Width as StaticMaybe<usize>>::Opposite: Sized, <A::Width as StaticMaybe<usize>>::Opposite: Sized, Vec<T>: TryInto<B> + TryInto<A>, [(); { _ }]:,

fn invfreqz<ZB>( hfw: HFW, nb: <B::Width as StaticMaybe<usize>>::Opposite, na: <A::Width as StaticMaybe<usize>>::Opposite, zb: ZB, method: InvFreqMethod ) -> (Self, T)

where ZB: Maybe<<B::Width as StaticMaybe<usize>>::Opposite>,

impl<'a, T, B, A> IsAllPass<'a> for Tf<T, B, A>

where T: ComplexFloat + DivAssign, B: MaybeLists<T>, A: MaybeList<T>,

type Output = <B as MaybeLists<T>>::RowsMapped<bool>

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

where TOL: Maybe<T::Real>,

impl<'a, T, B, A> IsLinPhase<'a> for Tf<T, B, A>

where T: ComplexFloat + 'a, B: MaybeLists<T> + 'a, A: MaybeList<T> + 'a, A::View<'a>: MaybeList<T> + Clone,

type Output = <B as MaybeLists<T>>::RowsMapped<bool>

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

where TOL: Maybe<T::Real>,

impl<'a, T, B, A> IsMaxPhase<'a> for Tf<T, B, A>

where T: ComplexFloat + 'a, B: MaybeLists<T> + 'a, A: MaybeList<T> + 'a, A::View<'a>: MaybeList<T> + Clone, Tf<T, B::RowView<'a>, A::View<'a>>: ToZpk<Complex<T::Real>, Vec<Complex<T::Real>>, Vec<Complex<T::Real>>, T, (), ()>, Zpk<Complex<T::Real>, Vec<Complex<T::Real>>, Vec<Complex<T::Real>>, T>: for<'b> IsMaxPhase<'b, Output = bool> + System<Domain = T>,

type Output = <B as MaybeLists<T>>::RowsMapped<bool>

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

where TOL: Maybe<T::Real>,

impl<'a, T, B, A> IsStable<'a> for Tf<T, B, A>

where T: ComplexFloat + 'a, B: MaybeLists<T> + 'a, A: MaybeList<T> + 'a, A::View<'a>: MaybeList<T> + Clone, Tf<T, B::RowView<'a>, A::View<'a>>: ToZpk<Complex<T::Real>, Vec<Complex<T::Real>>, Vec<Complex<T::Real>>, T, (), ()>, Zpk<Complex<T::Real>, Vec<Complex<T::Real>>, Vec<Complex<T::Real>>, T>: for<'b> IsStable<'b, Output = bool> + System<Domain = T>,

type Output = <B as MaybeLists<T>>::RowsMapped<bool>

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

where TOL: Maybe<T::Real>,

impl<T, B, A> MaxPhase for Tf<T, B, A>

where T: ComplexFloat + MulAssign<T::Real>, B: MaybeLists<T>, A: MaybeList<T>, Self: ToZpk<Complex<T::Real>, Vec<Complex<T::Real>>, Vec<Complex<T::Real>>, T, (), ()> + System<Domain = T>, Zpk<Complex<T::Real>, Vec<Complex<T::Real>>, Vec<Complex<T::Real>>, T>: ToTf<T, Vec<T>, Vec<T>, (), ()>, Zpk<Complex<T::Real>, Vec<Complex<T::Real>>, Vec<Complex<T::Real>>, T::Real>: ToTf<T, Vec<T>, Vec<T>, (), ()>,

type OutputMax = Tf<T, Vec<T>, Vec<T>>

type OutputAp = Tf<T, Vec<T>, Vec<T>>

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

impl<T, B, A> MinPhase for Tf<T, B, A>

where T: ComplexFloat + MulAssign<T::Real>, B: MaybeLists<T>, A: MaybeList<T>, Self: ToZpk<Complex<T::Real>, Vec<Complex<T::Real>>, Vec<Complex<T::Real>>, T, (), ()> + System<Domain = T>, Zpk<Complex<T::Real>, Vec<Complex<T::Real>>, Vec<Complex<T::Real>>, T>: ToTf<T, Vec<T>, Vec<T>, (), ()>, Zpk<Complex<T::Real>, Vec<Complex<T::Real>>, Vec<Complex<T::Real>>, T::Real>: ToTf<T, Vec<T>, Vec<T>, (), ()>,

type OutputMin = Tf<T, Vec<T>, Vec<T>>

type OutputAp = Tf<T, Vec<T>, Vec<T>>

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

impl<'a, 'b, T, B, A, O> Mul<&'b T> for &'a Tf<T, B, A>

where T: ComplexFloat, B: MaybeLists<T>, A: MaybeList<T>, Self: Mul<Tf<T, &'b [T; 1], ()>, Output = O>,

type Output = O

The resulting type after applying the * operator.

fn mul(self, rhs: &'b T) -> Self::Output

Performs the * operation.

impl<'b, T, B, A, O> Mul<&'b T> for Tf<T, B, A>

where T: ComplexFloat, B: MaybeLists<T>, A: MaybeList<T>, Self: Mul<Tf<T, &'b [T; 1], ()>, Output = O>,

type Output = O

The resulting type after applying the * operator.

fn mul(self, rhs: &'b T) -> Self::Output

Performs the * operation.

impl<'a, 'b, T1, B1, A1, T2, B2, A2, O> Mul<&'b Tf<T2, B2, A2>> for &'a Tf<T1, B1, A1>

where T1: ComplexFloat, T2: ComplexFloat, B1: MaybeLists<T1>, A1: MaybeList<T1>, B2: MaybeLists<T2>, A2: MaybeList<T2>, B1::View<'a>: MaybeLists<T1>, A1::View<'a>: MaybeList<T1>, B2::View<'b>: MaybeLists<T2>, A2::View<'b>: MaybeList<T2>, Tf<T1, B1::View<'a>, A1::View<'a>>: Mul<Tf<T2, B2::View<'b>, A2::View<'b>>, Output = O>,

type Output = O

The resulting type after applying the * operator.

fn mul(self, rhs: &'b Tf<T2, B2, A2>) -> Self::Output

Performs the * operation.

impl<'b, T1, B1, A1, T2, B2, A2, O> Mul<&'b Tf<T2, B2, A2>> for Tf<T1, B1, A1>

where T1: ComplexFloat, T2: ComplexFloat, B1: MaybeLists<T1>, A1: MaybeList<T1>, B2: MaybeLists<T2>, A2: MaybeList<T2>, B2::View<'b>: MaybeLists<T2>, A2::View<'b>: MaybeList<T2>, Tf<T1, B1, A1>: Mul<Tf<T2, B2::View<'b>, A2::View<'b>>, Output = O>,

type Output = O

The resulting type after applying the * operator.

fn mul(self, rhs: &'b Tf<T2, B2, A2>) -> Self::Output

Performs the * operation.

impl<'a, T, B, A, O> Mul<T> for &'a Tf<T, B, A>

where T: ComplexFloat, B: MaybeLists<T>, A: MaybeList<T>, Self: Mul<Tf<T, [T; 1], ()>, Output = O>,

type Output = O

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T, B, A, O> Mul<T> for Tf<T, B, A>

where T: ComplexFloat, B: MaybeLists<T>, A: MaybeList<T>, Self: Mul<Tf<T, [T; 1], ()>, Output = O>,

type Output = O

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, T1, B1, A1, T2, B2, A2, O> Mul<Tf<T2, B2, A2>> for &'a Tf<T1, B1, A1>

where T1: ComplexFloat, T2: ComplexFloat, B1: MaybeLists<T1>, A1: MaybeList<T1>, B2: MaybeLists<T2>, A2: MaybeList<T2>, B1::View<'a>: MaybeLists<T1>, A1::View<'a>: MaybeList<T1>, Tf<T1, B1::View<'a>, A1::View<'a>>: Mul<Tf<T2, B2, A2>, Output = O>,

type Output = O

The resulting type after applying the * operator.

fn mul(self, rhs: Tf<T2, B2, A2>) -> Self::Output

Performs the * operation.

impl<T1, T2, T3, B1, B2, B3, A1, A2, A3> Mul<Tf<T2, B2, A2>> for Tf<T1, B1, A1>

where T1: ComplexFloat, T2: ComplexFloat, T3: ComplexFloat, B1: MaybeLists<T1>, A1: MaybeList<T1>, B2: MaybeLists<T2>, A2: MaybeList<T2>, B3: MaybeLists<T3>, A3: MaybeList<T3>, Polynomial<T1, B1>: Mul<Polynomial<T2, B2>, Output = Polynomial<T3, B3>>, Polynomial<T1, A1>: Mul<Polynomial<T2, A2>, Output = Polynomial<T3, A3>>, Tf<T3, B3, A3>: Normalize,

type Output = <Tf<T3, B3, A3> as Normalize>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: Tf<T2, B2, A2>) -> Self::Output

Performs the * operation.

impl<'a, T, B, A, O> Neg for &'a Tf<T, B, A>

where T: ComplexFloat, B: MaybeLists<T>, A: MaybeList<T>, B::View<'a>: MaybeLists<T>, A::View<'a>: MaybeList<T>, Tf<T, B::View<'a>, A::View<'a>>: Neg<Output = O>,

type Output = O

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<T, B1, B2, A> Neg for Tf<T, B1, A>

where T: ComplexFloat, B1: MaybeLists<T>, B2: MaybeLists<T>, A: MaybeList<T>, Polynomial<T, B1>: Neg<Output = Polynomial<T, B2>>,

type Output = Tf<T, B2, A>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<T, B, A, B2, BB2, BB, AA> Normalize for Tf<T, B, A>

where Vec<T>: NotVoid, T: ComplexFloat + AddAssign + MulAssign + DivAssign, B: MaybeLists<T, RowsMapped<Vec<T>> = B2>, B::MaybeSome: StaticMaybe<B::Some, Maybe<Vec<T>> = BB>, A::MaybeSome: StaticMaybe<A::Some, Maybe<Vec<T>> = AA>, A: MaybeList<T>, B2: OwnedLists<T, RowOwned = Vec<T>, RowsMapped<Vec<T>> = B2> + Clone, B2::MaybeSome: StaticMaybe<B2::Some, Maybe<B2>: MaybeOr<B2, B::RowsMapped<BB>, Output = BB2>>, Polynomial<T, B>: Into<Polynomial<T, BB2>>, Polynomial<T, A>: Into<Polynomial<T, AA>>, Polynomial<T, Vec<T>>: Euclid, BB: MaybeList<T> + Maybe<Vec<T>>, AA: MaybeList<T> + Maybe<Vec<T>> + Clone, B::RowsMapped<BB>: MaybeLists<T> + StaticMaybe<B2>, BB2: MaybeLists<T> + Maybe<B2> + Clone, Polynomial<T, AA>: Into<Polynomial<T, Vec<T>>>, Polynomial<T, BB2::RowOwned>: Into<Polynomial<T, Vec<T>>>,

type Output = Tf<T, BB2, AA>

fn normalize(self) -> Self::Output

impl<T, B, A> One for Tf<T, B, A>

where T: ComplexFloat, Self: Mul<Output = Self> + Default, B: MaybeList<T>, A: MaybeList<T>,

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, BB> PeiTsengNotch<BB> for Tf<T, Vec<T>, Vec<T>>

where T: Float + FloatConst + DivAssign + MulAssign + Lapack, BB: List<(T, T)>,

fn pei_tseng_notch<FS>( bands: BB, sampling_frequency: FS ) -> Result<Self, PeiTsengNotchError>

where FS: Maybe<<Self::Domain as ComplexFloat>::Real>,

impl<T, B, A, I> Pow<I> for Tf<T, B, A>

where T: ComplexFloat + AddAssign, B: MaybeList<T>, A: MaybeList<T>, I: Integer + BitAnd<I, Output = I> + Shr<usize, Output = I> + Copy, Self: ToTf<T, Vec<T>, Vec<T>, (), ()> + Inv<Output: ToTf<T, Vec<T>, Vec<T>, (), ()>>, Tf<T, Vec<T>, Vec<T>>: Normalize<Output = Tf<T, Vec<T>, Vec<T>>>,

type Output = Tf<T, Vec<T>, Vec<T>>

The result after applying the operator.

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

Returns self to the power rhs.

impl<T1, B1, A1, T2, B2, A2> Product<Tf<T1, B1, A1>> for Tf<T2, B2, A2>

where T1: ComplexFloat, T2: ComplexFloat, B1: MaybeLists<T1>, A1: MaybeList<T1>, B2: MaybeLists<T2>, A2: MaybeList<T2>, Tf<T1, B1, A1>: ToTf<T2, B2, A2, (), ()>, Tf<T2, B2, A2>: Mul<Output = Tf<T2, B2, A2>> + One,

fn product<I: Iterator<Item = Tf<T1, B1, A1>>>(iter: I) -> Self

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

impl<T> QpKaiser for Tf<T, Vec<T>>

where T: Float + FloatConst + MulAssign + DivAssign + Sum + Into<Complex<T>> + 'static, Vec<T>: Conv<T, T, Vec<T>, Output = Vec<T>>, Complex<T>: AddAssign + MulAssign + MulAssign<T>,

fn qp_kaiser(num_bands: usize, attenuation: T, linear: bool) -> Self

impl<'a, T, B, A, const N: usize> RealFreqZ<'a, [Complex<T>; N], [T; N], ()> for Tf<T, B, A>

where T: Float + FloatConst, B: MaybeList<T>, A: MaybeList<T>, Complex<T>: AddAssign + MulAssign, Self: 'a, &'a Self: Into<Tf<T, Vec<T>, Vec<T>>>,

fn real_freqz(&'a self, (): ()) -> ([Complex<T>; N], [T; N])

impl<'a, T, B, A> RealFreqZ<'a, Vec<Complex<T>>, Vec<T>, usize> for Tf<T, B, A>

where T: Float + FloatConst, B: MaybeList<T>, A: MaybeList<T>, Complex<T>: AddAssign + MulAssign, Self: 'a, &'a Self: Into<Tf<T, Vec<T>, Vec<T>>>,

fn real_freqz(&'a self, n: usize) -> (Vec<Complex<T>>, Vec<T>)

impl<T, B, A, R> Residue for Tf<T, B, A>

where T: ComplexFloat<Real = R> + Lapack<Complex = Complex<R>> + 'static, R: Float + FloatConst + TotalOrder + Into<T>, B: MaybeList<T>, A: MaybeList<T>, Self: Normalize<Output: ToTf<T, Vec<T>, Vec<T>, (), ()>> + System<Domain = T>, Complex<R>: AddAssign + SubAssign + MulAssign + DivAssign + From<T> + DivAssign<R> + Div<T, Output = Complex<R>>, Polynomial<T, Vec<T>>: Euclid,

type Output = Rpk<T, Complex<R>, Complex<R>, Vec<(Complex<R>, Complex<R>)>, Vec<T>>

fn residue<TOL>(self, tol: TOL) -> Self::Output

where TOL: Maybe<R>,

impl<T, TR, B, A, R, P, RP, K> ResidueD for Tf<T, B, A>

where T: ComplexFloat<Real = TR> + ComplexOp<TR, Output = T>, TR: Float + FloatConst + Into<T>, B: MaybeList<T, Owned: MaybeOwnedList<T>>, A: MaybeList<T> + for<'a> Conv<T, T, &'a [T], Output = Vec<T>, OutputT = T> + Clone, Tf<T, B::Owned, A>: ResidueZ<Output = Rpk<T, R, P, RP, K>> + System<Domain = T>, for<'b> Tf<T, Vec<T>, A>: Filter<'b, TR, Vec<TR>, Output = Vec<T>> + System<Domain = T>, R: ComplexFloat<Real = TR>, P: ComplexFloat<Real = TR>, RP: MaybeList<(R, P)>, K: MaybeList<T>,

type Output = Rpk<T, R, P, RP, Vec<T>>

fn residued<TOL>(self, tol: TOL) -> Self::Output

where TOL: Maybe<<Self::Domain as ComplexFloat>::Real>,

impl<T, B, B2, A, A2, TR, R, P, RP, K> ResidueZ for Tf<T, B, A>

where T: ComplexFloat<Real = TR>, B: MaybeList<T>, A: MaybeList<T>, B2: MaybeOwnedList<T>, A2: MaybeOwnedList<T>, TR: Float + FloatConst, Self: Normalize<Output = Tf<T, B2, A2>> + System<Domain = T>, Tf<T, B2, A2>: Residue<Output = Rpk<T, R, P, RP, K>> + System<Domain = T>, RP: MaybeOwnedList<(R, P)>, K: MaybeOwnedList<T>, R: ComplexFloat<Real = TR> + Mul<P, Output = R>, P: ComplexFloat<Real = TR>,

type Output = Rpk<T, R, P, RP, K>

fn residuez<TOL>(self, tol: TOL) -> Self::Output

where TOL: Maybe<TR>,

impl<T, B, A> RtfOrSystem for Tf<T, B, A>

where T: ComplexFloat, B: MaybeLists<T>, A: MaybeList<T>,

type Domain = T

impl<L, T, B, N, NN> SGolay<L, N> for Tf<T, B>

where T: ComplexFloat<Real: Lapack<Real = <T as ComplexFloat>::Real> + Into<T>> + Mul<<T as ComplexFloat>::Real, Output = T> + MulAssign, Vec<T>: TryInto<B>, Vec<Tf<T, B>>: TryInto<L>, L: OwnedList<Tf<T, B>> + MaybeLenEq<B, true>, B: OwnedList<T>, <L::Length as StaticMaybe<usize>>::Opposite: MaybeAnd<usize, <B::Length as StaticMaybe<usize>>::Opposite, Output = NN>, NN: MaybeAnd<usize, N, Output = N, Opposite: Sized>, N: StaticMaybe<usize>, [(); { _ }]:,

fn sgolay<TS, M>( order: usize, numtaps: N, derivative: M, scale: TS ) -> Result<L, SGolayError>

where TS: Maybe<T>, M: Maybe<usize>,

impl<T, B, A> SplitNumerDenom for Tf<T, B, A>

where T: ComplexFloat, B: MaybeLists<T>, A: MaybeList<T>,

type OutputNum = Tf<T, B>

type OutputDen = Tf<T, (), A>

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

impl<T, B, A> Stabilize for Tf<T, B, A>

where T: ComplexFloat<Real: Into<T>> + Lapack<Complex = Complex<<T as ComplexFloat>::Real>> + 'static, B: MaybeLists<T>, A: MaybeList<T, Owned: MaybeOwnedList<T>>, Complex<<T as ComplexFloat>::Real>: ComplexFloat<Real = <T as ComplexFloat>::Real> + AddAssign + SubAssign + MulAssign + DivAssign + DivAssign<<T as ComplexFloat>::Real> + From<T> + TruncateIm, [(); { _ }]:,

type Output = Tf<T, B, <A as MaybeContainer<T>>::Owned>

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

impl<'a, 'b, T, B, A, O> Sub<&'b T> for &'a Tf<T, B, A>

where T: ComplexFloat, B: MaybeLists<T>, A: MaybeList<T>, Self: Sub<Tf<T, &'b [T; 1], ()>, Output = O>,

type Output = O

The resulting type after applying the - operator.

fn sub(self, rhs: &'b T) -> Self::Output

Performs the - operation.

impl<'b, T, B, A, O> Sub<&'b T> for Tf<T, B, A>

where T: ComplexFloat, B: MaybeLists<T>, A: MaybeList<T>, Self: Sub<Tf<T, &'b [T; 1], ()>, Output = O>,

type Output = O

The resulting type after applying the - operator.

fn sub(self, rhs: &'b T) -> Self::Output

Performs the - operation.

impl<'a, 'b, T1, B1, A1, T2, B2, A2, O> Sub<&'b Tf<T2, B2, A2>> for &'a Tf<T1, B1, A1>

where T1: ComplexFloat, T2: ComplexFloat, B1: MaybeLists<T1>, A1: MaybeList<T1>, B2: MaybeLists<T2>, A2: MaybeList<T2>, B1::View<'a>: MaybeLists<T1>, A1::View<'a>: MaybeList<T1>, B2::View<'b>: MaybeLists<T2>, A2::View<'b>: MaybeList<T2>, Tf<T1, B1::View<'a>, A1::View<'a>>: Sub<Tf<T2, B2::View<'b>, A2::View<'b>>, Output = O>,

type Output = O

The resulting type after applying the - operator.

fn sub(self, rhs: &'b Tf<T2, B2, A2>) -> Self::Output

Performs the - operation.

impl<'b, T1, B1, A1, T2, B2, A2, O> Sub<&'b Tf<T2, B2, A2>> for Tf<T1, B1, A1>

where T1: ComplexFloat, T2: ComplexFloat, B1: MaybeLists<T1>, A1: MaybeList<T1>, B2: MaybeLists<T2>, A2: MaybeList<T2>, B2::View<'b>: MaybeLists<T2>, A2::View<'b>: MaybeList<T2>, Tf<T1, B1, A1>: Sub<Tf<T2, B2::View<'b>, A2::View<'b>>, Output = O>,

type Output = O

The resulting type after applying the - operator.

fn sub(self, rhs: &'b Tf<T2, B2, A2>) -> Self::Output

Performs the - operation.

impl<'a, T, B, A, O> Sub<T> for &'a Tf<T, B, A>

where T: ComplexFloat, B: MaybeLists<T>, A: MaybeList<T>, Self: Sub<Tf<T, [T; 1], ()>, Output = O>,

type Output = O

The resulting type after applying the - operator.

fn sub(self, rhs: T) -> Self::Output

Performs the - operation.

impl<T, B, A, O> Sub<T> for Tf<T, B, A>

where T: ComplexFloat, B: MaybeLists<T>, A: MaybeList<T>, Self: Sub<Tf<T, [T; 1], ()>, Output = O>,

type Output = O

The resulting type after applying the - operator.

fn sub(self, rhs: T) -> Self::Output

Performs the - operation.

impl<'a, T1, B1, A1, T2, B2, A2, O> Sub<Tf<T2, B2, A2>> for &'a Tf<T1, B1, A1>

where T1: ComplexFloat, T2: ComplexFloat, B1: MaybeLists<T1>, A1: MaybeList<T1>, B2: MaybeLists<T2>, A2: MaybeList<T2>, B1::View<'a>: MaybeLists<T1>, A1::View<'a>: MaybeList<T1>, Tf<T1, B1::View<'a>, A1::View<'a>>: Sub<Tf<T2, B2, A2>, Output = O>,

type Output = O

The resulting type after applying the - operator.

fn sub(self, rhs: Tf<T2, B2, A2>) -> Self::Output

Performs the - operation.

impl<T1, B1, A1, T2, B2, A2, T3, B3, A3> Sub<Tf<T2, B2, A2>> for Tf<T1, B1, A1>

where T1: ComplexFloat, T2: ComplexFloat, T3: ComplexFloat, B1: MaybeLists<T1>, A1: MaybeList<T1> + Clone, B2: MaybeLists<T2>, A2: MaybeList<T2> + Clone, B3: MaybeLists<T3>, A3: MaybeList<T3>, Polynomial<T1, A1>: Mul<Polynomial<T2, A2>, Output = Polynomial<T3, A3>>, Polynomial<T1, B1>: Mul<Polynomial<T2, A2>, Output: Sub<<Polynomial<T2, B2> as Mul<Polynomial<T1, A1>>>::Output, Output = Polynomial<T3, B3>>>, Polynomial<T2, B2>: Mul<Polynomial<T1, A1>>, Tf<T3, B3, A3>: Normalize,

type Output = <Tf<T3, B3, A3> as Normalize>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: Tf<T2, B2, A2>) -> Self::Output

Performs the - operation.

impl<T1, B1, A1, T2, B2, A2> Sum<Tf<T1, B1, A1>> for Tf<T2, B2, A2>

where T1: ComplexFloat, T2: ComplexFloat, B1: MaybeLists<T1>, A1: MaybeList<T1>, B2: MaybeLists<T2>, A2: MaybeList<T2>, Tf<T1, B1, A1>: Into<Tf<T2, B2, A2>>, Tf<T2, B2, A2>: Mul<Output = Tf<T2, B2, A2>> + Zero,

fn sum<I: Iterator<Item = Tf<T1, B1, A1>>>(iter: I) -> Self

Method which takes an iterator and generates Self from the elements by “summing up” the items.

impl<T1, T2, B1, B2, A1, A2, Z, P, O> ToSos<T2, B2, A2, Vec<Tf<T2, B2, A2>>, (), O> for Tf<T1, B1, A1>

where T1: ComplexFloat, T2: ComplexFloat, B1: MaybeLists<T1, Some: NotVoid, MaybeSome: StaticMaybe<B1::Some, Maybe<[T2; 3]>: MaybeOr<[T2; 3], B2, Output = B2>> + StaticMaybe<B1::Some, Maybe<Vec<Complex<T1::Real>>> = Z>>, A1: MaybeList<T1, Some: NotVoid, MaybeSome: StaticMaybe<B1::Some, Maybe<[T2; 3]>: MaybeOr<[T2; 3], A2, Output = A2>> + StaticMaybe<A1::Some, Maybe<Vec<Complex<T1::Real>>> = P>>, B2: StaticMaybe<[T2; 3]> + MaybeOwnedList<T2>, A2: StaticMaybe<[T2; 3]> + MaybeOwnedList<T2>, O: Maybe<usize>, Z: MaybeList<Complex<T1::Real>>, P: MaybeList<Complex<T1::Real>>, Self: ToZpk<Complex<T1::Real>, Z, P, T1, (), O>, Zpk<Complex<T1::Real>, Z, P, T1>: ToSos<T2, B2, A2, Vec<Tf<T2, B2, A2>>, (), ()>,

fn to_sos(self, (): (), output: O) -> Sos<T2, B2, A2, Vec<Tf<T2, B2, A2>>>

impl<T1, T2, B, A> 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 Tf<T1, B, A>

where T1: ComplexFloat, T2: ComplexFloat + Default, B: MaybeLists<T1>, A: MaybeList<T1>, Self: ToTf<T2, Vec<Vec<T2>>, Vec<T2>, (), ()>, Tf<T2, Vec<Vec<T2>>, Vec<T2>>: Normalize<Output = Tf<T2, Vec<Vec<T2>>, Vec<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, B1, A1, T2, B2, A2> ToTf<T2, B2, A2, (), ()> for Tf<T1, B1, A1>

where T1: ComplexFloat, T2: ComplexFloat, B1: MaybeLists<T1>, A1: MaybeList<T1>, B2: MaybeLists<T2>, A2: MaybeList<T2>, Polynomial<T1, B1>: Into<Polynomial<T2, B2>>, Polynomial<T1, A1>: Into<Polynomial<T2, A2>>,

fn to_tf(self, (): (), (): ()) -> Tf<T2, B2, A2>

impl<T1, B1, A1, T2, B2, A2> ToTf<T2, B2, A2, (), usize> for Tf<T1, B1, A1>

where T1: ComplexFloat + 'static, T2: ComplexFloat, B1: MaybeLists<T1>, A1: MaybeList<T1>, B2: MaybeLists<T2>, A2: MaybeList<T2>, for<'a> Polynomial<T1, B1::RowView<'a>>: Into<Polynomial<T2, B2>>, Polynomial<T1, A1>: Into<Polynomial<T2, A2>>,

fn to_tf(self, (): (), output: usize) -> Tf<T2, B2, A2>

impl<T, K, B, B2, A, A2, Z, P, O> ToZpk<Complex<<K as ComplexFloat>::Real>, Z, P, K, (), O> for Tf<T, B, A>

where O: Maybe<usize>, T: ComplexFloat, K: ComplexFloat + DivAssign + Lapack<Complex = Complex<<K as ComplexFloat>::Real>>, B: MaybeLists<T, MaybeSome: StaticMaybe<B::Some, Maybe<Vec<Complex<<K as ComplexFloat>::Real>>>: MaybeOr<Vec<Complex<<K as ComplexFloat>::Real>>, Z, Output = Z>>>, A: MaybeList<T, MaybeSome: StaticMaybe<A::Some, Maybe<Vec<Complex<<K as ComplexFloat>::Real>>>: MaybeOr<Vec<Complex<<K as ComplexFloat>::Real>>, P, Output = P>>>, Z: MaybeList<Complex<<K as ComplexFloat>::Real>> + StaticMaybe<Vec<Complex<<K as ComplexFloat>::Real>>, Maybe<Vec<K>> = B2>, P: MaybeList<Complex<<K as ComplexFloat>::Real>> + StaticMaybe<Vec<Complex<<K as ComplexFloat>::Real>>, Maybe<Vec<K>> = A2>, Self: Normalize<Output: ToTf<K, B2, A2, (), O>>, B2: MaybeList<K> + Maybe<Vec<K>>, A2: MaybeList<K> + Maybe<Vec<K>>, Complex<<K as ComplexFloat>::Real>: From<K> + AddAssign + SubAssign + MulAssign + DivAssign + DivAssign<<K as ComplexFloat>::Real>,

fn to_zpk( self, (): (), output: O ) -> Zpk<Complex<<K as ComplexFloat>::Real>, Z, P, K>

impl<T, B, A, W, WW, Y, A2> Window<W, WW, Tf<Y, <B as MaybeLists<T>>::RowsMapped<<WW as Container<W>>::Mapped<Y>>, A2>> for Tf<T, B, A>

where T: ComplexOp<W, Output = Y>, B: MaybeLists<T>, A: MaybeList<T>, W: ComplexFloat + Into<Y>, Y: ComplexFloat, WW: List<W>, A2: MaybeList<Y>, B::RowsMapped<Vec<T>>: Lists<T, RowsMapped<WW::Mapped<Y>> = B::RowsMapped<WW::Mapped<Y>>>, B::RowsMapped<WW::Mapped<Y>>: Lists<Y>, Polynomial<Y, ()>: Into<Polynomial<Y, A2>>, Self: for<'a> ImpZ<'a, B::RowsMapped<Vec<T>>, Vec<T::Real>, usize> + System<Domain = T>,

fn window(&self, window: WW) -> Tf<Y, B::RowsMapped<WW::Mapped<Y>>, A2>

impl<T, B, A> Zero for Tf<T, B, A>

where T: ComplexFloat, B: MaybeLists<T>, A: MaybeList<T>, Polynomial<T, [T; 0]>: Into<Polynomial<T, B>>, Polynomial<T, ()>: Into<Polynomial<T, A>>, Self: Add<Output = Self>,

fn zero() -> Self

Returns the additive identity element of Self, 0.

fn is_zero(&self) -> bool

Returns true if self is equal to the additive identity.

fn set_zero(&mut self)

Sets self to the additive identity element of Self, 0.

impl<T, B, A, const W: usize> ZfTrans<W> for Tf<T, B, A>

where T: ComplexFloat + Mul<T::Real, Output = T> + Div<T::Real, Output = T> + AddAssign + DivAssign, B: MaybeLists<T>, A: MaybeList<T>, B::RowsMapped<Vec<T>>: MaybeLists<T, RowsMapped<Tf<T, Vec<T>, Vec<T>>> = B::RowsMapped<Tf<T, Vec<T>, Vec<T>>>, RowOwned = Vec<T>>, Self: ToTf<T, B::RowsMapped<Vec<T>>, Vec<T>, (), ()> + System<Domain = T>, [(); { _ }]:,

type Output = (<B as MaybeLists<T>>::RowsMapped<Tf<T, Vec<T>, Vec<T>>>, Tf<T, Vec<T>, Vec<T>>)

fn zftrans<FS>( self, wo: T::Real, w: [T::Real; W], sampling_frequency: FS, stop: bool ) -> Result<Self::Output, ZfTransError>

where FS: Maybe<T::Real>,

impl<T: Copy + ComplexFloat, B: Copy + MaybeLists<T>, A: Copy + MaybeList<T>> Copy for Tf<T, B, A>

impl<T, B, A> System for Tf<T, B, A>

where T: ComplexFloat, B: MaybeLists<T>, A: MaybeList<T>,