Struct chfft::CFft2D

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

Perform a complex-to-complex two-dimensional Fourier transform

Example

extern crate chfft;
extern crate num_complex;
use num_complex::Complex;
use chfft::CFft2D;

fn main() {
    let input = [
        vec![
            Complex::new(2.0, 0.0),
            Complex::new(1.0, 1.0),
            Complex::new(0.0, 3.0),
            Complex::new(2.0, 4.0),
        ],
        vec![
            Complex::new(5.0, 0.0),
            Complex::new(3.0, 1.0),
            Complex::new(2.0, 3.0),
            Complex::new(2.0, 8.0),
        ],
        vec![
            Complex::new(2.0, 5.0),
            Complex::new(2.0, 3.0),
            Complex::new(3.0, 7.0),
            Complex::new(2.0, 1.0),
        ],
        vec![
            Complex::new(5.0, 4.0),
            Complex::new(1.0, 2.0),
            Complex::new(4.0, 3.0),
            Complex::new(2.0, 1.0),
        ],
    ];

    let mut fft = CFft2D::<f64>::with_len(input.len(), input[0].len());

    let output = fft.forward(&input);

    println!("the transform of {:?} is {:?}", input, output);
}

Methods

impl<T: Float + FloatConst + NumAssign> CFft2D<T>

fn new() -> Self

Returns a instances to execute FFT

use chfft::CFft2D;
let mut fft = CFft2D::<f64>::new();

fn with_len(len_m: usize, len_n: usize) -> Self

Returns a instances to execute length initialized FFT

use chfft::CFft2D;
let mut fft = CFft2D::<f64>::with_len(1024, 1024);

fn setup(&mut self, len_m: usize, len_n: usize)

Reinitialize length

use chfft::CFft2D;
let mut fft = CFft2D::<f64>::with_len(1024, 1024);

// reinitialize
fft.setup(2048, 2048);

fn forward(&mut self, source: &[Vec<Complex<T>>]) -> Vec<Vec<Complex<T>>>

The 1 scaling factor forward transform

extern crate chfft;
extern crate num_complex;

let input = [
    vec![
        num_complex::Complex::new(2.0, 0.0),
        num_complex::Complex::new(1.0, 1.0),
        num_complex::Complex::new(0.0, 3.0),
        num_complex::Complex::new(2.0, 4.0),
    ],
    vec![
        num_complex::Complex::new(5.0, 0.0),
        num_complex::Complex::new(3.0, 1.0),
        num_complex::Complex::new(2.0, 3.0),
        num_complex::Complex::new(2.0, 8.0),
    ],
];

let mut fft = chfft::CFft2D::<f64>::with_len(input.len(), input[0].len());
let output = fft.forward(&input);

fn forward0(&mut self, source: &[Vec<Complex<T>>]) -> Vec<Vec<Complex<T>>>

The 1 scaling factor forward transform

extern crate chfft;
extern crate num_complex;

let input = [
    vec![
        num_complex::Complex::new(2.0, 0.0),
        num_complex::Complex::new(1.0, 1.0),
        num_complex::Complex::new(0.0, 3.0),
        num_complex::Complex::new(2.0, 4.0),
    ],
    vec![
        num_complex::Complex::new(5.0, 0.0),
        num_complex::Complex::new(3.0, 1.0),
        num_complex::Complex::new(2.0, 3.0),
        num_complex::Complex::new(2.0, 8.0),
    ],
];

let mut fft = chfft::CFft2D::<f64>::with_len(input.len(), input[0].len());
let output = fft.forward0(&input);

fn forwardu(&mut self, source: &[Vec<Complex<T>>]) -> Vec<Vec<Complex<T>>>

The \(\frac 1 {\sqrt n}\) scaling factor forward transform

extern crate chfft;
extern crate num_complex;

