Trait ConvFFTExt 

pub trait ConvFFTExt<'a, T, InElem, S, SK, const N: usize>
where
    T: NumAssign + Copy + FftNum,
    InElem: GetProcessor<T, InElem> + Copy + NumAssign,
    S: RawData,
    SK: RawData,
{
    // Required methods
    fn conv_fft(
        &self,
        kernel: impl IntoKernelWithDilation<'a, SK, N>,
        conv_mode: ConvMode<N>,
        padding_mode: PaddingMode<N, InElem>,
    ) -> Result<Array<InElem, Dim<[Ix; N]>>, Error<N>>;
    fn conv_fft_with_processor(
        &self,
        kernel: impl IntoKernelWithDilation<'a, SK, N>,
        conv_mode: ConvMode<N>,
        padding_mode: PaddingMode<N, InElem>,
        fft_processor: &mut impl Processor<T, InElem>,
    ) -> Result<Array<InElem, Dim<[Ix; N]>>, Error<N>>;
}

Extends ndarray’s ArrayBase with FFT-accelerated convolution operations.

This trait adds the conv_fft and conv_fft_with_processor methods to ArrayBase, enabling efficient FFT-based convolutions on N-dimensional arrays.

Type Parameters

• T: The numeric type used internally for FFT operations. Must be a floating-point type that implements FftNum.
• InElem: The element type of the input arrays. Can be real (T) or complex (Complex<T>).
• S: The data storage type of the input array.
• SK: The data storage type of the kernel array.

Methods

• conv_fft: Performs an FFT-accelerated convolution with default settings.
• conv_fft_with_processor: Performs an FFT-accelerated convolution using a provided Processor instance, allowing for reuse of FFT plans across multiple convolutions for better performance.

Example

use ndarray::prelude::*;
use ndarray_conv::{ConvFFTExt, ConvMode, PaddingMode};

let arr = array![[1., 2.], [3., 4.]];
let kernel = array![[1., 0.], [0., 1.]];
let result = arr.conv_fft(&kernel, ConvMode::Same, PaddingMode::Zeros).unwrap();

Notes

FFT-based convolutions are generally faster for larger kernels but may have higher overhead for smaller kernels. Use standard convolution (ConvExt::conv) for small kernels or when working with integer types.

Performance Tips

For repeated convolutions with different data but the same kernel and settings, consider using conv_fft_with_processor to reuse the FFT planner and avoid redundant setup overhead.

Required Methods

fn conv_fft( &self, kernel: impl IntoKernelWithDilation<'a, SK, N>, conv_mode: ConvMode<N>, padding_mode: PaddingMode<N, InElem>, ) -> Result<Array<InElem, Dim<[Ix; N]>>, Error<N>>

Performs an FFT-accelerated convolution operation.

This method convolves the input array with a given kernel using FFT, which is typically faster for larger kernels.

Arguments

• kernel: The convolution kernel. Can be a reference to an array, or an array with dilation settings.
• conv_mode: The convolution mode (Full, Same, Valid, Custom, Explicit).
• padding_mode: The padding mode (Zeros, Const, Reflect, Replicate, Circular, Custom, Explicit).

Returns

Returns Ok(Array<InElem, Dim<[Ix; N]>>) containing the convolution result, or an Err(Error<N>) if the operation fails.

Example

use ndarray::array;
use ndarray_conv::{ConvFFTExt, ConvMode, PaddingMode};

let input = array![[1.0, 2.0], [3.0, 4.0]];
let kernel = array![[1.0, 0.0], [0.0, 1.0]];
let result = input.conv_fft(&kernel, ConvMode::Same, PaddingMode::Zeros).unwrap();

fn conv_fft_with_processor( &self, kernel: impl IntoKernelWithDilation<'a, SK, N>, conv_mode: ConvMode<N>, padding_mode: PaddingMode<N, InElem>, fft_processor: &mut impl Processor<T, InElem>, ) -> Result<Array<InElem, Dim<[Ix; N]>>, Error<N>>

Performs an FFT-accelerated convolution using a provided processor.

This method is useful when performing multiple convolutions, as it allows reusing the FFT planner and avoiding redundant initialization overhead.

Arguments

• kernel: The convolution kernel.
• conv_mode: The convolution mode.
• padding_mode: The padding mode.
• fft_processor: A mutable reference to an FFT processor instance.

Returns

Returns Ok(Array<InElem, Dim<[Ix; N]>>) containing the convolution result, or an Err(Error<N>) if the operation fails.

Example

use ndarray::array;
use ndarray_conv::{ConvFFTExt, ConvMode, PaddingMode, get_fft_processor};

let input1 = array![[1.0, 2.0], [3.0, 4.0]];
let input2 = array![[5.0, 6.0], [7.0, 8.0]];
let kernel = array![[1.0, 0.0], [0.0, 1.0]];

// Reuse the same processor for multiple convolutions
let mut proc = get_fft_processor::<f32, f32>();
let result1 = input1.conv_fft_with_processor(&kernel, ConvMode::Same, PaddingMode::Zeros, &mut proc).unwrap();
let result2 = input2.conv_fft_with_processor(&kernel, ConvMode::Same, PaddingMode::Zeros, &mut proc).unwrap();

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl<'a, T, InElem, S, SK, const N: usize> ConvFFTExt<'a, T, InElem, S, SK, N> for ArrayBase<S, Dim<[Ix; N]>>

where T: NumAssign + FftNum, InElem: GetProcessor<T, InElem> + NumAssign + Copy + Debug, S: Data<Elem = InElem> + 'a, SK: Data<Elem = InElem> + 'a, [Ix; N]: IntoDimension<Dim = Dim<[Ix; N]>>, SliceInfo<[SliceInfoElem; N], Dim<[Ix; N]>, Dim<[Ix; N]>>: SliceArg<Dim<[Ix; N]>, OutDim = Dim<[Ix; N]>>, Dim<[Ix; N]>: RemoveAxis,

fn conv_fft( &self, kernel: impl IntoKernelWithDilation<'a, SK, N>, conv_mode: ConvMode<N>, padding_mode: PaddingMode<N, InElem>, ) -> Result<Array<InElem, Dim<[Ix; N]>>, Error<N>>

fn conv_fft_with_processor( &self, kernel: impl IntoKernelWithDilation<'a, SK, N>, conv_mode: ConvMode<N>, padding_mode: PaddingMode<N, InElem>, fft_processor: &mut impl Processor<T, InElem>, ) -> Result<Array<InElem, Dim<[Ix; N]>>, Error<N>>

Implementors