dft 0.5.5

The package provides an algorithm to compute the discrete Fourier transform.
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
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
120
121
122
123
124
125
126

extern crate assert;
extern crate dft;

use dft::{transform, unpack, Operation, Plan, c64};

mod fixtures;

#[test]
fn complex_forward_1() {
    let mut data = vec![c64::new(1.0, -2.0)];
    transform(&mut data, &Plan::new(Operation::Forward, 1));
    assert!(data == vec![c64::new(1.0, -2.0)]);
}

#[test]
fn complex_forward_2() {
    let mut data = vec![c64::new(1.0, -2.0), c64::new(3.0, -4.0)];
    transform(&mut data, &Plan::new(Operation::Forward, 2));
    assert!(data == vec![c64::new(4.0, -6.0), c64::new(-2.0, 2.0)]);
}

#[test]
fn complex_forward_128() {
    let mut data = fixtures::TIME_DATA_256.to_vec();
    transform(as_c64_mut(&mut data), &Plan::new(Operation::Forward, 128));
    assert::close(&data, &fixtures::FREQUENCY_DATA_128_COMPLEX[..], 1e-14);
}

#[test]
fn complex_forward_real_256() {
    let mut data = to_c64(&fixtures::TIME_DATA_256);
    transform(&mut data, &Plan::new(Operation::Forward, 256));
    assert::close(
        as_f64(&data),
        &fixtures::FREQUENCY_DATA_256_REAL_UNPACKED[..],
        1e-13,
    );
}

#[test]
fn complex_inverse_128() {
    let mut data = fixtures::FREQUENCY_DATA_128_COMPLEX.to_vec();
    transform(as_c64_mut(&mut data), &Plan::new(Operation::Inverse, 128));
    assert::close(&data, &fixtures::TIME_DATA_256[..], 1e-14);
}

#[test]
fn real_forward_1() {
    let mut data = vec![1.0];
    transform(&mut data, &Plan::new(Operation::Forward, 1));
    assert!(unpack(&data) == vec![c64::new(1.0, 0.0)]);
}

#[test]
fn real_forward_2() {
    let mut data = vec![1.0, -2.0];
    transform(&mut data, &Plan::new(Operation::Forward, 2));
    assert!(unpack(&data) == vec![c64::new(-1.0, 0.0), c64::new(3.0, 0.0)]);
}

#[test]
fn real_forward_4() {
    let mut data = vec![1.0, -2.0, 3.0, -4.0];
    transform(&mut data, &Plan::new(Operation::Forward, 4));
    assert!(
        unpack(&data)
            == vec![
                c64::new(-2.0, 0.0),
                c64::new(-2.0, -2.0),
                c64::new(10.0, 0.0),
                c64::new(-2.0, 2.0),
            ]
    );
}

#[test]
fn real_forward_256() {
    let mut data = fixtures::TIME_DATA_256.to_vec();
    transform(&mut data, &Plan::new(Operation::Forward, 256));
    assert::close(&data, &fixtures::FREQUENCY_DATA_256_REAL_PACKED[..], 1e-13);
    let data = unpack(&data);
    assert::close(
        as_f64(&data),
        &fixtures::FREQUENCY_DATA_256_REAL_UNPACKED[..],
        1e-13,
    );
}

#[test]
fn real_forward_512() {
    let mut data = fixtures::TIME_DATA_512.to_vec();
    transform(&mut data, &Plan::new(Operation::Forward, 512));
    let data = unpack(&data);
    assert::close(
        as_f64(&data),
        &fixtures::FREQUENCY_DATA_512_REAL_UNPACKED[..],
        1e-12,
    );
}

#[test]
fn real_inverse_256() {
    let mut data = fixtures::FREQUENCY_DATA_256_REAL_PACKED.to_vec();
    transform(&mut data, &Plan::new(Operation::Inverse, 256));
    assert::close(&data, &fixtures::TIME_DATA_256[..], 1e-14);
}

#[test]
fn real_inverse_512() {
    let mut data = fixtures::TIME_DATA_512.to_vec();
    transform(&mut data, &Plan::new(Operation::Forward, 512));
    transform(&mut data, &Plan::new(Operation::Inverse, 512));
    assert::close(&data, &fixtures::TIME_DATA_512[..], 1e-14);
}

fn as_f64(slice: &[c64]) -> &[f64] {
    unsafe { std::slice::from_raw_parts(slice.as_ptr() as *const _, 2 * slice.len()) }
}

fn as_c64_mut(slice: &mut [f64]) -> &mut [c64] {
    unsafe { std::slice::from_raw_parts_mut(slice.as_mut_ptr() as *mut _, slice.len() / 2) }
}

fn to_c64(slice: &[f64]) -> Vec<c64> {
    slice.iter().map(|&re| c64::new(re, 0.0)).collect()
}