Struct ndrustfft::FftHandler

pub struct FftHandler<T> { /* private fields */ }

n-dimensional complex-to-complex Fourier Transform.

Transforms a complex ndarray of size n to a complex array of size n and vice versa. The transformation is performed along a single axis, all other array dimensions are unaffected. Performs best on sizes which are mutiple of 2 or 3.

The accompanying functions for the forward transform are ndfft (serial) and ndfft_par (parallel).

The accompanying functions for the inverse transform are ndifft (serial) and ndifft_par (parallel).

Example

2-Dimensional complex-to-complex fft along first axis

use ndarray::{Array2, Dim, Ix};
use ndrustfft::{ndfft, Complex, FftHandler};

let (nx, ny) = (6, 4);
let mut data = Array2::<Complex<f64>>::zeros((nx, ny));
let mut vhat = Array2::<Complex<f64>>::zeros((nx, ny));
for (i, v) in data.iter_mut().enumerate() {
    v.re = i as f64;
    v.im = i as f64;
}
let mut fft_handler: FftHandler<f64> = FftHandler::new(nx);
ndfft(&data, &mut vhat, &mut fft_handler, 0);

Implementations

impl<T: FftNum> FftHandler<T>

pub fn new(n: usize) -> Self

Creates a new FftHandler.

Arguments

• n - Length of array along axis of which fft will be performed. The size of the complex array after the fft is performed will be of size n.

Examples

use ndrustfft::FftHandler;
let handler: FftHandler<f64> = FftHandler::new(10);

pub fn normalization(self, norm: Normalization<Complex<T>>) -> Self

This method allows modifying the normalization applied to the backward transform. See Normalization for more details.

Trait Implementations

impl<T: Clone> Clone for FftHandler<T>

fn clone(&self) -> FftHandler<T>

Returns a copy of the value.

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

Performs copy-assignment from source.