use-zero-crossing 0.0.1

Primitive zero-crossing helpers for signal slices
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

#![forbid(unsafe_code)]
//! Primitive zero-crossing helpers.
//!
//! Exact zero values are treated as neutral samples: they do not create a
//! crossing on their own, but they also do not break the sign continuity
//! between surrounding non-zero finite samples.
//!
//! # Examples
//!
//! ```rust
//! use use_zero_crossing::{crosses_zero, zero_crossing_count, zero_crossing_rate};
//!
//! let samples = [-1.0, 0.0, 1.0, -1.0];
//!
//! assert!(crosses_zero(-1.0, 1.0));
//! assert_eq!(zero_crossing_count(&samples), 2);
//! assert_eq!(zero_crossing_rate(&samples), Some(2.0 / 3.0));
//! ```

fn non_zero_sign(sample: f64) -> Option<i8> {
    if !sample.is_finite() || sample == 0.0 {
        None
    } else if sample.is_sign_positive() {
        Some(1)
    } else {
        Some(-1)
    }
}

#[must_use]
pub fn crosses_zero(previous: f64, current: f64) -> bool {
    previous.is_finite()
        && current.is_finite()
        && ((previous < 0.0 && current > 0.0) || (previous > 0.0 && current < 0.0))
}

#[must_use]
pub fn zero_crossing_count(samples: &[f64]) -> usize {
    let mut previous_sign = None;
    let mut count = 0;

    for sample in samples.iter().copied() {
        match non_zero_sign(sample) {
            Some(sign) => {
                if let Some(previous) = previous_sign && previous != sign {
                    count += 1;
                }

                previous_sign = Some(sign);
            }
            None if !sample.is_finite() => previous_sign = None,
            None => {}
        }
    }

    count
}

pub fn zero_crossing_rate(samples: &[f64]) -> Option<f64> {
    if samples.len() < 2 || samples.iter().any(|sample| !sample.is_finite()) {
        return None;
    }

    Some(zero_crossing_count(samples) as f64 / (samples.len() - 1) as f64)
}

#[cfg(test)]
mod tests {
    use super::{crosses_zero, zero_crossing_count, zero_crossing_rate};

    #[test]
    fn detects_direct_crossings() {
        assert!(crosses_zero(-1.0, 1.0));
        assert!(crosses_zero(1.0, -1.0));
        assert!(!crosses_zero(-1.0, 0.0));
        assert!(!crosses_zero(0.0, 1.0));
    }

    #[test]
    fn counts_crossings_while_skipping_exact_zero_samples() {
        assert_eq!(zero_crossing_count(&[-1.0, 0.0, 1.0, 0.0, -1.0]), 2);
        assert_eq!(zero_crossing_count(&[1.0]), 0);
    }

    #[test]
    fn computes_zero_crossing_rate() {
        assert_eq!(zero_crossing_rate(&[-1.0, 0.0, 1.0, -1.0]), Some(2.0 / 3.0));
    }

    #[test]
    fn rejects_invalid_rate_inputs() {
        assert_eq!(zero_crossing_rate(&[]), None);
        assert_eq!(zero_crossing_rate(&[1.0]), None);
        assert_eq!(zero_crossing_rate(&[1.0, f64::NAN]), None);
    }
}