Struct chfft::RFft1D

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

Perform a real-to-complex one-dimensional Fourier transform

Example

use chfft::RFft1D;

fn main() {
    let input = [2.0, 0.0, 1.0, 1.0, 0.0, 3.0, 2.0, 4.0];

    let mut fft = RFft1D::<f64>::new(input.len());

    let output = fft.forward(&input);

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

Methods

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

pub fn new(len: usize) -> Self

Returns a instances to execute FFT

use chfft::RFft1D;
let mut rfft = RFft1D::<f64>::new(1024);

pub fn setup(&mut self, len: usize)

Reinitialize length

use chfft::RFft1D;
let mut rfft = RFft1D::<f64>::new(1024);

// reinitialize
rfft.setup(2048);

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

The 1 scaling factor forward transform

use chfft::RFft1D;

let input = [2.0, 0.0, 1.0, 1.0, 0.0, 3.0, 2.0, 4.0];

let mut fft = RFft1D::<f64>::new(input.len());
let output = fft.forward0(&input);

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

The 1 scaling factor forward transform

use chfft::RFft1D;

let input = [2.0, 0.0, 1.0, 1.0, 0.0, 3.0, 2.0, 4.0];

let mut fft = RFft1D::<f64>::new(input.len());
let output = fft.forward0(&input);

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

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

use chfft::RFft1D;

let input = [2.0, 0.0, 1.0, 1.0, 0.0, 3.0, 2.0, 4.0];

let mut fft = RFft1D::<f64>::new(input.len());
let output = fft.forwardu(&input);

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

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

use chfft::RFft1D;

let input = [2.0, 0.0, 1.0, 1.0, 0.0, 3.0, 2.0, 4.0];

let mut fft = RFft1D::<f64>::new(input.len());
let output = fft.forwardn(&input);

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

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

use chfft::RFft1D;
use num_complex::Complex;

let input = [Complex::new(2.0, 0.0), Complex::new(1.0, 1.0),
             Complex::new(4.0, 3.0), Complex::new(2.0, 0.0)];

let mut fft = RFft1D::<f64>::new(6);
let output = fft.backward(&input);

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

The 1 scaling factor backward transform

use chfft::RFft1D;
use num_complex::Complex;

let input = [Complex::new(2.0, 0.0), Complex::new(1.0, 1.0),
             Complex::new(4.0, 3.0), Complex::new(2.0, 0.0)];

let mut fft = RFft1D::<f64>::new(6);
let output = fft.backward0(&input);

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

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

use chfft::RFft1D;
use num_complex::Complex;

let input = [Complex::new(2.0, 0.0), Complex::new(1.0, 1.0),
             Complex::new(4.0, 3.0), Complex::new(2.0, 0.0)];

let mut fft = RFft1D::<f64>::new(6);
let output = fft.backwardu(&input);

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

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

use chfft::RFft1D;
use num_complex::Complex;

let input = [Complex::new(2.0, 0.0), Complex::new(1.0, 1.0),
             Complex::new(4.0, 3.0), Complex::new(2.0, 0.0)];

let mut fft = RFft1D::<f64>::new(6);
let output = fft.backwardn(&input);

Trait Implementations

impl<T: Debug> Debug for RFft1D<T>

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.