Trait signal_processing::operations::convolution::Conv

pub trait Conv<T1, T2, Rhs>: MaybeContainer<T1>
where
    T1: Mul<T2>,
    Rhs: MaybeContainer<T2>,
{
    type OutputT;
    type Output: MaybeContainer<Self::OutputT>;

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

Required Associated Types

type OutputT

type Output: MaybeContainer<Self::OutputT>

Required Methods

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

Object Safety

This trait is not object safe.

Implementations on Foreign Types

impl<'a, 'b, T1, T2> Conv<T1, T2, &'b [T2]> for &'a [T1]

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign,

type OutputT = <T1 as Mul<T2>>::Output

type Output = Vec<<T1 as Mul<T2>>::Output>

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

impl<'a, 'b, const M: usize, T1, T2> Conv<T1, T2, &'b [T2; M]> for &'a [T1]

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign,

type OutputT = <T1 as Mul<T2>>::Output

type Output = Vec<<T1 as Mul<T2>>::Output>

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

impl<'a, 'b, const N: usize, T1, T2> Conv<T1, T2, &'b [T2]> for &'a [T1; N]

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign,

type OutputT = <T1 as Mul<T2>>::Output

type Output = Vec<<T1 as Mul<T2>>::Output>

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

impl<'a, 'b, const N: usize, const M: usize, T1, T2> Conv<T1, T2, &'b [T2; M]> for &'a [T1; N]

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign, [(); { _ }]:,

type OutputT = <T1 as Mul<T2>>::Output

type Output = [<T1 as Mul<T2>>::Output; { _ }]

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

impl<'a, 'c, T1, T2> Conv<T1, T2, ()> for &'c [&'a [T1]]

where T1: Mul<T2>,

type OutputT = T1

type Output = &'c [&'a [T1]]

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

impl<'a, 'c, const K: usize, T1, T2> Conv<T1, T2, ()> for &'c [&'a [T1]; K]

where T1: Mul<T2>,

type OutputT = T1

type Output = &'c [&'a [T1]; K]

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

impl<'a, 'c, const K: usize, const N: usize, T1, T2> Conv<T1, T2, ()> for &'c [&'a [T1; N]; K]

where T1: Mul<T2>,

type OutputT = T1

type Output = &'c [&'a [T1; N]; K]

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

impl<'a, 'c, const N: usize, T1, T2> Conv<T1, T2, ()> for &'c [&'a [T1; N]]

where T1: Mul<T2>,

type OutputT = T1

type Output = &'c [&'a [T1; N]]

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

impl<'a, T1, T2> Conv<T1, T2, ()> for &'a [T1]

where T1: Mul<T2>,

type OutputT = T1

type Output = &'a [T1]

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

impl<'a, T1, T2> Conv<T1, T2, ()> for Vec<&'a [T1]>

where T1: Mul<T2>,

type OutputT = T1

type Output = Vec<&'a [T1]>

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

impl<'a, T1, T2> Conv<T1, T2, Vec<T2>> for &'a [T1]

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign,

type OutputT = <T1 as Mul<T2>>::Output

type Output = Vec<<T1 as Mul<T2>>::Output>

fn conv(self, rhs: Vec<T2>) -> Self::Output

impl<'a, const K: usize, T1, T2> Conv<T1, T2, ()> for [&'a [T1]; K]

where T1: Mul<T2>,

type OutputT = T1

type Output = [&'a [T1]; K]

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

impl<'a, const K: usize, const N: usize, T1, T2> Conv<T1, T2, ()> for [&'a [T1; N]; K]

where T1: Mul<T2>,

type OutputT = T1

type Output = [&'a [T1; N]; K]

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

impl<'a, const M: usize, T1, T2> Conv<T1, T2, [T2; M]> for &'a [T1]

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign,

type OutputT = <T1 as Mul<T2>>::Output

type Output = Vec<<T1 as Mul<T2>>::Output>

fn conv(self, rhs: [T2; M]) -> Self::Output

impl<'a, const N: usize, T1, T2> Conv<T1, T2, ()> for &'a [T1; N]

where T1: Mul<T2>,

type OutputT = T1

type Output = &'a [T1; N]

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

impl<'a, const N: usize, T1, T2> Conv<T1, T2, ()> for Vec<&'a [T1; N]>

where T1: Mul<T2>,

type OutputT = T1

type Output = Vec<&'a [T1; N]>

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

impl<'a, const N: usize, T1, T2> Conv<T1, T2, Vec<T2>> for &'a [T1; N]

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign,

type OutputT = <T1 as Mul<T2>>::Output

type Output = Vec<<T1 as Mul<T2>>::Output>

fn conv(self, rhs: Vec<T2>) -> Self::Output

impl<'a, const N: usize, const M: usize, T1, T2> Conv<T1, T2, [T2; M]> for &'a [T1; N]

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign, [(); { _ }]:,

type OutputT = <T1 as Mul<T2>>::Output

type Output = [<T1 as Mul<T2>>::Output; { _ }]

fn conv(self, rhs: [T2; M]) -> Self::Output

impl<'b, T1, T2> Conv<T1, T2, &'b [T2]> for &[&[T1]]

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign,

type OutputT = <T1 as Mul<T2>>::Output

type Output = Vec<Vec<<T1 as Mul<T2>>::Output>>

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

impl<'b, T1, T2> Conv<T1, T2, &'b [T2]> for &[Vec<T1>]

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign,

type OutputT = <T1 as Mul<T2>>::Output

type Output = Vec<Vec<<T1 as Mul<T2>>::Output>>

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

impl<'b, T1, T2> Conv<T1, T2, &'b [T2]> for ()

where T1: Mul<T2>,

type OutputT = T2

type Output = &'b [T2]

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

impl<'b, T1, T2> Conv<T1, T2, &'b [T2]> for Vec<&[T1]>

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign,

type OutputT = <T1 as Mul<T2>>::Output

type Output = Vec<Vec<<T1 as Mul<T2>>::Output>>

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

impl<'b, T1, T2> Conv<T1, T2, &'b [T2]> for Vec<Vec<T1>>

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign,

type OutputT = <T1 as Mul<T2>>::Output

type Output = Vec<Vec<<T1 as Mul<T2>>::Output>>

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

impl<'b, T1, T2> Conv<T1, T2, &'b [T2]> for Vec<T1>

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign,

type OutputT = <T1 as Mul<T2>>::Output

type Output = Vec<<T1 as Mul<T2>>::Output>

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

impl<'b, T1, T2> Conv<T1, T2, Vec<&'b [T2]>> for &[T1]

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign,

type OutputT = <T1 as Mul<T2>>::Output

type Output = Vec<Vec<<T1 as Mul<T2>>::Output>>

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

impl<'b, T1, T2> Conv<T1, T2, Vec<&'b [T2]>> for ()

where T1: Mul<T2>,

type OutputT = T2

type Output = Vec<&'b [T2]>

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

impl<'b, T1, T2> Conv<T1, T2, Vec<&'b [T2]>> for Vec<T1>

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign,

type OutputT = <T1 as Mul<T2>>::Output

type Output = Vec<Vec<<T1 as Mul<T2>>::Output>>

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

impl<'b, const K: usize, T1, T2> Conv<T1, T2, &'b [T2]> for &[&[T1]; K]

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign,

type OutputT = <T1 as Mul<T2>>::Output

type Output = [Vec<<T1 as Mul<T2>>::Output>; K]

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

impl<'b, const K: usize, T1, T2> Conv<T1, T2, &'b [T2]> for &[Vec<T1>; K]

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign,

type OutputT = <T1 as Mul<T2>>::Output

type Output = [Vec<<T1 as Mul<T2>>::Output>; K]

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

impl<'b, const K: usize, T1, T2> Conv<T1, T2, &'b [T2]> for [&[T1]; K]

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign,

type OutputT = <T1 as Mul<T2>>::Output

type Output = [Vec<<T1 as Mul<T2>>::Output>; K]

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

impl<'b, const K: usize, T1, T2> Conv<T1, T2, &'b [T2]> for [Vec<T1>; K]

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign,

type OutputT = <T1 as Mul<T2>>::Output

type Output = [Vec<<T1 as Mul<T2>>::Output>; K]

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

impl<'b, const K: usize, T1, T2> Conv<T1, T2, [&'b [T2]; K]> for &[T1]

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign,

