lodviz_core 0.3.0

Core visualization primitives and data structures for lodviz
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

/// Nearest-point search for tooltip interaction
use crate::core::data::DataPoint;

/// Find the DataPoint with x closest to `target_x`.
/// Assumes data is sorted by x. Uses binary search for O(log n).
/// Returns the index and a reference to the nearest point.
pub fn find_nearest_point(data: &[DataPoint], target_x: f64) -> Option<(usize, &DataPoint)> {
    if data.is_empty() {
        return None;
    }

    let idx = data.partition_point(|p| p.x < target_x);

    // Compare the candidates on either side of the partition point
    let candidates: &[usize] = match idx {
        0 => &[0],
        i if i >= data.len() => &[data.len() - 1],
        i => &[i - 1, i],
    };

    candidates
        .iter()
        .copied()
        .min_by(|&a, &b| {
            let da = (data[a].x - target_x).abs();
            let db = (data[b].x - target_x).abs();
            da.partial_cmp(&db).unwrap_or(std::cmp::Ordering::Equal)
        })
        .map(|i| (i, &data[i]))
}

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

    fn sample_data() -> Vec<DataPoint> {
        vec![
            DataPoint::new(0.0, 10.0),
            DataPoint::new(1.0, 20.0),
            DataPoint::new(2.0, 15.0),
            DataPoint::new(5.0, 30.0),
            DataPoint::new(10.0, 5.0),
        ]
    }

    #[test]
    fn test_nearest_exact_match() {
        let data = sample_data();
        let (idx, pt) = find_nearest_point(&data, 2.0).unwrap();
        assert_eq!(idx, 2);
        assert_eq!(pt.x, 2.0);
        assert_eq!(pt.y, 15.0);
    }

    #[test]
    fn test_nearest_between_points() {
        let data = sample_data();
        // 4.0 is closer to 5.0 than to 2.0
        let (idx, pt) = find_nearest_point(&data, 4.0).unwrap();
        assert_eq!(idx, 3);
        assert_eq!(pt.x, 5.0);
    }

    #[test]
    fn test_nearest_before_first() {
        let data = sample_data();
        let (idx, _) = find_nearest_point(&data, -5.0).unwrap();
        assert_eq!(idx, 0);
    }

    #[test]
    fn test_nearest_after_last() {
        let data = sample_data();
        let (idx, _) = find_nearest_point(&data, 100.0).unwrap();
        assert_eq!(idx, 4);
    }

    #[test]
    fn test_nearest_empty() {
        assert!(find_nearest_point(&[], 5.0).is_none());
    }

    #[test]
    fn test_nearest_single_point() {
        let data = vec![DataPoint::new(3.0, 7.0)];
        let (idx, pt) = find_nearest_point(&data, 100.0).unwrap();
        assert_eq!(idx, 0);
        assert_eq!(pt.x, 3.0);
    }

    #[test]
    fn test_nearest_midpoint_prefers_left() {
        let data = vec![DataPoint::new(0.0, 0.0), DataPoint::new(2.0, 0.0)];
        // At exact midpoint (1.0), both are equidistant. Either is acceptable.
        let (idx, _) = find_nearest_point(&data, 1.0).unwrap();
        assert!(idx == 0 || idx == 1);
    }
}