Struct R2cFftHandler

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

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 ndfft_r2c (serial) and ndfft_r2c_par (parallel).

The accompanying functions for the inverse transform are ndifft_r2c (serial) and ndifft_r2c_par (parallel).

Example

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

use ndarray::{Array2, Dim, Ix};
use ndrustfft::{ndfft_r2c, Complex, R2cFftHandler};

let (nx, ny) = (6, 4);
let mut data = Array2::<f64>::zeros((nx, ny));
let mut vhat = Array2::<Complex<f64>>::zeros((nx / 2 + 1, ny));
for (i, v) in data.iter_mut().enumerate() {
    *v = i as f64;
}
let mut fft_handler = R2cFftHandler::<f64>::new(nx);
ndfft_r2c(&data, &mut vhat, &mut fft_handler, 0);

Implementations

impl<T: FftNum> R2cFftHandler<T>

pub fn new(n: usize) -> Self

Creates a new RealFftPlanner.

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::R2cFftHandler;
let handler = R2cFftHandler::<f64>::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 R2cFftHandler<T>

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

Returns a copy of the value.

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

Performs copy-assignment from source.