type OutputT = <T1 as Mul<T2>>::Output

type Output = [Vec<<T1 as Mul<T2>>::Output>; K]

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

impl<'b, const K: usize, T1, T2> Conv<T1, T2, [&'b [T2]; K]> for ()

where T1: Mul<T2>,

type OutputT = T2

type Output = [&'b [T2]; K]

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

impl<'b, const K: usize, T1, T2> Conv<T1, T2, [&'b [T2]; K]> for Vec<T1>

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign,

type OutputT = <T1 as Mul<T2>>::Output

type Output = [Vec<<T1 as Mul<T2>>::Output>; K]

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

impl<'b, const K: usize, const M: usize, T1, T2> Conv<T1, T2, &'b [T2; M]> for &[&[T1]; K]

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign,

type OutputT = <T1 as Mul<T2>>::Output

type Output = [Vec<<T1 as Mul<T2>>::Output>; K]

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

impl<'b, const K: usize, const M: usize, T1, T2> Conv<T1, T2, &'b [T2; M]> for &[Vec<T1>; K]

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign,

type OutputT = <T1 as Mul<T2>>::Output

type Output = [Vec<<T1 as Mul<T2>>::Output>; K]

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

impl<'b, const K: usize, const M: usize, T1, T2> Conv<T1, T2, &'b [T2; M]> for [&[T1]; K]

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign,

type OutputT = <T1 as Mul<T2>>::Output

type Output = [Vec<<T1 as Mul<T2>>::Output>; K]

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

impl<'b, const K: usize, const M: usize, T1, T2> Conv<T1, T2, &'b [T2; M]> for [Vec<T1>; K]

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign,

type OutputT = <T1 as Mul<T2>>::Output

type Output = [Vec<<T1 as Mul<T2>>::Output>; K]

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

impl<'b, const K: usize, const M: usize, T1, T2> Conv<T1, T2, [&'b [T2; M]; K]> for &[T1]

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign,

type OutputT = <T1 as Mul<T2>>::Output

type Output = [Vec<<T1 as Mul<T2>>::Output>; K]

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

impl<'b, const K: usize, const M: usize, T1, T2> Conv<T1, T2, [&'b [T2; M]; K]> for ()

where T1: Mul<T2>,

type OutputT = T2

type Output = [&'b [T2; M]; K]

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

impl<'b, const K: usize, const M: usize, T1, T2> Conv<T1, T2, [&'b [T2; M]; K]> for Vec<T1>

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign,

type OutputT = <T1 as Mul<T2>>::Output

type Output = [Vec<<T1 as Mul<T2>>::Output>; K]

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

impl<'b, const K: usize, const N: usize, T1, T2> Conv<T1, T2, &'b [T2]> for &[&[T1; N]; K]

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign,

type OutputT = <T1 as Mul<T2>>::Output

type Output = [Vec<<T1 as Mul<T2>>::Output>; K]

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

impl<'b, const K: usize, const N: usize, T1, T2> Conv<T1, T2, &'b [T2]> for &[[T1; N]; K]

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign,

type OutputT = <T1 as Mul<T2>>::Output

type Output = [Vec<<T1 as Mul<T2>>::Output>; K]

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

impl<'b, const K: usize, const N: usize, T1, T2> Conv<T1, T2, &'b [T2]> for [&[T1; N]; K]

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign,

type OutputT = <T1 as Mul<T2>>::Output

type Output = [Vec<<T1 as Mul<T2>>::Output>; K]

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

impl<'b, const K: usize, const N: usize, T1, T2> Conv<T1, T2, &'b [T2]> for [[T1; N]; K]

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign,

type OutputT = <T1 as Mul<T2>>::Output

type Output = [Vec<<T1 as Mul<T2>>::Output>; K]

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

impl<'b, const K: usize, const N: usize, T1, T2> Conv<T1, T2, [&'b [T2]; K]> for &[T1; N]

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign,

type OutputT = <T1 as Mul<T2>>::Output

type Output = [Vec<<T1 as Mul<T2>>::Output>; K]

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

impl<'b, const K: usize, const N: usize, T1, T2> Conv<T1, T2, [&'b [T2]; K]> for [T1; N]

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign,

type OutputT = <T1 as Mul<T2>>::Output

type Output = [Vec<<T1 as Mul<T2>>::Output>; K]

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

impl<'b, const K: usize, const N: usize, const M: usize, T1, T2> Conv<T1, T2, &'b [T2; M]> for &[&[T1; N]; K]

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign, [(); { _ }]:,

type OutputT = <T1 as Mul<T2>>::Output

type Output = [[<T1 as Mul<T2>>::Output; { _ }]; K]

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

impl<'b, const K: usize, const N: usize, const M: usize, T1, T2> Conv<T1, T2, &'b [T2; M]> for &[[T1; N]; K]

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign, [(); { _ }]:,

type OutputT = <T1 as Mul<T2>>::Output

