Struct ndrustfft::FftHandler

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

n-dimensional real-to-complex Fourier Transform.

Transforms a real ndarray of size n to a complex array of size n/2+1 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 ndrfft (serial) and ndrfft_par (parallel).

The accompanying functions for the inverse transform are ndirfft (serial) and ndirfft_par (parallel).

Example

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

use ndarray::{Array, Dim, Ix};
use ndrustfft::{ndrfft, Complex, FftHandler};

let (nx, ny) = (6, 4);
let mut data = Array::<f64, Dim<[Ix; 2]>>::zeros((nx, ny));
let mut vhat = Array::<Complex<f64>, Dim<[Ix; 2]>>::zeros((nx / 2 + 1, ny));
for (i, v) in data.iter_mut().enumerate() {
    *v = i as f64;
}
let mut fft_handler: FftHandler<f64> = FftHandler::new(nx);
ndrfft(
    &mut data.view_mut(),
    &mut vhat.view_mut(),
    &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 / 2 + 1.

Examples

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