fourier 0.1.0

Fast Fourier transforms (FFTs)
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
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119

use fourier::{create_fft_f32, create_fft_f64};
use num_complex::Complex;
use num_traits::Float;
use serde::Deserialize;

fn near_f32(actual: &[Complex<f32>], expected: &[Complex<f32>]) {
    assert_eq!(actual.len(), expected.len());
    println!("actual: {:?}\nexpect: {:?}", actual, expected);
    let tolerance = 1e-4;
    for (actual, expected) in actual.iter().zip(expected.iter()) {
        assert!(
            float_cmp::approx_eq!(
                f32,
                actual.re,
                expected.re,
                float_cmp::F32Margin {
                    epsilon: tolerance,
                    ulps: 8
                }
            ) && float_cmp::approx_eq!(
                f32,
                actual.im,
                expected.im,
                float_cmp::F32Margin {
                    epsilon: tolerance,
                    ulps: 8
                }
            ),
            format!("{} != {}", actual, expected)
        );
    }
}

fn near_f64(actual: &[Complex<f64>], expected: &[Complex<f64>]) {
    assert_eq!(actual.len(), expected.len());
    println!("actual: {:?}\nexpect: {:?}", actual, expected);
    let tolerance = 1e-11;
    for (actual, expected) in actual.iter().zip(expected.iter()) {
        assert!(
            float_cmp::approx_eq!(
                f64,
                actual.re,
                expected.re,
                float_cmp::F64Margin {
                    epsilon: tolerance,
                    ulps: 8
                }
            ) && float_cmp::approx_eq!(
                f64,
                actual.im,
                expected.im,
                float_cmp::F64Margin {
                    epsilon: tolerance,
                    ulps: 8
                }
            ),
            format!("{} != {}", actual, expected)
        );
    }
}

macro_rules! generate_vector_test {
    {
        @forward_f32 $test:ident, $file:tt
    } => {
        #[test]
        fn $test() {
            let serialized = std::include_str!($file);
            let mut data: Data<f32> = serde_json::from_str(serialized).unwrap();
            let fft = create_fft_f32(data.x.len());
            fft.fft_in_place(&mut data.x);
            near_f32(&data.x, &data.y);
        }
    };
    {
        @inverse_f32 $test:ident, $file:tt
    } => {
        #[test]
        fn $test() {
            let serialized = std::include_str!($file);
            let mut data: Data<f32> = serde_json::from_str(serialized).unwrap();
            let fft = create_fft_f32(data.x.len());
            fft.ifft_in_place(&mut data.y);
            near_f32(&data.y, &data.x);
        }
    };
    {
        @forward_f64 $test:ident, $file:tt
    } => {
        #[test]
        fn $test() {
            let serialized = std::include_str!($file);
            let mut data: Data<f64> = serde_json::from_str(serialized).unwrap();
            let fft = create_fft_f64(data.x.len());
            fft.fft_in_place(&mut data.x);
            near_f64(&data.x, &data.y);
        }
    };
    {
        @inverse_f64 $test:ident, $file:tt
    } => {
        #[test]
        fn $test() {
            let serialized = std::include_str!($file);
            let mut data: Data<f64> = serde_json::from_str(serialized).unwrap();
            let fft = create_fft_f64(data.x.len());
            fft.ifft_in_place(&mut data.y);
            near_f64(&data.y, &data.x);
        }
    }
}

#[derive(Deserialize)]
struct Data<T: Clone + Float> {
    x: Vec<Complex<T>>,
    y: Vec<Complex<T>>,
}

std::include! {"vectors/generate_tests.rs"}