type Output = [[<T1 as Mul<T2>>::Output; { _ }]; K]

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

impl<'b, const K: usize, const N: usize, const M: usize, T1, T2> Conv<T1, T2, &'b [T2; M]> for [&[T1; N]; K]

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign, [(); { _ }]:,

type OutputT = <T1 as Mul<T2>>::Output

type Output = [[<T1 as Mul<T2>>::Output; { _ }]; K]

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

impl<'b, const K: usize, const N: usize, const M: usize, T1, T2> Conv<T1, T2, &'b [T2; M]> for [[T1; N]; K]

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign, [(); { _ }]:,

type OutputT = <T1 as Mul<T2>>::Output

type Output = [[<T1 as Mul<T2>>::Output; { _ }]; K]

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

impl<'b, const K: usize, const N: usize, const M: usize, T1, T2> Conv<T1, T2, [&'b [T2; M]; K]> for &[T1; N]

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign, [(); { _ }]:,

type OutputT = <T1 as Mul<T2>>::Output

type Output = [[<T1 as Mul<T2>>::Output; { _ }]; K]

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

impl<'b, const K: usize, const N: usize, const M: usize, T1, T2> Conv<T1, T2, [&'b [T2; M]; K]> for [T1; N]

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign, [(); { _ }]:,

type OutputT = <T1 as Mul<T2>>::Output

type Output = [[<T1 as Mul<T2>>::Output; { _ }]; K]

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

impl<'b, const M: usize, T1, T2> Conv<T1, T2, &'b [T2; M]> for &[&[T1]]

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign,

type OutputT = <T1 as Mul<T2>>::Output

type Output = Vec<Vec<<T1 as Mul<T2>>::Output>>

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

impl<'b, const M: usize, T1, T2> Conv<T1, T2, &'b [T2; M]> for &[Vec<T1>]

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign,

type OutputT = <T1 as Mul<T2>>::Output

type Output = Vec<Vec<<T1 as Mul<T2>>::Output>>

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

impl<'b, const M: usize, T1, T2> Conv<T1, T2, &'b [T2; M]> for ()

where T1: Mul<T2>,

type OutputT = T2

type Output = &'b [T2; M]

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

impl<'b, const M: usize, T1, T2> Conv<T1, T2, &'b [T2; M]> for Vec<&[T1]>

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign,

type OutputT = <T1 as Mul<T2>>::Output

type Output = Vec<Vec<<T1 as Mul<T2>>::Output>>

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

impl<'b, const M: usize, T1, T2> Conv<T1, T2, &'b [T2; M]> for Vec<Vec<T1>>

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign,

type OutputT = <T1 as Mul<T2>>::Output

type Output = Vec<Vec<<T1 as Mul<T2>>::Output>>

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

impl<'b, const M: usize, T1, T2> Conv<T1, T2, &'b [T2; M]> for Vec<T1>

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign,

type OutputT = <T1 as Mul<T2>>::Output

type Output = Vec<<T1 as Mul<T2>>::Output>

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

impl<'b, const M: usize, T1, T2> Conv<T1, T2, Vec<&'b [T2; M]>> for &[T1]

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign,

type OutputT = <T1 as Mul<T2>>::Output

type Output = Vec<Vec<<T1 as Mul<T2>>::Output>>

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

impl<'b, const M: usize, T1, T2> Conv<T1, T2, Vec<&'b [T2; M]>> for ()

where T1: Mul<T2>,

type OutputT = T2

type Output = Vec<&'b [T2; M]>

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

impl<'b, const M: usize, T1, T2> Conv<T1, T2, Vec<&'b [T2; M]>> for Vec<T1>

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign,

type OutputT = <T1 as Mul<T2>>::Output

type Output = Vec<Vec<<T1 as Mul<T2>>::Output>>

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

impl<'b, const N: usize, T1, T2> Conv<T1, T2, &'b [T2]> for &[&[T1; N]]

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign,

type OutputT = <T1 as Mul<T2>>::Output

type Output = Vec<Vec<<T1 as Mul<T2>>::Output>>

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

impl<'b, const N: usize, T1, T2> Conv<T1, T2, &'b [T2]> for &[[T1; N]]

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign,

type OutputT = <T1 as Mul<T2>>::Output

type Output = Vec<Vec<<T1 as Mul<T2>>::Output>>

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

impl<'b, const N: usize, T1, T2> Conv<T1, T2, &'b [T2]> for [T1; N]

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign,

type OutputT = <T1 as Mul<T2>>::Output

type Output = Vec<<T1 as Mul<T2>>::Output>

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

impl<'b, const N: usize, T1, T2> Conv<T1, T2, &'b [T2]> for Vec<&[T1; N]>

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign,

type OutputT = <T1 as Mul<T2>>::Output

type Output = Vec<Vec<<T1 as Mul<T2>>::Output>>

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

impl<'b, const N: usize, T1, T2> Conv<T1, T2, &'b [T2]> for Vec<[T1; N]>

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign,

type OutputT = <T1 as Mul<T2>>::Output

type Output = Vec<Vec<<T1 as Mul<T2>>::Output>>

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

impl<'b, const N: usize, T1, T2> Conv<T1, T2, Vec<&'b [T2]>> for &[T1; N]

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign,

type OutputT = <T1 as Mul<T2>>::Output

type Output = Vec<Vec<<T1 as Mul<T2>>::Output>>

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

impl<'b, const N: usize, T1, T2> Conv<T1, T2, Vec<&'b [T2]>> for [T1; N]

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign,

type OutputT = <T1 as Mul<T2>>::Output

type Output = Vec<Vec<<T1 as Mul<T2>>::Output>>

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

impl<'b, const N: usize, const M: usize, T1, T2> Conv<T1, T2, &'b [T2; M]> for &[&[T1; N]]

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign, [(); { _ }]:,

type OutputT = <T1 as Mul<T2>>::Output

type Output = Vec<[<T1 as Mul<T2>>::Output; { _ }]>

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

impl<'b, const N: usize, const M: usize, T1, T2> Conv<T1, T2, &'b [T2; M]> for &[[T1; N]]

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign, [(); { _ }]:,

type OutputT = <T1 as Mul<T2>>::Output

type Output = Vec<[<T1 as Mul<T2>>::Output; { _ }]>

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

impl<'b, const N: usize, const M: usize, T1, T2> Conv<T1, T2, &'b [T2; M]> for [T1; N]

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign, [(); { _ }]:,

type OutputT = <T1 as Mul<T2>>::Output

type Output = [<T1 as Mul<T2>>::Output; { _ }]

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

