Trait signal_processing::operations::convolution::Conv2d

pub trait Conv2d<T1, T2, Rhs>: MaybeMatrix<T1>
where
    T1: Mul<T2>,
    Rhs: MaybeMatrix<T2>,
{
    type Output: MaybeMatrix<<T1 as Mul<T2>>::Output>;

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

Required Associated Types

type Output: MaybeMatrix<<T1 as Mul<T2>>::Output>

Required Methods

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

Object Safety

This trait is not object safe.

Implementations on Foreign Types

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

where T1: Mul<T2, Output = T3>, &'a [T1]: Conv<T1, T2, &'b [T2]>, <&'a [T1] as Conv<T1, T2, &'b [T2]>>::Output: MaybeMatrix<T3>,

type Output = <&'a [T1] as Conv<T1, T2, &'b [T2]>>::Output

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

impl<'a, 'b, T1, T2, T3> Conv2d<T1, T2, ArrayBase<ViewRepr<&'b T2>, Dim<[usize; 1]>>> for &'a [T1]

where T1: Mul<T2, Output = T3>, &'a [T1]: Conv<T1, T2, ArrayView1<'b, T2>>, <&'a [T1] as Conv<T1, T2, ArrayView1<'b, T2>>>::Output: MaybeMatrix<T3>,

type Output = <&'a [T1] as Conv<T1, T2, ArrayBase<ViewRepr<&'b T2>, Dim<[usize; 1]>>>>::Output

fn conv_2d(self, rhs: ArrayView1<'b, T2>) -> Self::Output

impl<'a, 'b, T1, T2, T3> Conv2d<T1, T2, ArrayBase<ViewRepr<&'b T2>, Dim<[usize; 2]>>> for ArrayView2<'a, T1>

where T1: ComplexFloat + Mul<T2, Output = T3> + Into<Complex<T1::Real>>, T2: ComplexFloat + Into<Complex<T2::Real>>, T3: ComplexFloat<Real: Into<T3>> + 'static, ArrayView2<'a, T1>: Matrix<T1, Index = (usize, usize)>, ArrayView2<'b, T2>: Matrix<T2, Index = (usize, usize)>, Array2<Complex<T1::Real>>: Dft2d<Complex<T1::Real>, Mapped<Complex<T1::Real>> = Array2<Complex<T1::Real>>> + Mul<Array2<Complex<T2::Real>>, Output = Array2<Complex<T3::Real>>>, Array2<Complex<T2::Real>>: Dft2d<Complex<T2::Real>, Mapped<Complex<T2::Real>> = Array2<Complex<T2::Real>>>, Array2<Complex<T3::Real>>: Idft2d<Complex<T3::Real>, Mapped<Complex<T3::Real>> = Array2<Complex<T3::Real>>>,

type Output = ArrayBase<OwnedRepr<T3>, Dim<[usize; 2]>>

fn conv_2d(self, rhs: ArrayView2<'b, T2>) -> Self::Output

impl<'a, 'b, const N1: usize, T1, T2, T3> Conv2d<T1, T2, &'b [T2]> for &'a [T1; N1]

where T1: Mul<T2, Output = T3>, &'a [T1; N1]: Conv<T1, T2, &'b [T2]>, <&'a [T1; N1] as Conv<T1, T2, &'b [T2]>>::Output: MaybeMatrix<T3>,

type Output = <&'a [T1; N1] as Conv<T1, T2, &'b [T2]>>::Output

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

impl<'a, 'b, const N1: usize, T1, T2, T3> Conv2d<T1, T2, ArrayBase<ViewRepr<&'b T2>, Dim<[usize; 1]>>> for &'a [T1; N1]

where T1: Mul<T2, Output = T3>, &'a [T1; N1]: Conv<T1, T2, ArrayView1<'b, T2>>, <&'a [T1; N1] as Conv<T1, T2, ArrayView1<'b, T2>>>::Output: MaybeMatrix<T3>,

type Output = <&'a [T1; N1] as Conv<T1, T2, ArrayBase<ViewRepr<&'b T2>, Dim<[usize; 1]>>>>::Output

fn conv_2d(self, rhs: ArrayView1<'b, T2>) -> Self::Output

impl<'a, 'b, const N1: usize, const N2: usize, T1, T2, T3> Conv2d<T1, T2, &'b [T2; N2]> for &'a [T1; N1]

where T1: Mul<T2, Output = T3>, &'a [T1; N1]: Conv<T1, T2, &'b [T2; N2]>, <&'a [T1; N1] as Conv<T1, T2, &'b [T2; N2]>>::Output: MaybeMatrix<T3>,

type Output = <&'a [T1; N1] as Conv<T1, T2, &'b [T2; N2]>>::Output

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

impl<'a, 'b, const N2: usize, T1, T2, T3> Conv2d<T1, T2, &'b [T2; N2]> for &'a [T1]

where T1: Mul<T2, Output = T3>, &'a [T1]: Conv<T1, T2, &'b [T2; N2]>, <&'a [T1] as Conv<T1, T2, &'b [T2; N2]>>::Output: MaybeMatrix<T3>,

type Output = <&'a [T1] as Conv<T1, T2, &'b [T2; N2]>>::Output

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

impl<'a, 'bm, 'bn, const N2: usize, T1, T2, T3> Conv2d<T1, T2, &'bm [&'bn [T2; N2]]> for ArrayView2<'a, T1>

where T1: ComplexFloat + Mul<T2, Output = T3> + Into<Complex<T1::Real>>, T2: ComplexFloat + Into<Complex<T2::Real>>, T3: ComplexFloat<Real: Into<T3>> + 'static, ArrayView2<'a, T1>: Matrix<T1, Index = (usize, usize)>, &'bm [&'bn [T2; N2]]: Matrix<T2, Index = (usize, usize)>, Array2<Complex<T1::Real>>: Dft2d<Complex<T1::Real>, Mapped<Complex<T1::Real>> = Array2<Complex<T1::Real>>> + Mul<Array2<Complex<T2::Real>>, Output = Array2<Complex<T3::Real>>>, Array2<Complex<T2::Real>>: Dft2d<Complex<T2::Real>, Mapped<Complex<T2::Real>> = Array2<Complex<T2::Real>>>, Array2<Complex<T3::Real>>: Idft2d<Complex<T3::Real>, Mapped<Complex<T3::Real>> = Array2<Complex<T3::Real>>>,

type Output = ArrayBase<OwnedRepr<T3>, Dim<[usize; 2]>>

fn conv_2d(self, rhs: &'bm [&'bn [T2; N2]]) -> Self::Output

impl<'a, 'bm, 'bn, const N2: usize, const M2: usize, T1, T2, T3> Conv2d<T1, T2, &'bm [&'bn [T2; N2]; M2]> for ArrayView2<'a, T1>

where T1: ComplexFloat + Mul<T2, Output = T3> + Into<Complex<T1::Real>>, T2: ComplexFloat + Into<Complex<T2::Real>>, T3: ComplexFloat<Real: Into<T3>> + 'static, ArrayView2<'a, T1>: Matrix<T1, Index = (usize, usize)>, &'bm [&'bn [T2; N2]; M2]: Matrix<T2, Index = (usize, usize)>, Array2<Complex<T1::Real>>: Dft2d<Complex<T1::Real>, Mapped<Complex<T1::Real>> = Array2<Complex<T1::Real>>> + Mul<Array2<Complex<T2::Real>>, Output = Array2<Complex<T3::Real>>>, Array2<Complex<T2::Real>>: Dft2d<Complex<T2::Real>, Mapped<Complex<T2::Real>> = Array2<Complex<T2::Real>>>, Array2<Complex<T3::Real>>: Idft2d<Complex<T3::Real>, Mapped<Complex<T3::Real>> = Array2<Complex<T3::Real>>>,

type Output = ArrayBase<OwnedRepr<T3>, Dim<[usize; 2]>>

fn conv_2d(self, rhs: &'bm [&'bn [T2; N2]; M2]) -> Self::Output

impl<'a, 'bm, const N2: usize, T1, T2, T3> Conv2d<T1, T2, &'bm [[T2; N2]]> for ArrayView2<'a, T1>

where T1: ComplexFloat + Mul<T2, Output = T3> + Into<Complex<T1::Real>>, T2: ComplexFloat + Into<Complex<T2::Real>>, T3: ComplexFloat<Real: Into<T3>> + 'static, ArrayView2<'a, T1>: Matrix<T1, Index = (usize, usize)>, &'bm [[T2; N2]]: Matrix<T2, Index = (usize, usize)>, Array2<Complex<T1::Real>>: Dft2d<Complex<T1::Real>, Mapped<Complex<T1::Real>> = Array2<Complex<T1::Real>>> + Mul<Array2<Complex<T2::Real>>, Output = Array2<Complex<T3::Real>>>, Array2<Complex<T2::Real>>: Dft2d<Complex<T2::Real>, Mapped<Complex<T2::Real>> = Array2<Complex<T2::Real>>>, Array2<Complex<T3::Real>>: Idft2d<Complex<T3::Real>, Mapped<Complex<T3::Real>> = Array2<Complex<T3::Real>>>,

type Output = ArrayBase<OwnedRepr<T3>, Dim<[usize; 2]>>

fn conv_2d(self, rhs: &'bm [[T2; N2]]) -> Self::Output

impl<'a, 'bm, const N2: usize, const M2: usize, T1, T2, T3> Conv2d<T1, T2, &'bm [[T2; N2]; M2]> for ArrayView2<'a, T1>

where T1: ComplexFloat + Mul<T2, Output = T3> + Into<Complex<T1::Real>>, T2: ComplexFloat + Into<Complex<T2::Real>>, T3: ComplexFloat<Real: Into<T3>> + 'static, ArrayView2<'a, T1>: Matrix<T1, Index = (usize, usize)>, &'bm [[T2; N2]; M2]: Matrix<T2, Index = (usize, usize)>, Array2<Complex<T1::Real>>: Dft2d<Complex<T1::Real>, Mapped<Complex<T1::Real>> = Array2<Complex<T1::Real>>> + Mul<Array2<Complex<T2::Real>>, Output = Array2<Complex<T3::Real>>>, Array2<Complex<T2::Real>>: Dft2d<Complex<T2::Real>, Mapped<Complex<T2::Real>> = Array2<Complex<T2::Real>>>, Array2<Complex<T3::Real>>: Idft2d<Complex<T3::Real>, Mapped<Complex<T3::Real>> = Array2<Complex<T3::Real>>>,

type Output = ArrayBase<OwnedRepr<T3>, Dim<[usize; 2]>>

fn conv_2d(self, rhs: &'bm [[T2; N2]; M2]) -> Self::Output

impl<'a, 'bn, const N2: usize, T1, T2, T3> Conv2d<T1, T2, Vec<&'bn [T2; N2]>> for ArrayView2<'a, T1>

where T1: ComplexFloat + Mul<T2, Output = T3> + Into<Complex<T1::Real>>, T2: ComplexFloat + Into<Complex<T2::Real>>, T3: ComplexFloat<Real: Into<T3>> + 'static, ArrayView2<'a, T1>: Matrix<T1, Index = (usize, usize)>, Vec<&'bn [T2; N2]>: Matrix<T2, Index = (usize, usize)>, Array2<Complex<T1::Real>>: Dft2d<Complex<T1::Real>, Mapped<Complex<T1::Real>> = Array2<Complex<T1::Real>>> + Mul<Array2<Complex<T2::Real>>, Output = Array2<Complex<T3::Real>>>, Array2<Complex<T2::Real>>: Dft2d<Complex<T2::Real>, Mapped<Complex<T2::Real>> = Array2<Complex<T2::Real>>>, Array2<Complex<T3::Real>>: Idft2d<Complex<T3::Real>, Mapped<Complex<T3::Real>> = Array2<Complex<T3::Real>>>,

type Output = ArrayBase<OwnedRepr<T3>, Dim<[usize; 2]>>

fn conv_2d(self, rhs: Vec<&'bn [T2; N2]>) -> Self::Output

impl<'a, 'bn, const N2: usize, const M2: usize, T1, T2, T3> Conv2d<T1, T2, [&'bn [T2; N2]; M2]> for ArrayView2<'a, T1>

where T1: ComplexFloat + Mul<T2, Output = T3> + Into<Complex<T1::Real>>, T2: ComplexFloat + Into<Complex<T2::Real>>, T3: ComplexFloat<Real: Into<T3>> + 'static, ArrayView2<'a, T1>: Matrix<T1, Index = (usize, usize)>, [&'bn [T2; N2]; M2]: Matrix<T2, Index = (usize, usize)>, Array2<Complex<T1::Real>>: Dft2d<Complex<T1::Real>, Mapped<Complex<T1::Real>> = Array2<Complex<T1::Real>>> + Mul<Array2<Complex<T2::Real>>, Output = Array2<Complex<T3::Real>>>, Array2<Complex<T2::Real>>: Dft2d<Complex<T2::Real>, Mapped<Complex<T2::Real>> = Array2<Complex<T2::Real>>>, Array2<Complex<T3::Real>>: Idft2d<Complex<T3::Real>, Mapped<Complex<T3::Real>> = Array2<Complex<T3::Real>>>,

type Output = ArrayBase<OwnedRepr<T3>, Dim<[usize; 2]>>

fn conv_2d(self, rhs: [&'bn [T2; N2]; M2]) -> Self::Output

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

where T1: Mul<T2, Output = T3>, &'a [T1]: Conv<T1, T2, ()>, <&'a [T1] as Conv<T1, T2, ()>>::Output: MaybeMatrix<T3>,

type Output = <&'a [T1] as Conv<T1, T2, ()>>::Output

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

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

where T1: Mul<T2, Output = T3>, &'a [T1]: Conv<T1, T2, Vec<T2>>, <&'a [T1] as Conv<T1, T2, Vec<T2>>>::Output: MaybeMatrix<T3>,

type Output = <&'a [T1] as Conv<T1, T2, Vec<T2>>>::Output

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

impl<'a, T1, T2, T3> Conv2d<T1, T2, ArrayBase<OwnedRepr<T2>, Dim<[usize; 1]>>> for &'a [T1]

where T1: Mul<T2, Output = T3>, &'a [T1]: Conv<T1, T2, Array1<T2>>, <&'a [T1] as Conv<T1, T2, Array1<T2>>>::Output: MaybeMatrix<T3>,

type Output = <&'a [T1] as Conv<T1, T2, ArrayBase<OwnedRepr<T2>, Dim<[usize; 1]>>>>::Output

fn conv_2d(self, rhs: Array1<T2>) -> Self::Output

impl<'a, T1, T2, T3> Conv2d<T1, T2, ArrayBase<OwnedRepr<T2>, Dim<[usize; 2]>>> for ArrayView2<'a, T1>

where T1: ComplexFloat + Mul<T2, Output = T3> + Into<Complex<T1::Real>>, T2: ComplexFloat + Into<Complex<T2::Real>>, T3: ComplexFloat<Real: Into<T3>> + 'static, ArrayView2<'a, T1>: Matrix<T1, Index = (usize, usize)>, Array2<T2>: Matrix<T2, Index = (usize, usize)>, Array2<Complex<T1::Real>>: Dft2d<Complex<T1::Real>, Mapped<Complex<T1::Real>> = Array2<Complex<T1::Real>>> + Mul<Array2<Complex<T2::Real>>, Output = Array2<Complex<T3::Real>>>, Array2<Complex<T2::Real>>: Dft2d<Complex<T2::Real>, Mapped<Complex<T2::Real>> = Array2<Complex<T2::Real>>>, Array2<Complex<T3::Real>>: Idft2d<Complex<T3::Real>, Mapped<Complex<T3::Real>> = Array2<Complex<T3::Real>>>,

type Output = ArrayBase<OwnedRepr<T3>, Dim<[usize; 2]>>

fn conv_2d(self, rhs: Array2<T2>) -> Self::Output

impl<'a, const N1: usize, T1, T2, T3> Conv2d<T1, T2, ()> for &'a [T1; N1]

where T1: Mul<T2, Output = T3>, &'a [T1; N1]: Conv<T1, T2, ()>, <&'a [T1; N1] as Conv<T1, T2, ()>>::Output: MaybeMatrix<T3>,

type Output = <&'a [T1; N1] as Conv<T1, T2, ()>>::Output

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

impl<'a, const N1: usize, T1, T2, T3> Conv2d<T1, T2, Vec<T2>> for &'a [T1; N1]

where T1: Mul<T2, Output = T3>, &'a [T1; N1]: Conv<T1, T2, Vec<T2>>, <&'a [T1; N1] as Conv<T1, T2, Vec<T2>>>::Output: MaybeMatrix<T3>,

type Output = <&'a [T1; N1] as Conv<T1, T2, Vec<T2>>>::Output

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

impl<'a, const N1: usize, T1, T2, T3> Conv2d<T1, T2, ArrayBase<OwnedRepr<T2>, Dim<[usize; 1]>>> for &'a [T1; N1]

where T1: Mul<T2, Output = T3>, &'a [T1; N1]: Conv<T1, T2, Array1<T2>>, <&'a [T1; N1] as Conv<T1, T2, Array1<T2>>>::Output: MaybeMatrix<T3>,

type Output = <&'a [T1; N1] as Conv<T1, T2, ArrayBase<OwnedRepr<T2>, Dim<[usize; 1]>>>>::Output

fn conv_2d(self, rhs: Array1<T2>) -> Self::Output

impl<'a, const N1: usize, const N2: usize, T1, T2, T3> Conv2d<T1, T2, [T2; N2]> for &'a [T1; N1]

where T1: Mul<T2, Output = T3>, &'a [T1; N1]: Conv<T1, T2, [T2; N2]>, <&'a [T1; N1] as Conv<T1, T2, [T2; N2]>>::Output: MaybeMatrix<T3>,

type Output = <&'a [T1; N1] as Conv<T1, T2, [T2; N2]>>::Output

fn conv_2d(self, rhs: [T2; N2]) -> Self::Output

impl<'a, const N2: usize, T1, T2, T3> Conv2d<T1, T2, [T2; N2]> for &'a [T1]

where T1: Mul<T2, Output = T3>, &'a [T1]: Conv<T1, T2, [T2; N2]>, <&'a [T1] as Conv<T1, T2, [T2; N2]>>::Output: MaybeMatrix<T3>,

type Output = <&'a [T1] as Conv<T1, T2, [T2; N2]>>::Output

fn conv_2d(self, rhs: [T2; N2]) -> Self::Output

impl<'a, const N2: usize, T1, T2, T3> Conv2d<T1, T2, Vec<[T2; N2]>> for ArrayView2<'a, T1>

where T1: ComplexFloat + Mul<T2, Output = T3> + Into<Complex<T1::Real>>, T2: ComplexFloat + Into<Complex<T2::Real>>, T3: ComplexFloat<Real: Into<T3>> + 'static, ArrayView2<'a, T1>: Matrix<T1, Index = (usize, usize)>, Vec<[T2; N2]>: Matrix<T2, Index = (usize, usize)>, Array2<Complex<T1::Real>>: Dft2d<Complex<T1::Real>, Mapped<Complex<T1::Real>> = Array2<Complex<T1::Real>>> + Mul<Array2<Complex<T2::Real>>, Output = Array2<Complex<T3::Real>>>, Array2<Complex<T2::Real>>: Dft2d<Complex<T2::Real>, Mapped<Complex<T2::Real>> = Array2<Complex<T2::Real>>>, Array2<Complex<T3::Real>>: Idft2d<Complex<T3::Real>, Mapped<Complex<T3::Real>> = Array2<Complex<T3::Real>>>,

type Output = ArrayBase<OwnedRepr<T3>, Dim<[usize; 2]>>

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

impl<'a, const N2: usize, const M2: usize, T1, T2, T3> Conv2d<T1, T2, [[T2; N2]; M2]> for ArrayView2<'a, T1>

where T1: ComplexFloat + Mul<T2, Output = T3> + Into<Complex<T1::Real>>, T2: ComplexFloat + Into<Complex<T2::Real>>, T3: ComplexFloat<Real: Into<T3>> + 'static, ArrayView2<'a, T1>: Matrix<T1, Index = (usize, usize)>, [[T2; N2]; M2]: Matrix<T2, Index = (usize, usize)>, Array2<Complex<T1::Real>>: Dft2d<Complex<T1::Real>, Mapped<Complex<T1::Real>> = Array2<Complex<T1::Real>>> + Mul<Array2<Complex<T2::Real>>, Output = Array2<Complex<T3::Real>>>, Array2<Complex<T2::Real>>: Dft2d<Complex<T2::Real>, Mapped<Complex<T2::Real>> = Array2<Complex<T2::Real>>>, Array2<Complex<T3::Real>>: Idft2d<Complex<T3::Real>, Mapped<Complex<T3::Real>> = Array2<Complex<T3::Real>>>,

type Output = ArrayBase<OwnedRepr<T3>, Dim<[usize; 2]>>

fn conv_2d(self, rhs: [[T2; N2]; M2]) -> Self::Output

impl<'am, 'an, 'b, const N1: usize, const M1: usize, T1, T2, T3> Conv2d<T1, T2, ArrayBase<ViewRepr<&'b T2>, Dim<[usize; 2]>>> for &'am [&'an [T1; N1]; M1]

where T1: ComplexFloat + Mul<T2, Output = T3> + Into<Complex<T1::Real>>, T2: ComplexFloat + Into<Complex<T2::Real>>, T3: ComplexFloat<Real: Into<T3>> + 'static, &'am [&'an [T1; N1]; M1]: Matrix<T1, Index = (usize, usize)>, ArrayView2<'b, T2>: Matrix<T2, Index = (usize, usize)>, Array2<Complex<T1::Real>>: Dft2d<Complex<T1::Real>, Mapped<Complex<T1::Real>> = Array2<Complex<T1::Real>>> + Mul<Array2<Complex<T2::Real>>, Output = Array2<Complex<T3::Real>>>, Array2<Complex<T2::Real>>: Dft2d<Complex<T2::Real>, Mapped<Complex<T2::Real>> = Array2<Complex<T2::Real>>>, Array2<Complex<T3::Real>>: Idft2d<Complex<T3::Real>, Mapped<Complex<T3::Real>> = Array2<Complex<T3::Real>>>,

type Output = ArrayBase<OwnedRepr<T3>, Dim<[usize; 2]>>

fn conv_2d(self, rhs: ArrayView2<'b, T2>) -> Self::Output

impl<'am, 'an, 'bm, 'bn, const N1: usize, const N2: usize, const M1: usize, T1, T2, T3> Conv2d<T1, T2, &'bm [&'bn [T2; N2]]> for &'am [&'an [T1; N1]; M1]

where T1: ComplexFloat + Mul<T2, Output = T3> + Into<Complex<T1::Real>>, T2: ComplexFloat + Into<Complex<T2::Real>>, T3: ComplexFloat<Real: Into<T3>> + 'static, &'am [&'an [T1; N1]; M1]: Matrix<T1, Index = (usize, usize)>, &'bm [&'bn [T2; N2]]: Matrix<T2, Index = (usize, usize)>, Array2<Complex<T1::Real>>: Dft2d<Complex<T1::Real>, Mapped<Complex<T1::Real>> = Array2<Complex<T1::Real>>> + Mul<Array2<Complex<T2::Real>>, Output = Array2<Complex<T3::Real>>>, Array2<Complex<T2::Real>>: Dft2d<Complex<T2::Real>, Mapped<Complex<T2::Real>> = Array2<Complex<T2::Real>>>, Array2<Complex<T3::Real>>: Idft2d<Complex<T3::Real>, Mapped<Complex<T3::Real>> = Array2<Complex<T3::Real>>>, Vec<[T3; { _ }]>: MaybeMatrix<T3>,

type Output = Vec<[T3; { _ }]>

fn conv_2d(self, rhs: &'bm [&'bn [T2; N2]]) -> Self::Output

impl<'am, 'an, 'bm, 'bn, const N1: usize, const N2: usize, const M1: usize, const M2: usize, T1, T2, T3> Conv2d<T1, T2, &'bm [&'bn [T2; N2]; M2]> for &'am [&'an [T1; N1]; M1]

where T1: ComplexFloat + Mul<T2, Output = T3> + Into<Complex<T1::Real>>, T2: ComplexFloat + Into<Complex<T2::Real>>, T3: ComplexFloat<Real: Into<T3>> + 'static, &'am [&'an [T1; N1]; M1]: Matrix<T1, Index = (usize, usize)>, &'bm [&'bn [T2; N2]; M2]: Matrix<T2, Index = (usize, usize)>, Array2<Complex<T1::Real>>: Dft2d<Complex<T1::Real>, Mapped<Complex<T1::Real>> = Array2<Complex<T1::Real>>> + Mul<Array2<Complex<T2::Real>>, Output = Array2<Complex<T3::Real>>>, Array2<Complex<T2::Real>>: Dft2d<Complex<T2::Real>, Mapped<Complex<T2::Real>> = Array2<Complex<T2::Real>>>, Array2<Complex<T3::Real>>: Idft2d<Complex<T3::Real>, Mapped<Complex<T3::Real>> = Array2<Complex<T3::Real>>>, [[T3; { _ }]; { _ }]: MaybeMatrix<T3>,

type Output = [[T3; { _ }]; { _ }]

fn conv_2d(self, rhs: &'bm [&'bn [T2; N2]; M2]) -> Self::Output

impl<'am, 'an, 'bm, const N1: usize, const N2: usize, const M1: usize, T1, T2, T3> Conv2d<T1, T2, &'bm [[T2; N2]]> for &'am [&'an [T1; N1]; M1]

where T1: ComplexFloat + Mul<T2, Output = T3> + Into<Complex<T1::Real>>, T2: ComplexFloat + Into<Complex<T2::Real>>, T3: ComplexFloat<Real: Into<T3>> + 'static, &'am [&'an [T1; N1]; M1]: Matrix<T1, Index = (usize, usize)>, &'bm [[T2; N2]]: Matrix<T2, Index = (usize, usize)>, Array2<Complex<T1::Real>>: Dft2d<Complex<T1::Real>, Mapped<Complex<T1::Real>> = Array2<Complex<T1::Real>>> + Mul<Array2<Complex<T2::Real>>, Output = Array2<Complex<T3::Real>>>, Array2<Complex<T2::Real>>: Dft2d<Complex<T2::Real>, Mapped<Complex<T2::Real>> = Array2<Complex<T2::Real>>>, Array2<Complex<T3::Real>>: Idft2d<Complex<T3::Real>, Mapped<Complex<T3::Real>> = Array2<Complex<T3::Real>>>, Vec<[T3; { _ }]>: MaybeMatrix<T3>,

type Output = Vec<[T3; { _ }]>

fn conv_2d(self, rhs: &'bm [[T2; N2]]) -> Self::Output

impl<'am, 'an, 'bm, const N1: usize, const N2: usize, const M1: usize, const M2: usize, T1, T2, T3> Conv2d<T1, T2, &'bm [[T2; N2]; M2]> for &'am [&'an [T1; N1]; M1]

where T1: ComplexFloat + Mul<T2, Output = T3> + Into<Complex<T1::Real>>, T2: ComplexFloat + Into<Complex<T2::Real>>, T3: ComplexFloat<Real: Into<T3>> + 'static, &'am [&'an [T1; N1]; M1]: Matrix<T1, Index = (usize, usize)>, &'bm [[T2; N2]; M2]: Matrix<T2, Index = (usize, usize)>, Array2<Complex<T1::Real>>: Dft2d<Complex<T1::Real>, Mapped<Complex<T1::Real>> = Array2<Complex<T1::Real>>> + Mul<Array2<Complex<T2::Real>>, Output = Array2<Complex<T3::Real>>>, Array2<Complex<T2::Real>>: Dft2d<Complex<T2::Real>, Mapped<Complex<T2::Real>> = Array2<Complex<T2::Real>>>, Array2<Complex<T3::Real>>: Idft2d<Complex<T3::Real>, Mapped<Complex<T3::Real>> = Array2<Complex<T3::Real>>>, [[T3; { _ }]; { _ }]: MaybeMatrix<T3>,

type Output = [[T3; { _ }]; { _ }]

fn conv_2d(self, rhs: &'bm [[T2; N2]; M2]) -> Self::Output

impl<'am, 'an, 'bn, const N1: usize, const N2: usize, const M1: usize, T1, T2, T3> Conv2d<T1, T2, Vec<&'bn [T2; N2]>> for &'am [&'an [T1; N1]; M1]

where T1: ComplexFloat + Mul<T2, Output = T3> + Into<Complex<T1::Real>>, T2: ComplexFloat + Into<Complex<T2::Real>>, T3: ComplexFloat<Real: Into<T3>> + 'static, &'am [&'an [T1; N1]; M1]: Matrix<T1, Index = (usize, usize)>, Vec<&'bn [T2; N2]>: Matrix<T2, Index = (usize, usize)>, Array2<Complex<T1::Real>>: Dft2d<Complex<T1::Real>, Mapped<Complex<T1::Real>> = Array2<Complex<T1::Real>>> + Mul<Array2<Complex<T2::Real>>, Output = Array2<Complex<T3::Real>>>, Array2<Complex<T2::Real>>: Dft2d<Complex<T2::Real>, Mapped<Complex<T2::Real>> = Array2<Complex<T2::Real>>>, Array2<Complex<T3::Real>>: Idft2d<Complex<T3::Real>, Mapped<Complex<T3::Real>> = Array2<Complex<T3::Real>>>, Vec<[T3; { _ }]>: MaybeMatrix<T3>,

type Output = Vec<[T3; { _ }]>

fn conv_2d(self, rhs: Vec<&'bn [T2; N2]>) -> Self::Output

impl<'am, 'an, 'bn, const N1: usize, const N2: usize, const M1: usize, const M2: usize, T1, T2, T3> Conv2d<T1, T2, [&'bn [T2; N2]; M2]> for &'am [&'an [T1; N1]; M1]

where T1: ComplexFloat + Mul<T2, Output = T3> + Into<Complex<T1::Real>>, T2: ComplexFloat + Into<Complex<T2::Real>>, T3: ComplexFloat<Real: Into<T3>> + 'static, &'am [&'an [T1; N1]; M1]: Matrix<T1, Index = (usize, usize)>, [&'bn [T2; N2]; M2]: Matrix<T2, Index = (usize, usize)>, Array2<Complex<T1::Real>>: Dft2d<Complex<T1::Real>, Mapped<Complex<T1::Real>> = Array2<Complex<T1::Real>>> + Mul<Array2<Complex<T2::Real>>, Output = Array2<Complex<T3::Real>>>, Array2<Complex<T2::Real>>: Dft2d<Complex<T2::Real>, Mapped<Complex<T2::Real>> = Array2<Complex<T2::Real>>>, Array2<Complex<T3::Real>>: Idft2d<Complex<T3::Real>, Mapped<Complex<T3::Real>> = Array2<Complex<T3::Real>>>, [[T3; { _ }]; { _ }]: MaybeMatrix<T3>,

type Output = [[T3; { _ }]; { _ }]

fn conv_2d(self, rhs: [&'bn [T2; N2]; M2]) -> Self::Output

impl<'am, 'an, const N1: usize, const M1: usize, T1, T2, T3> Conv2d<T1, T2, ArrayBase<OwnedRepr<T2>, Dim<[usize; 2]>>> for &'am [&'an [T1; N1]; M1]

where T1: ComplexFloat + Mul<T2, Output = T3> + Into<Complex<T1::Real>>, T2: ComplexFloat + Into<Complex<T2::Real>>, T3: ComplexFloat<Real: Into<T3>> + 'static, &'am [&'an [T1; N1]; M1]: Matrix<T1, Index = (usize, usize)>, Array2<T2>: Matrix<T2, Index = (usize, usize)>, Array2<Complex<T1::Real>>: Dft2d<Complex<T1::Real>, Mapped<Complex<T1::Real>> = Array2<Complex<T1::Real>>> + Mul<Array2<Complex<T2::Real>>, Output = Array2<Complex<T3::Real>>>, Array2<Complex<T2::Real>>: Dft2d<Complex<T2::Real>, Mapped<Complex<T2::Real>> = Array2<Complex<T2::Real>>>, Array2<Complex<T3::Real>>: Idft2d<Complex<T3::Real>, Mapped<Complex<T3::Real>> = Array2<Complex<T3::Real>>>,

type Output = ArrayBase<OwnedRepr<T3>, Dim<[usize; 2]>>

fn conv_2d(self, rhs: Array2<T2>) -> Self::Output

impl<'am, 'an, const N1: usize, const N2: usize, const M1: usize, T1, T2, T3> Conv2d<T1, T2, Vec<[T2; N2]>> for &'am [&'an [T1; N1]; M1]

where T1: ComplexFloat + Mul<T2, Output = T3> + Into<Complex<T1::Real>>, T2: ComplexFloat + Into<Complex<T2::Real>>, T3: ComplexFloat<Real: Into<T3>> + 'static, &'am [&'an [T1; N1]; M1]: Matrix<T1, Index = (usize, usize)>, Vec<[T2; N2]>: Matrix<T2, Index = (usize, usize)>, Array2<Complex<T1::Real>>: Dft2d<Complex<T1::Real>, Mapped<Complex<T1::Real>> = Array2<Complex<T1::Real>>> + Mul<Array2<Complex<T2::Real>>, Output = Array2<Complex<T3::Real>>>, Array2<Complex<T2::Real>>: Dft2d<Complex<T2::Real>, Mapped<Complex<T2::Real>> = Array2<Complex<T2::Real>>>, Array2<Complex<T3::Real>>: Idft2d<Complex<T3::Real>, Mapped<Complex<T3::Real>> = Array2<Complex<T3::Real>>>, Vec<[T3; { _ }]>: MaybeMatrix<T3>,

type Output = Vec<[T3; { _ }]>

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

impl<'am, 'an, const N1: usize, const N2: usize, const M1: usize, const M2: usize, T1, T2, T3> Conv2d<T1, T2, [[T2; N2]; M2]> for &'am [&'an [T1; N1]; M1]

where T1: ComplexFloat + Mul<T2, Output = T3> + Into<Complex<T1::Real>>, T2: ComplexFloat + Into<Complex<T2::Real>>, T3: ComplexFloat<Real: Into<T3>> + 'static, &'am [&'an [T1; N1]; M1]: Matrix<T1, Index = (usize, usize)>, [[T2; N2]; M2]: Matrix<T2, Index = (usize, usize)>, Array2<Complex<T1::Real>>: Dft2d<Complex<T1::Real>, Mapped<Complex<T1::Real>> = Array2<Complex<T1::Real>>> + Mul<Array2<Complex<T2::Real>>, Output = Array2<Complex<T3::Real>>>, Array2<Complex<T2::Real>>: Dft2d<Complex<T2::Real>, Mapped<Complex<T2::Real>> = Array2<Complex<T2::Real>>>, Array2<Complex<T3::Real>>: Idft2d<Complex<T3::Real>, Mapped<Complex<T3::Real>> = Array2<Complex<T3::Real>>>, [[T3; { _ }]; { _ }]: MaybeMatrix<T3>,

type Output = [[T3; { _ }]; { _ }]

fn conv_2d(self, rhs: [[T2; N2]; M2]) -> Self::Output

impl<'am, 'b, const N1: usize, const M1: usize, T1, T2, T3> Conv2d<T1, T2, ArrayBase<ViewRepr<&'b T2>, Dim<[usize; 2]>>> for &'am [[T1; N1]; M1]

where T1: ComplexFloat + Mul<T2, Output = T3> + Into<Complex<T1::Real>>, T2: ComplexFloat + Into<Complex<T2::Real>>, T3: ComplexFloat<Real: Into<T3>> + 'static, &'am [[T1; N1]; M1]: Matrix<T1, Index = (usize, usize)>, ArrayView2<'b, T2>: Matrix<T2, Index = (usize, usize)>, Array2<Complex<T1::Real>>: Dft2d<Complex<T1::Real>, Mapped<Complex<T1::Real>> = Array2<Complex<T1::Real>>> + Mul<Array2<Complex<T2::Real>>, Output = Array2<Complex<T3::Real>>>, Array2<Complex<T2::Real>>: Dft2d<Complex<T2::Real>, Mapped<Complex<T2::Real>> = Array2<Complex<T2::Real>>>, Array2<Complex<T3::Real>>: Idft2d<Complex<T3::Real>, Mapped<Complex<T3::Real>> = Array2<Complex<T3::Real>>>,

type Output = ArrayBase<OwnedRepr<T3>, Dim<[usize; 2]>>

fn conv_2d(self, rhs: ArrayView2<'b, T2>) -> Self::Output

impl<'am, 'bm, 'bn, const N1: usize, const N2: usize, const M1: usize, T1, T2, T3> Conv2d<T1, T2, &'bm [&'bn [T2; N2]]> for &'am [[T1; N1]; M1]

where T1: ComplexFloat + Mul<T2, Output = T3> + Into<Complex<T1::Real>>, T2: ComplexFloat + Into<Complex<T2::Real>>, T3: ComplexFloat<Real: Into<T3>> + 'static, &'am [[T1; N1]; M1]: Matrix<T1, Index = (usize, usize)>, &'bm [&'bn [T2; N2]]: Matrix<T2, Index = (usize, usize)>, Array2<Complex<T1::Real>>: Dft2d<Complex<T1::Real>, Mapped<Complex<T1::Real>> = Array2<Complex<T1::Real>>> + Mul<Array2<Complex<T2::Real>>, Output = Array2<Complex<T3::Real>>>, Array2<Complex<T2::Real>>: Dft2d<Complex<T2::Real>, Mapped<Complex<T2::Real>> = Array2<Complex<T2::Real>>>, Array2<Complex<T3::Real>>: Idft2d<Complex<T3::Real>, Mapped<Complex<T3::Real>> = Array2<Complex<T3::Real>>>, Vec<[T3; { _ }]>: MaybeMatrix<T3>,

type Output = Vec<[T3; { _ }]>

fn conv_2d(self, rhs: &'bm [&'bn [T2; N2]]) -> Self::Output

impl<'am, 'bm, 'bn, const N1: usize, const N2: usize, const M1: usize, const M2: usize, T1, T2, T3> Conv2d<T1, T2, &'bm [&'bn [T2; N2]; M2]> for &'am [[T1; N1]; M1]

where T1: ComplexFloat + Mul<T2, Output = T3> + Into<Complex<T1::Real>>, T2: ComplexFloat + Into<Complex<T2::Real>>, T3: ComplexFloat<Real: Into<T3>> + 'static, &'am [[T1; N1]; M1]: Matrix<T1, Index = (usize, usize)>, &'bm [&'bn [T2; N2]; M2]: Matrix<T2, Index = (usize, usize)>, Array2<Complex<T1::Real>>: Dft2d<Complex<T1::Real>, Mapped<Complex<T1::Real>> = Array2<Complex<T1::Real>>> + Mul<Array2<Complex<T2::Real>>, Output = Array2<Complex<T3::Real>>>, Array2<Complex<T2::Real>>: Dft2d<Complex<T2::Real>, Mapped<Complex<T2::Real>> = Array2<Complex<T2::Real>>>, Array2<Complex<T3::Real>>: Idft2d<Complex<T3::Real>, Mapped<Complex<T3::Real>> = Array2<Complex<T3::Real>>>, [[T3; { _ }]; { _ }]: MaybeMatrix<T3>,

type Output = [[T3; { _ }]; { _ }]

fn conv_2d(self, rhs: &'bm [&'bn [T2; N2]; M2]) -> Self::Output

impl<'am, 'bm, const N1: usize, const N2: usize, const M1: usize, T1, T2, T3> Conv2d<T1, T2, &'bm [[T2; N2]]> for &'am [[T1; N1]; M1]

where T1: ComplexFloat + Mul<T2, Output = T3> + Into<Complex<T1::Real>>, T2: ComplexFloat + Into<Complex<T2::Real>>, T3: ComplexFloat<Real: Into<T3>> + 'static, &'am [[T1; N1]; M1]: Matrix<T1, Index = (usize, usize)>, &'bm [[T2; N2]]: Matrix<T2, Index = (usize, usize)>, Array2<Complex<T1::Real>>: Dft2d<Complex<T1::Real>, Mapped<Complex<T1::Real>> = Array2<Complex<T1::Real>>> + Mul<Array2<Complex<T2::Real>>, Output = Array2<Complex<T3::Real>>>, Array2<Complex<T2::Real>>: Dft2d<Complex<T2::Real>, Mapped<Complex<T2::Real>> = Array2<Complex<T2::Real>>>, Array2<Complex<T3::Real>>: Idft2d<Complex<T3::Real>, Mapped<Complex<T3::Real>> = Array2<Complex<T3::Real>>>, Vec<[T3; { _ }]>: MaybeMatrix<T3>,

type Output = Vec<[T3; { _ }]>

fn conv_2d(self, rhs: &'bm [[T2; N2]]) -> Self::Output

impl<'am, 'bm, const N1: usize, const N2: usize, const M1: usize, const M2: usize, T1, T2, T3> Conv2d<T1, T2, &'bm [[T2; N2]; M2]> for &'am [[T1; N1]; M1]

where T1: ComplexFloat + Mul<T2, Output = T3> + Into<Complex<T1::Real>>, T2: ComplexFloat + Into<Complex<T2::Real>>, T3: ComplexFloat<Real: Into<T3>> + 'static, &'am [[T1; N1]; M1]: Matrix<T1, Index = (usize, usize)>, &'bm [[T2; N2]; M2]: Matrix<T2, Index = (usize, usize)>, Array2<Complex<T1::Real>>: Dft2d<Complex<T1::Real>, Mapped<Complex<T1::Real>> = Array2<Complex<T1::Real>>> + Mul<Array2<Complex<T2::Real>>, Output = Array2<Complex<T3::Real>>>, Array2<Complex<T2::Real>>: Dft2d<Complex<T2::Real>, Mapped<Complex<T2::Real>> = Array2<Complex<T2::Real>>>, Array2<Complex<T3::Real>>: Idft2d<Complex<T3::Real>, Mapped<Complex<T3::Real>> = Array2<Complex<T3::Real>>>, [[T3; { _ }]; { _ }]: MaybeMatrix<T3>,

type Output = [[T3; { _ }]; { _ }]

fn conv_2d(self, rhs: &'bm [[T2; N2]; M2]) -> Self::Output

impl<'am, 'bn, const N1: usize, const N2: usize, const M1: usize, T1, T2, T3> Conv2d<T1, T2, Vec<&'bn [T2; N2]>> for &'am [[T1; N1]; M1]

where T1: ComplexFloat + Mul<T2, Output = T3> + Into<Complex<T1::Real>>, T2: ComplexFloat + Into<Complex<T2::Real>>, T3: ComplexFloat<Real: Into<T3>> + 'static, &'am [[T1; N1]; M1]: Matrix<T1, Index = (usize, usize)>, Vec<&'bn [T2; N2]>: Matrix<T2, Index = (usize, usize)>, Array2<Complex<T1::Real>>: Dft2d<Complex<T1::Real>, Mapped<Complex<T1::Real>> = Array2<Complex<T1::Real>>> + Mul<Array2<Complex<T2::Real>>, Output = Array2<Complex<T3::Real>>>, Array2<Complex<T2::Real>>: Dft2d<Complex<T2::Real>, Mapped<Complex<T2::Real>> = Array2<Complex<T2::Real>>>, Array2<Complex<T3::Real>>: Idft2d<Complex<T3::Real>, Mapped<Complex<T3::Real>> = Array2<Complex<T3::Real>>>, Vec<[T3; { _ }]>: MaybeMatrix<T3>,

type Output = Vec<[T3; { _ }]>

fn conv_2d(self, rhs: Vec<&'bn [T2; N2]>) -> Self::Output

impl<'am, 'bn, const N1: usize, const N2: usize, const M1: usize, const M2: usize, T1, T2, T3> Conv2d<T1, T2, [&'bn [T2; N2]; M2]> for &'am [[T1; N1]; M1]

where T1: ComplexFloat + Mul<T2, Output = T3> + Into<Complex<T1::Real>>, T2: ComplexFloat + Into<Complex<T2::Real>>, T3: ComplexFloat<Real: Into<T3>> + 'static, &'am [[T1; N1]; M1]: Matrix<T1, Index = (usize, usize)>, [&'bn [T2; N2]; M2]: Matrix<T2, Index = (usize, usize)>, Array2<Complex<T1::Real>>: Dft2d<Complex<T1::Real>, Mapped<Complex<T1::Real>> = Array2<Complex<T1::Real>>> + Mul<Array2<Complex<T2::Real>>, Output = Array2<Complex<T3::Real>>>, Array2<Complex<T2::Real>>: Dft2d<Complex<T2::Real>, Mapped<Complex<T2::Real>> = Array2<Complex<T2::Real>>>, Array2<Complex<T3::Real>>: Idft2d<Complex<T3::Real>, Mapped<Complex<T3::Real>> = Array2<Complex<T3::Real>>>, [[T3; { _ }]; { _ }]: MaybeMatrix<T3>,

type Output = [[T3; { _ }]; { _ }]

fn conv_2d(self, rhs: [&'bn [T2; N2]; M2]) -> Self::Output

impl<'am, const N1: usize, const M1: usize, T1, T2, T3> Conv2d<T1, T2, ArrayBase<OwnedRepr<T2>, Dim<[usize; 2]>>> for &'am [[T1; N1]; M1]

where T1: ComplexFloat + Mul<T2, Output = T3> + Into<Complex<T1::Real>>, T2: ComplexFloat + Into<Complex<T2::Real>>, T3: ComplexFloat<Real: Into<T3>> + 'static, &'am [[T1; N1]; M1]: Matrix<T1, Index = (usize, usize)>, Array2<T2>: Matrix<T2, Index = (usize, usize)>, Array2<Complex<T1::Real>>: Dft2d<Complex<T1::Real>, Mapped<Complex<T1::Real>> = Array2<Complex<T1::Real>>> + Mul<Array2<Complex<T2::Real>>, Output = Array2<Complex<T3::Real>>>, Array2<Complex<T2::Real>>: Dft2d<Complex<T2::Real>, Mapped<Complex<T2::Real>> = Array2<Complex<T2::Real>>>, Array2<Complex<T3::Real>>: Idft2d<Complex<T3::Real>, Mapped<Complex<T3::Real>> = Array2<Complex<T3::Real>>>,

type Output = ArrayBase<OwnedRepr<T3>, Dim<[usize; 2]>>

fn conv_2d(self, rhs: Array2<T2>) -> Self::Output

impl<'am, const N1: usize, const N2: usize, const M1: usize, T1, T2, T3> Conv2d<T1, T2, Vec<[T2; N2]>> for &'am [[T1; N1]; M1]

where T1: ComplexFloat + Mul<T2, Output = T3> + Into<Complex<T1::Real>>, T2: ComplexFloat + Into<Complex<T2::Real>>, T3: ComplexFloat<Real: Into<T3>> + 'static, &'am [[T1; N1]; M1]: Matrix<T1, Index = (usize, usize)>, Vec<[T2; N2]>: Matrix<T2, Index = (usize, usize)>, Array2<Complex<T1::Real>>: Dft2d<Complex<T1::Real>, Mapped<Complex<T1::Real>> = Array2<Complex<T1::Real>>> + Mul<Array2<Complex<T2::Real>>, Output = Array2<Complex<T3::Real>>>, Array2<Complex<T2::Real>>: Dft2d<Complex<T2::Real>, Mapped<Complex<T2::Real>> = Array2<Complex<T2::Real>>>, Array2<Complex<T3::Real>>: Idft2d<Complex<T3::Real>, Mapped<Complex<T3::Real>> = Array2<Complex<T3::Real>>>, Vec<[T3; { _ }]>: MaybeMatrix<T3>,

type Output = Vec<[T3; { _ }]>

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

impl<'am, const N1: usize, const N2: usize, const M1: usize, const M2: usize, T1, T2, T3> Conv2d<T1, T2, [[T2; N2]; M2]> for &'am [[T1; N1]; M1]

where T1: ComplexFloat + Mul<T2, Output = T3> + Into<Complex<T1::Real>>, T2: ComplexFloat + Into<Complex<T2::Real>>, T3: ComplexFloat<Real: Into<T3>> + 'static, &'am [[T1; N1]; M1]: Matrix<T1, Index = (usize, usize)>, [[T2; N2]; M2]: Matrix<T2, Index = (usize, usize)>, Array2<Complex<T1::Real>>: Dft2d<Complex<T1::Real>, Mapped<Complex<T1::Real>> = Array2<Complex<T1::Real>>> + Mul<Array2<Complex<T2::Real>>, Output = Array2<Complex<T3::Real>>>, Array2<Complex<T2::Real>>: Dft2d<Complex<T2::Real>, Mapped<Complex<T2::Real>> = Array2<Complex<T2::Real>>>, Array2<Complex<T3::Real>>: Idft2d<Complex<T3::Real>, Mapped<Complex<T3::Real>> = Array2<Complex<T3::Real>>>, [[T3; { _ }]; { _ }]: MaybeMatrix<T3>,

type Output = [[T3; { _ }]; { _ }]

fn conv_2d(self, rhs: [[T2; N2]; M2]) -> Self::Output

impl<'an, 'b, const N1: usize, T1, T2, T3> Conv2d<T1, T2, ArrayBase<ViewRepr<&'b T2>, Dim<[usize; 2]>>> for Vec<&'an [T1; N1]>

where T1: ComplexFloat + Mul<T2, Output = T3> + Into<Complex<T1::Real>>, T2: ComplexFloat + Into<Complex<T2::Real>>, T3: ComplexFloat<Real: Into<T3>> + 'static, Vec<&'an [T1; N1]>: Matrix<T1, Index = (usize, usize)>, ArrayView2<'b, T2>: Matrix<T2, Index = (usize, usize)>, Array2<Complex<T1::Real>>: Dft2d<Complex<T1::Real>, Mapped<Complex<T1::Real>> = Array2<Complex<T1::Real>>> + Mul<Array2<Complex<T2::Real>>, Output = Array2<Complex<T3::Real>>>, Array2<Complex<T2::Real>>: Dft2d<Complex<T2::Real>, Mapped<Complex<T2::Real>> = Array2<Complex<T2::Real>>>, Array2<Complex<T3::Real>>: Idft2d<Complex<T3::Real>, Mapped<Complex<T3::Real>> = Array2<Complex<T3::Real>>>,

type Output = ArrayBase<OwnedRepr<T3>, Dim<[usize; 2]>>

fn conv_2d(self, rhs: ArrayView2<'b, T2>) -> Self::Output

impl<'an, 'b, const N1: usize, const M1: usize, T1, T2, T3> Conv2d<T1, T2, ArrayBase<ViewRepr<&'b T2>, Dim<[usize; 2]>>> for [&'an [T1; N1]; M1]

where T1: ComplexFloat + Mul<T2, Output = T3> + Into<Complex<T1::Real>>, T2: ComplexFloat + Into<Complex<T2::Real>>, T3: ComplexFloat<Real: Into<T3>> + 'static, [&'an [T1; N1]; M1]: Matrix<T1, Index = (usize, usize)>, ArrayView2<'b, T2>: Matrix<T2, Index = (usize, usize)>, Array2<Complex<T1::Real>>: Dft2d<Complex<T1::Real>, Mapped<Complex<T1::Real>> = Array2<Complex<T1::Real>>> + Mul<Array2<Complex<T2::Real>>, Output = Array2<Complex<T3::Real>>>, Array2<Complex<T2::Real>>: Dft2d<Complex<T2::Real>, Mapped<Complex<T2::Real>> = Array2<Complex<T2::Real>>>, Array2<Complex<T3::Real>>: Idft2d<Complex<T3::Real>, Mapped<Complex<T3::Real>> = Array2<Complex<T3::Real>>>,

type Output = ArrayBase<OwnedRepr<T3>, Dim<[usize; 2]>>

fn conv_2d(self, rhs: ArrayView2<'b, T2>) -> Self::Output

impl<'an, 'bm, 'bn, const N1: usize, const N2: usize, T1, T2, T3> Conv2d<T1, T2, &'bm [&'bn [T2; N2]]> for Vec<&'an [T1; N1]>

where T1: ComplexFloat + Mul<T2, Output = T3> + Into<Complex<T1::Real>>, T2: ComplexFloat + Into<Complex<T2::Real>>, T3: ComplexFloat<Real: Into<T3>> + 'static, Vec<&'an [T1; N1]>: Matrix<T1, Index = (usize, usize)>, &'bm [&'bn [T2; N2]]: Matrix<T2, Index = (usize, usize)>, Array2<Complex<T1::Real>>: Dft2d<Complex<T1::Real>, Mapped<Complex<T1::Real>> = Array2<Complex<T1::Real>>> + Mul<Array2<Complex<T2::Real>>, Output = Array2<Complex<T3::Real>>>, Array2<Complex<T2::Real>>: Dft2d<Complex<T2::Real>, Mapped<Complex<T2::Real>> = Array2<Complex<T2::Real>>>, Array2<Complex<T3::Real>>: Idft2d<Complex<T3::Real>, Mapped<Complex<T3::Real>> = Array2<Complex<T3::Real>>>, Vec<[T3; { _ }]>: MaybeMatrix<T3>,

type Output = Vec<[T3; { _ }]>

fn conv_2d(self, rhs: &'bm [&'bn [T2; N2]]) -> Self::Output

impl<'an, 'bm, 'bn, const N1: usize, const N2: usize, const M1: usize, T1, T2, T3> Conv2d<T1, T2, &'bm [&'bn [T2; N2]]> for [&'an [T1; N1]; M1]

where T1: ComplexFloat + Mul<T2, Output = T3> + Into<Complex<T1::Real>>, T2: ComplexFloat + Into<Complex<T2::Real>>, T3: ComplexFloat<Real: Into<T3>> + 'static, [&'an [T1; N1]; M1]: Matrix<T1, Index = (usize, usize)>, &'bm [&'bn [T2; N2]]: Matrix<T2, Index = (usize, usize)>, Array2<Complex<T1::Real>>: Dft2d<Complex<T1::Real>, Mapped<Complex<T1::Real>> = Array2<Complex<T1::Real>>> + Mul<Array2<Complex<T2::Real>>, Output = Array2<Complex<T3::Real>>>, Array2<Complex<T2::Real>>: Dft2d<Complex<T2::Real>, Mapped<Complex<T2::Real>> = Array2<Complex<T2::Real>>>, Array2<Complex<T3::Real>>: Idft2d<Complex<T3::Real>, Mapped<Complex<T3::Real>> = Array2<Complex<T3::Real>>>, Vec<[T3; { _ }]>: MaybeMatrix<T3>,

type Output = Vec<[T3; { _ }]>

fn conv_2d(self, rhs: &'bm [&'bn [T2; N2]]) -> Self::Output

impl<'an, 'bm, 'bn, const N1: usize, const N2: usize, const M1: usize, const M2: usize, T1, T2, T3> Conv2d<T1, T2, &'bm [&'bn [T2; N2]; M2]> for [&'an [T1; N1]; M1]

where T1: ComplexFloat + Mul<T2, Output = T3> + Into<Complex<T1::Real>>, T2: ComplexFloat + Into<Complex<T2::Real>>, T3: ComplexFloat<Real: Into<T3>> + 'static, [&'an [T1; N1]; M1]: Matrix<T1, Index = (usize, usize)>, &'bm [&'bn [T2; N2]; M2]: Matrix<T2, Index = (usize, usize)>, Array2<Complex<T1::Real>>: Dft2d<Complex<T1::Real>, Mapped<Complex<T1::Real>> = Array2<Complex<T1::Real>>> + Mul<Array2<Complex<T2::Real>>, Output = Array2<Complex<T3::Real>>>, Array2<Complex<T2::Real>>: Dft2d<Complex<T2::Real>, Mapped<Complex<T2::Real>> = Array2<Complex<T2::Real>>>, Array2<Complex<T3::Real>>: Idft2d<Complex<T3::Real>, Mapped<Complex<T3::Real>> = Array2<Complex<T3::Real>>>, [[T3; { _ }]; { _ }]: MaybeMatrix<T3>,

type Output = [[T3; { _ }]; { _ }]

fn conv_2d(self, rhs: &'bm [&'bn [T2; N2]; M2]) -> Self::Output

impl<'an, 'bm, 'bn, const N1: usize, const N2: usize, const M2: usize, T1, T2, T3> Conv2d<T1, T2, &'bm [&'bn [T2; N2]; M2]> for Vec<&'an [T1; N1]>

where T1: ComplexFloat + Mul<T2, Output = T3> + Into<Complex<T1::Real>>, T2: ComplexFloat + Into<Complex<T2::Real>>, T3: ComplexFloat<Real: Into<T3>> + 'static, Vec<&'an [T1; N1]>: Matrix<T1, Index = (usize, usize)>, &'bm [&'bn [T2; N2]; M2]: Matrix<T2, Index = (usize, usize)>, Array2<Complex<T1::Real>>: Dft2d<Complex<T1::Real>, Mapped<Complex<T1::Real>> = Array2<Complex<T1::Real>>> + Mul<Array2<Complex<T2::Real>>, Output = Array2<Complex<T3::Real>>>, Array2<Complex<T2::Real>>: Dft2d<Complex<T2::Real>, Mapped<Complex<T2::Real>> = Array2<Complex<T2::Real>>>, Array2<Complex<T3::Real>>: Idft2d<Complex<T3::Real>, Mapped<Complex<T3::Real>> = Array2<Complex<T3::Real>>>, Vec<[T3; { _ }]>: MaybeMatrix<T3>,

type Output = Vec<[T3; { _ }]>

fn conv_2d(self, rhs: &'bm [&'bn [T2; N2]; M2]) -> Self::Output

impl<'an, 'bm, const N1: usize, const N2: usize, T1, T2, T3> Conv2d<T1, T2, &'bm [[T2; N2]]> for Vec<&'an [T1; N1]>

where T1: ComplexFloat + Mul<T2, Output = T3> + Into<Complex<T1::Real>>, T2: ComplexFloat + Into<Complex<T2::Real>>, T3: ComplexFloat<Real: Into<T3>> + 'static, Vec<&'an [T1; N1]>: Matrix<T1, Index = (usize, usize)>, &'bm [[T2; N2]]: Matrix<T2, Index = (usize, usize)>, Array2<Complex<T1::Real>>: Dft2d<Complex<T1::Real>, Mapped<Complex<T1::Real>> = Array2<Complex<T1::Real>>> + Mul<Array2<Complex<T2::Real>>, Output = Array2<Complex<T3::Real>>>, Array2<Complex<T2::Real>>: Dft2d<Complex<T2::Real>, Mapped<Complex<T2::Real>> = Array2<Complex<T2::Real>>>, Array2<Complex<T3::Real>>: Idft2d<Complex<T3::Real>, Mapped<Complex<T3::Real>> = Array2<Complex<T3::Real>>>, Vec<[T3; { _ }]>: MaybeMatrix<T3>,

type Output = Vec<[T3; { _ }]>

fn conv_2d(self, rhs: &'bm [[T2; N2]]) -> Self::Output

impl<'an, 'bm, const N1: usize, const N2: usize, const M1: usize, T1, T2, T3> Conv2d<T1, T2, &'bm [[T2; N2]]> for [&'an [T1; N1]; M1]

where T1: ComplexFloat + Mul<T2, Output = T3> + Into<Complex<T1::Real>>, T2: ComplexFloat + Into<Complex<T2::Real>>, T3: ComplexFloat<Real: Into<T3>> + 'static, [&'an [T1; N1]; M1]: Matrix<T1, Index = (usize, usize)>, &'bm [[T2; N2]]: Matrix<T2, Index = (usize, usize)>, Array2<Complex<T1::Real>>: Dft2d<Complex<T1::Real>, Mapped<Complex<T1::Real>> = Array2<Complex<T1::Real>>> + Mul<Array2<Complex<T2::Real>>, Output = Array2<Complex<T3::Real>>>, Array2<Complex<T2::Real>>: Dft2d<Complex<T2::Real>, Mapped<Complex<T2::Real>> = Array2<Complex<T2::Real>>>, Array2<Complex<T3::Real>>: Idft2d<Complex<T3::Real>, Mapped<Complex<T3::Real>> = Array2<Complex<T3::Real>>>, Vec<[T3; { _ }]>: MaybeMatrix<T3>,

type Output = Vec<[T3; { _ }]>

fn conv_2d(self, rhs: &'bm [[T2; N2]]) -> Self::Output

impl<'an, 'bm, const N1: usize, const N2: usize, const M1: usize, const M2: usize, T1, T2, T3> Conv2d<T1, T2, &'bm [[T2; N2]; M2]> for [&'an [T1; N1]; M1]

where T1: ComplexFloat + Mul<T2, Output = T3> + Into<Complex<T1::Real>>, T2: ComplexFloat + Into<Complex<T2::Real>>, T3: ComplexFloat<Real: Into<T3>> + 'static, [&'an [T1; N1]; M1]: Matrix<T1, Index = (usize, usize)>, &'bm [[T2; N2]; M2]: Matrix<T2, Index = (usize, usize)>, Array2<Complex<T1::Real>>: Dft2d<Complex<T1::Real>, Mapped<Complex<T1::Real>> = Array2<Complex<T1::Real>>> + Mul<Array2<Complex<T2::Real>>, Output = Array2<Complex<T3::Real>>>, Array2<Complex<T2::Real>>: Dft2d<Complex<T2::Real>, Mapped<Complex<T2::Real>> = Array2<Complex<T2::Real>>>, Array2<Complex<T3::Real>>: Idft2d<Complex<T3::Real>, Mapped<Complex<T3::Real>> = Array2<Complex<T3::Real>>>, [[T3; { _ }]; { _ }]: MaybeMatrix<T3>,

type Output = [[T3; { _ }]; { _ }]

fn conv_2d(self, rhs: &'bm [[T2; N2]; M2]) -> Self::Output

impl<'an, 'bm, const N1: usize, const N2: usize, const M2: usize, T1, T2, T3> Conv2d<T1, T2, &'bm [[T2; N2]; M2]> for Vec<&'an [T1; N1]>

where T1: ComplexFloat + Mul<T2, Output = T3> + Into<Complex<T1::Real>>, T2: ComplexFloat + Into<Complex<T2::Real>>, T3: ComplexFloat<Real: Into<T3>> + 'static, Vec<&'an [T1; N1]>: Matrix<T1, Index = (usize, usize)>, &'bm [[T2; N2]; M2]: Matrix<T2, Index = (usize, usize)>, Array2<Complex<T1::Real>>: Dft2d<Complex<T1::Real>, Mapped<Complex<T1::Real>> = Array2<Complex<T1::Real>>> + Mul<Array2<Complex<T2::Real>>, Output = Array2<Complex<T3::Real>>>, Array2<Complex<T2::Real>>: Dft2d<Complex<T2::Real>, Mapped<Complex<T2::Real>> = Array2<Complex<T2::Real>>>, Array2<Complex<T3::Real>>: Idft2d<Complex<T3::Real>, Mapped<Complex<T3::Real>> = Array2<Complex<T3::Real>>>, Vec<[T3; { _ }]>: MaybeMatrix<T3>,

type Output = Vec<[T3; { _ }]>

fn conv_2d(self, rhs: &'bm [[T2; N2]; M2]) -> Self::Output

impl<'an, 'bn, const N1: usize, const N2: usize, T1, T2, T3> Conv2d<T1, T2, Vec<&'bn [T2; N2]>> for Vec<&'an [T1; N1]>

where T1: ComplexFloat + Mul<T2, Output = T3> + Into<Complex<T1::Real>>, T2: ComplexFloat + Into<Complex<T2::Real>>, T3: ComplexFloat<Real: Into<T3>> + 'static, Vec<&'an [T1; N1]>: Matrix<T1, Index = (usize, usize)>, Vec<&'bn [T2; N2]>: Matrix<T2, Index = (usize, usize)>, Array2<Complex<T1::Real>>: Dft2d<Complex<T1::Real>, Mapped<Complex<T1::Real>> = Array2<Complex<T1::Real>>> + Mul<Array2<Complex<T2::Real>>, Output = Array2<Complex<T3::Real>>>, Array2<Complex<T2::Real>>: Dft2d<Complex<T2::Real>, Mapped<Complex<T2::Real>> = Array2<Complex<T2::Real>>>, Array2<Complex<T3::Real>>: Idft2d<Complex<T3::Real>, Mapped<Complex<T3::Real>> = Array2<Complex<T3::Real>>>, Vec<[T3; { _ }]>: MaybeMatrix<T3>,

type Output = Vec<[T3; { _ }]>

fn conv_2d(self, rhs: Vec<&'bn [T2; N2]>) -> Self::Output

impl<'an, 'bn, const N1: usize, const N2: usize, const M1: usize, T1, T2, T3> Conv2d<T1, T2, Vec<&'bn [T2; N2]>> for [&'an [T1; N1]; M1]

where T1: ComplexFloat + Mul<T2, Output = T3> + Into<Complex<T1::Real>>, T2: ComplexFloat + Into<Complex<T2::Real>>, T3: ComplexFloat<Real: Into<T3>> + 'static, [&'an [T1; N1]; M1]: Matrix<T1, Index = (usize, usize)>, Vec<&'bn [T2; N2]>: Matrix<T2, Index = (usize, usize)>, Array2<Complex<T1::Real>>: Dft2d<Complex<T1::Real>, Mapped<Complex<T1::Real>> = Array2<Complex<T1::Real>>> + Mul<Array2<Complex<T2::Real>>, Output = Array2<Complex<T3::Real>>>, Array2<Complex<T2::Real>>: Dft2d<Complex<T2::Real>, Mapped<Complex<T2::Real>> = Array2<Complex<T2::Real>>>, Array2<Complex<T3::Real>>: Idft2d<Complex<T3::Real>, Mapped<Complex<T3::Real>> = Array2<Complex<T3::Real>>>, Vec<[T3; { _ }]>: MaybeMatrix<T3>,

type Output = Vec<[T3; { _ }]>

fn conv_2d(self, rhs: Vec<&'bn [T2; N2]>) -> Self::Output

impl<'an, 'bn, const N1: usize, const N2: usize, const M1: usize, const M2: usize, T1, T2, T3> Conv2d<T1, T2, [&'bn [T2; N2]; M2]> for [&'an [T1; N1]; M1]

where T1: ComplexFloat + Mul<T2, Output = T3> + Into<Complex<T1::Real>>, T2: ComplexFloat + Into<Complex<T2::Real>>, T3: ComplexFloat<Real: Into<T3>> + 'static, [&'an [T1; N1]; M1]: Matrix<T1, Index = (usize, usize)>, [&'bn [T2; N2]; M2]: Matrix<T2, Index = (usize, usize)>, Array2<Complex<T1::Real>>: Dft2d<Complex<T1::Real>, Mapped<Complex<T1::Real>> = Array2<Complex<T1::Real>>> + Mul<Array2<Complex<T2::Real>>, Output = Array2<Complex<T3::Real>>>, Array2<Complex<T2::Real>>: Dft2d<Complex<T2::Real>, Mapped<Complex<T2::Real>> = Array2<Complex<T2::Real>>>, Array2<Complex<T3::Real>>: Idft2d<Complex<T3::Real>, Mapped<Complex<T3::Real>> = Array2<Complex<T3::Real>>>, [[T3; { _ }]; { _ }]: MaybeMatrix<T3>,

type Output = [[T3; { _ }]; { _ }]

fn conv_2d(self, rhs: [&'bn [T2; N2]; M2]) -> Self::Output

impl<'an, 'bn, const N1: usize, const N2: usize, const M2: usize, T1, T2, T3> Conv2d<T1, T2, [&'bn [T2; N2]; M2]> for Vec<&'an [T1; N1]>

where T1: ComplexFloat + Mul<T2, Output = T3> + Into<Complex<T1::Real>>, T2: ComplexFloat + Into<Complex<T2::Real>>, T3: ComplexFloat<Real: Into<T3>> + 'static, Vec<&'an [T1; N1]>: Matrix<T1, Index = (usize, usize)>, [&'bn [T2; N2]; M2]: Matrix<T2, Index = (usize, usize)>, Array2<Complex<T1::Real>>: Dft2d<Complex<T1::Real>, Mapped<Complex<T1::Real>> = Array2<Complex<T1::Real>>> + Mul<Array2<Complex<T2::Real>>, Output = Array2<Complex<T3::Real>>>, Array2<Complex<T2::Real>>: Dft2d<Complex<T2::Real>, Mapped<Complex<T2::Real>> = Array2<Complex<T2::Real>>>, Array2<Complex<T3::Real>>: Idft2d<Complex<T3::Real>, Mapped<Complex<T3::Real>> = Array2<Complex<T3::Real>>>, Vec<[T3; { _ }]>: MaybeMatrix<T3>,

type Output = Vec<[T3; { _ }]>

fn conv_2d(self, rhs: [&'bn [T2; N2]; M2]) -> Self::Output

impl<'an, const N1: usize, T1, T2, T3> Conv2d<T1, T2, ArrayBase<OwnedRepr<T2>, Dim<[usize; 2]>>> for Vec<&'an [T1; N1]>

where T1: ComplexFloat + Mul<T2, Output = T3> + Into<Complex<T1::Real>>, T2: ComplexFloat + Into<Complex<T2::Real>>, T3: ComplexFloat<Real: Into<T3>> + 'static, Vec<&'an [T1; N1]>: Matrix<T1, Index = (usize, usize)>, Array2<T2>: Matrix<T2, Index = (usize, usize)>, Array2<Complex<T1::Real>>: Dft2d<Complex<T1::Real>, Mapped<Complex<T1::Real>> = Array2<Complex<T1::Real>>> + Mul<Array2<Complex<T2::Real>>, Output = Array2<Complex<T3::Real>>>, Array2<Complex<T2::Real>>: Dft2d<Complex<T2::Real>, Mapped<Complex<T2::Real>> = Array2<Complex<T2::Real>>>, Array2<Complex<T3::Real>>: Idft2d<Complex<T3::Real>, Mapped<Complex<T3::Real>> = Array2<Complex<T3::Real>>>,

type Output = ArrayBase<OwnedRepr<T3>, Dim<[usize; 2]>>

fn conv_2d(self, rhs: Array2<T2>) -> Self::Output

impl<'an, const N1: usize, const M1: usize, T1, T2, T3> Conv2d<T1, T2, ArrayBase<OwnedRepr<T2>, Dim<[usize; 2]>>> for [&'an [T1; N1]; M1]

where T1: ComplexFloat + Mul<T2, Output = T3> + Into<Complex<T1::Real>>, T2: ComplexFloat + Into<Complex<T2::Real>>, T3: ComplexFloat<Real: Into<T3>> + 'static, [&'an [T1; N1]; M1]: Matrix<T1, Index = (usize, usize)>, Array2<T2>: Matrix<T2, Index = (usize, usize)>, Array2<Complex<T1::Real>>: Dft2d<Complex<T1::Real>, Mapped<Complex<T1::Real>> = Array2<Complex<T1::Real>>> + Mul<Array2<Complex<T2::Real>>, Output = Array2<Complex<T3::Real>>>, Array2<Complex<T2::Real>>: Dft2d<Complex<T2::Real>, Mapped<Complex<T2::Real>> = Array2<Complex<T2::Real>>>, Array2<Complex<T3::Real>>: Idft2d<Complex<T3::Real>, Mapped<Complex<T3::Real>> = Array2<Complex<T3::Real>>>,

type Output = ArrayBase<OwnedRepr<T3>, Dim<[usize; 2]>>

fn conv_2d(self, rhs: Array2<T2>) -> Self::Output

impl<'an, const N1: usize, const N2: usize, T1, T2, T3> Conv2d<T1, T2, Vec<[T2; N2]>> for Vec<&'an [T1; N1]>

where T1: ComplexFloat + Mul<T2, Output = T3> + Into<Complex<T1::Real>>, T2: ComplexFloat + Into<Complex<T2::Real>>, T3: ComplexFloat<Real: Into<T3>> + 'static, Vec<&'an [T1; N1]>: Matrix<T1, Index = (usize, usize)>, Vec<[T2; N2]>: Matrix<T2, Index = (usize, usize)>, Array2<Complex<T1::Real>>: Dft2d<Complex<T1::Real>, Mapped<Complex<T1::Real>> = Array2<Complex<T1::Real>>> + Mul<Array2<Complex<T2::Real>>, Output = Array2<Complex<T3::Real>>>, Array2<Complex<T2::Real>>: Dft2d<Complex<T2::Real>, Mapped<Complex<T2::Real>> = Array2<Complex<T2::Real>>>, Array2<Complex<T3::Real>>: Idft2d<Complex<T3::Real>, Mapped<Complex<T3::Real>> = Array2<Complex<T3::Real>>>, Vec<[T3; { _ }]>: MaybeMatrix<T3>,

type Output = Vec<[T3; { _ }]>

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

impl<'an, const N1: usize, const N2: usize, const M1: usize, T1, T2, T3> Conv2d<T1, T2, Vec<[T2; N2]>> for [&'an [T1; N1]; M1]

where T1: ComplexFloat + Mul<T2, Output = T3> + Into<Complex<T1::Real>>, T2: ComplexFloat + Into<Complex<T2::Real>>, T3: ComplexFloat<Real: Into<T3>> + 'static, [&'an [T1; N1]; M1]: Matrix<T1, Index = (usize, usize)>, Vec<[T2; N2]>: Matrix<T2, Index = (usize, usize)>, Array2<Complex<T1::Real>>: Dft2d<Complex<T1::Real>, Mapped<Complex<T1::Real>> = Array2<Complex<T1::Real>>> + Mul<Array2<Complex<T2::Real>>, Output = Array2<Complex<T3::Real>>>, Array2<Complex<T2::Real>>: Dft2d<Complex<T2::Real>, Mapped<Complex<T2::Real>> = Array2<Complex<T2::Real>>>, Array2<Complex<T3::Real>>: Idft2d<Complex<T3::Real>, Mapped<Complex<T3::Real>> = Array2<Complex<T3::Real>>>, Vec<[T3; { _ }]>: MaybeMatrix<T3>,

type Output = Vec<[T3; { _ }]>

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

impl<'an, const N1: usize, const N2: usize, const M1: usize, const M2: usize, T1, T2, T3> Conv2d<T1, T2, [[T2; N2]; M2]> for [&'an [T1; N1]; M1]

where T1: ComplexFloat + Mul<T2, Output = T3> + Into<Complex<T1::Real>>, T2: ComplexFloat + Into<Complex<T2::Real>>, T3: ComplexFloat<Real: Into<T3>> + 'static, [&'an [T1; N1]; M1]: Matrix<T1, Index = (usize, usize)>, [[T2; N2]; M2]: Matrix<T2, Index = (usize, usize)>, Array2<Complex<T1::Real>>: Dft2d<Complex<T1::Real>, Mapped<Complex<T1::Real>> = Array2<Complex<T1::Real>>> + Mul<Array2<Complex<T2::Real>>, Output = Array2<Complex<T3::Real>>>, Array2<Complex<T2::Real>>: Dft2d<Complex<T2::Real>, Mapped<Complex<T2::Real>> = Array2<Complex<T2::Real>>>, Array2<Complex<T3::Real>>: Idft2d<Complex<T3::Real>, Mapped<Complex<T3::Real>> = Array2<Complex<T3::Real>>>, [[T3; { _ }]; { _ }]: MaybeMatrix<T3>,

type Output = [[T3; { _ }]; { _ }]

fn conv_2d(self, rhs: [[T2; N2]; M2]) -> Self::Output

impl<'an, const N1: usize, const N2: usize, const M2: usize, T1, T2, T3> Conv2d<T1, T2, [[T2; N2]; M2]> for Vec<&'an [T1; N1]>

where T1: ComplexFloat + Mul<T2, Output = T3> + Into<Complex<T1::Real>>, T2: ComplexFloat + Into<Complex<T2::Real>>, T3: ComplexFloat<Real: Into<T3>> + 'static, Vec<&'an [T1; N1]>: Matrix<T1, Index = (usize, usize)>, [[T2; N2]; M2]: Matrix<T2, Index = (usize, usize)>, Array2<Complex<T1::Real>>: Dft2d<Complex<T1::Real>, Mapped<Complex<T1::Real>> = Array2<Complex<T1::Real>>> + Mul<Array2<Complex<T2::Real>>, Output = Array2<Complex<T3::Real>>>, Array2<Complex<T2::Real>>: Dft2d<Complex<T2::Real>, Mapped<Complex<T2::Real>> = Array2<Complex<T2::Real>>>, Array2<Complex<T3::Real>>: Idft2d<Complex<T3::Real>, Mapped<Complex<T3::Real>> = Array2<Complex<T3::Real>>>, Vec<[T3; { _ }]>: MaybeMatrix<T3>,

type Output = Vec<[T3; { _ }]>

fn conv_2d(self, rhs: [[T2; N2]; M2]) -> Self::Output

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

where T1: Mul<T2, Output = T3>, (): Conv<T1, T2, &'b [T2]>, <() as Conv<T1, T2, &'b [T2]>>::Output: MaybeMatrix<T3>,

type Output = <() as Conv<T1, T2, &'b [T2]>>::Output

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

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

where T1: Mul<T2, Output = T3>, Vec<T1>: Conv<T1, T2, &'b [T2]>, <Vec<T1> as Conv<T1, T2, &'b [T2]>>::Output: MaybeMatrix<T3>,

type Output = <Vec<T1> as Conv<T1, T2, &'b [T2]>>::Output

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

impl<'b, T1, T2, T3> Conv2d<T1, T2, ()> for ArrayView2<'b, T1>

where T1: Mul<T2, Output = T3>, ArrayView2<'b, T1>: Conv<T1, T2, ()>, <ArrayView2<'b, T1> as Conv<T1, T2, ()>>::Output: MaybeMatrix<T3>,

type Output = <ArrayBase<ViewRepr<&'b T1>, Dim<[usize; 2]>> as Conv<T1, T2, ()>>::Output

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

impl<'b, T1, T2, T3> Conv2d<T1, T2, ArrayBase<ViewRepr<&'b T2>, Dim<[usize; 1]>>> for ()

where T1: Mul<T2, Output = T3>, (): Conv<T1, T2, ArrayView1<'b, T2>>, <() as Conv<T1, T2, ArrayView1<'b, T2>>>::Output: MaybeMatrix<T3>,

type Output = <() as Conv<T1, T2, ArrayBase<ViewRepr<&'b T2>, Dim<[usize; 1]>>>>::Output

fn conv_2d(self, rhs: ArrayView1<'b, T2>) -> Self::Output

impl<'b, T1, T2, T3> Conv2d<T1, T2, ArrayBase<ViewRepr<&'b T2>, Dim<[usize; 1]>>> for Vec<T1>

where T1: Mul<T2, Output = T3>, Vec<T1>: Conv<T1, T2, ArrayView1<'b, T2>>, <Vec<T1> as Conv<T1, T2, ArrayView1<'b, T2>>>::Output: MaybeMatrix<T3>,

type Output = <Vec<T1> as Conv<T1, T2, ArrayBase<ViewRepr<&'b T2>, Dim<[usize; 1]>>>>::Output

fn conv_2d(self, rhs: ArrayView1<'b, T2>) -> Self::Output

impl<'b, T1, T2, T3> Conv2d<T1, T2, ArrayBase<ViewRepr<&'b T2>, Dim<[usize; 2]>>> for ()

where T1: Mul<T2, Output = T3>, (): Conv<T1, T2, ArrayView2<'b, T2>>, <() as Conv<T1, T2, ArrayView2<'b, T2>>>::Output: MaybeMatrix<T3>,

type Output = <() as Conv<T1, T2, ArrayBase<ViewRepr<&'b T2>, Dim<[usize; 2]>>>>::Output

fn conv_2d(self, rhs: ArrayView2<'b, T2>) -> Self::Output

impl<'b, T1, T2, T3> Conv2d<T1, T2, ArrayBase<ViewRepr<&'b T2>, Dim<[usize; 2]>>> for Array2<T1>

where T1: ComplexFloat + Mul<T2, Output = T3> + Into<Complex<T1::Real>>, T2: ComplexFloat + Into<Complex<T2::Real>>, T3: ComplexFloat<Real: Into<T3>> + 'static, Array2<T1>: Matrix<T1, Index = (usize, usize)>, ArrayView2<'b, T2>: Matrix<T2, Index = (usize, usize)>, Array2<Complex<T1::Real>>: Dft2d<Complex<T1::Real>, Mapped<Complex<T1::Real>> = Array2<Complex<T1::Real>>> + Mul<Array2<Complex<T2::Real>>, Output = Array2<Complex<T3::Real>>>, Array2<Complex<T2::Real>>: Dft2d<Complex<T2::Real>, Mapped<Complex<T2::Real>> = Array2<Complex<T2::Real>>>, Array2<Complex<T3::Real>>: Idft2d<Complex<T3::Real>, Mapped<Complex<T3::Real>> = Array2<Complex<T3::Real>>>,

type Output = ArrayBase<OwnedRepr<T3>, Dim<[usize; 2]>>

fn conv_2d(self, rhs: ArrayView2<'b, T2>) -> Self::Output

impl<'b, const N1: usize, T1, T2, T3> Conv2d<T1, T2, &'b [T2]> for [T1; N1]

where T1: Mul<T2, Output = T3>, [T1; N1]: Conv<T1, T2, &'b [T2]>, <[T1; N1] as Conv<T1, T2, &'b [T2]>>::Output: MaybeMatrix<T3>,

type Output = <[T1; N1] as Conv<T1, T2, &'b [T2]>>::Output

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

impl<'b, const N1: usize, T1, T2, T3> Conv2d<T1, T2, ArrayBase<ViewRepr<&'b T2>, Dim<[usize; 1]>>> for [T1; N1]

where T1: Mul<T2, Output = T3>, [T1; N1]: Conv<T1, T2, ArrayView1<'b, T2>>, <[T1; N1] as Conv<T1, T2, ArrayView1<'b, T2>>>::Output: MaybeMatrix<T3>,

type Output = <[T1; N1] as Conv<T1, T2, ArrayBase<ViewRepr<&'b T2>, Dim<[usize; 1]>>>>::Output

fn conv_2d(self, rhs: ArrayView1<'b, T2>) -> Self::Output

impl<'b, const N1: usize, T1, T2, T3> Conv2d<T1, T2, ArrayBase<ViewRepr<&'b T2>, Dim<[usize; 2]>>> for Vec<[T1; N1]>

where T1: ComplexFloat + Mul<T2, Output = T3> + Into<Complex<T1::Real>>, T2: ComplexFloat + Into<Complex<T2::Real>>, T3: ComplexFloat<Real: Into<T3>> + 'static, Vec<[T1; N1]>: Matrix<T1, Index = (usize, usize)>, ArrayView2<'b, T2>: Matrix<T2, Index = (usize, usize)>, Array2<Complex<T1::Real>>: Dft2d<Complex<T1::Real>, Mapped<Complex<T1::Real>> = Array2<Complex<T1::Real>>> + Mul<Array2<Complex<T2::Real>>, Output = Array2<Complex<T3::Real>>>, Array2<Complex<T2::Real>>: Dft2d<Complex<T2::Real>, Mapped<Complex<T2::Real>> = Array2<Complex<T2::Real>>>, Array2<Complex<T3::Real>>: Idft2d<Complex<T3::Real>, Mapped<Complex<T3::Real>> = Array2<Complex<T3::Real>>>,

type Output = ArrayBase<OwnedRepr<T3>, Dim<[usize; 2]>>

fn conv_2d(self, rhs: ArrayView2<'b, T2>) -> Self::Output

impl<'b, const N1: usize, const M1: usize, T1, T2, T3> Conv2d<T1, T2, ArrayBase<ViewRepr<&'b T2>, Dim<[usize; 2]>>> for [[T1; N1]; M1]

where T1: ComplexFloat + Mul<T2, Output = T3> + Into<Complex<T1::Real>>, T2: ComplexFloat + Into<Complex<T2::Real>>, T3: ComplexFloat<Real: Into<T3>> + 'static, [[T1; N1]; M1]: Matrix<T1, Index = (usize, usize)>, ArrayView2<'b, T2>: Matrix<T2, Index = (usize, usize)>, Array2<Complex<T1::Real>>: Dft2d<Complex<T1::Real>, Mapped<Complex<T1::Real>> = Array2<Complex<T1::Real>>> + Mul<Array2<Complex<T2::Real>>, Output = Array2<Complex<T3::Real>>>, Array2<Complex<T2::Real>>: Dft2d<Complex<T2::Real>, Mapped<Complex<T2::Real>> = Array2<Complex<T2::Real>>>, Array2<Complex<T3::Real>>: Idft2d<Complex<T3::Real>, Mapped<Complex<T3::Real>> = Array2<Complex<T3::Real>>>,

type Output = ArrayBase<OwnedRepr<T3>, Dim<[usize; 2]>>

fn conv_2d(self, rhs: ArrayView2<'b, T2>) -> Self::Output

impl<'b, const N1: usize, const N2: usize, T1, T2, T3> Conv2d<T1, T2, &'b [T2; N2]> for [T1; N1]

where T1: Mul<T2, Output = T3>, [T1; N1]: Conv<T1, T2, &'b [T2; N2]>, <[T1; N1] as Conv<T1, T2, &'b [T2; N2]>>::Output: MaybeMatrix<T3>,

type Output = <[T1; N1] as Conv<T1, T2, &'b [T2; N2]>>::Output

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

impl<'b, const N2: usize, T1, T2, T3> Conv2d<T1, T2, &'b [T2; N2]> for ()

where T1: Mul<T2, Output = T3>, (): Conv<T1, T2, &'b [T2; N2]>, <() as Conv<T1, T2, &'b [T2; N2]>>::Output: MaybeMatrix<T3>,

type Output = <() as Conv<T1, T2, &'b [T2; N2]>>::Output

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

impl<'b, const N2: usize, T1, T2, T3> Conv2d<T1, T2, &'b [T2; N2]> for Vec<T1>

where T1: Mul<T2, Output = T3>, Vec<T1>: Conv<T1, T2, &'b [T2; N2]>, <Vec<T1> as Conv<T1, T2, &'b [T2; N2]>>::Output: MaybeMatrix<T3>,

type Output = <Vec<T1> as Conv<T1, T2, &'b [T2; N2]>>::Output

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

impl<'bm, 'bn, const N1: usize, T1, T2, T3> Conv2d<T1, T2, ()> for &'bm [&'bn [T1; N1]]

where T1: Mul<T2, Output = T3>, &'bm [&'bn [T1; N1]]: Conv<T1, T2, ()>, <&'bm [&'bn [T1; N1]] as Conv<T1, T2, ()>>::Output: MaybeMatrix<T3>,

type Output = <&'bm [&'bn [T1; N1]] as Conv<T1, T2, ()>>::Output

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

impl<'bm, 'bn, const N1: usize, const M1: usize, T1, T2, T3> Conv2d<T1, T2, ()> for &'bm [&'bn [T1; N1]; M1]

where T1: Mul<T2, Output = T3>, &'bm [&'bn [T1; N1]; M1]: Conv<T1, T2, ()>, <&'bm [&'bn [T1; N1]; M1] as Conv<T1, T2, ()>>::Output: MaybeMatrix<T3>,

type Output = <&'bm [&'bn [T1; N1]; M1] as Conv<T1, T2, ()>>::Output

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

impl<'bm, 'bn, const N1: usize, const N2: usize, T1, T2, T3> Conv2d<T1, T2, &'bm [&'bn [T2; N2]]> for Vec<[T1; N1]>

where T1: ComplexFloat + Mul<T2, Output = T3> + Into<Complex<T1::Real>>, T2: ComplexFloat + Into<Complex<T2::Real>>, T3: ComplexFloat<Real: Into<T3>> + 'static, Vec<[T1; N1]>: Matrix<T1, Index = (usize, usize)>, &'bm [&'bn [T2; N2]]: Matrix<T2, Index = (usize, usize)>, Array2<Complex<T1::Real>>: Dft2d<Complex<T1::Real>, Mapped<Complex<T1::Real>> = Array2<Complex<T1::Real>>> + Mul<Array2<Complex<T2::Real>>, Output = Array2<Complex<T3::Real>>>, Array2<Complex<T2::Real>>: Dft2d<Complex<T2::Real>, Mapped<Complex<T2::Real>> = Array2<Complex<T2::Real>>>, Array2<Complex<T3::Real>>: Idft2d<Complex<T3::Real>, Mapped<Complex<T3::Real>> = Array2<Complex<T3::Real>>>, Vec<[T3; { _ }]>: MaybeMatrix<T3>,

type Output = Vec<[T3; { _ }]>

fn conv_2d(self, rhs: &'bm [&'bn [T2; N2]]) -> Self::Output

impl<'bm, 'bn, const N1: usize, const N2: usize, const M1: usize, T1, T2, T3> Conv2d<T1, T2, &'bm [&'bn [T2; N2]]> for [[T1; N1]; M1]

where T1: ComplexFloat + Mul<T2, Output = T3> + Into<Complex<T1::Real>>, T2: ComplexFloat + Into<Complex<T2::Real>>, T3: ComplexFloat<Real: Into<T3>> + 'static, [[T1; N1]; M1]: Matrix<T1, Index = (usize, usize)>, &'bm [&'bn [T2; N2]]: Matrix<T2, Index = (usize, usize)>, Array2<Complex<T1::Real>>: Dft2d<Complex<T1::Real>, Mapped<Complex<T1::Real>> = Array2<Complex<T1::Real>>> + Mul<Array2<Complex<T2::Real>>, Output = Array2<Complex<T3::Real>>>, Array2<Complex<T2::Real>>: Dft2d<Complex<T2::Real>, Mapped<Complex<T2::Real>> = Array2<Complex<T2::Real>>>, Array2<Complex<T3::Real>>: Idft2d<Complex<T3::Real>, Mapped<Complex<T3::Real>> = Array2<Complex<T3::Real>>>, Vec<[T3; { _ }]>: MaybeMatrix<T3>,

type Output = Vec<[T3; { _ }]>

fn conv_2d(self, rhs: &'bm [&'bn [T2; N2]]) -> Self::Output

impl<'bm, 'bn, const N1: usize, const N2: usize, const M1: usize, const M2: usize, T1, T2, T3> Conv2d<T1, T2, &'bm [&'bn [T2; N2]; M2]> for [[T1; N1]; M1]

where T1: ComplexFloat + Mul<T2, Output = T3> + Into<Complex<T1::Real>>, T2: ComplexFloat + Into<Complex<T2::Real>>, T3: ComplexFloat<Real: Into<T3>> + 'static, [[T1; N1]; M1]: Matrix<T1, Index = (usize, usize)>, &'bm [&'bn [T2; N2]; M2]: Matrix<T2, Index = (usize, usize)>, Array2<Complex<T1::Real>>: Dft2d<Complex<T1::Real>, Mapped<Complex<T1::Real>> = Array2<Complex<T1::Real>>> + Mul<Array2<Complex<T2::Real>>, Output = Array2<Complex<T3::Real>>>, Array2<Complex<T2::Real>>: Dft2d<Complex<T2::Real>, Mapped<Complex<T2::Real>> = Array2<Complex<T2::Real>>>, Array2<Complex<T3::Real>>: Idft2d<Complex<T3::Real>, Mapped<Complex<T3::Real>> = Array2<Complex<T3::Real>>>, [[T3; { _ }]; { _ }]: MaybeMatrix<T3>,

type Output = [[T3; { _ }]; { _ }]

fn conv_2d(self, rhs: &'bm [&'bn [T2; N2]; M2]) -> Self::Output

impl<'bm, 'bn, const N1: usize, const N2: usize, const M2: usize, T1, T2, T3> Conv2d<T1, T2, &'bm [&'bn [T2; N2]; M2]> for Vec<[T1; N1]>

where T1: ComplexFloat + Mul<T2, Output = T3> + Into<Complex<T1::Real>>, T2: ComplexFloat + Into<Complex<T2::Real>>, T3: ComplexFloat<Real: Into<T3>> + 'static, Vec<[T1; N1]>: Matrix<T1, Index = (usize, usize)>, &'bm [&'bn [T2; N2]; M2]: Matrix<T2, Index = (usize, usize)>, Array2<Complex<T1::Real>>: Dft2d<Complex<T1::Real>, Mapped<Complex<T1::Real>> = Array2<Complex<T1::Real>>> + Mul<Array2<Complex<T2::Real>>, Output = Array2<Complex<T3::Real>>>, Array2<Complex<T2::Real>>: Dft2d<Complex<T2::Real>, Mapped<Complex<T2::Real>> = Array2<Complex<T2::Real>>>, Array2<Complex<T3::Real>>: Idft2d<Complex<T3::Real>, Mapped<Complex<T3::Real>> = Array2<Complex<T3::Real>>>, Vec<[T3; { _ }]>: MaybeMatrix<T3>,

type Output = Vec<[T3; { _ }]>

fn conv_2d(self, rhs: &'bm [&'bn [T2; N2]; M2]) -> Self::Output

impl<'bm, 'bn, const N2: usize, T1, T2, T3> Conv2d<T1, T2, &'bm [&'bn [T2; N2]]> for ()

where T1: Mul<T2, Output = T3>, (): Conv<T1, T2, &'bm [&'bn [T2; N2]]>, <() as Conv<T1, T2, &'bm [&'bn [T2; N2]]>>::Output: MaybeMatrix<T3>,

type Output = <() as Conv<T1, T2, &'bm [&'bn [T2; N2]]>>::Output

