Trait signal_processing::operations::convolution::Deconv

pub trait Deconv<T, Rhs>: MaybeContainer<T>
where
    T: Div,
    Rhs: MaybeContainer<T>,
{
    type Q: MaybeContainer<T>;
    type R: MaybeContainer<T>;
    type Output: ListOrSingle<Option<(Self::Q, Self::R)>>;

    // Required method
    fn deconv(self, rhs: Rhs) -> Self::Output;
}

Required Associated Types

type Q: MaybeContainer<T>

type R: MaybeContainer<T>

type Output: ListOrSingle<Option<(Self::Q, Self::R)>>

Required Methods

fn deconv(self, rhs: Rhs) -> Self::Output

Object Safety

This trait is not object safe.

Implementations on Foreign Types

impl<'a, 'b, T> Deconv<T, &'b [T]> for &'a [T]

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, Vec<T>: TryInto<<&'a [T] as MaybeContainer<T>>::Owned>,

type Q = Vec<T>

type R = <&'a [T] as MaybeContainer<T>>::Owned

type Output = Option<(<&'a [T] as Deconv<T, &'b [T]>>::Q, <&'a [T] as Deconv<T, &'b [T]>>::R)>

fn deconv(self, rhs: &'b [T]) -> Self::Output

impl<'a, 'b, const M: usize, T> Deconv<T, &'b [T; M]> for &'a [T]

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, Vec<T>: TryInto<<&'a [T] as MaybeContainer<T>>::Owned>,

type Q = Vec<T>

type R = <&'a [T] as MaybeContainer<T>>::Owned

type Output = Option<(<&'a [T] as Deconv<T, &'b [T; M]>>::Q, <&'a [T] as Deconv<T, &'b [T; M]>>::R)>

fn deconv(self, rhs: &'b [T; M]) -> Self::Output

impl<'a, 'b, const N: usize, T> Deconv<T, &'b [T]> for &'a [T; N]

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, Vec<T>: TryInto<<&'a [T; N] as MaybeContainer<T>>::Owned>,

type Q = Vec<T>

type R = <&'a [T; N] as MaybeContainer<T>>::Owned

type Output = Option<(<&'a [T; N] as Deconv<T, &'b [T]>>::Q, <&'a [T; N] as Deconv<T, &'b [T]>>::R)>

fn deconv(self, rhs: &'b [T]) -> Self::Output

impl<'a, 'b, const N: usize, const M: usize, T> Deconv<T, &'b [T; M]> for &'a [T; N]

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, [(); { _ }]:,

type Q = [T; { _ }]

type R = [T; N]

type Output = Option<(<&'a [T; N] as Deconv<T, &'b [T; M]>>::Q, <&'a [T; N] as Deconv<T, &'b [T; M]>>::R)>

fn deconv(self, rhs: &'b [T; M]) -> Self::Output

impl<'a, 'c, T> Deconv<T, ()> for &'c [&'a [T]]

where T: Div + One, &'c [&'a [T]]: Deconv<T, [T; 1]>,

type Q = <&'c [&'a [T]] as Deconv<T, [T; 1]>>::Q

type R = <&'c [&'a [T]] as Deconv<T, [T; 1]>>::R

type Output = <&'c [&'a [T]] as Deconv<T, [T; 1]>>::Output

fn deconv(self, _: ()) -> Self::Output

impl<'a, 'c, const K: usize, T> Deconv<T, ()> for &'c [&'a [T]; K]

where T: Div + One, &'c [&'a [T]; K]: Deconv<T, [T; 1]>,

type Q = <&'c [&'a [T]; K] as Deconv<T, [T; 1]>>::Q

type R = <&'c [&'a [T]; K] as Deconv<T, [T; 1]>>::R

type Output = <&'c [&'a [T]; K] as Deconv<T, [T; 1]>>::Output

fn deconv(self, _: ()) -> Self::Output

impl<'a, 'c, const K: usize, const N: usize, T> Deconv<T, ()> for &'c [&'a [T; N]; K]

where T: Div + One, &'c [&'a [T; N]; K]: Deconv<T, [T; 1]>,

type Q = <&'c [&'a [T; N]; K] as Deconv<T, [T; 1]>>::Q

type R = <&'c [&'a [T; N]; K] as Deconv<T, [T; 1]>>::R

type Output = <&'c [&'a [T; N]; K] as Deconv<T, [T; 1]>>::Output

fn deconv(self, _: ()) -> Self::Output

impl<'a, 'c, const N: usize, T> Deconv<T, ()> for &'c [&'a [T; N]]

where T: Div + One, &'c [&'a [T; N]]: Deconv<T, [T; 1]>,

type Q = <&'c [&'a [T; N]] as Deconv<T, [T; 1]>>::Q

type R = <&'c [&'a [T; N]] as Deconv<T, [T; 1]>>::R

type Output = <&'c [&'a [T; N]] as Deconv<T, [T; 1]>>::Output

fn deconv(self, _: ()) -> Self::Output

impl<'a, T> Deconv<T, ()> for &'a [T]

where T: Div + One, &'a [T]: Deconv<T, [T; 1]>,

type Q = <&'a [T] as Deconv<T, [T; 1]>>::Q

type R = <&'a [T] as Deconv<T, [T; 1]>>::R

type Output = <&'a [T] as Deconv<T, [T; 1]>>::Output

fn deconv(self, _: ()) -> Self::Output

impl<'a, T> Deconv<T, ()> for Vec<&'a [T]>

where T: Div + One, Vec<&'a [T]>: Deconv<T, [T; 1]>,

type Q = <Vec<&'a [T]> as Deconv<T, [T; 1]>>::Q

type R = <Vec<&'a [T]> as Deconv<T, [T; 1]>>::R

type Output = <Vec<&'a [T]> as Deconv<T, [T; 1]>>::Output

fn deconv(self, _: ()) -> Self::Output

impl<'a, T> Deconv<T, Vec<Vec<T>>> for &'a [T]

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, Vec<T>: TryInto<<&'a [T] as MaybeContainer<T>>::Owned>,

type Q = Vec<T>

type R = <&'a [T] as MaybeContainer<T>>::Owned

type Output = Vec<Option<(<&'a [T] as Deconv<T, Vec<Vec<T>>>>::Q, <&'a [T] as Deconv<T, Vec<Vec<T>>>>::R)>>

fn deconv(self, rhs: Vec<Vec<T>>) -> Self::Output

impl<'a, T> Deconv<T, Vec<T>> for &'a [T]

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, Vec<T>: TryInto<<&'a [T] as MaybeContainer<T>>::Owned>,

type Q = Vec<T>

type R = <&'a [T] as MaybeContainer<T>>::Owned

type Output = Option<(<&'a [T] as Deconv<T, Vec<T>>>::Q, <&'a [T] as Deconv<T, Vec<T>>>::R)>

fn deconv(self, rhs: Vec<T>) -> Self::Output

impl<'a, T> Deconv<T, Vec<T>> for Vec<&'a [T]>

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, Vec<T>: TryInto<<Vec<&'a [T]> as MaybeContainer<T>>::Owned>,

type Q = Vec<T>

type R = <Vec<&'a [T]> as MaybeContainer<T>>::Owned

type Output = Vec<Option<(<Vec<&'a [T]> as Deconv<T, Vec<T>>>::Q, <Vec<&'a [T]> as Deconv<T, Vec<T>>>::R)>>

fn deconv(self, rhs: Vec<T>) -> Self::Output

impl<'a, const K: usize, T> Deconv<T, ()> for [&'a [T]; K]