impl<'b, const N: usize, const M: usize, T1, T2> Conv<T1, T2, &'b [T2; M]> for Vec<&[T1; N]>

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign, [(); { _ }]:,

type OutputT = <T1 as Mul<T2>>::Output

type Output = Vec<[<T1 as Mul<T2>>::Output; { _ }]>

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

impl<'b, const N: usize, const M: usize, T1, T2> Conv<T1, T2, &'b [T2; M]> for Vec<[T1; N]>

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign, [(); { _ }]:,

type OutputT = <T1 as Mul<T2>>::Output

type Output = Vec<[<T1 as Mul<T2>>::Output; { _ }]>

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

impl<'b, const N: usize, const M: usize, T1, T2> Conv<T1, T2, Vec<&'b [T2; M]>> for &[T1; N]

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign, [(); { _ }]:,

type OutputT = <T1 as Mul<T2>>::Output

type Output = Vec<[<T1 as Mul<T2>>::Output; { _ }]>

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

impl<'b, const N: usize, const M: usize, T1, T2> Conv<T1, T2, Vec<&'b [T2; M]>> for [T1; N]

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign, [(); { _ }]:,

type OutputT = <T1 as Mul<T2>>::Output

type Output = Vec<[<T1 as Mul<T2>>::Output; { _ }]>

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

impl<'c, 'b, T1, T2> Conv<T1, T2, &'c [&'b [T2]]> for &[T1]

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign,

type OutputT = <T1 as Mul<T2>>::Output

type Output = Vec<Vec<<T1 as Mul<T2>>::Output>>

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

impl<'c, 'b, T1, T2> Conv<T1, T2, &'c [&'b [T2]]> for ()

where T1: Mul<T2>,

type OutputT = T2

type Output = &'c [&'b [T2]]

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

impl<'c, 'b, T1, T2> Conv<T1, T2, &'c [&'b [T2]]> for Vec<T1>

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign,

type OutputT = <T1 as Mul<T2>>::Output

type Output = Vec<Vec<<T1 as Mul<T2>>::Output>>

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

impl<'c, 'b, const K: usize, T1, T2> Conv<T1, T2, &'c [&'b [T2]; K]> for &[T1]

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign,

type OutputT = <T1 as Mul<T2>>::Output

type Output = [Vec<<T1 as Mul<T2>>::Output>; K]

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

impl<'c, 'b, const K: usize, T1, T2> Conv<T1, T2, &'c [&'b [T2]; K]> for ()

where T1: Mul<T2>,

type OutputT = T2

type Output = &'c [&'b [T2]; K]

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

impl<'c, 'b, const K: usize, T1, T2> Conv<T1, T2, &'c [&'b [T2]; K]> for Vec<T1>

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign,

type OutputT = <T1 as Mul<T2>>::Output

type Output = [Vec<<T1 as Mul<T2>>::Output>; K]

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

impl<'c, 'b, const K: usize, const M: usize, T1, T2> Conv<T1, T2, &'c [&'b [T2; M]; K]> for &[T1]

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign,

type OutputT = <T1 as Mul<T2>>::Output

type Output = [Vec<<T1 as Mul<T2>>::Output>; K]

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

impl<'c, 'b, const K: usize, const M: usize, T1, T2> Conv<T1, T2, &'c [&'b [T2; M]; K]> for ()

where T1: Mul<T2>,

type OutputT = T2

type Output = &'c [&'b [T2; M]; K]

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

impl<'c, 'b, const K: usize, const M: usize, T1, T2> Conv<T1, T2, &'c [&'b [T2; M]; K]> for Vec<T1>

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign,

type OutputT = <T1 as Mul<T2>>::Output

type Output = [Vec<<T1 as Mul<T2>>::Output>; K]

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

impl<'c, 'b, const K: usize, const N: usize, T1, T2> Conv<T1, T2, &'c [&'b [T2]; K]> for &[T1; N]

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign,

type OutputT = <T1 as Mul<T2>>::Output

type Output = [Vec<<T1 as Mul<T2>>::Output>; K]

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

impl<'c, 'b, const K: usize, const N: usize, T1, T2> Conv<T1, T2, &'c [&'b [T2]; K]> for [T1; N]

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign,

type OutputT = <T1 as Mul<T2>>::Output

type Output = [Vec<<T1 as Mul<T2>>::Output>; K]

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

impl<'c, 'b, const K: usize, const N: usize, const M: usize, T1, T2> Conv<T1, T2, &'c [&'b [T2; M]; K]> for &[T1; N]

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign, [(); { _ }]:,

type OutputT = <T1 as Mul<T2>>::Output

type Output = [[<T1 as Mul<T2>>::Output; { _ }]; K]

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

impl<'c, 'b, const K: usize, const N: usize, const M: usize, T1, T2> Conv<T1, T2, &'c [&'b [T2; M]; K]> for [T1; N]

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign, [(); { _ }]:,

type OutputT = <T1 as Mul<T2>>::Output

type Output = [[<T1 as Mul<T2>>::Output; { _ }]; K]

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

impl<'c, 'b, const M: usize, T1, T2> Conv<T1, T2, &'c [&'b [T2; M]]> for &[T1]

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign,

type OutputT = <T1 as Mul<T2>>::Output

type Output = Vec<Vec<<T1 as Mul<T2>>::Output>>

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

impl<'c, 'b, const M: usize, T1, T2> Conv<T1, T2, &'c [&'b [T2; M]]> for ()

where T1: Mul<T2>,

type OutputT = T2

type Output = &'c [&'b [T2; M]]

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

impl<'c, 'b, const M: usize, T1, T2> Conv<T1, T2, &'c [&'b [T2; M]]> for Vec<T1>

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign,

type OutputT = <T1 as Mul<T2>>::Output

type Output = Vec<Vec<<T1 as Mul<T2>>::Output>>

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

impl<'c, 'b, const N: usize, T1, T2> Conv<T1, T2, &'c [&'b [T2]]> for &[T1; N]

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign,

type OutputT = <T1 as Mul<T2>>::Output

type Output = Vec<Vec<<T1 as Mul<T2>>::Output>>

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

impl<'c, 'b, const N: usize, T1, T2> Conv<T1, T2, &'c [&'b [T2]]> for [T1; N]

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign,

type OutputT = <T1 as Mul<T2>>::Output

type Output = Vec<Vec<<T1 as Mul<T2>>::Output>>

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

impl<'c, 'b, const N: usize, const M: usize, T1, T2> Conv<T1, T2, &'c [&'b [T2; M]]> for &[T1; N]

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign, [(); { _ }]:,

type OutputT = <T1 as Mul<T2>>::Output

type Output = Vec<[<T1 as Mul<T2>>::Output; { _ }]>

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