let input = [
    vec![
        num_complex::Complex::new(2.0, 0.0),
        num_complex::Complex::new(1.0, 1.0),
        num_complex::Complex::new(0.0, 3.0),
        num_complex::Complex::new(2.0, 4.0),
    ],
    vec![
        num_complex::Complex::new(5.0, 0.0),
        num_complex::Complex::new(3.0, 1.0),
        num_complex::Complex::new(2.0, 3.0),
        num_complex::Complex::new(2.0, 8.0),
    ],
];

let mut fft = chfft::CFft2D::<f64>::with_len(input.len(), input[0].len());
let output = fft.forwardu(&input);

fn forwardn(&mut self, source: &[Vec<Complex<T>>]) -> Vec<Vec<Complex<T>>>

The \(\frac 1 n\) scaling factor forward transform

extern crate chfft;
extern crate num_complex;

let input = [
    vec![
        num_complex::Complex::new(2.0, 0.0),
        num_complex::Complex::new(1.0, 1.0),
        num_complex::Complex::new(0.0, 3.0),
        num_complex::Complex::new(2.0, 4.0),
    ],
    vec![
        num_complex::Complex::new(5.0, 0.0),
        num_complex::Complex::new(3.0, 1.0),
        num_complex::Complex::new(2.0, 3.0),
        num_complex::Complex::new(2.0, 8.0),
    ],
];

let mut fft = chfft::CFft2D::<f64>::with_len(input.len(), input[0].len());
let output = fft.forwardn(&input);

fn backward(&mut self, source: &[Vec<Complex<T>>]) -> Vec<Vec<Complex<T>>>

The \(\frac 1 n\) scaling factor backward transform

extern crate chfft;
extern crate num_complex;

let input = [
    vec![
        num_complex::Complex::new(2.0, 0.0),
        num_complex::Complex::new(1.0, 1.0),
        num_complex::Complex::new(0.0, 3.0),
        num_complex::Complex::new(2.0, 4.0),
    ],
    vec![
        num_complex::Complex::new(5.0, 0.0),
        num_complex::Complex::new(3.0, 1.0),
        num_complex::Complex::new(2.0, 3.0),
        num_complex::Complex::new(2.0, 8.0),
    ],
];

let mut fft = chfft::CFft2D::<f64>::with_len(input.len(), input[0].len());
let output = fft.backward(&input);

fn backward0(&mut self, source: &[Vec<Complex<T>>]) -> Vec<Vec<Complex<T>>>

The 1 scaling factor backward transform

extern crate chfft;
extern crate num_complex;

let input = [
    vec![
        num_complex::Complex::new(2.0, 0.0),
        num_complex::Complex::new(1.0, 1.0),
        num_complex::Complex::new(0.0, 3.0),
        num_complex::Complex::new(2.0, 4.0),
    ],
    vec![
        num_complex::Complex::new(5.0, 0.0),
        num_complex::Complex::new(3.0, 1.0),
        num_complex::Complex::new(2.0, 3.0),
        num_complex::Complex::new(2.0, 8.0),
    ],
];

let mut fft = chfft::CFft2D::<f64>::with_len(input.len(), input[0].len());
let output = fft.backward0(&input);

fn backwardu(&mut self, source: &[Vec<Complex<T>>]) -> Vec<Vec<Complex<T>>>

The \(\frac 1 {\sqrt n}\) scaling factor backward transform

extern crate chfft;
extern crate num_complex;

let input = [
    vec![
        num_complex::Complex::new(2.0, 0.0),
        num_complex::Complex::new(1.0, 1.0),
        num_complex::Complex::new(0.0, 3.0),
        num_complex::Complex::new(2.0, 4.0),
    ],
    vec![
        num_complex::Complex::new(5.0, 0.0),
        num_complex::Complex::new(3.0, 1.0),
        num_complex::Complex::new(2.0, 3.0),
        num_complex::Complex::new(2.0, 8.0),
    ],
];

let mut fft = chfft::CFft2D::<f64>::with_len(input.len(), input[0].len());
let output = fft.backwardu(&input);