where T: Div + One, [&'a [T]; K]: Deconv<T, [T; 1]>,

type Q = <[&'a [T]; K] as Deconv<T, [T; 1]>>::Q

type R = <[&'a [T]; K] as Deconv<T, [T; 1]>>::R

type Output = <[&'a [T]; K] as Deconv<T, [T; 1]>>::Output

fn deconv(self, _: ()) -> Self::Output

impl<'a, const K: usize, T> Deconv<T, Vec<T>> for [&'a [T]; K]

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, Vec<T>: TryInto<<[&'a [T]; K] as MaybeContainer<T>>::Owned>,

type Q = Vec<T>

type R = <[&'a [T]; K] as MaybeContainer<T>>::Owned

type Output = [Option<(<[&'a [T]; K] as Deconv<T, Vec<T>>>::Q, <[&'a [T]; K] as Deconv<T, Vec<T>>>::R)>; K]

fn deconv(self, rhs: Vec<T>) -> Self::Output

impl<'a, const K: usize, T> Deconv<T, [Vec<T>; K]> for &'a [T]

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, Vec<T>: TryInto<<&'a [T] as MaybeContainer<T>>::Owned>,

type Q = Vec<T>

type R = <&'a [T] as MaybeContainer<T>>::Owned

type Output = [Option<(<&'a [T] as Deconv<T, [Vec<T>; K]>>::Q, <&'a [T] as Deconv<T, [Vec<T>; K]>>::R)>; K]

fn deconv(self, rhs: [Vec<T>; K]) -> Self::Output

impl<'a, const K: usize, const M: usize, T> Deconv<T, [T; M]> for [&'a [T]; K]

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, Vec<T>: TryInto<<[&'a [T]; K] as MaybeContainer<T>>::Owned>,

type Q = Vec<T>

type R = <[&'a [T]; K] as MaybeContainer<T>>::Owned

type Output = [Option<(<[&'a [T]; K] as Deconv<T, [T; M]>>::Q, <[&'a [T]; K] as Deconv<T, [T; M]>>::R)>; K]

fn deconv(self, rhs: [T; M]) -> Self::Output

impl<'a, const K: usize, const M: usize, T> Deconv<T, [[T; M]; K]> for &'a [T]

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, Vec<T>: TryInto<<&'a [T] as MaybeContainer<T>>::Owned>,

type Q = Vec<T>

type R = <&'a [T] as MaybeContainer<T>>::Owned

type Output = [Option<(<&'a [T] as Deconv<T, [[T; M]; K]>>::Q, <&'a [T] as Deconv<T, [[T; M]; K]>>::R)>; K]

fn deconv(self, rhs: [[T; M]; K]) -> Self::Output

impl<'a, const K: usize, const N: usize, T> Deconv<T, ()> for [&'a [T; N]; K]

where T: Div + One, [&'a [T; N]; K]: Deconv<T, [T; 1]>,

type Q = <[&'a [T; N]; K] as Deconv<T, [T; 1]>>::Q

type R = <[&'a [T; N]; K] as Deconv<T, [T; 1]>>::R

type Output = <[&'a [T; N]; K] as Deconv<T, [T; 1]>>::Output

fn deconv(self, _: ()) -> Self::Output

impl<'a, const K: usize, const N: usize, T> Deconv<T, Vec<T>> for &'a [[T; N]; K]

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, Vec<T>: TryInto<<&'a [[T; N]; K] as MaybeContainer<T>>::Owned>,

type Q = Vec<T>

type R = <&'a [[T; N]; K] as MaybeContainer<T>>::Owned

type Output = [Option<(<&'a [[T; N]; K] as Deconv<T, Vec<T>>>::Q, <&'a [[T; N]; K] as Deconv<T, Vec<T>>>::R)>; K]

fn deconv(self, rhs: Vec<T>) -> Self::Output

impl<'a, const K: usize, const N: usize, T> Deconv<T, Vec<T>> for [&'a [T; N]; K]

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, Vec<T>: TryInto<<[&'a [T; N]; K] as MaybeContainer<T>>::Owned>,

type Q = Vec<T>

type R = <[&'a [T; N]; K] as MaybeContainer<T>>::Owned

type Output = [Option<(<[&'a [T; N]; K] as Deconv<T, Vec<T>>>::Q, <[&'a [T; N]; K] as Deconv<T, Vec<T>>>::R)>; K]

fn deconv(self, rhs: Vec<T>) -> Self::Output

impl<'a, const K: usize, const N: usize, T> Deconv<T, [Vec<T>; K]> for &'a [T; N]

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, Vec<T>: TryInto<<&'a [T; N] as MaybeContainer<T>>::Owned>,

type Q = Vec<T>

type R = <&'a [T; N] as MaybeContainer<T>>::Owned

type Output = [Option<(<&'a [T; N] as Deconv<T, [Vec<T>; K]>>::Q, <&'a [T; N] as Deconv<T, [Vec<T>; K]>>::R)>; K]

fn deconv(self, rhs: [Vec<T>; K]) -> Self::Output

impl<'a, const M: usize, T> Deconv<T, [T; M]> for &'a [T]

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, Vec<T>: TryInto<<&'a [T] as MaybeContainer<T>>::Owned>,

type Q = Vec<T>

type R = <&'a [T] as MaybeContainer<T>>::Owned

type Output = Option<(<&'a [T] as Deconv<T, [T; M]>>::Q, <&'a [T] as Deconv<T, [T; M]>>::R)>

fn deconv(self, rhs: [T; M]) -> Self::Output

impl<'a, const M: usize, T> Deconv<T, [T; M]> for Vec<&'a [T]>

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, Vec<T>: TryInto<<Vec<&'a [T]> as MaybeContainer<T>>::Owned>,

type Q = Vec<T>

type R = <Vec<&'a [T]> as MaybeContainer<T>>::Owned

type Output = Vec<Option<(<Vec<&'a [T]> as Deconv<T, [T; M]>>::Q, <Vec<&'a [T]> as Deconv<T, [T; M]>>::R)>>

fn deconv(self, rhs: [T; M]) -> Self::Output

impl<'a, const M: usize, T> Deconv<T, Vec<[T; M]>> for &'a [T]

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, Vec<T>: TryInto<<&'a [T] as MaybeContainer<T>>::Owned>,

type Q = Vec<T>

type R = <&'a [T] as MaybeContainer<T>>::Owned

type Output = Vec<Option<(<&'a [T] as Deconv<T, Vec<[T; M]>>>::Q, <&'a [T] as Deconv<T, Vec<[T; M]>>>::R)>>

fn deconv(self, rhs: Vec<[T; M]>) -> Self::Output

impl<'a, const N: usize, T> Deconv<T, ()> for &'a [T; N]

where T: Div + One, &'a [T; N]: Deconv<T, [T; 1]>,

type Q = <&'a [T; N] as Deconv<T, [T; 1]>>::Q

type R = <&'a [T; N] as Deconv<T, [T; 1]>>::R

type Output = <&'a [T; N] as Deconv<T, [T; 1]>>::Output

fn deconv(self, _: ()) -> Self::Output

impl<'a, const N: usize, T> Deconv<T, ()> for Vec<&'a [T; N]>

where T: Div + One, Vec<&'a [T; N]>: Deconv<T, [T; 1]>,

type Q = <Vec<&'a [T; N]> as Deconv<T, [T; 1]>>::Q

type R = <Vec<&'a [T; N]> as Deconv<T, [T; 1]>>::R

type Output = <Vec<&'a [T; N]> as Deconv<T, [T; 1]>>::Output

fn deconv(self, _: ()) -> Self::Output

impl<'a, const N: usize, T> Deconv<T, Vec<Vec<T>>> for &'a [T; N]

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, Vec<T>: TryInto<<&'a [T; N] as MaybeContainer<T>>::Owned>,

type Q = Vec<T>

type R = <&'a [T; N] as MaybeContainer<T>>::Owned

type Output = Vec<Option<(<&'a [T; N] as Deconv<T, Vec<Vec<T>>>>::Q, <&'a [T; N] as Deconv<T, Vec<Vec<T>>>>::R)>>

fn deconv(self, rhs: Vec<Vec<T>>) -> Self::Output

impl<'a, const N: usize, T> Deconv<T, Vec<T>> for &'a [T; N]

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, Vec<T>: TryInto<<&'a [T; N] as MaybeContainer<T>>::Owned>,

type Q = Vec<T>

type R = <&'a [T; N] as MaybeContainer<T>>::Owned

type Output = Option<(<&'a [T; N] as Deconv<T, Vec<T>>>::Q, <&'a [T; N] as Deconv<T, Vec<T>>>::R)>

fn deconv(self, rhs: Vec<T>) -> Self::Output

impl<'a, const N: usize, T> Deconv<T, Vec<T>> for &'a [[T; N]]

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, Vec<T>: TryInto<<&'a [[T; N]] as MaybeContainer<T>>::Owned>,

type Q = Vec<T>

type R = <&'a [[T; N]] as MaybeContainer<T>>::Owned

type Output = Vec<Option<(<&'a [[T; N]] as Deconv<T, Vec<T>>>::Q, <&'a [[T; N]] as Deconv<T, Vec<T>>>::R)>>

fn deconv(self, rhs: Vec<T>) -> Self::Output

impl<'a, const N: usize, T> Deconv<T, Vec<T>> for Vec<&'a [T; N]>

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, Vec<T>: TryInto<<Vec<&'a [T; N]> as MaybeContainer<T>>::Owned>,

type Q = Vec<T>

type R = <Vec<&'a [T; N]> as MaybeContainer<T>>::Owned

type Output = Vec<Option<(<Vec<&'a [T; N]> as Deconv<T, Vec<T>>>::Q, <Vec<&'a [T; N]> as Deconv<T, Vec<T>>>::R)>>

fn deconv(self, rhs: Vec<T>) -> Self::Output

impl<'a, const N: usize, const M: usize, T> Deconv<T, [T; M]> for &'a [T; N]

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, [(); { _ }]:,

type Q = [T; { _ }]

type R = [T; N]

type Output = Option<(<&'a [T; N] as Deconv<T, [T; M]>>::Q, <&'a [T; N] as Deconv<T, [T; M]>>::R)>

fn deconv(self, rhs: [T; M]) -> Self::Output

impl<'a, const N: usize, const M: usize, T> Deconv<T, Vec<[T; M]>> for &'a [T; N]

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, [(); { _ }]:,

type Q = [T; { _ }]

type R = [T; N]

type Output = Vec<Option<(<&'a [T; N] as Deconv<T, Vec<[T; M]>>>::Q, <&'a [T; N] as Deconv<T, Vec<[T; M]>>>::R)>>

fn deconv(self, rhs: Vec<[T; M]>) -> Self::Output

impl<'b, 'a, T> Deconv<T, &'b [T]> for Vec<&'a [T]>

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, Vec<T>: TryInto<<Vec<&'a [T]> as MaybeContainer<T>>::Owned>,

type Q = Vec<T>

type R = <Vec<&'a [T]> as MaybeContainer<T>>::Owned

type Output = Vec<Option<(<Vec<&'a [T]> as Deconv<T, &'b [T]>>::Q, <Vec<&'a [T]> as Deconv<T, &'b [T]>>::R)>>

fn deconv(self, rhs: &'b [T]) -> Self::Output

impl<'b, 'a, T> Deconv<T, Vec<&'b [T]>> for &'a [T]

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, Vec<T>: TryInto<<&'a [T] as MaybeContainer<T>>::Owned>,

type Q = Vec<T>

type R = <&'a [T] as MaybeContainer<T>>::Owned

type Output = Vec<Option<(<&'a [T] as Deconv<T, Vec<&'b [T]>>>::Q, <&'a [T] as Deconv<T, Vec<&'b [T]>>>::R)>>

fn deconv(self, rhs: Vec<&'b [T]>) -> Self::Output

impl<'b, 'a, const K: usize, T> Deconv<T, &'b [T]> for [&'a [T]; K]

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, Vec<T>: TryInto<<[&'a [T]; K] as MaybeContainer<T>>::Owned>,

type Q = Vec<T>

type R = <[&'a [T]; K] as MaybeContainer<T>>::Owned

type Output = [Option<(<[&'a [T]; K] as Deconv<T, &'b [T]>>::Q, <[&'a [T]; K] as Deconv<T, &'b [T]>>::R)>; K]

fn deconv(self, rhs: &'b [T]) -> Self::Output

impl<'b, 'a, const K: usize, T> Deconv<T, [&'b [T]; K]> for &'a [T]

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, Vec<T>: TryInto<<&'a [T] as MaybeContainer<T>>::Owned>,

type Q = Vec<T>

type R = <&'a [T] as MaybeContainer<T>>::Owned

type Output = [Option<(<&'a [T] as Deconv<T, [&'b [T]; K]>>::Q, <&'a [T] as Deconv<T, [&'b [T]; K]>>::R)>; K]

fn deconv(self, rhs: [&'b [T]; K]) -> Self::Output

impl<'b, 'a, const K: usize, const M: usize, T> Deconv<T, &'b [T; M]> for [&'a [T]; K]

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, Vec<T>: TryInto<<[&'a [T]; K] as MaybeContainer<T>>::Owned>,

type Q = Vec<T>

type R = <[&'a [T]; K] as MaybeContainer<T>>::Owned

type Output = [Option<(<[&'a [T]; K] as Deconv<T, &'b [T; M]>>::Q, <[&'a [T]; K] as Deconv<T, &'b [T; M]>>::R)>; K]

fn deconv(self, rhs: &'b [T; M]) -> Self::Output

impl<'b, 'a, const K: usize, const M: usize, T> Deconv<T, [&'b [T; M]; K]> for &'a [T]

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, Vec<T>: TryInto<<&'a [T] as MaybeContainer<T>>::Owned>,

type Q = Vec<T>

type R = <&'a [T] as MaybeContainer<T>>::Owned

type Output = [Option<(<&'a [T] as Deconv<T, [&'b [T; M]; K]>>::Q, <&'a [T] as Deconv<T, [&'b [T; M]; K]>>::R)>; K]

fn deconv(self, rhs: [&'b [T; M]; K]) -> Self::Output

impl<'b, 'a, const K: usize, const N: usize, T> Deconv<T, &'b [T]> for &'a [[T; N]; K]

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, Vec<T>: TryInto<<&'a [[T; N]; K] as MaybeContainer<T>>::Owned>,

type Q = Vec<T>

type R = <&'a [[T; N]; K] as MaybeContainer<T>>::Owned

type Output = [Option<(<&'a [[T; N]; K] as Deconv<T, &'b [T]>>::Q, <&'a [[T; N]; K] as Deconv<T, &'b [T]>>::R)>; K]

fn deconv(self, rhs: &'b [T]) -> Self::Output

impl<'b, 'a, const K: usize, const N: usize, T> Deconv<T, &'b [T]> for [&'a [T; N]; K]

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, Vec<T>: TryInto<<[&'a [T; N]; K] as MaybeContainer<T>>::Owned>,

type Q = Vec<T>

type R = <[&'a [T; N]; K] as MaybeContainer<T>>::Owned

type Output = [Option<(<[&'a [T; N]; K] as Deconv<T, &'b [T]>>::Q, <[&'a [T; N]; K] as Deconv<T, &'b [T]>>::R)>; K]

fn deconv(self, rhs: &'b [T]) -> Self::Output

impl<'b, 'a, const K: usize, const N: usize, T> Deconv<T, Vec<T>> for &'b [&'a [T; N]; K]

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, Vec<T>: TryInto<<&'b [&'a [T; N]; K] as MaybeContainer<T>>::Owned>,

type Q = Vec<T>

type R = <&'b [&'a [T; N]; K] as MaybeContainer<T>>::Owned

type Output = [Option<(<&'b [&'a [T; N]; K] as Deconv<T, Vec<T>>>::Q, <&'b [&'a [T; N]; K] as Deconv<T, Vec<T>>>::R)>; K]

fn deconv(self, rhs: Vec<T>) -> Self::Output

impl<'b, 'a, const K: usize, const N: usize, T> Deconv<T, [&'b [T]; K]> for &'a [T; N]

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, Vec<T>: TryInto<<&'a [T; N] as MaybeContainer<T>>::Owned>,

type Q = Vec<T>

type R = <&'a [T; N] as MaybeContainer<T>>::Owned

type Output = [Option<(<&'a [T; N] as Deconv<T, [&'b [T]; K]>>::Q, <&'a [T; N] as Deconv<T, [&'b [T]; K]>>::R)>; K]

fn deconv(self, rhs: [&'b [T]; K]) -> Self::Output

impl<'b, 'a, const M: usize, T> Deconv<T, &'b [T; M]> for Vec<&'a [T]>

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, Vec<T>: TryInto<<Vec<&'a [T]> as MaybeContainer<T>>::Owned>,

type Q = Vec<T>

type R = <Vec<&'a [T]> as MaybeContainer<T>>::Owned

type Output = Vec<Option<(<Vec<&'a [T]> as Deconv<T, &'b [T; M]>>::Q, <Vec<&'a [T]> as Deconv<T, &'b [T; M]>>::R)>>

fn deconv(self, rhs: &'b [T; M]) -> Self::Output

impl<'b, 'a, const M: usize, T> Deconv<T, Vec<&'b [T; M]>> for &'a [T]

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, Vec<T>: TryInto<<&'a [T] as MaybeContainer<T>>::Owned>,

type Q = Vec<T>

type R = <&'a [T] as MaybeContainer<T>>::Owned

type Output = Vec<Option<(<&'a [T] as Deconv<T, Vec<&'b [T; M]>>>::Q, <&'a [T] as Deconv<T, Vec<&'b [T; M]>>>::R)>>

fn deconv(self, rhs: Vec<&'b [T; M]>) -> Self::Output

impl<'b, 'a, const N: usize, T> Deconv<T, &'b [T]> for &'a [[T; N]]

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, Vec<T>: TryInto<<&'a [[T; N]] as MaybeContainer<T>>::Owned>,

type Q = Vec<T>

type R = <&'a [[T; N]] as MaybeContainer<T>>::Owned

type Output = Vec<Option<(<&'a [[T; N]] as Deconv<T, &'b [T]>>::Q, <&'a [[T; N]] as Deconv<T, &'b [T]>>::R)>>

fn deconv(self, rhs: &'b [T]) -> Self::Output

impl<'b, 'a, const N: usize, T> Deconv<T, &'b [T]> for Vec<&'a [T; N]>

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, Vec<T>: TryInto<<Vec<&'a [T; N]> as MaybeContainer<T>>::Owned>,

type Q = Vec<T>

type R = <Vec<&'a [T; N]> as MaybeContainer<T>>::Owned

type Output = Vec<Option<(<Vec<&'a [T; N]> as Deconv<T, &'b [T]>>::Q, <Vec<&'a [T; N]> as Deconv<T, &'b [T]>>::R)>>

fn deconv(self, rhs: &'b [T]) -> Self::Output

impl<'b, 'a, const N: usize, T> Deconv<T, Vec<&'b [T]>> for &'a [T; N]

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, Vec<T>: TryInto<<&'a [T; N] as MaybeContainer<T>>::Owned>,

type Q = Vec<T>

type R = <&'a [T; N] as MaybeContainer<T>>::Owned

type Output = Vec<Option<(<&'a [T; N] as Deconv<T, Vec<&'b [T]>>>::Q, <&'a [T; N] as Deconv<T, Vec<&'b [T]>>>::R)>>

fn deconv(self, rhs: Vec<&'b [T]>) -> Self::Output

impl<'b, 'a, const N: usize, const M: usize, T> Deconv<T, Vec<&'b [T; M]>> for &'a [T; N]

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, [(); { _ }]:,

type Q = [T; { _ }]

type R = [T; N]

type Output = Vec<Option<(<&'a [T; N] as Deconv<T, Vec<&'b [T; M]>>>::Q, <&'a [T; N] as Deconv<T, Vec<&'b [T; M]>>>::R)>>

fn deconv(self, rhs: Vec<&'b [T; M]>) -> Self::Output

impl<'b, T> Deconv<T, &'b [T]> for ()

where T: Div + One, [T; 1]: Deconv<T, &'b [T]>,

type Q = <[T; 1] as Deconv<T, &'b [T]>>::Q

type R = <[T; 1] as Deconv<T, &'b [T]>>::R

type Output = <[T; 1] as Deconv<T, &'b [T]>>::Output

fn deconv(self, rhs: &'b [T]) -> Self::Output

impl<'b, T> Deconv<T, &'b [T]> for Vec<Vec<T>>

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, Vec<T>: TryInto<<Vec<Vec<T>> as MaybeContainer<T>>::Owned>,

type Q = Vec<T>

type R = <Vec<Vec<T>> as MaybeContainer<T>>::Owned

type Output = Vec<Option<(<Vec<Vec<T>> as Deconv<T, &'b [T]>>::Q, <Vec<Vec<T>> as Deconv<T, &'b [T]>>::R)>>

fn deconv(self, rhs: &'b [T]) -> Self::Output

impl<'b, T> Deconv<T, &'b [T]> for Vec<T>

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, Vec<T>: TryInto<<Vec<T> as MaybeContainer<T>>::Owned>,

type Q = Vec<T>

type R = <Vec<T> as MaybeContainer<T>>::Owned

type Output = Option<(<Vec<T> as Deconv<T, &'b [T]>>::Q, <Vec<T> as Deconv<T, &'b [T]>>::R)>

fn deconv(self, rhs: &'b [T]) -> Self::Output

impl<'b, T> Deconv<T, Vec<&'b [T]>> for ()

where T: Div + One, [T; 1]: Deconv<T, Vec<&'b [T]>>,

type Q = <[T; 1] as Deconv<T, Vec<&'b [T]>>>::Q

type R = <[T; 1] as Deconv<T, Vec<&'b [T]>>>::R

type Output = <[T; 1] as Deconv<T, Vec<&'b [T]>>>::Output

fn deconv(self, rhs: Vec<&'b [T]>) -> Self::Output

impl<'b, T> Deconv<T, Vec<&'b [T]>> for Vec<T>

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, Vec<T>: TryInto<<Vec<T> as MaybeContainer<T>>::Owned>,

type Q = Vec<T>

type R = <Vec<T> as MaybeContainer<T>>::Owned

type Output = Vec<Option<(<Vec<T> as Deconv<T, Vec<&'b [T]>>>::Q, <Vec<T> as Deconv<T, Vec<&'b [T]>>>::R)>>

fn deconv(self, rhs: Vec<&'b [T]>) -> Self::Output

impl<'b, const K: usize, T> Deconv<T, &'b [T]> for [Vec<T>; K]

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, Vec<T>: TryInto<<[Vec<T>; K] as MaybeContainer<T>>::Owned>,

type Q = Vec<T>

type R = <[Vec<T>; K] as MaybeContainer<T>>::Owned

type Output = [Option<(<[Vec<T>; K] as Deconv<T, &'b [T]>>::Q, <[Vec<T>; K] as Deconv<T, &'b [T]>>::R)>; K]

fn deconv(self, rhs: &'b [T]) -> Self::Output

impl<'b, const K: usize, T> Deconv<T, [&'b [T]; K]> for ()

where T: Div + One, [T; 1]: Deconv<T, [&'b [T]; K]>,

type Q = <[T; 1] as Deconv<T, [&'b [T]; K]>>::Q

type R = <[T; 1] as Deconv<T, [&'b [T]; K]>>::R

type Output = <[T; 1] as Deconv<T, [&'b [T]; K]>>::Output

fn deconv(self, rhs: [&'b [T]; K]) -> Self::Output

impl<'b, const K: usize, T> Deconv<T, [&'b [T]; K]> for Vec<T>

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, Vec<T>: TryInto<<Vec<T> as MaybeContainer<T>>::Owned>,

type Q = Vec<T>

type R = <Vec<T> as MaybeContainer<T>>::Owned

type Output = [Option<(<Vec<T> as Deconv<T, [&'b [T]; K]>>::Q, <Vec<T> as Deconv<T, [&'b [T]; K]>>::R)>; K]

fn deconv(self, rhs: [&'b [T]; K]) -> Self::Output

impl<'b, const K: usize, const M: usize, T> Deconv<T, &'b [T; M]> for [Vec<T>; K]

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, Vec<T>: TryInto<<[Vec<T>; K] as MaybeContainer<T>>::Owned>,

type Q = Vec<T>

type R = <[Vec<T>; K] as MaybeContainer<T>>::Owned

type Output = [Option<(<[Vec<T>; K] as Deconv<T, &'b [T; M]>>::Q, <[Vec<T>; K] as Deconv<T, &'b [T; M]>>::R)>; K]

fn deconv(self, rhs: &'b [T; M]) -> Self::Output

impl<'b, const K: usize, const M: usize, T> Deconv<T, [&'b [T; M]; K]> for ()

where T: Div + One, [T; 1]: Deconv<T, [&'b [T; M]; K]>,

type Q = <[T; 1] as Deconv<T, [&'b [T; M]; K]>>::Q

type R = <[T; 1] as Deconv<T, [&'b [T; M]; K]>>::R

type Output = <[T; 1] as Deconv<T, [&'b [T; M]; K]>>::Output

fn deconv(self, rhs: [&'b [T; M]; K]) -> Self::Output

impl<'b, const K: usize, const M: usize, T> Deconv<T, [&'b [T; M]; K]> for Vec<T>

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, Vec<T>: TryInto<<Vec<T> as MaybeContainer<T>>::Owned>,

type Q = Vec<T>

type R = <Vec<T> as MaybeContainer<T>>::Owned

type Output = [Option<(<Vec<T> as Deconv<T, [&'b [T; M]; K]>>::Q, <Vec<T> as Deconv<T, [&'b [T; M]; K]>>::R)>; K]

fn deconv(self, rhs: [&'b [T; M]; K]) -> Self::Output

impl<'b, const K: usize, const N: usize, T> Deconv<T, &'b [T]> for [[T; N]; K]

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, Vec<T>: TryInto<<[[T; N]; K] as MaybeContainer<T>>::Owned>,

type Q = Vec<T>

type R = <[[T; N]; K] as MaybeContainer<T>>::Owned

type Output = [Option<(<[[T; N]; K] as Deconv<T, &'b [T]>>::Q, <[[T; N]; K] as Deconv<T, &'b [T]>>::R)>; K]

fn deconv(self, rhs: &'b [T]) -> Self::Output

impl<'b, const K: usize, const N: usize, T> Deconv<T, [&'b [T]; K]> for [T; N]

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, Vec<T>: TryInto<<[T; N] as MaybeContainer<T>>::Owned>,

type Q = Vec<T>

type R = <[T; N] as MaybeContainer<T>>::Owned

type Output = [Option<(<[T; N] as Deconv<T, [&'b [T]; K]>>::Q, <[T; N] as Deconv<T, [&'b [T]; K]>>::R)>; K]

fn deconv(self, rhs: [&'b [T]; K]) -> Self::Output

impl<'b, const K: usize, const N: usize, const M: usize, T> Deconv<T, &'b [T; M]> for &[&[T; N]; K]

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, [(); { _ }]:,

type Q = [T; { _ }]

type R = [T; N]

type Output = [Option<(<&[&[T; N]; K] as Deconv<T, &'b [T; M]>>::Q, <&[&[T; N]; K] as Deconv<T, &'b [T; M]>>::R)>; K]

fn deconv(self, rhs: &'b [T; M]) -> Self::Output

impl<'b, const K: usize, const N: usize, const M: usize, T> Deconv<T, &'b [T; M]> for &[[T; N]; K]

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, [(); { _ }]:,

type Q = [T; { _ }]

type R = [T; N]

type Output = [Option<(<&[[T; N]; K] as Deconv<T, &'b [T; M]>>::Q, <&[[T; N]; K] as Deconv<T, &'b [T; M]>>::R)>; K]

fn deconv(self, rhs: &'b [T; M]) -> Self::Output

impl<'b, const K: usize, const N: usize, const M: usize, T> Deconv<T, &'b [T; M]> for [&[T; N]; K]

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, [(); { _ }]:,

type Q = [T; { _ }]

type R = [T; N]

type Output = [Option<(<[&[T; N]; K] as Deconv<T, &'b [T; M]>>::Q, <[&[T; N]; K] as Deconv<T, &'b [T; M]>>::R)>; K]

fn deconv(self, rhs: &'b [T; M]) -> Self::Output

impl<'b, const K: usize, const N: usize, const M: usize, T> Deconv<T, &'b [T; M]> for [[T; N]; K]

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, [(); { _ }]:,

type Q = [T; { _ }]

type R = [T; N]

type Output = [Option<(<[[T; N]; K] as Deconv<T, &'b [T; M]>>::Q, <[[T; N]; K] as Deconv<T, &'b [T; M]>>::R)>; K]

fn deconv(self, rhs: &'b [T; M]) -> Self::Output

impl<'b, const K: usize, const N: usize, const M: usize, T> Deconv<T, [&'b [T; M]; K]> for &[T; N]

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, [(); { _ }]:,

type Q = [T; { _ }]

type R = [T; N]

type Output = [Option<(<&[T; N] as Deconv<T, [&'b [T; M]; K]>>::Q, <&[T; N] as Deconv<T, [&'b [T; M]; K]>>::R)>; K]

fn deconv(self, rhs: [&'b [T; M]; K]) -> Self::Output

impl<'b, const K: usize, const N: usize, const M: usize, T> Deconv<T, [&'b [T; M]; K]> for [T; N]

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, [(); { _ }]:,

type Q = [T; { _ }]

type R = [T; N]

type Output = [Option<(<[T; N] as Deconv<T, [&'b [T; M]; K]>>::Q, <[T; N] as Deconv<T, [&'b [T; M]; K]>>::R)>; K]

fn deconv(self, rhs: [&'b [T; M]; K]) -> Self::Output

impl<'b, const M: usize, T> Deconv<T, &'b [T; M]> for ()

where T: Div + One, [T; 1]: Deconv<T, &'b [T; M]>,

type Q = <[T; 1] as Deconv<T, &'b [T; M]>>::Q

type R = <[T; 1] as Deconv<T, &'b [T; M]>>::R

type Output = <[T; 1] as Deconv<T, &'b [T; M]>>::Output

fn deconv(self, rhs: &'b [T; M]) -> Self::Output

impl<'b, const M: usize, T> Deconv<T, &'b [T; M]> for Vec<Vec<T>>

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, Vec<T>: TryInto<<Vec<Vec<T>> as MaybeContainer<T>>::Owned>,

type Q = Vec<T>

type R = <Vec<Vec<T>> as MaybeContainer<T>>::Owned

type Output = Vec<Option<(<Vec<Vec<T>> as Deconv<T, &'b [T; M]>>::Q, <Vec<Vec<T>> as Deconv<T, &'b [T; M]>>::R)>>

fn deconv(self, rhs: &'b [T; M]) -> Self::Output

impl<'b, const M: usize, T> Deconv<T, &'b [T; M]> for Vec<T>

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, Vec<T>: TryInto<<Vec<T> as MaybeContainer<T>>::Owned>,

type Q = Vec<T>

type R = <Vec<T> as MaybeContainer<T>>::Owned

type Output = Option<(<Vec<T> as Deconv<T, &'b [T; M]>>::Q, <Vec<T> as Deconv<T, &'b [T; M]>>::R)>

fn deconv(self, rhs: &'b [T; M]) -> Self::Output

impl<'b, const M: usize, T> Deconv<T, Vec<&'b [T; M]>> for ()

where T: Div + One, [T; 1]: Deconv<T, Vec<&'b [T; M]>>,

type Q = <[T; 1] as Deconv<T, Vec<&'b [T; M]>>>::Q

type R = <[T; 1] as Deconv<T, Vec<&'b [T; M]>>>::R

type Output = <[T; 1] as Deconv<T, Vec<&'b [T; M]>>>::Output

fn deconv(self, rhs: Vec<&'b [T; M]>) -> Self::Output

impl<'b, const M: usize, T> Deconv<T, Vec<&'b [T; M]>> for Vec<T>

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, Vec<T>: TryInto<<Vec<T> as MaybeContainer<T>>::Owned>,

type Q = Vec<T>

type R = <Vec<T> as MaybeContainer<T>>::Owned

type Output = Vec<Option<(<Vec<T> as Deconv<T, Vec<&'b [T; M]>>>::Q, <Vec<T> as Deconv<T, Vec<&'b [T; M]>>>::R)>>

fn deconv(self, rhs: Vec<&'b [T; M]>) -> Self::Output

impl<'b, const N: usize, T> Deconv<T, &'b [T]> for [T; N]

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, Vec<T>: TryInto<<[T; N] as MaybeContainer<T>>::Owned>,

type Q = Vec<T>

type R = <[T; N] as MaybeContainer<T>>::Owned

type Output = Option<(<[T; N] as Deconv<T, &'b [T]>>::Q, <[T; N] as Deconv<T, &'b [T]>>::R)>

fn deconv(self, rhs: &'b [T]) -> Self::Output

impl<'b, const N: usize, T> Deconv<T, &'b [T]> for Vec<[T; N]>

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, Vec<T>: TryInto<<Vec<[T; N]> as MaybeContainer<T>>::Owned>,

type Q = Vec<T>

type R = <Vec<[T; N]> as MaybeContainer<T>>::Owned

type Output = Vec<Option<(<Vec<[T; N]> as Deconv<T, &'b [T]>>::Q, <Vec<[T; N]> as Deconv<T, &'b [T]>>::R)>>

fn deconv(self, rhs: &'b [T]) -> Self::Output

impl<'b, const N: usize, T> Deconv<T, Vec<&'b [T]>> for [T; N]

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, Vec<T>: TryInto<<[T; N] as MaybeContainer<T>>::Owned>,

type Q = Vec<T>

type R = <[T; N] as MaybeContainer<T>>::Owned

type Output = Vec<Option<(<[T; N] as Deconv<T, Vec<&'b [T]>>>::Q, <[T; N] as Deconv<T, Vec<&'b [T]>>>::R)>>

fn deconv(self, rhs: Vec<&'b [T]>) -> Self::Output

impl<'b, const N: usize, const M: usize, T> Deconv<T, &'b [T; M]> for &[&[T; N]]

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, [(); { _ }]:,

type Q = [T; { _ }]

type R = [T; N]

type Output = Vec<Option<(<&[&[T; N]] as Deconv<T, &'b [T; M]>>::Q, <&[&[T; N]] as Deconv<T, &'b [T; M]>>::R)>>

fn deconv(self, rhs: &'b [T; M]) -> Self::Output

impl<'b, const N: usize, const M: usize, T> Deconv<T, &'b [T; M]> for &[[T; N]]

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, [(); { _ }]:,

type Q = [T; { _ }]

type R = [T; N]

type Output = Vec<Option<(<&[[T; N]] as Deconv<T, &'b [T; M]>>::Q, <&[[T; N]] as Deconv<T, &'b [T; M]>>::R)>>

fn deconv(self, rhs: &'b [T; M]) -> Self::Output

impl<'b, const N: usize, const M: usize, T> Deconv<T, &'b [T; M]> for [T; N]

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, [(); { _ }]:,

type Q = [T; { _ }]

type R = [T; N]

type Output = Option<(<[T; N] as Deconv<T, &'b [T; M]>>::Q, <[T; N] as Deconv<T, &'b [T; M]>>::R)>

fn deconv(self, rhs: &'b [T; M]) -> Self::Output

impl<'b, const N: usize, const M: usize, T> Deconv<T, &'b [T; M]> for Vec<&[T; N]>

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, [(); { _ }]:,

type Q = [T; { _ }]

type R = [T; N]

type Output = Vec<Option<(<Vec<&[T; N]> as Deconv<T, &'b [T; M]>>::Q, <Vec<&[T; N]> as Deconv<T, &'b [T; M]>>::R)>>

fn deconv(self, rhs: &'b [T; M]) -> Self::Output

impl<'b, const N: usize, const M: usize, T> Deconv<T, &'b [T; M]> for Vec<[T; N]>

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, [(); { _ }]:,

type Q = [T; { _ }]

type R = [T; N]

type Output = Vec<Option<(<Vec<[T; N]> as Deconv<T, &'b [T; M]>>::Q, <Vec<[T; N]> as Deconv<T, &'b [T; M]>>::R)>>

fn deconv(self, rhs: &'b [T; M]) -> Self::Output

impl<'b, const N: usize, const M: usize, T> Deconv<T, Vec<&'b [T; M]>> for [T; N]

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, [(); { _ }]:,

type Q = [T; { _ }]

type R = [T; N]

type Output = Vec<Option<(<[T; N] as Deconv<T, Vec<&'b [T; M]>>>::Q, <[T; N] as Deconv<T, Vec<&'b [T; M]>>>::R)>>

fn deconv(self, rhs: Vec<&'b [T; M]>) -> Self::Output

impl<'c, 'a, T> Deconv<T, &'c [Vec<T>]> for &'a [T]

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, Vec<T>: TryInto<<&'a [T] as MaybeContainer<T>>::Owned>,

type Q = Vec<T>

type R = <&'a [T] as MaybeContainer<T>>::Owned

type Output = Vec<Option<(<&'a [T] as Deconv<T, &'c [Vec<T>]>>::Q, <&'a [T] as Deconv<T, &'c [Vec<T>]>>::R)>>

fn deconv(self, rhs: &'c [Vec<T>]) -> Self::Output

impl<'c, 'a, T> Deconv<T, Vec<T>> for &'c [&'a [T]]

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, Vec<T>: TryInto<<&'c [&'a [T]] as MaybeContainer<T>>::Owned>,

type Q = Vec<T>

type R = <&'c [&'a [T]] as MaybeContainer<T>>::Owned

type Output = Vec<Option<(<&'c [&'a [T]] as Deconv<T, Vec<T>>>::Q, <&'c [&'a [T]] as Deconv<T, Vec<T>>>::R)>>

fn deconv(self, rhs: Vec<T>) -> Self::Output

impl<'c, 'a, const K: usize, T> Deconv<T, &'c [Vec<T>; K]> for &'a [T]

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, Vec<T>: TryInto<<&'a [T] as MaybeContainer<T>>::Owned>,

type Q = Vec<T>

type R = <&'a [T] as MaybeContainer<T>>::Owned

type Output = [Option<(<&'a [T] as Deconv<T, &'c [Vec<T>; K]>>::Q, <&'a [T] as Deconv<T, &'c [Vec<T>; K]>>::R)>; K]

fn deconv(self, rhs: &'c [Vec<T>; K]) -> Self::Output

impl<'c, 'a, const K: usize, T> Deconv<T, Vec<T>> for &'c [&'a [T]; K]

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, Vec<T>: TryInto<<&'c [&'a [T]; K] as MaybeContainer<T>>::Owned>,

type Q = Vec<T>

type R = <&'c [&'a [T]; K] as MaybeContainer<T>>::Owned

type Output = [Option<(<&'c [&'a [T]; K] as Deconv<T, Vec<T>>>::Q, <&'c [&'a [T]; K] as Deconv<T, Vec<T>>>::R)>; K]

fn deconv(self, rhs: Vec<T>) -> Self::Output

impl<'c, 'a, const K: usize, const M: usize, T> Deconv<T, &'c [[T; M]; K]> for &'a [T]

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, Vec<T>: TryInto<<&'a [T] as MaybeContainer<T>>::Owned>,

type Q = Vec<T>

type R = <&'a [T] as MaybeContainer<T>>::Owned

type Output = [Option<(<&'a [T] as Deconv<T, &'c [[T; M]; K]>>::Q, <&'a [T] as Deconv<T, &'c [[T; M]; K]>>::R)>; K]

fn deconv(self, rhs: &'c [[T; M]; K]) -> Self::Output

impl<'c, 'a, const K: usize, const M: usize, T> Deconv<T, [T; M]> for &'c [&'a [T]; K]

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, Vec<T>: TryInto<<&'c [&'a [T]; K] as MaybeContainer<T>>::Owned>,

type Q = Vec<T>

type R = <&'c [&'a [T]; K] as MaybeContainer<T>>::Owned

type Output = [Option<(<&'c [&'a [T]; K] as Deconv<T, [T; M]>>::Q, <&'c [&'a [T]; K] as Deconv<T, [T; M]>>::R)>; K]

fn deconv(self, rhs: [T; M]) -> Self::Output

impl<'c, 'a, const K: usize, const N: usize, T> Deconv<T, &'c [Vec<T>; K]> for &'a [T; N]

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, Vec<T>: TryInto<<&'a [T; N] as MaybeContainer<T>>::Owned>,

type Q = Vec<T>

type R = <&'a [T; N] as MaybeContainer<T>>::Owned

type Output = [Option<(<&'a [T; N] as Deconv<T, &'c [Vec<T>; K]>>::Q, <&'a [T; N] as Deconv<T, &'c [Vec<T>; K]>>::R)>; K]

fn deconv(self, rhs: &'c [Vec<T>; K]) -> Self::Output

impl<'c, 'a, const K: usize, const N: usize, const M: usize, T> Deconv<T, &'c [[T; M]; K]> for &'a [T; N]

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, [(); { _ }]:,

type Q = [T; { _ }]

type R = [T; N]

type Output = [Option<(<&'a [T; N] as Deconv<T, &'c [[T; M]; K]>>::Q, <&'a [T; N] as Deconv<T, &'c [[T; M]; K]>>::R)>; K]

fn deconv(self, rhs: &'c [[T; M]; K]) -> Self::Output

impl<'c, 'a, const M: usize, T> Deconv<T, &'c [[T; M]]> for &'a [T]

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, Vec<T>: TryInto<<&'a [T] as MaybeContainer<T>>::Owned>,

type Q = Vec<T>

type R = <&'a [T] as MaybeContainer<T>>::Owned

type Output = Vec<Option<(<&'a [T] as Deconv<T, &'c [[T; M]]>>::Q, <&'a [T] as Deconv<T, &'c [[T; M]]>>::R)>>

fn deconv(self, rhs: &'c [[T; M]]) -> Self::Output

impl<'c, 'a, const M: usize, T> Deconv<T, [T; M]> for &'c [&'a [T]]

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, Vec<T>: TryInto<<&'c [&'a [T]] as MaybeContainer<T>>::Owned>,

type Q = Vec<T>

type R = <&'c [&'a [T]] as MaybeContainer<T>>::Owned

type Output = Vec<Option<(<&'c [&'a [T]] as Deconv<T, [T; M]>>::Q, <&'c [&'a [T]] as Deconv<T, [T; M]>>::R)>>

fn deconv(self, rhs: [T; M]) -> Self::Output

impl<'c, 'a, const N: usize, T> Deconv<T, &'c [Vec<T>]> for &'a [T; N]

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, Vec<T>: TryInto<<&'a [T; N] as MaybeContainer<T>>::Owned>,

type Q = Vec<T>

type R = <&'a [T; N] as MaybeContainer<T>>::Owned

type Output = Vec<Option<(<&'a [T; N] as Deconv<T, &'c [Vec<T>]>>::Q, <&'a [T; N] as Deconv<T, &'c [Vec<T>]>>::R)>>

fn deconv(self, rhs: &'c [Vec<T>]) -> Self::Output

impl<'c, 'a, const N: usize, T> Deconv<T, Vec<T>> for &'c [&'a [T; N]]

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, Vec<T>: TryInto<<&'c [&'a [T; N]] as MaybeContainer<T>>::Owned>,

type Q = Vec<T>

type R = <&'c [&'a [T; N]] as MaybeContainer<T>>::Owned

type Output = Vec<Option<(<&'c [&'a [T; N]] as Deconv<T, Vec<T>>>::Q, <&'c [&'a [T; N]] as Deconv<T, Vec<T>>>::R)>>

fn deconv(self, rhs: Vec<T>) -> Self::Output

impl<'c, 'a, const N: usize, const M: usize, T> Deconv<T, &'c [[T; M]]> for &'a [T; N]

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, [(); { _ }]:,

type Q = [T; { _ }]

type R = [T; N]

type Output = Vec<Option<(<&'a [T; N] as Deconv<T, &'c [[T; M]]>>::Q, <&'a [T; N] as Deconv<T, &'c [[T; M]]>>::R)>>

fn deconv(self, rhs: &'c [[T; M]]) -> Self::Output

impl<'c, 'b, 'a, T> Deconv<T, &'b [T]> for &'c [&'a [T]]

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, Vec<T>: TryInto<<&'c [&'a [T]] as MaybeContainer<T>>::Owned>,

type Q = Vec<T>

type R = <&'c [&'a [T]] as MaybeContainer<T>>::Owned

type Output = Vec<Option<(<&'c [&'a [T]] as Deconv<T, &'b [T]>>::Q, <&'c [&'a [T]] as Deconv<T, &'b [T]>>::R)>>

fn deconv(self, rhs: &'b [T]) -> Self::Output

impl<'c, 'b, 'a, T> Deconv<T, &'c [&'b [T]]> for &'a [T]

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, Vec<T>: TryInto<<&'a [T] as MaybeContainer<T>>::Owned>,

type Q = Vec<T>

type R = <&'a [T] as MaybeContainer<T>>::Owned

type Output = Vec<Option<(<&'a [T] as Deconv<T, &'c [&'b [T]]>>::Q, <&'a [T] as Deconv<T, &'c [&'b [T]]>>::R)>>

fn deconv(self, rhs: &'c [&'b [T]]) -> Self::Output

impl<'c, 'b, 'a, const K: usize, T> Deconv<T, &'b [T]> for &'c [&'a [T]; K]

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, Vec<T>: TryInto<<&'c [&'a [T]; K] as MaybeContainer<T>>::Owned>,

type Q = Vec<T>

type R = <&'c [&'a [T]; K] as MaybeContainer<T>>::Owned

type Output = [Option<(<&'c [&'a [T]; K] as Deconv<T, &'b [T]>>::Q, <&'c [&'a [T]; K] as Deconv<T, &'b [T]>>::R)>; K]

fn deconv(self, rhs: &'b [T]) -> Self::Output

impl<'c, 'b, 'a, const K: usize, T> Deconv<T, &'c [&'b [T]; K]> for &'a [T]

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, Vec<T>: TryInto<<&'a [T] as MaybeContainer<T>>::Owned>,

type Q = Vec<T>

type R = <&'a [T] as MaybeContainer<T>>::Owned

type Output = [Option<(<&'a [T] as Deconv<T, &'c [&'b [T]; K]>>::Q, <&'a [T] as Deconv<T, &'c [&'b [T]; K]>>::R)>; K]

fn deconv(self, rhs: &'c [&'b [T]; K]) -> Self::Output

impl<'c, 'b, 'a, const K: usize, const M: usize, T> Deconv<T, &'b [T; M]> for &'c [&'a [T]; K]

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, Vec<T>: TryInto<<&'c [&'a [T]; K] as MaybeContainer<T>>::Owned>,

type Q = Vec<T>

type R = <&'c [&'a [T]; K] as MaybeContainer<T>>::Owned

type Output = [Option<(<&'c [&'a [T]; K] as Deconv<T, &'b [T; M]>>::Q, <&'c [&'a [T]; K] as Deconv<T, &'b [T; M]>>::R)>; K]

fn deconv(self, rhs: &'b [T; M]) -> Self::Output

impl<'c, 'b, 'a, const K: usize, const M: usize, T> Deconv<T, &'c [&'b [T; M]; K]> for &'a [T]

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, Vec<T>: TryInto<<&'a [T] as MaybeContainer<T>>::Owned>,

type Q = Vec<T>

type R = <&'a [T] as MaybeContainer<T>>::Owned

type Output = [Option<(<&'a [T] as Deconv<T, &'c [&'b [T; M]; K]>>::Q, <&'a [T] as Deconv<T, &'c [&'b [T; M]; K]>>::R)>; K]

fn deconv(self, rhs: &'c [&'b [T; M]; K]) -> Self::Output

impl<'c, 'b, 'a, const K: usize, const N: usize, T> Deconv<T, &'b [T]> for &'c [&'a [T; N]; K]

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, Vec<T>: TryInto<<&'c [&'a [T; N]; K] as MaybeContainer<T>>::Owned>,

type Q = Vec<T>

type R = <&'c [&'a [T; N]; K] as MaybeContainer<T>>::Owned

type Output = [Option<(<&'c [&'a [T; N]; K] as Deconv<T, &'b [T]>>::Q, <&'c [&'a [T; N]; K] as Deconv<T, &'b [T]>>::R)>; K]

fn deconv(self, rhs: &'b [T]) -> Self::Output

impl<'c, 'b, 'a, const K: usize, const N: usize, T> Deconv<T, &'c [&'b [T]; K]> for &'a [T; N]

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, Vec<T>: TryInto<<&'a [T; N] as MaybeContainer<T>>::Owned>,

type Q = Vec<T>

type R = <&'a [T; N] as MaybeContainer<T>>::Owned

type Output = [Option<(<&'a [T; N] as Deconv<T, &'c [&'b [T]; K]>>::Q, <&'a [T; N] as Deconv<T, &'c [&'b [T]; K]>>::R)>; K]

fn deconv(self, rhs: &'c [&'b [T]; K]) -> Self::Output

impl<'c, 'b, 'a, const K: usize, const N: usize, const M: usize, T> Deconv<T, &'c [&'b [T; M]; K]> for &'a [T; N]

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, [(); { _ }]:,

type Q = [T; { _ }]

type R = [T; N]

type Output = [Option<(<&'a [T; N] as Deconv<T, &'c [&'b [T; M]; K]>>::Q, <&'a [T; N] as Deconv<T, &'c [&'b [T; M]; K]>>::R)>; K]

fn deconv(self, rhs: &'c [&'b [T; M]; K]) -> Self::Output

impl<'c, 'b, 'a, const M: usize, T> Deconv<T, &'b [T; M]> for &'c [&'a [T]]

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, Vec<T>: TryInto<<&'c [&'a [T]] as MaybeContainer<T>>::Owned>,

type Q = Vec<T>

type R = <&'c [&'a [T]] as MaybeContainer<T>>::Owned

type Output = Vec<Option<(<&'c [&'a [T]] as Deconv<T, &'b [T; M]>>::Q, <&'c [&'a [T]] as Deconv<T, &'b [T; M]>>::R)>>

fn deconv(self, rhs: &'b [T; M]) -> Self::Output

impl<'c, 'b, 'a, const M: usize, T> Deconv<T, &'c [&'b [T; M]]> for &'a [T]

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, Vec<T>: TryInto<<&'a [T] as MaybeContainer<T>>::Owned>,

type Q = Vec<T>

type R = <&'a [T] as MaybeContainer<T>>::Owned

type Output = Vec<Option<(<&'a [T] as Deconv<T, &'c [&'b [T; M]]>>::Q, <&'a [T] as Deconv<T, &'c [&'b [T; M]]>>::R)>>

fn deconv(self, rhs: &'c [&'b [T; M]]) -> Self::Output

impl<'c, 'b, 'a, const N: usize, T> Deconv<T, &'b [T]> for &'c [&'a [T; N]]

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, Vec<T>: TryInto<<&'c [&'a [T; N]] as MaybeContainer<T>>::Owned>,

type Q = Vec<T>

type R = <&'c [&'a [T; N]] as MaybeContainer<T>>::Owned

type Output = Vec<Option<(<&'c [&'a [T; N]] as Deconv<T, &'b [T]>>::Q, <&'c [&'a [T; N]] as Deconv<T, &'b [T]>>::R)>>

fn deconv(self, rhs: &'b [T]) -> Self::Output

impl<'c, 'b, 'a, const N: usize, T> Deconv<T, &'c [&'b [T]]> for &'a [T; N]

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, Vec<T>: TryInto<<&'a [T; N] as MaybeContainer<T>>::Owned>,

type Q = Vec<T>

type R = <&'a [T; N] as MaybeContainer<T>>::Owned

type Output = Vec<Option<(<&'a [T; N] as Deconv<T, &'c [&'b [T]]>>::Q, <&'a [T; N] as Deconv<T, &'c [&'b [T]]>>::R)>>

fn deconv(self, rhs: &'c [&'b [T]]) -> Self::Output

impl<'c, 'b, 'a, const N: usize, const M: usize, T> Deconv<T, &'c [&'b [T; M]]> for &'a [T; N]

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, [(); { _ }]:,

type Q = [T; { _ }]

type R = [T; N]

type Output = Vec<Option<(<&'a [T; N] as Deconv<T, &'c [&'b [T; M]]>>::Q, <&'a [T; N] as Deconv<T, &'c [&'b [T; M]]>>::R)>>

fn deconv(self, rhs: &'c [&'b [T; M]]) -> Self::Output

impl<'c, 'b, T> Deconv<T, &'b [T]> for &'c [Vec<T>]

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, Vec<T>: TryInto<<&'c [Vec<T>] as MaybeContainer<T>>::Owned>,

type Q = Vec<T>

type R = <&'c [Vec<T>] as MaybeContainer<T>>::Owned

type Output = Vec<Option<(<&'c [Vec<T>] as Deconv<T, &'b [T]>>::Q, <&'c [Vec<T>] as Deconv<T, &'b [T]>>::R)>>

fn deconv(self, rhs: &'b [T]) -> Self::Output

impl<'c, 'b, T> Deconv<T, &'c [&'b [T]]> for ()

where T: Div + One, [T; 1]: Deconv<T, &'c [&'b [T]]>,

type Q = <[T; 1] as Deconv<T, &'c [&'b [T]]>>::Q

type R = <[T; 1] as Deconv<T, &'c [&'b [T]]>>::R

type Output = <[T; 1] as Deconv<T, &'c [&'b [T]]>>::Output

fn deconv(self, rhs: &'c [&'b [T]]) -> Self::Output

impl<'c, 'b, T> Deconv<T, &'c [&'b [T]]> for Vec<T>

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, Vec<T>: TryInto<<Vec<T> as MaybeContainer<T>>::Owned>,

type Q = Vec<T>

type R = <Vec<T> as MaybeContainer<T>>::Owned

type Output = Vec<Option<(<Vec<T> as Deconv<T, &'c [&'b [T]]>>::Q, <Vec<T> as Deconv<T, &'c [&'b [T]]>>::R)>>

fn deconv(self, rhs: &'c [&'b [T]]) -> Self::Output

impl<'c, 'b, const K: usize, T> Deconv<T, &'b [T]> for &'c [Vec<T>; K]

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, Vec<T>: TryInto<<&'c [Vec<T>; K] as MaybeContainer<T>>::Owned>,

type Q = Vec<T>

type R = <&'c [Vec<T>; K] as MaybeContainer<T>>::Owned

type Output = [Option<(<&'c [Vec<T>; K] as Deconv<T, &'b [T]>>::Q, <&'c [Vec<T>; K] as Deconv<T, &'b [T]>>::R)>; K]

fn deconv(self, rhs: &'b [T]) -> Self::Output

impl<'c, 'b, const K: usize, T> Deconv<T, &'c [&'b [T]; K]> for ()

where T: Div + One, [T; 1]: Deconv<T, &'c [&'b [T]; K]>,

type Q = <[T; 1] as Deconv<T, &'c [&'b [T]; K]>>::Q

type R = <[T; 1] as Deconv<T, &'c [&'b [T]; K]>>::R

type Output = <[T; 1] as Deconv<T, &'c [&'b [T]; K]>>::Output

fn deconv(self, rhs: &'c [&'b [T]; K]) -> Self::Output

impl<'c, 'b, const K: usize, T> Deconv<T, &'c [&'b [T]; K]> for Vec<T>

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, Vec<T>: TryInto<<Vec<T> as MaybeContainer<T>>::Owned>,

type Q = Vec<T>

type R = <Vec<T> as MaybeContainer<T>>::Owned

type Output = [Option<(<Vec<T> as Deconv<T, &'c [&'b [T]; K]>>::Q, <Vec<T> as Deconv<T, &'c [&'b [T]; K]>>::R)>; K]

fn deconv(self, rhs: &'c [&'b [T]; K]) -> Self::Output

impl<'c, 'b, const K: usize, const M: usize, T> Deconv<T, &'b [T; M]> for &'c [Vec<T>; K]

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, Vec<T>: TryInto<<&'c [Vec<T>; K] as MaybeContainer<T>>::Owned>,

type Q = Vec<T>

type R = <&'c [Vec<T>; K] as MaybeContainer<T>>::Owned

type Output = [Option<(<&'c [Vec<T>; K] as Deconv<T, &'b [T; M]>>::Q, <&'c [Vec<T>; K] as Deconv<T, &'b [T; M]>>::R)>; K]

fn deconv(self, rhs: &'b [T; M]) -> Self::Output

impl<'c, 'b, const K: usize, const M: usize, T> Deconv<T, &'c [&'b [T; M]; K]> for ()

where T: Div + One, [T; 1]: Deconv<T, &'c [&'b [T; M]; K]>,

type Q = <[T; 1] as Deconv<T, &'c [&'b [T; M]; K]>>::Q

type R = <[T; 1] as Deconv<T, &'c [&'b [T; M]; K]>>::R

type Output = <[T; 1] as Deconv<T, &'c [&'b [T; M]; K]>>::Output

fn deconv(self, rhs: &'c [&'b [T; M]; K]) -> Self::Output

impl<'c, 'b, const K: usize, const M: usize, T> Deconv<T, &'c [&'b [T; M]; K]> for Vec<T>

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, Vec<T>: TryInto<<Vec<T> as MaybeContainer<T>>::Owned>,

type Q = Vec<T>

type R = <Vec<T> as MaybeContainer<T>>::Owned

type Output = [Option<(<Vec<T> as Deconv<T, &'c [&'b [T; M]; K]>>::Q, <Vec<T> as Deconv<T, &'c [&'b [T; M]; K]>>::R)>; K]

fn deconv(self, rhs: &'c [&'b [T; M]; K]) -> Self::Output

impl<'c, 'b, const K: usize, const N: usize, T> Deconv<T, &'c [&'b [T]; K]> for [T; N]

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, Vec<T>: TryInto<<[T; N] as MaybeContainer<T>>::Owned>,

type Q = Vec<T>

type R = <[T; N] as MaybeContainer<T>>::Owned

type Output = [Option<(<[T; N] as Deconv<T, &'c [&'b [T]; K]>>::Q, <[T; N] as Deconv<T, &'c [&'b [T]; K]>>::R)>; K]

fn deconv(self, rhs: &'c [&'b [T]; K]) -> Self::Output

impl<'c, 'b, const K: usize, const N: usize, const M: usize, T> Deconv<T, &'c [&'b [T; M]; K]> for [T; N]

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, [(); { _ }]:,

type Q = [T; { _ }]

type R = [T; N]

type Output = [Option<(<[T; N] as Deconv<T, &'c [&'b [T; M]; K]>>::Q, <[T; N] as Deconv<T, &'c [&'b [T; M]; K]>>::R)>; K]

fn deconv(self, rhs: &'c [&'b [T; M]; K]) -> Self::Output

impl<'c, 'b, const M: usize, T> Deconv<T, &'b [T; M]> for &'c [Vec<T>]

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, Vec<T>: TryInto<<&'c [Vec<T>] as MaybeContainer<T>>::Owned>,

type Q = Vec<T>

type R = <&'c [Vec<T>] as MaybeContainer<T>>::Owned

type Output = Vec<Option<(<&'c [Vec<T>] as Deconv<T, &'b [T; M]>>::Q, <&'c [Vec<T>] as Deconv<T, &'b [T; M]>>::R)>>

fn deconv(self, rhs: &'b [T; M]) -> Self::Output

impl<'c, 'b, const M: usize, T> Deconv<T, &'c [&'b [T; M]]> for ()

where T: Div + One, [T; 1]: Deconv<T, &'c [&'b [T; M]]>,

type Q = <[T; 1] as Deconv<T, &'c [&'b [T; M]]>>::Q

type R = <[T; 1] as Deconv<T, &'c [&'b [T; M]]>>::R

type Output = <[T; 1] as Deconv<T, &'c [&'b [T; M]]>>::Output

fn deconv(self, rhs: &'c [&'b [T; M]]) -> Self::Output

impl<'c, 'b, const M: usize, T> Deconv<T, &'c [&'b [T; M]]> for Vec<T>

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, Vec<T>: TryInto<<Vec<T> as MaybeContainer<T>>::Owned>,