impl<'c, 'b, const N: usize, const M: usize, T1, T2> Conv<T1, T2, &'c [&'b [T2; M]]> for [T1; N]

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign, [(); { _ }]:,

type OutputT = <T1 as Mul<T2>>::Output

type Output = Vec<[<T1 as Mul<T2>>::Output; { _ }]>

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

impl<'c, T1, T2> Conv<T1, T2, &'c [Vec<T2>]> for &[T1]

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign,

type OutputT = <T1 as Mul<T2>>::Output

type Output = Vec<Vec<<T1 as Mul<T2>>::Output>>

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

impl<'c, T1, T2> Conv<T1, T2, &'c [Vec<T2>]> for ()

where T1: Mul<T2>,

type OutputT = T2

type Output = &'c [Vec<T2>]

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

impl<'c, T1, T2> Conv<T1, T2, &'c [Vec<T2>]> for Vec<T1>

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign,

type OutputT = <T1 as Mul<T2>>::Output

type Output = Vec<Vec<<T1 as Mul<T2>>::Output>>

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

impl<'c, T1, T2> Conv<T1, T2, ()> for &'c [Vec<T1>]

where T1: Mul<T2>,

type OutputT = T1

type Output = &'c [Vec<T1>]

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

impl<'c, const K: usize, T1, T2> Conv<T1, T2, &'c [Vec<T2>; K]> for &[T1]

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign,

type OutputT = <T1 as Mul<T2>>::Output

type Output = [Vec<<T1 as Mul<T2>>::Output>; K]

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

impl<'c, const K: usize, T1, T2> Conv<T1, T2, &'c [Vec<T2>; K]> for ()

where T1: Mul<T2>,

type OutputT = T2

type Output = &'c [Vec<T2>; K]

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

impl<'c, const K: usize, T1, T2> Conv<T1, T2, &'c [Vec<T2>; K]> for Vec<T1>

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign,

type OutputT = <T1 as Mul<T2>>::Output

type Output = [Vec<<T1 as Mul<T2>>::Output>; K]

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

impl<'c, const K: usize, T1, T2> Conv<T1, T2, ()> for &'c [Vec<T1>; K]

where T1: Mul<T2>,

type OutputT = T1

type Output = &'c [Vec<T1>; K]

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

impl<'c, const K: usize, const M: usize, T1, T2> Conv<T1, T2, &'c [[T2; M]; K]> for &[T1]

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign,

type OutputT = <T1 as Mul<T2>>::Output

type Output = [Vec<<T1 as Mul<T2>>::Output>; K]

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

impl<'c, const K: usize, const M: usize, T1, T2> Conv<T1, T2, &'c [[T2; M]; K]> for ()

where T1: Mul<T2>,

type OutputT = T2

type Output = &'c [[T2; M]; K]

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

impl<'c, const K: usize, const M: usize, T1, T2> Conv<T1, T2, &'c [[T2; M]; K]> for Vec<T1>

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign,

type OutputT = <T1 as Mul<T2>>::Output

type Output = [Vec<<T1 as Mul<T2>>::Output>; K]

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

impl<'c, const K: usize, const N: usize, T1, T2> Conv<T1, T2, &'c [Vec<T2>; K]> for &[T1; N]

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign,

type OutputT = <T1 as Mul<T2>>::Output

type Output = [Vec<<T1 as Mul<T2>>::Output>; K]

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

impl<'c, const K: usize, const N: usize, T1, T2> Conv<T1, T2, &'c [Vec<T2>; K]> for [T1; N]

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign,

type OutputT = <T1 as Mul<T2>>::Output

type Output = [Vec<<T1 as Mul<T2>>::Output>; K]

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

impl<'c, const K: usize, const N: usize, T1, T2> Conv<T1, T2, ()> for &'c [[T1; N]; K]

where T1: Mul<T2>,

type OutputT = T1

type Output = &'c [[T1; N]; K]

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

impl<'c, const K: usize, const N: usize, const M: usize, T1, T2> Conv<T1, T2, &'c [[T2; M]; K]> for &[T1; N]

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign, [(); { _ }]:,

type OutputT = <T1 as Mul<T2>>::Output

type Output = [[<T1 as Mul<T2>>::Output; { _ }]; K]

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

impl<'c, const K: usize, const N: usize, const M: usize, T1, T2> Conv<T1, T2, &'c [[T2; M]; K]> for [T1; N]

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign, [(); { _ }]:,

type OutputT = <T1 as Mul<T2>>::Output

type Output = [[<T1 as Mul<T2>>::Output; { _ }]; K]

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

impl<'c, const M: usize, T1, T2> Conv<T1, T2, &'c [[T2; M]]> for &[T1]

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign,

type OutputT = <T1 as Mul<T2>>::Output

type Output = Vec<Vec<<T1 as Mul<T2>>::Output>>

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

impl<'c, const M: usize, T1, T2> Conv<T1, T2, &'c [[T2; M]]> for ()

where T1: Mul<T2>,

type OutputT = T2

type Output = &'c [[T2; M]]

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

impl<'c, const M: usize, T1, T2> Conv<T1, T2, &'c [[T2; M]]> for Vec<T1>

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign,

type OutputT = <T1 as Mul<T2>>::Output

type Output = Vec<Vec<<T1 as Mul<T2>>::Output>>

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

impl<'c, const N: usize, T1, T2> Conv<T1, T2, &'c [Vec<T2>]> for &[T1; N]

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign,

type OutputT = <T1 as Mul<T2>>::Output

type Output = Vec<Vec<<T1 as Mul<T2>>::Output>>

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

impl<'c, const N: usize, T1, T2> Conv<T1, T2, &'c [Vec<T2>]> for [T1; N]

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign,

type OutputT = <T1 as Mul<T2>>::Output

type Output = Vec<Vec<<T1 as Mul<T2>>::Output>>

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

impl<'c, const N: usize, T1, T2> Conv<T1, T2, ()> for &'c [[T1; N]]

where T1: Mul<T2>,

type OutputT = T1

type Output = &'c [[T1; N]]

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

impl<'c, const N: usize, const M: usize, T1, T2> Conv<T1, T2, &'c [[T2; M]]> for &[T1; N]

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign, [(); { _ }]:,

type OutputT = <T1 as Mul<T2>>::Output

type Output = Vec<[<T1 as Mul<T2>>::Output; { _ }]>

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

impl<'c, const N: usize, const M: usize, T1, T2> Conv<T1, T2, &'c [[T2; M]]> for [T1; N]

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign, [(); { _ }]:,

type OutputT = <T1 as Mul<T2>>::Output

