lsph 0.1.9

Learned Spatial HashMap
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

use crate::geometry::Point;
use core::marker::PhantomData;
use num_traits::float::Float;

/// Distance trait for measuring the distance between two points
pub trait Distance {
    type F;
    /// Distance between two points in tuple format
    fn distance(a: &[Self::F; 2], b: &[Self::F; 2]) -> Self::F;
    /// Distance between two points in points format
    fn distance_point(a: &Point<Self::F>, b: &Point<Self::F>) -> Self::F;
}

/// Euclidean Distance
pub struct Euclidean<F: Float> {
    _marker: PhantomData<F>,
}

impl<F> Distance for Euclidean<F>
where
    F: Float,
{
    type F = F;
    fn distance(a: &[F; 2], b: &[F; 2]) -> F {
        F::sqrt((a[0] - b[0]).powi(2) + (a[1] - b[1]).powi(2))
    }

    fn distance_point(a: &Point<Self::F>, b: &Point<Self::F>) -> Self::F {
        Self::distance(&[a.x, a.y], &[b.x, b.y])
    }
}

/// Manhattan Distance
pub struct Manhattan<F: Float> {
    _marker: PhantomData<F>,
}

impl<F> Distance for Manhattan<F>
where
    F: Float,
{
    type F = F;
    fn distance(a: &[F; 2], b: &[F; 2]) -> F {
        (a[0] - b[0]).abs() + (a[1] - b[1]).abs()
    }

    fn distance_point(a: &Point<Self::F>, b: &Point<Self::F>) -> Self::F {
        Self::distance(&[a.x, a.y], &[b.x, b.y])
    }
}

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

    #[test]
    fn test_euclidean_f32() {
        let a = Point::<f32> { x: 0., y: 0. };
        let b = Point::<f32> { x: 1., y: 1. };
        let d = Euclidean::distance_point(&a, &b);
        assert_delta!(d, std::f32::consts::SQRT_2, 0.00001);
    }

    #[test]
    fn test_euclidean_f64() {
        let a = Point::<f64> { x: 0., y: 0. };
        let b = Point::<f64> { x: 1., y: 1. };
        let d = Euclidean::distance_point(&a, &b);
        assert_delta!(d, std::f64::consts::SQRT_2, 0.00001);
    }

    #[test]
    fn test_manhattan_f32() {
        let a = Point::<f32> { x: 0., y: 0. };
        let b = Point::<f32> { x: 1., y: 1. };
        let d = Manhattan::distance_point(&a, &b);
        assert_delta!(d, 2., 0.00001);
    }

    #[test]
    fn test_manhattan_f64() {
        let a = Point::<f64> { x: 0., y: 0. };
        let b = Point::<f64> { x: 1., y: 1. };
        let d = Manhattan::distance_point(&a, &b);
        assert_delta!(d, 2., 0.00001);
    }
}