fn conv_2d(self, rhs: &'bm [&'bn [T2; N2]]) -> Self::Output

impl<'bm, 'bn, const N2: usize, T1, T2, T3> Conv2d<T1, T2, &'bm [&'bn [T2; N2]]> for Array2<T1>

where T1: ComplexFloat + Mul<T2, Output = T3> + Into<Complex<T1::Real>>, T2: ComplexFloat + Into<Complex<T2::Real>>, T3: ComplexFloat<Real: Into<T3>> + 'static, Array2<T1>: Matrix<T1, Index = (usize, usize)>, &'bm [&'bn [T2; N2]]: Matrix<T2, Index = (usize, usize)>, Array2<Complex<T1::Real>>: Dft2d<Complex<T1::Real>, Mapped<Complex<T1::Real>> = Array2<Complex<T1::Real>>> + Mul<Array2<Complex<T2::Real>>, Output = Array2<Complex<T3::Real>>>, Array2<Complex<T2::Real>>: Dft2d<Complex<T2::Real>, Mapped<Complex<T2::Real>> = Array2<Complex<T2::Real>>>, Array2<Complex<T3::Real>>: Idft2d<Complex<T3::Real>, Mapped<Complex<T3::Real>> = Array2<Complex<T3::Real>>>,

type Output = ArrayBase<OwnedRepr<T3>, Dim<[usize; 2]>>

fn conv_2d(self, rhs: &'bm [&'bn [T2; N2]]) -> Self::Output