type Output = Vec<[<T1 as Mul<T2>>::Output; { _ }]>

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

impl<T1, T2> Conv<T1, T2, ()> for ()

where T1: Mul<T2>,

type OutputT = T2

type Output = ()

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

impl<T1, T2> Conv<T1, T2, ()> for Vec<Vec<T1>>

where T1: Mul<T2>,

type OutputT = T1

type Output = Vec<Vec<T1>>

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

impl<T1, T2> Conv<T1, T2, ()> for Vec<T1>

where T1: Mul<T2>,

type OutputT = T1

type Output = Vec<T1>

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

impl<T1, T2> Conv<T1, T2, Vec<Vec<T2>>> for &[T1]

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign,

type OutputT = <T1 as Mul<T2>>::Output

type Output = Vec<Vec<<T1 as Mul<T2>>::Output>>

fn conv(self, rhs: Vec<Vec<T2>>) -> Self::Output

impl<T1, T2> Conv<T1, T2, Vec<Vec<T2>>> for ()

where T1: Mul<T2>,

type OutputT = T2

type Output = Vec<Vec<T2>>

fn conv(self, rhs: Vec<Vec<T2>>) -> Self::Output

impl<T1, T2> Conv<T1, T2, Vec<Vec<T2>>> for Vec<T1>

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign,

type OutputT = <T1 as Mul<T2>>::Output

type Output = Vec<Vec<<T1 as Mul<T2>>::Output>>

fn conv(self, rhs: Vec<Vec<T2>>) -> Self::Output

impl<T1, T2> Conv<T1, T2, Vec<T2>> for &[&[T1]]

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign,

type OutputT = <T1 as Mul<T2>>::Output

type Output = Vec<Vec<<T1 as Mul<T2>>::Output>>

fn conv(self, rhs: Vec<T2>) -> Self::Output

impl<T1, T2> Conv<T1, T2, Vec<T2>> for &[Vec<T1>]

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign,

type OutputT = <T1 as Mul<T2>>::Output

type Output = Vec<Vec<<T1 as Mul<T2>>::Output>>

fn conv(self, rhs: Vec<T2>) -> Self::Output

impl<T1, T2> Conv<T1, T2, Vec<T2>> for ()

where T1: Mul<T2>,

type OutputT = T2

type Output = Vec<T2>

fn conv(self, rhs: Vec<T2>) -> Self::Output

impl<T1, T2> Conv<T1, T2, Vec<T2>> for Vec<&[T1]>

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign,

type OutputT = <T1 as Mul<T2>>::Output

type Output = Vec<Vec<<T1 as Mul<T2>>::Output>>

fn conv(self, rhs: Vec<T2>) -> Self::Output

impl<T1, T2> Conv<T1, T2, Vec<T2>> for Vec<Vec<T1>>

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign,

type OutputT = <T1 as Mul<T2>>::Output

type Output = Vec<Vec<<T1 as Mul<T2>>::Output>>

fn conv(self, rhs: Vec<T2>) -> Self::Output

impl<T1, T2> Conv<T1, T2, Vec<T2>> for Vec<T1>

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign,

type OutputT = <T1 as Mul<T2>>::Output

type Output = Vec<<T1 as Mul<T2>>::Output>

fn conv(self, rhs: Vec<T2>) -> Self::Output

impl<const K: usize, T1, T2> Conv<T1, T2, ()> for [Vec<T1>; K]

where T1: Mul<T2>,

type OutputT = T1

type Output = [Vec<T1>; K]

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

impl<const K: usize, T1, T2> Conv<T1, T2, Vec<T2>> for &[&[T1]; K]

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign,

type OutputT = <T1 as Mul<T2>>::Output

type Output = [Vec<<T1 as Mul<T2>>::Output>; K]

fn conv(self, rhs: Vec<T2>) -> Self::Output

impl<const K: usize, T1, T2> Conv<T1, T2, Vec<T2>> for &[Vec<T1>; K]

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign,

type OutputT = <T1 as Mul<T2>>::Output

type Output = [Vec<<T1 as Mul<T2>>::Output>; K]

fn conv(self, rhs: Vec<T2>) -> Self::Output

impl<const K: usize, T1, T2> Conv<T1, T2, Vec<T2>> for [&[T1]; K]

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign,

type OutputT = <T1 as Mul<T2>>::Output

type Output = [Vec<<T1 as Mul<T2>>::Output>; K]

fn conv(self, rhs: Vec<T2>) -> Self::Output

impl<const K: usize, T1, T2> Conv<T1, T2, Vec<T2>> for [Vec<T1>; K]

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign,

type OutputT = <T1 as Mul<T2>>::Output

type Output = [Vec<<T1 as Mul<T2>>::Output>; K]

fn conv(self, rhs: Vec<T2>) -> Self::Output

impl<const K: usize, T1, T2> Conv<T1, T2, [Vec<T2>; K]> for &[T1]

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign,

type OutputT = <T1 as Mul<T2>>::Output

type Output = [Vec<<T1 as Mul<T2>>::Output>; K]

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

impl<const K: usize, T1, T2> Conv<T1, T2, [Vec<T2>; K]> for ()

where T1: Mul<T2>,

type OutputT = T2

type Output = [Vec<T2>; K]

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

impl<const K: usize, T1, T2> Conv<T1, T2, [Vec<T2>; K]> for Vec<T1>

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign,

type OutputT = <T1 as Mul<T2>>::Output

type Output = [Vec<<T1 as Mul<T2>>::Output>; K]

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

impl<const K: usize, const M: usize, T1, T2> Conv<T1, T2, [T2; M]> for &[&[T1]; K]

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign,

type OutputT = <T1 as Mul<T2>>::Output

type Output = [Vec<<T1 as Mul<T2>>::Output>; K]

fn conv(self, rhs: [T2; M]) -> Self::Output

impl<const K: usize, const M: usize, T1, T2> Conv<T1, T2, [T2; M]> for &[Vec<T1>; K]

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign,

type OutputT = <T1 as Mul<T2>>::Output

type Output = [Vec<<T1 as Mul<T2>>::Output>; K]

fn conv(self, rhs: [T2; M]) -> Self::Output

impl<const K: usize, const M: usize, T1, T2> Conv<T1, T2, [T2; M]> for [&[T1]; K]

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign,

type OutputT = <T1 as Mul<T2>>::Output

type Output = [Vec<<T1 as Mul<T2>>::Output>; K]

fn conv(self, rhs: [T2; M]) -> Self::Output

impl<const K: usize, const M: usize, T1, T2> Conv<T1, T2, [T2; M]> for [Vec<T1>; K]

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign,