type Q = Vec<T>

type R = <Vec<T> as MaybeContainer<T>>::Owned

type Output = Vec<Option<(<Vec<T> as Deconv<T, &'c [&'b [T; M]]>>::Q, <Vec<T> as Deconv<T, &'c [&'b [T; M]]>>::R)>>

fn deconv(self, rhs: &'c [&'b [T; M]]) -> Self::Output

impl<'c, 'b, const N: usize, T> Deconv<T, &'c [&'b [T]]> for [T; N]

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, Vec<T>: TryInto<<[T; N] as MaybeContainer<T>>::Owned>,

type Q = Vec<T>

type R = <[T; N] as MaybeContainer<T>>::Owned

type Output = Vec<Option<(<[T; N] as Deconv<T, &'c [&'b [T]]>>::Q, <[T; N] as Deconv<T, &'c [&'b [T]]>>::R)>>

fn deconv(self, rhs: &'c [&'b [T]]) -> Self::Output

impl<'c, 'b, const N: usize, const M: usize, T> Deconv<T, &'c [&'b [T; M]]> for [T; N]

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, [(); { _ }]:,

type Q = [T; { _ }]

type R = [T; N]

type Output = Vec<Option<(<[T; N] as Deconv<T, &'c [&'b [T; M]]>>::Q, <[T; N] as Deconv<T, &'c [&'b [T; M]]>>::R)>>