impl<'bm, 'bn, const N2: usize, const M2: usize, T1, T2, T3> Conv2d<T1, T2, &'bm [&'bn [T2; N2]; M2]> for ()

where T1: Mul<T2, Output = T3>, (): Conv<T1, T2, &'bm [&'bn [T2; N2]; M2]>, <() as Conv<T1, T2, &'bm [&'bn [T2; N2]; M2]>>::Output: MaybeMatrix<T3>,

type Output = <() as Conv<T1, T2, &'bm [&'bn [T2; N2]; M2]>>::Output

fn conv_2d(self, rhs: &'bm [&'bn [T2; N2]; M2]) -> Self::Output

impl<'bm, 'bn, const N2: usize, const M2: usize, T1, T2, T3> Conv2d<T1, T2, &'bm [&'bn [T2; N2]; M2]> for Array2<T1>

where T1: ComplexFloat + Mul<T2, Output = T3> + Into<Complex<T1::Real>>, T2: ComplexFloat + Into<Complex<T2::Real>>, T3: ComplexFloat<Real: Into<T3>> + 'static, Array2<T1>: Matrix<T1, Index = (usize, usize)>, &'bm [&'bn [T2; N2]; M2]: Matrix<T2, Index = (usize, usize)>, Array2<Complex<T1::Real>>: Dft2d<Complex<T1::Real>, Mapped<Complex<T1::Real>> = Array2<Complex<T1::Real>>> + Mul<Array2<Complex<T2::Real>>, Output = Array2<Complex<T3::Real>>>, Array2<Complex<T2::Real>>: Dft2d<Complex<T2::Real>, Mapped<Complex<T2::Real>> = Array2<Complex<T2::Real>>>, Array2<Complex<T3::Real>>: Idft2d<Complex<T3::Real>, Mapped<Complex<T3::Real>> = Array2<Complex<T3::Real>>>,

type Output = ArrayBase<OwnedRepr<T3>, Dim<[usize; 2]>>

fn conv_2d(self, rhs: &'bm [&'bn [T2; N2]; M2]) -> Self::Output