type OutputT = <T1 as Mul<T2>>::Output

type Output = [Vec<<T1 as Mul<T2>>::Output>; K]

fn conv(self, rhs: [T2; M]) -> Self::Output

impl<const K: usize, const M: usize, T1, T2> Conv<T1, T2, [[T2; M]; K]> for &[T1]

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign,

type OutputT = <T1 as Mul<T2>>::Output

type Output = [Vec<<T1 as Mul<T2>>::Output>; K]

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

impl<const K: usize, const M: usize, T1, T2> Conv<T1, T2, [[T2; M]; K]> for ()

where T1: Mul<T2>,

type OutputT = T2

type Output = [[T2; M]; K]

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

impl<const K: usize, const M: usize, T1, T2> Conv<T1, T2, [[T2; M]; K]> for Vec<T1>

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign,

type OutputT = <T1 as Mul<T2>>::Output

type Output = [Vec<<T1 as Mul<T2>>::Output>; K]

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

impl<const K: usize, const N: usize, T1, T2> Conv<T1, T2, ()> for [[T1; N]; K]

where T1: Mul<T2>,

type OutputT = T1

type Output = [[T1; N]; K]

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

impl<const K: usize, const N: usize, T1, T2> Conv<T1, T2, Vec<T2>> for &[&[T1; N]; K]

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign,

type OutputT = <T1 as Mul<T2>>::Output

type Output = [Vec<<T1 as Mul<T2>>::Output>; K]

fn conv(self, rhs: Vec<T2>) -> Self::Output

impl<const K: usize, const N: usize, T1, T2> Conv<T1, T2, Vec<T2>> for &[[T1; N]; K]

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign,

type OutputT = <T1 as Mul<T2>>::Output

type Output = [Vec<<T1 as Mul<T2>>::Output>; K]

fn conv(self, rhs: Vec<T2>) -> Self::Output

impl<const K: usize, const N: usize, T1, T2> Conv<T1, T2, Vec<T2>> for [&[T1; N]; K]

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign,

type OutputT = <T1 as Mul<T2>>::Output

type Output = [Vec<<T1 as Mul<T2>>::Output>; K]

fn conv(self, rhs: Vec<T2>) -> Self::Output

impl<const K: usize, const N: usize, T1, T2> Conv<T1, T2, Vec<T2>> for [[T1; N]; K]

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign,

type OutputT = <T1 as Mul<T2>>::Output

type Output = [Vec<<T1 as Mul<T2>>::Output>; K]

fn conv(self, rhs: Vec<T2>) -> Self::Output

impl<const K: usize, const N: usize, T1, T2> Conv<T1, T2, [Vec<T2>; K]> for &[T1; N]

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign,

type OutputT = <T1 as Mul<T2>>::Output

type Output = [Vec<<T1 as Mul<T2>>::Output>; K]

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

impl<const K: usize, const N: usize, T1, T2> Conv<T1, T2, [Vec<T2>; K]> for [T1; N]

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign,

type OutputT = <T1 as Mul<T2>>::Output

type Output = [Vec<<T1 as Mul<T2>>::Output>; K]

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

impl<const K: usize, const N: usize, const M: usize, T1, T2> Conv<T1, T2, [T2; M]> for &[&[T1; N]; K]

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign, [(); { _ }]:,

type OutputT = <T1 as Mul<T2>>::Output

type Output = [[<T1 as Mul<T2>>::Output; { _ }]; K]

fn conv(self, rhs: [T2; M]) -> Self::Output

impl<const K: usize, const N: usize, const M: usize, T1, T2> Conv<T1, T2, [T2; M]> for &[[T1; N]; K]

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign, [(); { _ }]:,

type OutputT = <T1 as Mul<T2>>::Output

type Output = [[<T1 as Mul<T2>>::Output; { _ }]; K]

fn conv(self, rhs: [T2; M]) -> Self::Output

impl<const K: usize, const N: usize, const M: usize, T1, T2> Conv<T1, T2, [T2; M]> for [&[T1; N]; K]

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign, [(); { _ }]:,

type OutputT = <T1 as Mul<T2>>::Output

type Output = [[<T1 as Mul<T2>>::Output; { _ }]; K]

fn conv(self, rhs: [T2; M]) -> Self::Output

impl<const K: usize, const N: usize, const M: usize, T1, T2> Conv<T1, T2, [T2; M]> for [[T1; N]; K]

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign, [(); { _ }]:,

type OutputT = <T1 as Mul<T2>>::Output

type Output = [[<T1 as Mul<T2>>::Output; { _ }]; K]

fn conv(self, rhs: [T2; M]) -> Self::Output

impl<const K: usize, const N: usize, const M: usize, T1, T2> Conv<T1, T2, [[T2; M]; K]> for &[T1; N]

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign, [(); { _ }]:,

type OutputT = <T1 as Mul<T2>>::Output

type Output = [[<T1 as Mul<T2>>::Output; { _ }]; K]

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

impl<const K: usize, const N: usize, const M: usize, T1, T2> Conv<T1, T2, [[T2; M]; K]> for [T1; N]

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign, [(); { _ }]:,

type OutputT = <T1 as Mul<T2>>::Output

type Output = [[<T1 as Mul<T2>>::Output; { _ }]; K]

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

impl<const M: usize, T1, T2> Conv<T1, T2, [T2; M]> for &[&[T1]]

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign,

type OutputT = <T1 as Mul<T2>>::Output

type Output = Vec<Vec<<T1 as Mul<T2>>::Output>>

fn conv(self, rhs: [T2; M]) -> Self::Output

impl<const M: usize, T1, T2> Conv<T1, T2, [T2; M]> for &[Vec<T1>]

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign,

type OutputT = <T1 as Mul<T2>>::Output

type Output = Vec<Vec<<T1 as Mul<T2>>::Output>>

fn conv(self, rhs: [T2; M]) -> Self::Output

impl<const M: usize, T1, T2> Conv<T1, T2, [T2; M]> for ()

where T1: Mul<T2>,

type OutputT = T2

type Output = [T2; M]

fn conv(self, rhs: [T2; M]) -> Self::Output

impl<const M: usize, T1, T2> Conv<T1, T2, [T2; M]> for Vec<&[T1]>

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign,

type OutputT = <T1 as Mul<T2>>::Output

type Output = Vec<Vec<<T1 as Mul<T2>>::Output>>

fn conv(self, rhs: [T2; M]) -> Self::Output

impl<const M: usize, T1, T2> Conv<T1, T2, [T2; M]> for Vec<Vec<T1>>

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign,

type OutputT = <T1 as Mul<T2>>::Output