fn deconv(self, rhs: &'c [&'b [T; M]]) -> Self::Output

impl<'c, T> Deconv<T, &'c [Vec<T>]> for ()

where T: Div + One, [T; 1]: Deconv<T, &'c [Vec<T>]>,

type Q = <[T; 1] as Deconv<T, &'c [Vec<T>]>>::Q

type R = <[T; 1] as Deconv<T, &'c [Vec<T>]>>::R

type Output = <[T; 1] as Deconv<T, &'c [Vec<T>]>>::Output

fn deconv(self, rhs: &'c [Vec<T>]) -> Self::Output

impl<'c, T> Deconv<T, &'c [Vec<T>]> for Vec<T>

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, Vec<T>: TryInto<<Vec<T> as MaybeContainer<T>>::Owned>,

type Q = Vec<T>

type R = <Vec<T> as MaybeContainer<T>>::Owned

type Output = Vec<Option<(<Vec<T> as Deconv<T, &'c [Vec<T>]>>::Q, <Vec<T> as Deconv<T, &'c [Vec<T>]>>::R)>>

fn deconv(self, rhs: &'c [Vec<T>]) -> Self::Output

impl<'c, T> Deconv<T, ()> for &'c [Vec<T>]

where T: Div + One, &'c [Vec<T>]: Deconv<T, [T; 1]>,

type Q = <&'c [Vec<T>] as Deconv<T, [T; 1]>>::Q

type R = <&'c [Vec<T>] as Deconv<T, [T; 1]>>::R

type Output = <&'c [Vec<T>] as Deconv<T, [T; 1]>>::Output

fn deconv(self, _: ()) -> Self::Output

impl<'c, T> Deconv<T, Vec<T>> for &'c [Vec<T>]

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, Vec<T>: TryInto<<&'c [Vec<T>] as MaybeContainer<T>>::Owned>,

type Q = Vec<T>

type R = <&'c [Vec<T>] as MaybeContainer<T>>::Owned

type Output = Vec<Option<(<&'c [Vec<T>] as Deconv<T, Vec<T>>>::Q, <&'c [Vec<T>] as Deconv<T, Vec<T>>>::R)>>

fn deconv(self, rhs: Vec<T>) -> Self::Output

impl<'c, const K: usize, T> Deconv<T, &'c [Vec<T>; K]> for ()

where T: Div + One, [T; 1]: Deconv<T, &'c [Vec<T>; K]>,

type Q = <[T; 1] as Deconv<T, &'c [Vec<T>; K]>>::Q

type R = <[T; 1] as Deconv<T, &'c [Vec<T>; K]>>::R

type Output = <[T; 1] as Deconv<T, &'c [Vec<T>; K]>>::Output

fn deconv(self, rhs: &'c [Vec<T>; K]) -> Self::Output

impl<'c, const K: usize, T> Deconv<T, &'c [Vec<T>; K]> for Vec<T>

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, Vec<T>: TryInto<<Vec<T> as MaybeContainer<T>>::Owned>,

type Q = Vec<T>

type R = <Vec<T> as MaybeContainer<T>>::Owned

type Output = [Option<(<Vec<T> as Deconv<T, &'c [Vec<T>; K]>>::Q, <Vec<T> as Deconv<T, &'c [Vec<T>; K]>>::R)>; K]

fn deconv(self, rhs: &'c [Vec<T>; K]) -> Self::Output

impl<'c, const K: usize, T> Deconv<T, ()> for &'c [Vec<T>; K]

where T: Div + One, &'c [Vec<T>; K]: Deconv<T, [T; 1]>,

type Q = <&'c [Vec<T>; K] as Deconv<T, [T; 1]>>::Q

type R = <&'c [Vec<T>; K] as Deconv<T, [T; 1]>>::R

type Output = <&'c [Vec<T>; K] as Deconv<T, [T; 1]>>::Output

fn deconv(self, _: ()) -> Self::Output

impl<'c, const K: usize, T> Deconv<T, Vec<T>> for &'c [Vec<T>; K]

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, Vec<T>: TryInto<<&'c [Vec<T>; K] as MaybeContainer<T>>::Owned>,

type Q = Vec<T>

type R = <&'c [Vec<T>; K] as MaybeContainer<T>>::Owned

type Output = [Option<(<&'c [Vec<T>; K] as Deconv<T, Vec<T>>>::Q, <&'c [Vec<T>; K] as Deconv<T, Vec<T>>>::R)>; K]

fn deconv(self, rhs: Vec<T>) -> Self::Output

impl<'c, const K: usize, const M: usize, T> Deconv<T, &'c [[T; M]; K]> for ()

where T: Div + One, [T; 1]: Deconv<T, &'c [[T; M]; K]>,

type Q = <[T; 1] as Deconv<T, &'c [[T; M]; K]>>::Q

type R = <[T; 1] as Deconv<T, &'c [[T; M]; K]>>::R

type Output = <[T; 1] as Deconv<T, &'c [[T; M]; K]>>::Output

fn deconv(self, rhs: &'c [[T; M]; K]) -> Self::Output

impl<'c, const K: usize, const M: usize, T> Deconv<T, &'c [[T; M]; K]> for Vec<T>

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, Vec<T>: TryInto<<Vec<T> as MaybeContainer<T>>::Owned>,

type Q = Vec<T>

type R = <Vec<T> as MaybeContainer<T>>::Owned

type Output = [Option<(<Vec<T> as Deconv<T, &'c [[T; M]; K]>>::Q, <Vec<T> as Deconv<T, &'c [[T; M]; K]>>::R)>; K]

fn deconv(self, rhs: &'c [[T; M]; K]) -> Self::Output

impl<'c, const K: usize, const M: usize, T> Deconv<T, [T; M]> for &'c [Vec<T>; K]

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, Vec<T>: TryInto<<&'c [Vec<T>; K] as MaybeContainer<T>>::Owned>,

type Q = Vec<T>

type R = <&'c [Vec<T>; K] as MaybeContainer<T>>::Owned

type Output = [Option<(<&'c [Vec<T>; K] as Deconv<T, [T; M]>>::Q, <&'c [Vec<T>; K] as Deconv<T, [T; M]>>::R)>; K]

fn deconv(self, rhs: [T; M]) -> Self::Output

impl<'c, const K: usize, const N: usize, T> Deconv<T, &'c [Vec<T>; K]> for [T; N]

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, Vec<T>: TryInto<<[T; N] as MaybeContainer<T>>::Owned>,

type Q = Vec<T>

type R = <[T; N] as MaybeContainer<T>>::Owned

type Output = [Option<(<[T; N] as Deconv<T, &'c [Vec<T>; K]>>::Q, <[T; N] as Deconv<T, &'c [Vec<T>; K]>>::R)>; K]

fn deconv(self, rhs: &'c [Vec<T>; K]) -> Self::Output

impl<'c, const K: usize, const N: usize, T> Deconv<T, ()> for &'c [[T; N]; K]

where T: Div + One, &'c [[T; N]; K]: Deconv<T, [T; 1]>,

type Q = <&'c [[T; N]; K] as Deconv<T, [T; 1]>>::Q

type R = <&'c [[T; N]; K] as Deconv<T, [T; 1]>>::R

type Output = <&'c [[T; N]; K] as Deconv<T, [T; 1]>>::Output

fn deconv(self, _: ()) -> Self::Output

impl<'c, const K: usize, const N: usize, const M: usize, T> Deconv<T, &'c [[T; M]; K]> for [T; N]

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, [(); { _ }]:,

type Q = [T; { _ }]

type R = [T; N]

type Output = [Option<(<[T; N] as Deconv<T, &'c [[T; M]; K]>>::Q, <[T; N] as Deconv<T, &'c [[T; M]; K]>>::R)>; K]

fn deconv(self, rhs: &'c [[T; M]; K]) -> Self::Output

impl<'c, const M: usize, T> Deconv<T, &'c [[T; M]]> for ()

where T: Div + One, [T; 1]: Deconv<T, &'c [[T; M]]>,

type Q = <[T; 1] as Deconv<T, &'c [[T; M]]>>::Q

type R = <[T; 1] as Deconv<T, &'c [[T; M]]>>::R

type Output = <[T; 1] as Deconv<T, &'c [[T; M]]>>::Output

fn deconv(self, rhs: &'c [[T; M]]) -> Self::Output

impl<'c, const M: usize, T> Deconv<T, &'c [[T; M]]> for Vec<T>

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, Vec<T>: TryInto<<Vec<T> as MaybeContainer<T>>::Owned>,

type Q = Vec<T>

type R = <Vec<T> as MaybeContainer<T>>::Owned

type Output = Vec<Option<(<Vec<T> as Deconv<T, &'c [[T; M]]>>::Q, <Vec<T> as Deconv<T, &'c [[T; M]]>>::R)>>

fn deconv(self, rhs: &'c [[T; M]]) -> Self::Output

impl<'c, const M: usize, T> Deconv<T, [T; M]> for &'c [Vec<T>]

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, Vec<T>: TryInto<<&'c [Vec<T>] as MaybeContainer<T>>::Owned>,

type Q = Vec<T>

type R = <&'c [Vec<T>] as MaybeContainer<T>>::Owned

type Output = Vec<Option<(<&'c [Vec<T>] as Deconv<T, [T; M]>>::Q, <&'c [Vec<T>] as Deconv<T, [T; M]>>::R)>>

fn deconv(self, rhs: [T; M]) -> Self::Output

impl<'c, const N: usize, T> Deconv<T, &'c [Vec<T>]> for [T; N]

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, Vec<T>: TryInto<<[T; N] as MaybeContainer<T>>::Owned>,

type Q = Vec<T>

type R = <[T; N] as MaybeContainer<T>>::Owned

type Output = Vec<Option<(<[T; N] as Deconv<T, &'c [Vec<T>]>>::Q, <[T; N] as Deconv<T, &'c [Vec<T>]>>::R)>>

fn deconv(self, rhs: &'c [Vec<T>]) -> Self::Output

impl<'c, const N: usize, T> Deconv<T, ()> for &'c [[T; N]]

where T: Div + One, &'c [[T; N]]: Deconv<T, [T; 1]>,

type Q = <&'c [[T; N]] as Deconv<T, [T; 1]>>::Q

type R = <&'c [[T; N]] as Deconv<T, [T; 1]>>::R

type Output = <&'c [[T; N]] as Deconv<T, [T; 1]>>::Output

fn deconv(self, _: ()) -> Self::Output

impl<'c, const N: usize, const M: usize, T> Deconv<T, &'c [[T; M]]> for [T; N]

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, [(); { _ }]:,

type Q = [T; { _ }]

type R = [T; N]

type Output = Vec<Option<(<[T; N] as Deconv<T, &'c [[T; M]]>>::Q, <[T; N] as Deconv<T, &'c [[T; M]]>>::R)>>

fn deconv(self, rhs: &'c [[T; M]]) -> Self::Output

impl<T> Deconv<T, ()> for ()

where T: Div + One, [T; 1]: Deconv<T, ()>,

type Q = <[T; 1] as Deconv<T, ()>>::Q

type R = <[T; 1] as Deconv<T, ()>>::R

type Output = <[T; 1] as Deconv<T, ()>>::Output

fn deconv(self, rhs: ()) -> Self::Output

impl<T> Deconv<T, ()> for Vec<Vec<T>>

where T: Div + One, Vec<Vec<T>>: Deconv<T, [T; 1]>,

type Q = <Vec<Vec<T>> as Deconv<T, [T; 1]>>::Q

type R = <Vec<Vec<T>> as Deconv<T, [T; 1]>>::R

type Output = <Vec<Vec<T>> as Deconv<T, [T; 1]>>::Output

fn deconv(self, _: ()) -> Self::Output

impl<T> Deconv<T, ()> for Vec<T>

where T: Div + One, Vec<T>: Deconv<T, [T; 1]>,

type Q = <Vec<T> as Deconv<T, [T; 1]>>::Q

type R = <Vec<T> as Deconv<T, [T; 1]>>::R

type Output = <Vec<T> as Deconv<T, [T; 1]>>::Output

fn deconv(self, _: ()) -> Self::Output

impl<T> Deconv<T, Vec<Vec<T>>> for ()

where T: Div + One, [T; 1]: Deconv<T, Vec<Vec<T>>>,

type Q = <[T; 1] as Deconv<T, Vec<Vec<T>>>>::Q

type R = <[T; 1] as Deconv<T, Vec<Vec<T>>>>::R

type Output = <[T; 1] as Deconv<T, Vec<Vec<T>>>>::Output

fn deconv(self, rhs: Vec<Vec<T>>) -> Self::Output

impl<T> Deconv<T, Vec<Vec<T>>> for Vec<T>

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, Vec<T>: TryInto<<Vec<T> as MaybeContainer<T>>::Owned>,

type Q = Vec<T>

type R = <Vec<T> as MaybeContainer<T>>::Owned

type Output = Vec<Option<(<Vec<T> as Deconv<T, Vec<Vec<T>>>>::Q, <Vec<T> as Deconv<T, Vec<Vec<T>>>>::R)>>

fn deconv(self, rhs: Vec<Vec<T>>) -> Self::Output

impl<T> Deconv<T, Vec<T>> for ()

where T: Div + One, [T; 1]: Deconv<T, Vec<T>>,

type Q = <[T; 1] as Deconv<T, Vec<T>>>::Q

type R = <[T; 1] as Deconv<T, Vec<T>>>::R

type Output = <[T; 1] as Deconv<T, Vec<T>>>::Output

fn deconv(self, rhs: Vec<T>) -> Self::Output

impl<T> Deconv<T, Vec<T>> for Vec<Vec<T>>

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, Vec<T>: TryInto<<Vec<Vec<T>> as MaybeContainer<T>>::Owned>,

type Q = Vec<T>

type R = <Vec<Vec<T>> as MaybeContainer<T>>::Owned

type Output = Vec<Option<(<Vec<Vec<T>> as Deconv<T, Vec<T>>>::Q, <Vec<Vec<T>> as Deconv<T, Vec<T>>>::R)>>

fn deconv(self, rhs: Vec<T>) -> Self::Output

impl<T> Deconv<T, Vec<T>> for Vec<T>

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, Vec<T>: TryInto<<Vec<T> as MaybeContainer<T>>::Owned>,

type Q = Vec<T>

type R = <Vec<T> as MaybeContainer<T>>::Owned

type Output = Option<(<Vec<T> as Deconv<T, Vec<T>>>::Q, <Vec<T> as Deconv<T, Vec<T>>>::R)>

fn deconv(self, rhs: Vec<T>) -> Self::Output

impl<const K: usize, T> Deconv<T, ()> for [Vec<T>; K]

where T: Div + One, [Vec<T>; K]: Deconv<T, [T; 1]>,

type Q = <[Vec<T>; K] as Deconv<T, [T; 1]>>::Q

type R = <[Vec<T>; K] as Deconv<T, [T; 1]>>::R

type Output = <[Vec<T>; K] as Deconv<T, [T; 1]>>::Output

fn deconv(self, _: ()) -> Self::Output

impl<const K: usize, T> Deconv<T, Vec<T>> for [Vec<T>; K]

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, Vec<T>: TryInto<<[Vec<T>; K] as MaybeContainer<T>>::Owned>,

type Q = Vec<T>

type R = <[Vec<T>; K] as MaybeContainer<T>>::Owned

type Output = [Option<(<[Vec<T>; K] as Deconv<T, Vec<T>>>::Q, <[Vec<T>; K] as Deconv<T, Vec<T>>>::R)>; K]

fn deconv(self, rhs: Vec<T>) -> Self::Output

impl<const K: usize, T> Deconv<T, [Vec<T>; K]> for ()

where T: Div + One, [T; 1]: Deconv<T, [Vec<T>; K]>,

type Q = <[T; 1] as Deconv<T, [Vec<T>; K]>>::Q

type R = <[T; 1] as Deconv<T, [Vec<T>; K]>>::R

type Output = <[T; 1] as Deconv<T, [Vec<T>; K]>>::Output

fn deconv(self, rhs: [Vec<T>; K]) -> Self::Output

impl<const K: usize, T> Deconv<T, [Vec<T>; K]> for Vec<T>

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, Vec<T>: TryInto<<Vec<T> as MaybeContainer<T>>::Owned>,

type Q = Vec<T>

type R = <Vec<T> as MaybeContainer<T>>::Owned

type Output = [Option<(<Vec<T> as Deconv<T, [Vec<T>; K]>>::Q, <Vec<T> as Deconv<T, [Vec<T>; K]>>::R)>; K]

fn deconv(self, rhs: [Vec<T>; K]) -> Self::Output

impl<const K: usize, const M: usize, T> Deconv<T, [T; M]> for [Vec<T>; K]

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, Vec<T>: TryInto<<[Vec<T>; K] as MaybeContainer<T>>::Owned>,

type Q = Vec<T>

type R = <[Vec<T>; K] as MaybeContainer<T>>::Owned

type Output = [Option<(<[Vec<T>; K] as Deconv<T, [T; M]>>::Q, <[Vec<T>; K] as Deconv<T, [T; M]>>::R)>; K]

fn deconv(self, rhs: [T; M]) -> Self::Output

impl<const K: usize, const M: usize, T> Deconv<T, [[T; M]; K]> for ()

where T: Div + One, [T; 1]: Deconv<T, [[T; M]; K]>,

type Q = <[T; 1] as Deconv<T, [[T; M]; K]>>::Q

type R = <[T; 1] as Deconv<T, [[T; M]; K]>>::R

type Output = <[T; 1] as Deconv<T, [[T; M]; K]>>::Output

fn deconv(self, rhs: [[T; M]; K]) -> Self::Output

impl<const K: usize, const M: usize, T> Deconv<T, [[T; M]; K]> for Vec<T>

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, Vec<T>: TryInto<<Vec<T> as MaybeContainer<T>>::Owned>,

type Q = Vec<T>

type R = <Vec<T> as MaybeContainer<T>>::Owned

type Output = [Option<(<Vec<T> as Deconv<T, [[T; M]; K]>>::Q, <Vec<T> as Deconv<T, [[T; M]; K]>>::R)>; K]

fn deconv(self, rhs: [[T; M]; K]) -> Self::Output

impl<const K: usize, const N: usize, T> Deconv<T, ()> for [[T; N]; K]

where T: Div + One, [[T; N]; K]: Deconv<T, [T; 1]>,

type Q = <[[T; N]; K] as Deconv<T, [T; 1]>>::Q

type R = <[[T; N]; K] as Deconv<T, [T; 1]>>::R

type Output = <[[T; N]; K] as Deconv<T, [T; 1]>>::Output

fn deconv(self, _: ()) -> Self::Output

impl<const K: usize, const N: usize, T> Deconv<T, Vec<T>> for [[T; N]; K]

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, Vec<T>: TryInto<<[[T; N]; K] as MaybeContainer<T>>::Owned>,

type Q = Vec<T>

type R = <[[T; N]; K] as MaybeContainer<T>>::Owned

type Output = [Option<(<[[T; N]; K] as Deconv<T, Vec<T>>>::Q, <[[T; N]; K] as Deconv<T, Vec<T>>>::R)>; K]

fn deconv(self, rhs: Vec<T>) -> Self::Output

impl<const K: usize, const N: usize, T> Deconv<T, [Vec<T>; K]> for [T; N]

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, Vec<T>: TryInto<<[T; N] as MaybeContainer<T>>::Owned>,

type Q = Vec<T>

type R = <[T; N] as MaybeContainer<T>>::Owned

type Output = [Option<(<[T; N] as Deconv<T, [Vec<T>; K]>>::Q, <[T; N] as Deconv<T, [Vec<T>; K]>>::R)>; K]

fn deconv(self, rhs: [Vec<T>; K]) -> Self::Output

impl<const K: usize, const N: usize, const M: usize, T> Deconv<T, [T; M]> for &[&[T; N]; K]

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, [(); { _ }]:,

type Q = [T; { _ }]

type R = [T; N]

type Output = [Option<(<&[&[T; N]; K] as Deconv<T, [T; M]>>::Q, <&[&[T; N]; K] as Deconv<T, [T; M]>>::R)>; K]

fn deconv(self, rhs: [T; M]) -> Self::Output

impl<const K: usize, const N: usize, const M: usize, T> Deconv<T, [T; M]> for &[[T; N]; K]

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, [(); { _ }]:,

type Q = [T; { _ }]

type R = [T; N]

type Output = [Option<(<&[[T; N]; K] as Deconv<T, [T; M]>>::Q, <&[[T; N]; K] as Deconv<T, [T; M]>>::R)>; K]

fn deconv(self, rhs: [T; M]) -> Self::Output

impl<const K: usize, const N: usize, const M: usize, T> Deconv<T, [T; M]> for [&[T; N]; K]

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, [(); { _ }]:,

type Q = [T; { _ }]

type R = [T; N]

type Output = [Option<(<[&[T; N]; K] as Deconv<T, [T; M]>>::Q, <[&[T; N]; K] as Deconv<T, [T; M]>>::R)>; K]

fn deconv(self, rhs: [T; M]) -> Self::Output

impl<const K: usize, const N: usize, const M: usize, T> Deconv<T, [T; M]> for [[T; N]; K]

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, [(); { _ }]:,

type Q = [T; { _ }]

type R = [T; N]

type Output = [Option<(<[[T; N]; K] as Deconv<T, [T; M]>>::Q, <[[T; N]; K] as Deconv<T, [T; M]>>::R)>; K]

fn deconv(self, rhs: [T; M]) -> Self::Output

impl<const K: usize, const N: usize, const M: usize, T> Deconv<T, [[T; M]; K]> for &[T; N]

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, [(); { _ }]:,

type Q = [T; { _ }]

type R = [T; N]

type Output = [Option<(<&[T; N] as Deconv<T, [[T; M]; K]>>::Q, <&[T; N] as Deconv<T, [[T; M]; K]>>::R)>; K]

fn deconv(self, rhs: [[T; M]; K]) -> Self::Output

impl<const K: usize, const N: usize, const M: usize, T> Deconv<T, [[T; M]; K]> for [T; N]

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, [(); { _ }]:,

type Q = [T; { _ }]

type R = [T; N]

type Output = [Option<(<[T; N] as Deconv<T, [[T; M]; K]>>::Q, <[T; N] as Deconv<T, [[T; M]; K]>>::R)>; K]

fn deconv(self, rhs: [[T; M]; K]) -> Self::Output

impl<const M: usize, T> Deconv<T, [T; M]> for ()

where T: Div + One, [T; 1]: Deconv<T, [T; M]>,

type Q = <[T; 1] as Deconv<T, [T; M]>>::Q

type R = <[T; 1] as Deconv<T, [T; M]>>::R

type Output = <[T; 1] as Deconv<T, [T; M]>>::Output

fn deconv(self, rhs: [T; M]) -> Self::Output

impl<const M: usize, T> Deconv<T, [T; M]> for Vec<Vec<T>>

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, Vec<T>: TryInto<<Vec<Vec<T>> as MaybeContainer<T>>::Owned>,

type Q = Vec<T>

type R = <Vec<Vec<T>> as MaybeContainer<T>>::Owned

type Output = Vec<Option<(<Vec<Vec<T>> as Deconv<T, [T; M]>>::Q, <Vec<Vec<T>> as Deconv<T, [T; M]>>::R)>>

fn deconv(self, rhs: [T; M]) -> Self::Output

impl<const M: usize, T> Deconv<T, [T; M]> for Vec<T>

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, Vec<T>: TryInto<<Vec<T> as MaybeContainer<T>>::Owned>,

type Q = Vec<T>

type R = <Vec<T> as MaybeContainer<T>>::Owned

type Output = Option<(<Vec<T> as Deconv<T, [T; M]>>::Q, <Vec<T> as Deconv<T, [T; M]>>::R)>

fn deconv(self, rhs: [T; M]) -> Self::Output

impl<const M: usize, T> Deconv<T, Vec<[T; M]>> for ()

where T: Div + One, [T; 1]: Deconv<T, Vec<[T; M]>>,

type Q = <[T; 1] as Deconv<T, Vec<[T; M]>>>::Q

type R = <[T; 1] as Deconv<T, Vec<[T; M]>>>::R

type Output = <[T; 1] as Deconv<T, Vec<[T; M]>>>::Output

fn deconv(self, rhs: Vec<[T; M]>) -> Self::Output

impl<const M: usize, T> Deconv<T, Vec<[T; M]>> for Vec<T>

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, Vec<T>: TryInto<<Vec<T> as MaybeContainer<T>>::Owned>,

type Q = Vec<T>

type R = <Vec<T> as MaybeContainer<T>>::Owned

type Output = Vec<Option<(<Vec<T> as Deconv<T, Vec<[T; M]>>>::Q, <Vec<T> as Deconv<T, Vec<[T; M]>>>::R)>>

fn deconv(self, rhs: Vec<[T; M]>) -> Self::Output

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

where T: Div + One, [T; N]: Deconv<T, [T; 1]>,

type Q = <[T; N] as Deconv<T, [T; 1]>>::Q

type R = <[T; N] as Deconv<T, [T; 1]>>::R

type Output = <[T; N] as Deconv<T, [T; 1]>>::Output

fn deconv(self, _: ()) -> Self::Output

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

where T: Div + One, Vec<[T; N]>: Deconv<T, [T; 1]>,

type Q = <Vec<[T; N]> as Deconv<T, [T; 1]>>::Q

type R = <Vec<[T; N]> as Deconv<T, [T; 1]>>::R

type Output = <Vec<[T; N]> as Deconv<T, [T; 1]>>::Output

fn deconv(self, _: ()) -> Self::Output

impl<const N: usize, T> Deconv<T, Vec<Vec<T>>> for [T; N]

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, Vec<T>: TryInto<<[T; N] as MaybeContainer<T>>::Owned>,

type Q = Vec<T>

type R = <[T; N] as MaybeContainer<T>>::Owned

type Output = Vec<Option<(<[T; N] as Deconv<T, Vec<Vec<T>>>>::Q, <[T; N] as Deconv<T, Vec<Vec<T>>>>::R)>>

fn deconv(self, rhs: Vec<Vec<T>>) -> Self::Output

impl<const N: usize, T> Deconv<T, Vec<T>> for [T; N]

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, Vec<T>: TryInto<<[T; N] as MaybeContainer<T>>::Owned>,

type Q = Vec<T>

type R = <[T; N] as MaybeContainer<T>>::Owned

type Output = Option<(<[T; N] as Deconv<T, Vec<T>>>::Q, <[T; N] as Deconv<T, Vec<T>>>::R)>

fn deconv(self, rhs: Vec<T>) -> Self::Output

impl<const N: usize, T> Deconv<T, Vec<T>> for Vec<[T; N]>

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, Vec<T>: TryInto<<Vec<[T; N]> as MaybeContainer<T>>::Owned>,

type Q = Vec<T>

type R = <Vec<[T; N]> as MaybeContainer<T>>::Owned

type Output = Vec<Option<(<Vec<[T; N]> as Deconv<T, Vec<T>>>::Q, <Vec<[T; N]> as Deconv<T, Vec<T>>>::R)>>

fn deconv(self, rhs: Vec<T>) -> Self::Output

impl<const N: usize, const M: usize, T> Deconv<T, [T; M]> for &[&[T; N]]

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, [(); { _ }]:,

type Q = [T; { _ }]

type R = [T; N]

type Output = Vec<Option<(<&[&[T; N]] as Deconv<T, [T; M]>>::Q, <&[&[T; N]] as Deconv<T, [T; M]>>::R)>>

fn deconv(self, rhs: [T; M]) -> Self::Output

impl<const N: usize, const M: usize, T> Deconv<T, [T; M]> for &[[T; N]]

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, [(); { _ }]:,

type Q = [T; { _ }]

type R = [T; N]

type Output = Vec<Option<(<&[[T; N]] as Deconv<T, [T; M]>>::Q, <&[[T; N]] as Deconv<T, [T; M]>>::R)>>

fn deconv(self, rhs: [T; M]) -> Self::Output

impl<const N: usize, const M: usize, T> Deconv<T, [T; M]> for [T; N]

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, [(); { _ }]:,

type Q = [T; { _ }]

type R = [T; N]

type Output = Option<(<[T; N] as Deconv<T, [T; M]>>::Q, <[T; N] as Deconv<T, [T; M]>>::R)>

fn deconv(self, rhs: [T; M]) -> Self::Output

impl<const N: usize, const M: usize, T> Deconv<T, [T; M]> for Vec<&[T; N]>

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, [(); { _ }]:,

type Q = [T; { _ }]

type R = [T; N]

type Output = Vec<Option<(<Vec<&[T; N]> as Deconv<T, [T; M]>>::Q, <Vec<&[T; N]> as Deconv<T, [T; M]>>::R)>>

fn deconv(self, rhs: [T; M]) -> Self::Output

impl<const N: usize, const M: usize, T> Deconv<T, [T; M]> for Vec<[T; N]>

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, [(); { _ }]:,

type Q = [T; { _ }]

type R = [T; N]

type Output = Vec<Option<(<Vec<[T; N]> as Deconv<T, [T; M]>>::Q, <Vec<[T; N]> as Deconv<T, [T; M]>>::R)>>

fn deconv(self, rhs: [T; M]) -> Self::Output

impl<const N: usize, const M: usize, T> Deconv<T, Vec<[T; M]>> for [T; N]

where T: ComplexFloat<Real: Into<T>> + SubAssign + AddAssign + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>, [(); { _ }]:,

type Q = [T; { _ }]

type R = [T; N]

type Output = Vec<Option<(<[T; N] as Deconv<T, Vec<[T; M]>>>::Q, <[T; N] as Deconv<T, Vec<[T; M]>>>::R)>>

fn deconv(self, rhs: Vec<[T; M]>) -> Self::Output

Implementors