sphere-knn 0.1.0

fast nearest-neighbor lookups on a sphere. This is useful if, for example, you have a database of geographic points (latitude, longitude) and want to swiftly look up which of those points are near a given latitude, longitude pair.
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
127
128

use sphere_knn::{run, Opts, SphereKnnGetters};

#[derive(Debug, Clone, Copy, PartialEq)]
struct TestData<'name> {
    latitude: f64,
    longitude: f64,
    name: &'name str,
}
const TOKYO: TestData<'_> = TestData {
    latitude: 35.690,
    longitude: 139.692,
    name: "Tokyo",
};
const BOSTON: TestData<'_> = TestData {
    latitude: 42.358,
    longitude: -71.064,
    name: "Boston",
};
const TROY: TestData<'_> = TestData {
    latitude: 42.732,
    longitude: -73.693,
    name: "Troy",
};
const NY: TestData<'_> = TestData {
    latitude: 40.664,
    longitude: -73.939,
    name: "New York",
};
const MIAMI: TestData<'_> = TestData {
    latitude: 25.788,
    longitude: -80.224,
    name: "Miami",
};
const LONDON: TestData<'_> = TestData {
    latitude: 51.507,
    longitude: -0.128,
    name: "London",
};
const PARIS: TestData<'_> = TestData {
    latitude: 48.857,
    longitude: 2.351,
    name: "Paris",
};
const VIENNA: TestData<'_> = TestData {
    latitude: 48.208,
    longitude: 16.373,
    name: "Vienna",
};
const ROME: TestData<'_> = TestData {
    latitude: 41.900,
    longitude: 12.500,
    name: "Rome",
};
const BEIJING: TestData<'_> = TestData {
    latitude: 39.914,
    longitude: 116.392,
    name: "Beijing",
};
const HONG_KONG: TestData<'_> = TestData {
    latitude: 22.278,
    longitude: 114.159,
    name: "Hong Kong",
};
const SEOUL: TestData<'_> = TestData {
    latitude: 37.567,
    longitude: 126.978,
    name: "Seoul",
};
const LOS_ANGELES: TestData<'_> = TestData {
    latitude: 34.0549,
    longitude: -118.2426,
    name: "Los Angeles",
};
const MEXICO_CITY: TestData<'_> = TestData {
    latitude: 19.4326,
    longitude: -99.1332,
    name: "Mexico City",
};

impl<'name> SphereKnnGetters for TestData<'name> {
    fn get_lat(&self) -> f64 {
        return self.latitude;
    }
    fn get_lng(&self) -> f64 {
        return self.longitude;
    }
}

fn main() {
    let data = vec![
        TOKYO,
        BOSTON,
        TROY,
        NY,
        MIAMI,
        LONDON,
        PARIS,
        VIENNA,
        ROME,
        BEIJING,
        HONG_KONG,
        SEOUL,
        LOS_ANGELES,
        MEXICO_CITY,
    ];

    print!("\nBuilding a tree for 14 cities...\n-----------------------------------\n");
    let find_nearest = run(data);
    let hartford = TestData {
        latitude: 41.76,
        longitude: -72.67,
        name: "hartford",
    };

    println!(
        "Looking for closest cities to hartford within 200km:\n {:#?}\n-----------------------------------\n",
        hartford
    );
    let result = find_nearest(
        hartford.get_lat(),
        hartford.get_lng(),
        Opts {
            max_distance_threshold_meters: Some(200_000.0),
            number_results: Some(20 as usize),
        },
    );
    println!("{:#?}\n-----------------------------------\n", result);
}