type Output = Vec<Vec<<T1 as Mul<T2>>::Output>>

fn conv(self, rhs: [T2; M]) -> Self::Output

impl<const M: usize, T1, T2> Conv<T1, T2, [T2; M]> for Vec<T1>

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign,

type OutputT = <T1 as Mul<T2>>::Output

type Output = Vec<<T1 as Mul<T2>>::Output>

fn conv(self, rhs: [T2; M]) -> Self::Output

impl<const M: usize, T1, T2> Conv<T1, T2, Vec<[T2; M]>> for &[T1]

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign,

type OutputT = <T1 as Mul<T2>>::Output

type Output = Vec<Vec<<T1 as Mul<T2>>::Output>>

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

impl<const M: usize, T1, T2> Conv<T1, T2, Vec<[T2; M]>> for ()

where T1: Mul<T2>,

type OutputT = T2

type Output = Vec<[T2; M]>

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

impl<const M: usize, T1, T2> Conv<T1, T2, Vec<[T2; M]>> for Vec<T1>

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign,

type OutputT = <T1 as Mul<T2>>::Output

type Output = Vec<Vec<<T1 as Mul<T2>>::Output>>

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

impl<const N: usize, T1, T2> Conv<T1, T2, ()> for [T1; N]

where T1: Mul<T2>,

type OutputT = T1

type Output = [T1; N]

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

impl<const N: usize, T1, T2> Conv<T1, T2, ()> for Vec<[T1; N]>

where T1: Mul<T2>,

type OutputT = T1

type Output = Vec<[T1; N]>

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

impl<const N: usize, T1, T2> Conv<T1, T2, Vec<Vec<T2>>> for &[T1; N]

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign,

type OutputT = <T1 as Mul<T2>>::Output

type Output = Vec<Vec<<T1 as Mul<T2>>::Output>>

fn conv(self, rhs: Vec<Vec<T2>>) -> Self::Output

impl<const N: usize, T1, T2> Conv<T1, T2, Vec<Vec<T2>>> for [T1; N]

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign,

type OutputT = <T1 as Mul<T2>>::Output

type Output = Vec<Vec<<T1 as Mul<T2>>::Output>>

fn conv(self, rhs: Vec<Vec<T2>>) -> Self::Output

impl<const N: usize, T1, T2> Conv<T1, T2, Vec<T2>> for &[&[T1; N]]

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign,

type OutputT = <T1 as Mul<T2>>::Output

type Output = Vec<Vec<<T1 as Mul<T2>>::Output>>

fn conv(self, rhs: Vec<T2>) -> Self::Output

impl<const N: usize, T1, T2> Conv<T1, T2, Vec<T2>> for &[[T1; N]]

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign,

type OutputT = <T1 as Mul<T2>>::Output

type Output = Vec<Vec<<T1 as Mul<T2>>::Output>>

fn conv(self, rhs: Vec<T2>) -> Self::Output

impl<const N: usize, T1, T2> Conv<T1, T2, Vec<T2>> for [T1; N]

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign,

type OutputT = <T1 as Mul<T2>>::Output

type Output = Vec<<T1 as Mul<T2>>::Output>

fn conv(self, rhs: Vec<T2>) -> Self::Output

impl<const N: usize, T1, T2> Conv<T1, T2, Vec<T2>> for Vec<&[T1; N]>

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign,

type OutputT = <T1 as Mul<T2>>::Output

type Output = Vec<Vec<<T1 as Mul<T2>>::Output>>

fn conv(self, rhs: Vec<T2>) -> Self::Output

impl<const N: usize, T1, T2> Conv<T1, T2, Vec<T2>> for Vec<[T1; N]>

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign,

type OutputT = <T1 as Mul<T2>>::Output

type Output = Vec<Vec<<T1 as Mul<T2>>::Output>>

fn conv(self, rhs: Vec<T2>) -> Self::Output

impl<const N: usize, const M: usize, T1, T2> Conv<T1, T2, [T2; M]> for &[&[T1; N]]

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign, [(); { _ }]:,

type OutputT = <T1 as Mul<T2>>::Output

type Output = Vec<[<T1 as Mul<T2>>::Output; { _ }]>

fn conv(self, rhs: [T2; M]) -> Self::Output

impl<const N: usize, const M: usize, T1, T2> Conv<T1, T2, [T2; M]> for &[[T1; N]]

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign, [(); { _ }]:,

type OutputT = <T1 as Mul<T2>>::Output

type Output = Vec<[<T1 as Mul<T2>>::Output; { _ }]>

fn conv(self, rhs: [T2; M]) -> Self::Output

impl<const N: usize, const M: usize, T1, T2> Conv<T1, T2, [T2; M]> for [T1; N]

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign, [(); { _ }]:,

type OutputT = <T1 as Mul<T2>>::Output

type Output = [<T1 as Mul<T2>>::Output; { _ }]

fn conv(self, rhs: [T2; M]) -> Self::Output

impl<const N: usize, const M: usize, T1, T2> Conv<T1, T2, [T2; M]> for Vec<&[T1; N]>

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign, [(); { _ }]:,

type OutputT = <T1 as Mul<T2>>::Output

type Output = Vec<[<T1 as Mul<T2>>::Output; { _ }]>

fn conv(self, rhs: [T2; M]) -> Self::Output

impl<const N: usize, const M: usize, T1, T2> Conv<T1, T2, [T2; M]> for Vec<[T1; N]>

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign, [(); { _ }]:,

type OutputT = <T1 as Mul<T2>>::Output

type Output = Vec<[<T1 as Mul<T2>>::Output; { _ }]>

fn conv(self, rhs: [T2; M]) -> Self::Output

impl<const N: usize, const M: usize, T1, T2> Conv<T1, T2, Vec<[T2; M]>> for &[T1; N]

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign, [(); { _ }]:,

type OutputT = <T1 as Mul<T2>>::Output

type Output = Vec<[<T1 as Mul<T2>>::Output; { _ }]>

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

impl<const N: usize, const M: usize, T1, T2> Conv<T1, T2, Vec<[T2; M]>> for [T1; N]

where T1: ComplexFloat + Mul<T2, Output: ComplexFloat + From<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + 'static>, T2: ComplexFloat, Complex<T1::Real>: From<T1> + AddAssign + MulAssign + Mul<Complex<T2::Real>, Output: ComplexFloat<Real = <<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real> + From<Complex<<<T1 as Mul<T2>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<T2::Real>: From<T2> + AddAssign + MulAssign, [(); { _ }]:,

type OutputT = <T1 as Mul<T2>>::Output

type Output = Vec<[<T1 as Mul<T2>>::Output; { _ }]>

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

Implementors