impl<'bm, const N1: usize, T1, T2, T3> Conv2d<T1, T2, ()> for &'bm [[T1; N1]]

where T1: Mul<T2, Output = T3>, &'bm [[T1; N1]]: Conv<T1, T2, ()>, <&'bm [[T1; N1]] as Conv<T1, T2, ()>>::Output: MaybeMatrix<T3>,

type Output = <&'bm [[T1; N1]] as Conv<T1, T2, ()>>::Output

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

impl<'bm, const N1: usize, const M1: usize, T1, T2, T3> Conv2d<T1, T2, ()> for &'bm [[T1; N1]; M1]

where T1: Mul<T2, Output = T3>, &'bm [[T1; N1]; M1]: Conv<T1, T2, ()>, <&'bm [[T1; N1]; M1] as Conv<T1, T2, ()>>::Output: MaybeMatrix<T3>,

type Output = <&'bm [[T1; N1]; M1] as Conv<T1, T2, ()>>::Output

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

impl<'bm, const N1: usize, const N2: usize, T1, T2, T3> Conv2d<T1, T2, &'bm [[T2; N2]]> for Vec<[T1; N1]>

where T1: ComplexFloat + Mul<T2, Output = T3> + Into<Complex<T1::Real>>, T2: ComplexFloat + Into<Complex<T2::Real>>, T3: ComplexFloat<Real: Into<T3>> + 'static, Vec<[T1; N1]>: Matrix<T1, Index = (usize, usize)>, &'bm [[T2; N2]]: Matrix<T2, Index = (usize, usize)>, Array2<Complex<T1::Real>>: Dft2d<Complex<T1::Real>, Mapped<Complex<T1::Real>> = Array2<Complex<T1::Real>>> + Mul<Array2<Complex<T2::Real>>, Output = Array2<Complex<T3::Real>>>, Array2<Complex<T2::Real>>: Dft2d<Complex<T2::Real>, Mapped<Complex<T2::Real>> = Array2<Complex<T2::Real>>>, Array2<Complex<T3::Real>>: Idft2d<Complex<T3::Real>, Mapped<Complex<T3::Real>> = Array2<Complex<T3::Real>>>, Vec<[T3; { _ }]>: MaybeMatrix<T3>,

