rustfft 5.0.0-experimental.2

High-performance FFT library written in pure Rust.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52


use num_complex::Complex;
use crate::common::FFTnum;

pub fn generate_twiddle_factors<T: FFTnum>(fft_len: usize, inverse: bool) -> Vec<Complex<T>> {
    (0..fft_len).map(|i| T::generate_twiddle_factor(i, fft_len, inverse)).collect()
}

pub fn rotate_90<T: FFTnum>(value: Complex<T>, inverse:bool) -> Complex<T>
{
    if inverse {
        Complex{re:-value.im, im: value.re}
    } else {
        Complex{re: value.im, im:-value.re}
    }
}

#[cfg(test)]
mod unit_tests {
	use super::*;
	use std::f32;
    use crate::test_utils::{compare_vectors};

    #[test]
    fn test_generate() {
        //test the length-0 case
        let zero_twiddles: Vec<Complex<f32>> = generate_twiddle_factors(0, false);
        assert_eq!(0, zero_twiddles.len());

        let constant = -2f32 * f32::consts::PI;

        for len in 1..10 {
            let actual: Vec<Complex<f32>> = generate_twiddle_factors(len, false);
            let expected: Vec<Complex<f32>> = (0..len).map(|i| Complex::from_polar(1f32, constant * i as f32 / len as f32)).collect();

            assert!(compare_vectors(&actual, &expected), "len = {}", len)
        }

        //for each len, verify that each element in the inverse is the conjugate of the non-inverse
        for len in 1..10 {
            let twiddles: Vec<Complex<f32>> = generate_twiddle_factors(len, false);
            let mut twiddles_inverse: Vec<Complex<f32>> = generate_twiddle_factors(len, true);

            for value in twiddles_inverse.iter_mut()
            {
                *value = value.conj();
            }

            assert!(compare_vectors(&twiddles, &twiddles_inverse), "len = {}", len)
        }
    }
}