fcwt 0.1.3

Fast Continuous Wavelet Transforms
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

use crate::wavelet::Wavelet;

type Float = super::Float;

pub trait Scales {
    fn len(&self) -> usize;
    fn sample_rate(&self) -> usize;
    fn scale(&self, index: usize) -> Float;
    fn freq(&self, index: usize) -> Float;
}

pub struct LinFreqs {
    scales: Vec<Float>,
    sample_rate: usize,
}

impl LinFreqs {
    pub fn new<W: Wavelet>(_wavelet: &W, sample_rate: usize, start_freq: Float, end_freq: Float, size: usize) -> Self {

        let mut scales: Vec<Float> = vec![0.0; size];

        // Ensure end freq is below Nyquist frequency (sample rate/2)
        assert!(end_freq <= (sample_rate/2) as Float);

        // frequency delta
        let df = end_freq - start_freq;

        for i in 0..size {
            scales[size-i-1] = (sample_rate as Float) / (start_freq + (df/size as Float)*i as Float);

        }

        Self {
            scales,
            sample_rate,
        }
    }
}

impl Scales for LinFreqs {
    fn len(&self) -> usize {
        self.scales.len()
    }

    fn sample_rate(&self) -> usize {
        self.sample_rate
    }

    fn scale(&self, index: usize) -> Float {
        self.scales[index]
    }

    fn freq(&self, index: usize) -> Float {
        self.sample_rate as Float / self.scales[index]
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::wavelet::MorletWavelet;

    const EPS: Float = 1e-5;

    #[test]
    fn test_lin_freqs_new() {
        let wavelet = MorletWavelet::new(1.0);
        let sample_rate = 100;
        let start_freq = 10.0;
        let end_freq = 20.0;
        let size = 5;
        let lin_freqs = LinFreqs::new(&wavelet, sample_rate, start_freq, end_freq, size);

        assert_eq!(lin_freqs.scales.len(), size);
        assert_eq!(lin_freqs.sample_rate, sample_rate);

        // Check if scales are calculated correctly
        let df = end_freq - start_freq;
        for i in 0..size {
            let expected_scale = (sample_rate as Float) / (start_freq + (df / size as Float) * i as Float);
            assert_eq!(lin_freqs.scales[size - i - 1], expected_scale);
        }
    }

    #[test]
    #[should_panic]
    fn test_lin_freqs_new_end_freq_above_nyquist() {
        let wavelet = MorletWavelet::new(1.0);
        let sample_rate = 100;
        let start_freq = 10.0;
        let end_freq = 60.0; // Above Nyquist frequency (sample_rate / 2)
        let size = 5;
        let _ = LinFreqs::new(&wavelet, sample_rate, start_freq, end_freq, size);
    }

    #[test]
    fn test_values() {
        let wavelet = MorletWavelet::new(16.0);
        let scales = LinFreqs::new(&wavelet, 1000, 1.0, 20.0, 1000);
        assert_eq!(scales.len(), 1000);

        // Compare with values from python bindings to fCWT
        assert!(scales.freq(0) - 19.980999 < EPS);
        assert!(scales.freq(1) - 19.962 < EPS);
        assert_eq!(scales.freq(scales.len()-1), 1.0);
    }
}