type Output = Vec<[T3; { _ }]>

fn conv_2d(self, rhs: &'bm [[T2; N2]]) -> Self::Output

impl<'bm, const N1: usize, const N2: usize, const M1: usize, T1, T2, T3> Conv2d<T1, T2, &'bm [[T2; N2]]> for [[T1; N1]; M1]

where T1: ComplexFloat + Mul<T2, Output = T3> + Into<Complex<T1::Real>>, T2: ComplexFloat + Into<Complex<T2::Real>>, T3: ComplexFloat<Real: Into<T3>> + 'static, [[T1; N1]; M1]: Matrix<T1, Index = (usize, usize)>, &'bm [[T2; N2]]: Matrix<T2, Index = (usize, usize)>, Array2<Complex<T1::Real>>: Dft2d<Complex<T1::Real>, Mapped<Complex<T1::Real>> = Array2<Complex<T1::Real>>> + Mul<Array2<Complex<T2::Real>>, Output = Array2<Complex<T3::Real>>>, Array2<Complex<T2::Real>>: Dft2d<Complex<T2::Real>, Mapped<Complex<T2::Real>> = Array2<Complex<T2::Real>>>, Array2<Complex<T3::Real>>: Idft2d<Complex<T3::Real>, Mapped<Complex<T3::Real>> = Array2<Complex<T3::Real>>>, Vec<[T3; { _ }]>: MaybeMatrix<T3>,

type Output = Vec<[T3; { _ }]>

fn conv_2d(self, rhs: &'bm [[T2; N2]]) -> Self::Output

impl<'bm, const N1: usize, const N2: usize, const M1: usize, const M2: usize, T1, T2, T3> Conv2d<T1, T2, &'bm [[T2; N2]; M2]> for [[T1; N1]; M1]

where T1: ComplexFloat + Mul<T2, Output = T3> + Into<Complex<T1::Real>>, T2: ComplexFloat + Into<Complex<T2::Real>>, T3: ComplexFloat<Real: Into<T3>> + 'static, [[T1; N1]; M1]: Matrix<T1, Index = (usize, usize)>, &'bm [[T2; N2]; M2]: Matrix<T2, Index = (usize, usize)>, Array2<Complex<T1::Real>>: Dft2d<Complex<T1::Real>, Mapped<Complex<T1::Real>> = Array2<Complex<T1::Real>>> + Mul<Array2<Complex<T2::Real>>, Output = Array2<Complex<T3::Real>>>, Array2<Complex<T2::Real>>: Dft2d<Complex<T2::Real>, Mapped<Complex<T2::Real>> = Array2<Complex<T2::Real>>>, Array2<Complex<T3::Real>>: Idft2d<Complex<T3::Real>, Mapped<Complex<T3::Real>> = Array2<Complex<T3::Real>>>, [[T3; { _ }]; { _ }]: MaybeMatrix<T3>,

type Output = [[T3; { _ }]; { _ }]

fn conv_2d(self, rhs: &'bm [[T2; N2]; M2]) -> Self::Output

impl<'bm, const N1: usize, const N2: usize, const M2: usize, T1, T2, T3> Conv2d<T1, T2, &'bm [[T2; N2]; M2]> for Vec<[T1; N1]>

where T1: ComplexFloat + Mul<T2, Output = T3> + Into<Complex<T1::Real>>, T2: ComplexFloat + Into<Complex<T2::Real>>, T3: ComplexFloat<Real: Into<T3>> + 'static, Vec<[T1; N1]>: Matrix<T1, Index = (usize, usize)>, &'bm [[T2; N2]; M2]: Matrix<T2, Index = (usize, usize)>, Array2<Complex<T1::Real>>: Dft2d<Complex<T1::Real>, Mapped<Complex<T1::Real>> = Array2<Complex<T1::Real>>> + Mul<Array2<Complex<T2::Real>>, Output = Array2<Complex<T3::Real>>>, Array2<Complex<T2::Real>>: Dft2d<Complex<T2::Real>, Mapped<Complex<T2::Real>> = Array2<Complex<T2::Real>>>, Array2<Complex<T3::Real>>: Idft2d<Complex<T3::Real>, Mapped<Complex<T3::Real>> = Array2<Complex<T3::Real>>>, Vec<[T3; { _ }]>: MaybeMatrix<T3>,

type Output = Vec<[T3; { _ }]>

fn conv_2d(self, rhs: &'bm [[T2; N2]; M2]) -> Self::Output

impl<'bm, const N2: usize, T1, T2, T3> Conv2d<T1, T2, &'bm [[T2; N2]]> for ()

where T1: Mul<T2, Output = T3>, (): Conv<T1, T2, &'bm [[T2; N2]]>, <() as Conv<T1, T2, &'bm [[T2; N2]]>>::Output: MaybeMatrix<T3>,

type Output = <() as Conv<T1, T2, &'bm [[T2; N2]]>>::Output

fn conv_2d(self, rhs: &'bm [[T2; N2]]) -> Self::Output

impl<'bm, const N2: usize, T1, T2, T3> Conv2d<T1, T2, &'bm [[T2; N2]]> for Array2<T1>

where T1: ComplexFloat + Mul<T2, Output = T3> + Into<Complex<T1::Real>>, T2: ComplexFloat + Into<Complex<T2::Real>>, T3: ComplexFloat<Real: Into<T3>> + 'static, Array2<T1>: Matrix<T1, Index = (usize, usize)>, &'bm [[T2; N2]]: Matrix<T2, Index = (usize, usize)>, Array2<Complex<T1::Real>>: Dft2d<Complex<T1::Real>, Mapped<Complex<T1::Real>> = Array2<Complex<T1::Real>>> + Mul<Array2<Complex<T2::Real>>, Output = Array2<Complex<T3::Real>>>, Array2<Complex<T2::Real>>: Dft2d<Complex<T2::Real>, Mapped<Complex<T2::Real>> = Array2<Complex<T2::Real>>>, Array2<Complex<T3::Real>>: Idft2d<Complex<T3::Real>, Mapped<Complex<T3::Real>> = Array2<Complex<T3::Real>>>,

type Output = ArrayBase<OwnedRepr<T3>, Dim<[usize; 2]>>

fn conv_2d(self, rhs: &'bm [[T2; N2]]) -> Self::Output

impl<'bm, const N2: usize, const M2: usize, T1, T2, T3> Conv2d<T1, T2, &'bm [[T2; N2]; M2]> for ()

where T1: Mul<T2, Output = T3>, (): Conv<T1, T2, &'bm [[T2; N2]; M2]>, <() as Conv<T1, T2, &'bm [[T2; N2]; M2]>>::Output: MaybeMatrix<T3>,

type Output = <() as Conv<T1, T2, &'bm [[T2; N2]; M2]>>::Output

fn conv_2d(self, rhs: &'bm [[T2; N2]; M2]) -> Self::Output

impl<'bm, const N2: usize, const M2: usize, T1, T2, T3> Conv2d<T1, T2, &'bm [[T2; N2]; M2]> for Array2<T1>

where T1: ComplexFloat + Mul<T2, Output = T3> + Into<Complex<T1::Real>>, T2: ComplexFloat + Into<Complex<T2::Real>>, T3: ComplexFloat<Real: Into<T3>> + 'static, Array2<T1>: Matrix<T1, Index = (usize, usize)>, &'bm [[T2; N2]; M2]: Matrix<T2, Index = (usize, usize)>, Array2<Complex<T1::Real>>: Dft2d<Complex<T1::Real>, Mapped<Complex<T1::Real>> = Array2<Complex<T1::Real>>> + Mul<Array2<Complex<T2::Real>>, Output = Array2<Complex<T3::Real>>>, Array2<Complex<T2::Real>>: Dft2d<Complex<T2::Real>, Mapped<Complex<T2::Real>> = Array2<Complex<T2::Real>>>, Array2<Complex<T3::Real>>: Idft2d<Complex<T3::Real>, Mapped<Complex<T3::Real>> = Array2<Complex<T3::Real>>>,

type Output = ArrayBase<OwnedRepr<T3>, Dim<[usize; 2]>>

fn conv_2d(self, rhs: &'bm [[T2; N2]; M2]) -> Self::Output

impl<'bn, const N1: usize, T1, T2, T3> Conv2d<T1, T2, ()> for Vec<&'bn [T1; N1]>

where T1: Mul<T2, Output = T3>, Vec<&'bn [T1; N1]>: Conv<T1, T2, ()>, <Vec<&'bn [T1; N1]> as Conv<T1, T2, ()>>::Output: MaybeMatrix<T3>,

type Output = <Vec<&'bn [T1; N1]> as Conv<T1, T2, ()>>::Output

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

impl<'bn, const N1: usize, const M1: usize, T1, T2, T3> Conv2d<T1, T2, ()> for [&'bn [T1; N1]; M1]

where T1: Mul<T2, Output = T3>, [&'bn [T1; N1]; M1]: Conv<T1, T2, ()>, <[&'bn [T1; N1]; M1] as Conv<T1, T2, ()>>::Output: MaybeMatrix<T3>,

type Output = <[&'bn [T1; N1]; M1] as Conv<T1, T2, ()>>::Output

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

impl<'bn, const N1: usize, const N2: usize, T1, T2, T3> Conv2d<T1, T2, Vec<&'bn [T2; N2]>> for Vec<[T1; N1]>

where T1: ComplexFloat + Mul<T2, Output = T3> + Into<Complex<T1::Real>>, T2: ComplexFloat + Into<Complex<T2::Real>>, T3: ComplexFloat<Real: Into<T3>> + 'static, Vec<[T1; N1]>: Matrix<T1, Index = (usize, usize)>, Vec<&'bn [T2; N2]>: Matrix<T2, Index = (usize, usize)>, Array2<Complex<T1::Real>>: Dft2d<Complex<T1::Real>, Mapped<Complex<T1::Real>> = Array2<Complex<T1::Real>>> + Mul<Array2<Complex<T2::Real>>, Output = Array2<Complex<T3::Real>>>, Array2<Complex<T2::Real>>: Dft2d<Complex<T2::Real>, Mapped<Complex<T2::Real>> = Array2<Complex<T2::Real>>>, Array2<Complex<T3::Real>>: Idft2d<Complex<T3::Real>, Mapped<Complex<T3::Real>> = Array2<Complex<T3::Real>>>, Vec<[T3; { _ }]>: MaybeMatrix<T3>,

type Output = Vec<[T3; { _ }]>

fn conv_2d(self, rhs: Vec<&'bn [T2; N2]>) -> Self::Output

impl<'bn, const N1: usize, const N2: usize, const M1: usize, T1, T2, T3> Conv2d<T1, T2, Vec<&'bn [T2; N2]>> for [[T1; N1]; M1]

where T1: ComplexFloat + Mul<T2, Output = T3> + Into<Complex<T1::Real>>, T2: ComplexFloat + Into<Complex<T2::Real>>, T3: ComplexFloat<Real: Into<T3>> + 'static, [[T1; N1]; M1]: Matrix<T1, Index = (usize, usize)>, Vec<&'bn [T2; N2]>: Matrix<T2, Index = (usize, usize)>, Array2<Complex<T1::Real>>: Dft2d<Complex<T1::Real>, Mapped<Complex<T1::Real>> = Array2<Complex<T1::Real>>> + Mul<Array2<Complex<T2::Real>>, Output = Array2<Complex<T3::Real>>>, Array2<Complex<T2::Real>>: Dft2d<Complex<T2::Real>, Mapped<Complex<T2::Real>> = Array2<Complex<T2::Real>>>, Array2<Complex<T3::Real>>: Idft2d<Complex<T3::Real>, Mapped<Complex<T3::Real>> = Array2<Complex<T3::Real>>>, Vec<[T3; { _ }]>: MaybeMatrix<T3>,

type Output = Vec<[T3; { _ }]>

fn conv_2d(self, rhs: Vec<&'bn [T2; N2]>) -> Self::Output

impl<'bn, const N1: usize, const N2: usize, const M1: usize, const M2: usize, T1, T2, T3> Conv2d<T1, T2, [&'bn [T2; N2]; M2]> for [[T1; N1]; M1]

where T1: ComplexFloat + Mul<T2, Output = T3> + Into<Complex<T1::Real>>, T2: ComplexFloat + Into<Complex<T2::Real>>, T3: ComplexFloat<Real: Into<T3>> + 'static, [[T1; N1]; M1]: Matrix<T1, Index = (usize, usize)>, [&'bn [T2; N2]; M2]: Matrix<T2, Index = (usize, usize)>, Array2<Complex<T1::Real>>: Dft2d<Complex<T1::Real>, Mapped<Complex<T1::Real>> = Array2<Complex<T1::Real>>> + Mul<Array2<Complex<T2::Real>>, Output = Array2<Complex<T3::Real>>>, Array2<Complex<T2::Real>>: Dft2d<Complex<T2::Real>, Mapped<Complex<T2::Real>> = Array2<Complex<T2::Real>>>, Array2<Complex<T3::Real>>: Idft2d<Complex<T3::Real>, Mapped<Complex<T3::Real>> = Array2<Complex<T3::Real>>>, [[T3; { _ }]; { _ }]: MaybeMatrix<T3>,

type Output = [[T3; { _ }]; { _ }]

fn conv_2d(self, rhs: [&'bn [T2; N2]; M2]) -> Self::Output

impl<'bn, const N1: usize, const N2: usize, const M2: usize, T1, T2, T3> Conv2d<T1, T2, [&'bn [T2; N2]; M2]> for Vec<[T1; N1]>

where T1: ComplexFloat + Mul<T2, Output = T3> + Into<Complex<T1::Real>>, T2: ComplexFloat + Into<Complex<T2::Real>>, T3: ComplexFloat<Real: Into<T3>> + 'static, Vec<[T1; N1]>: Matrix<T1, Index = (usize, usize)>, [&'bn [T2; N2]; M2]: Matrix<T2, Index = (usize, usize)>, Array2<Complex<T1::Real>>: Dft2d<Complex<T1::Real>, Mapped<Complex<T1::Real>> = Array2<Complex<T1::Real>>> + Mul<Array2<Complex<T2::Real>>, Output = Array2<Complex<T3::Real>>>, Array2<Complex<T2::Real>>: Dft2d<Complex<T2::Real>, Mapped<Complex<T2::Real>> = Array2<Complex<T2::Real>>>, Array2<Complex<T3::Real>>: Idft2d<Complex<T3::Real>, Mapped<Complex<T3::Real>> = Array2<Complex<T3::Real>>>, Vec<[T3; { _ }]>: MaybeMatrix<T3>,

type Output = Vec<[T3; { _ }]>

fn conv_2d(self, rhs: [&'bn [T2; N2]; M2]) -> Self::Output

impl<'bn, const N2: usize, T1, T2, T3> Conv2d<T1, T2, Vec<&'bn [T2; N2]>> for ()

where T1: Mul<T2, Output = T3>, (): Conv<T1, T2, Vec<&'bn [T2; N2]>>, <() as Conv<T1, T2, Vec<&'bn [T2; N2]>>>::Output: MaybeMatrix<T3>,

type Output = <() as Conv<T1, T2, Vec<&'bn [T2; N2]>>>::Output

fn conv_2d(self, rhs: Vec<&'bn [T2; N2]>) -> Self::Output

impl<'bn, const N2: usize, T1, T2, T3> Conv2d<T1, T2, Vec<&'bn [T2; N2]>> for Array2<T1>

where T1: ComplexFloat + Mul<T2, Output = T3> + Into<Complex<T1::Real>>, T2: ComplexFloat + Into<Complex<T2::Real>>, T3: ComplexFloat<Real: Into<T3>> + 'static, Array2<T1>: Matrix<T1, Index = (usize, usize)>, Vec<&'bn [T2; N2]>: Matrix<T2, Index = (usize, usize)>, Array2<Complex<T1::Real>>: Dft2d<Complex<T1::Real>, Mapped<Complex<T1::Real>> = Array2<Complex<T1::Real>>> + Mul<Array2<Complex<T2::Real>>, Output = Array2<Complex<T3::Real>>>, Array2<Complex<T2::Real>>: Dft2d<Complex<T2::Real>, Mapped<Complex<T2::Real>> = Array2<Complex<T2::Real>>>, Array2<Complex<T3::Real>>: Idft2d<Complex<T3::Real>, Mapped<Complex<T3::Real>> = Array2<Complex<T3::Real>>>,

type Output = ArrayBase<OwnedRepr<T3>, Dim<[usize; 2]>>

fn conv_2d(self, rhs: Vec<&'bn [T2; N2]>) -> Self::Output

impl<'bn, const N2: usize, const M2: usize, T1, T2, T3> Conv2d<T1, T2, [&'bn [T2; N2]; M2]> for ()

where T1: Mul<T2, Output = T3>, (): Conv<T1, T2, [&'bn [T2; N2]; M2]>, <() as Conv<T1, T2, [&'bn [T2; N2]; M2]>>::Output: MaybeMatrix<T3>,

type Output = <() as Conv<T1, T2, [&'bn [T2; N2]; M2]>>::Output

fn conv_2d(self, rhs: [&'bn [T2; N2]; M2]) -> Self::Output

impl<'bn, const N2: usize, const M2: usize, T1, T2, T3> Conv2d<T1, T2, [&'bn [T2; N2]; M2]> for Array2<T1>

where T1: ComplexFloat + Mul<T2, Output = T3> + Into<Complex<T1::Real>>, T2: ComplexFloat + Into<Complex<T2::Real>>, T3: ComplexFloat<Real: Into<T3>> + 'static, Array2<T1>: Matrix<T1, Index = (usize, usize)>, [&'bn [T2; N2]; M2]: Matrix<T2, Index = (usize, usize)>, Array2<Complex<T1::Real>>: Dft2d<Complex<T1::Real>, Mapped<Complex<T1::Real>> = Array2<Complex<T1::Real>>> + Mul<Array2<Complex<T2::Real>>, Output = Array2<Complex<T3::Real>>>, Array2<Complex<T2::Real>>: Dft2d<Complex<T2::Real>, Mapped<Complex<T2::Real>> = Array2<Complex<T2::Real>>>, Array2<Complex<T3::Real>>: Idft2d<Complex<T3::Real>, Mapped<Complex<T3::Real>> = Array2<Complex<T3::Real>>>,

type Output = ArrayBase<OwnedRepr<T3>, Dim<[usize; 2]>>

fn conv_2d(self, rhs: [&'bn [T2; N2]; M2]) -> Self::Output

impl<T1, T2, T3> Conv2d<T1, T2, ()> for ()

where T1: Mul<T2, Output = T3>, (): Conv<T1, T2, ()>, <() as Conv<T1, T2, ()>>::Output: MaybeMatrix<T3>,

type Output = <() as Conv<T1, T2, ()>>::Output

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

impl<T1, T2, T3> Conv2d<T1, T2, ()> for Vec<T1>

where T1: Mul<T2, Output = T3>, Vec<T1>: Conv<T1, T2, ()>, <Vec<T1> as Conv<T1, T2, ()>>::Output: MaybeMatrix<T3>,

type Output = <Vec<T1> as Conv<T1, T2, ()>>::Output

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

impl<T1, T2, T3> Conv2d<T1, T2, ()> for Array2<T1>

where T1: Mul<T2, Output = T3>, Array2<T1>: Conv<T1, T2, ()>, <Array2<T1> as Conv<T1, T2, ()>>::Output: MaybeMatrix<T3>,

type Output = <ArrayBase<OwnedRepr<T1>, Dim<[usize; 2]>> as Conv<T1, T2, ()>>::Output

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

impl<T1, T2, T3> Conv2d<T1, T2, Vec<T2>> for ()

where T1: Mul<T2, Output = T3>, (): Conv<T1, T2, Vec<T2>>, <() as Conv<T1, T2, Vec<T2>>>::Output: MaybeMatrix<T3>,

type Output = <() as Conv<T1, T2, Vec<T2>>>::Output

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

impl<T1, T2, T3> Conv2d<T1, T2, Vec<T2>> for Vec<T1>

where T1: Mul<T2, Output = T3>, Vec<T1>: Conv<T1, T2, Vec<T2>>, <Vec<T1> as Conv<T1, T2, Vec<T2>>>::Output: MaybeMatrix<T3>,

type Output = <Vec<T1> as Conv<T1, T2, Vec<T2>>>::Output

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

impl<T1, T2, T3> Conv2d<T1, T2, ArrayBase<OwnedRepr<T2>, Dim<[usize; 1]>>> for ()

where T1: Mul<T2, Output = T3>, (): Conv<T1, T2, Array1<T2>>, <() as Conv<T1, T2, Array1<T2>>>::Output: MaybeMatrix<T3>,

type Output = <() as Conv<T1, T2, ArrayBase<OwnedRepr<T2>, Dim<[usize; 1]>>>>::Output

fn conv_2d(self, rhs: Array1<T2>) -> Self::Output

impl<T1, T2, T3> Conv2d<T1, T2, ArrayBase<OwnedRepr<T2>, Dim<[usize; 1]>>> for Vec<T1>

where T1: Mul<T2, Output = T3>, Vec<T1>: Conv<T1, T2, Array1<T2>>, <Vec<T1> as Conv<T1, T2, Array1<T2>>>::Output: MaybeMatrix<T3>,

type Output = <Vec<T1> as Conv<T1, T2, ArrayBase<OwnedRepr<T2>, Dim<[usize; 1]>>>>::Output

fn conv_2d(self, rhs: Array1<T2>) -> Self::Output

impl<T1, T2, T3> Conv2d<T1, T2, ArrayBase<OwnedRepr<T2>, Dim<[usize; 2]>>> for ()

where T1: Mul<T2, Output = T3>, (): Conv<T1, T2, Array2<T2>>, <() as Conv<T1, T2, Array2<T2>>>::Output: MaybeMatrix<T3>,

type Output = <() as Conv<T1, T2, ArrayBase<OwnedRepr<T2>, Dim<[usize; 2]>>>>::Output

fn conv_2d(self, rhs: Array2<T2>) -> Self::Output

impl<T1, T2, T3> Conv2d<T1, T2, ArrayBase<OwnedRepr<T2>, Dim<[usize; 2]>>> for Array2<T1>

where T1: ComplexFloat + Mul<T2, Output = T3> + Into<Complex<T1::Real>>, T2: ComplexFloat + Into<Complex<T2::Real>>, T3: ComplexFloat<Real: Into<T3>> + 'static, Array2<T1>: Matrix<T1, Index = (usize, usize)>, Array2<T2>: Matrix<T2, Index = (usize, usize)>, Array2<Complex<T1::Real>>: Dft2d<Complex<T1::Real>, Mapped<Complex<T1::Real>> = Array2<Complex<T1::Real>>> + Mul<Array2<Complex<T2::Real>>, Output = Array2<Complex<T3::Real>>>, Array2<Complex<T2::Real>>: Dft2d<Complex<T2::Real>, Mapped<Complex<T2::Real>> = Array2<Complex<T2::Real>>>, Array2<Complex<T3::Real>>: Idft2d<Complex<T3::Real>, Mapped<Complex<T3::Real>> = Array2<Complex<T3::Real>>>,

type Output = ArrayBase<OwnedRepr<T3>, Dim<[usize; 2]>>

fn conv_2d(self, rhs: Array2<T2>) -> Self::Output

impl<const N1: usize, T1, T2, T3> Conv2d<T1, T2, ()> for [T1; N1]

where T1: Mul<T2, Output = T3>, [T1; N1]: Conv<T1, T2, ()>, <[T1; N1] as Conv<T1, T2, ()>>::Output: MaybeMatrix<T3>,

type Output = <[T1; N1] as Conv<T1, T2, ()>>::Output

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

impl<const N1: usize, T1, T2, T3> Conv2d<T1, T2, ()> for Vec<[T1; N1]>

where T1: Mul<T2, Output = T3>, Vec<[T1; N1]>: Conv<T1, T2, ()>, <Vec<[T1; N1]> as Conv<T1, T2, ()>>::Output: MaybeMatrix<T3>,

type Output = <Vec<[T1; N1]> as Conv<T1, T2, ()>>::Output

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

impl<const N1: usize, T1, T2, T3> Conv2d<T1, T2, Vec<T2>> for [T1; N1]

where T1: Mul<T2, Output = T3>, [T1; N1]: Conv<T1, T2, Vec<T2>>, <[T1; N1] as Conv<T1, T2, Vec<T2>>>::Output: MaybeMatrix<T3>,

type Output = <[T1; N1] as Conv<T1, T2, Vec<T2>>>::Output

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

impl<const N1: usize, T1, T2, T3> Conv2d<T1, T2, ArrayBase<OwnedRepr<T2>, Dim<[usize; 1]>>> for [T1; N1]

where T1: Mul<T2, Output = T3>, [T1; N1]: Conv<T1, T2, Array1<T2>>, <[T1; N1] as Conv<T1, T2, Array1<T2>>>::Output: MaybeMatrix<T3>,

type Output = <[T1; N1] as Conv<T1, T2, ArrayBase<OwnedRepr<T2>, Dim<[usize; 1]>>>>::Output

fn conv_2d(self, rhs: Array1<T2>) -> Self::Output

impl<const N1: usize, T1, T2, T3> Conv2d<T1, T2, ArrayBase<OwnedRepr<T2>, Dim<[usize; 2]>>> for Vec<[T1; N1]>

where T1: ComplexFloat + Mul<T2, Output = T3> + Into<Complex<T1::Real>>, T2: ComplexFloat + Into<Complex<T2::Real>>, T3: ComplexFloat<Real: Into<T3>> + 'static, Vec<[T1; N1]>: Matrix<T1, Index = (usize, usize)>, Array2<T2>: Matrix<T2, Index = (usize, usize)>, Array2<Complex<T1::Real>>: Dft2d<Complex<T1::Real>, Mapped<Complex<T1::Real>> = Array2<Complex<T1::Real>>> + Mul<Array2<Complex<T2::Real>>, Output = Array2<Complex<T3::Real>>>, Array2<Complex<T2::Real>>: Dft2d<Complex<T2::Real>, Mapped<Complex<T2::Real>> = Array2<Complex<T2::Real>>>, Array2<Complex<T3::Real>>: Idft2d<Complex<T3::Real>, Mapped<Complex<T3::Real>> = Array2<Complex<T3::Real>>>,

type Output = ArrayBase<OwnedRepr<T3>, Dim<[usize; 2]>>

fn conv_2d(self, rhs: Array2<T2>) -> Self::Output

impl<const N1: usize, const M1: usize, T1, T2, T3> Conv2d<T1, T2, ()> for [[T1; N1]; M1]

where T1: Mul<T2, Output = T3>, [[T1; N1]; M1]: Conv<T1, T2, ()>, <[[T1; N1]; M1] as Conv<T1, T2, ()>>::Output: MaybeMatrix<T3>,

type Output = <[[T1; N1]; M1] as Conv<T1, T2, ()>>::Output

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

impl<const N1: usize, const M1: usize, T1, T2, T3> Conv2d<T1, T2, ArrayBase<OwnedRepr<T2>, Dim<[usize; 2]>>> for [[T1; N1]; M1]

where T1: ComplexFloat + Mul<T2, Output = T3> + Into<Complex<T1::Real>>, T2: ComplexFloat + Into<Complex<T2::Real>>, T3: ComplexFloat<Real: Into<T3>> + 'static, [[T1; N1]; M1]: Matrix<T1, Index = (usize, usize)>, Array2<T2>: Matrix<T2, Index = (usize, usize)>, Array2<Complex<T1::Real>>: Dft2d<Complex<T1::Real>, Mapped<Complex<T1::Real>> = Array2<Complex<T1::Real>>> + Mul<Array2<Complex<T2::Real>>, Output = Array2<Complex<T3::Real>>>, Array2<Complex<T2::Real>>: Dft2d<Complex<T2::Real>, Mapped<Complex<T2::Real>> = Array2<Complex<T2::Real>>>, Array2<Complex<T3::Real>>: Idft2d<Complex<T3::Real>, Mapped<Complex<T3::Real>> = Array2<Complex<T3::Real>>>,

type Output = ArrayBase<OwnedRepr<T3>, Dim<[usize; 2]>>

fn conv_2d(self, rhs: Array2<T2>) -> Self::Output

impl<const N1: usize, const N2: usize, T1, T2, T3> Conv2d<T1, T2, [T2; N2]> for [T1; N1]

where T1: Mul<T2, Output = T3>, [T1; N1]: Conv<T1, T2, [T2; N2]>, <[T1; N1] as Conv<T1, T2, [T2; N2]>>::Output: MaybeMatrix<T3>,

type Output = <[T1; N1] as Conv<T1, T2, [T2; N2]>>::Output

fn conv_2d(self, rhs: [T2; N2]) -> Self::Output

impl<const N1: usize, const N2: usize, T1, T2, T3> Conv2d<T1, T2, Vec<[T2; N2]>> for Vec<[T1; N1]>

where T1: ComplexFloat + Mul<T2, Output = T3> + Into<Complex<T1::Real>>, T2: ComplexFloat + Into<Complex<T2::Real>>, T3: ComplexFloat<Real: Into<T3>> + 'static, Vec<[T1; N1]>: Matrix<T1, Index = (usize, usize)>, Vec<[T2; N2]>: Matrix<T2, Index = (usize, usize)>, Array2<Complex<T1::Real>>: Dft2d<Complex<T1::Real>, Mapped<Complex<T1::Real>> = Array2<Complex<T1::Real>>> + Mul<Array2<Complex<T2::Real>>, Output = Array2<Complex<T3::Real>>>, Array2<Complex<T2::Real>>: Dft2d<Complex<T2::Real>, Mapped<Complex<T2::Real>> = Array2<Complex<T2::Real>>>, Array2<Complex<T3::Real>>: Idft2d<Complex<T3::Real>, Mapped<Complex<T3::Real>> = Array2<Complex<T3::Real>>>, Vec<[T3; { _ }]>: MaybeMatrix<T3>,

type Output = Vec<[T3; { _ }]>

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

impl<const N1: usize, const N2: usize, const M1: usize, T1, T2, T3> Conv2d<T1, T2, Vec<[T2; N2]>> for [[T1; N1]; M1]

where T1: ComplexFloat + Mul<T2, Output = T3> + Into<Complex<T1::Real>>, T2: ComplexFloat + Into<Complex<T2::Real>>, T3: ComplexFloat<Real: Into<T3>> + 'static, [[T1; N1]; M1]: Matrix<T1, Index = (usize, usize)>, Vec<[T2; N2]>: Matrix<T2, Index = (usize, usize)>, Array2<Complex<T1::Real>>: Dft2d<Complex<T1::Real>, Mapped<Complex<T1::Real>> = Array2<Complex<T1::Real>>> + Mul<Array2<Complex<T2::Real>>, Output = Array2<Complex<T3::Real>>>, Array2<Complex<T2::Real>>: Dft2d<Complex<T2::Real>, Mapped<Complex<T2::Real>> = Array2<Complex<T2::Real>>>, Array2<Complex<T3::Real>>: Idft2d<Complex<T3::Real>, Mapped<Complex<T3::Real>> = Array2<Complex<T3::Real>>>, Vec<[T3; { _ }]>: MaybeMatrix<T3>,

type Output = Vec<[T3; { _ }]>

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

impl<const N1: usize, const N2: usize, const M1: usize, const M2: usize, T1, T2, T3> Conv2d<T1, T2, [[T2; N2]; M2]> for [[T1; N1]; M1]

where T1: ComplexFloat + Mul<T2, Output = T3> + Into<Complex<T1::Real>>, T2: ComplexFloat + Into<Complex<T2::Real>>, T3: ComplexFloat<Real: Into<T3>> + 'static, [[T1; N1]; M1]: Matrix<T1, Index = (usize, usize)>, [[T2; N2]; M2]: Matrix<T2, Index = (usize, usize)>, Array2<Complex<T1::Real>>: Dft2d<Complex<T1::Real>, Mapped<Complex<T1::Real>> = Array2<Complex<T1::Real>>> + Mul<Array2<Complex<T2::Real>>, Output = Array2<Complex<T3::Real>>>, Array2<Complex<T2::Real>>: Dft2d<Complex<T2::Real>, Mapped<Complex<T2::Real>> = Array2<Complex<T2::Real>>>, Array2<Complex<T3::Real>>: Idft2d<Complex<T3::Real>, Mapped<Complex<T3::Real>> = Array2<Complex<T3::Real>>>, [[T3; { _ }]; { _ }]: MaybeMatrix<T3>,

type Output = [[T3; { _ }]; { _ }]

fn conv_2d(self, rhs: [[T2; N2]; M2]) -> Self::Output

impl<const N1: usize, const N2: usize, const M2: usize, T1, T2, T3> Conv2d<T1, T2, [[T2; N2]; M2]> for Vec<[T1; N1]>

where T1: ComplexFloat + Mul<T2, Output = T3> + Into<Complex<T1::Real>>, T2: ComplexFloat + Into<Complex<T2::Real>>, T3: ComplexFloat<Real: Into<T3>> + 'static, Vec<[T1; N1]>: Matrix<T1, Index = (usize, usize)>, [[T2; N2]; M2]: Matrix<T2, Index = (usize, usize)>, Array2<Complex<T1::Real>>: Dft2d<Complex<T1::Real>, Mapped<Complex<T1::Real>> = Array2<Complex<T1::Real>>> + Mul<Array2<Complex<T2::Real>>, Output = Array2<Complex<T3::Real>>>, Array2<Complex<T2::Real>>: Dft2d<Complex<T2::Real>, Mapped<Complex<T2::Real>> = Array2<Complex<T2::Real>>>, Array2<Complex<T3::Real>>: Idft2d<Complex<T3::Real>, Mapped<Complex<T3::Real>> = Array2<Complex<T3::Real>>>, Vec<[T3; { _ }]>: MaybeMatrix<T3>,

type Output = Vec<[T3; { _ }]>

fn conv_2d(self, rhs: [[T2; N2]; M2]) -> Self::Output

impl<const N2: usize, T1, T2, T3> Conv2d<T1, T2, [T2; N2]> for ()

where T1: Mul<T2, Output = T3>, (): Conv<T1, T2, [T2; N2]>, <() as Conv<T1, T2, [T2; N2]>>::Output: MaybeMatrix<T3>,

type Output = <() as Conv<T1, T2, [T2; N2]>>::Output

fn conv_2d(self, rhs: [T2; N2]) -> Self::Output

impl<const N2: usize, T1, T2, T3> Conv2d<T1, T2, [T2; N2]> for Vec<T1>

where T1: Mul<T2, Output = T3>, Vec<T1>: Conv<T1, T2, [T2; N2]>, <Vec<T1> as Conv<T1, T2, [T2; N2]>>::Output: MaybeMatrix<T3>,

type Output = <Vec<T1> as Conv<T1, T2, [T2; N2]>>::Output

fn conv_2d(self, rhs: [T2; N2]) -> Self::Output

impl<const N2: usize, T1, T2, T3> Conv2d<T1, T2, Vec<[T2; N2]>> for ()

where T1: Mul<T2, Output = T3>, (): Conv<T1, T2, Vec<[T2; N2]>>, <() as Conv<T1, T2, Vec<[T2; N2]>>>::Output: MaybeMatrix<T3>,

type Output = <() as Conv<T1, T2, Vec<[T2; N2]>>>::Output

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

impl<const N2: usize, T1, T2, T3> Conv2d<T1, T2, Vec<[T2; N2]>> for Array2<T1>

where T1: ComplexFloat + Mul<T2, Output = T3> + Into<Complex<T1::Real>>, T2: ComplexFloat + Into<Complex<T2::Real>>, T3: ComplexFloat<Real: Into<T3>> + 'static, Array2<T1>: Matrix<T1, Index = (usize, usize)>, Vec<[T2; N2]>: Matrix<T2, Index = (usize, usize)>, Array2<Complex<T1::Real>>: Dft2d<Complex<T1::Real>, Mapped<Complex<T1::Real>> = Array2<Complex<T1::Real>>> + Mul<Array2<Complex<T2::Real>>, Output = Array2<Complex<T3::Real>>>, Array2<Complex<T2::Real>>: Dft2d<Complex<T2::Real>, Mapped<Complex<T2::Real>> = Array2<Complex<T2::Real>>>, Array2<Complex<T3::Real>>: Idft2d<Complex<T3::Real>, Mapped<Complex<T3::Real>> = Array2<Complex<T3::Real>>>,

type Output = ArrayBase<OwnedRepr<T3>, Dim<[usize; 2]>>

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

impl<const N2: usize, const M2: usize, T1, T2, T3> Conv2d<T1, T2, [[T2; N2]; M2]> for ()

where T1: Mul<T2, Output = T3>, (): Conv<T1, T2, [[T2; N2]; M2]>, <() as Conv<T1, T2, [[T2; N2]; M2]>>::Output: MaybeMatrix<T3>,

type Output = <() as Conv<T1, T2, [[T2; N2]; M2]>>::Output

fn conv_2d(self, rhs: [[T2; N2]; M2]) -> Self::Output

impl<const N2: usize, const M2: usize, T1, T2, T3> Conv2d<T1, T2, [[T2; N2]; M2]> for Array2<T1>

where T1: ComplexFloat + Mul<T2, Output = T3> + Into<Complex<T1::Real>>, T2: ComplexFloat + Into<Complex<T2::Real>>, T3: ComplexFloat<Real: Into<T3>> + 'static, Array2<T1>: Matrix<T1, Index = (usize, usize)>, [[T2; N2]; M2]: Matrix<T2, Index = (usize, usize)>, Array2<Complex<T1::Real>>: Dft2d<Complex<T1::Real>, Mapped<Complex<T1::Real>> = Array2<Complex<T1::Real>>> + Mul<Array2<Complex<T2::Real>>, Output = Array2<Complex<T3::Real>>>, Array2<Complex<T2::Real>>: Dft2d<Complex<T2::Real>, Mapped<Complex<T2::Real>> = Array2<Complex<T2::Real>>>, Array2<Complex<T3::Real>>: Idft2d<Complex<T3::Real>, Mapped<Complex<T3::Real>> = Array2<Complex<T3::Real>>>,

type Output = ArrayBase<OwnedRepr<T3>, Dim<[usize; 2]>>

fn conv_2d(self, rhs: [[T2; N2]; M2]) -> Self::Output

Implementors