update precomputed average edge lengths

H3 reference implementation did the same in uber/h3#749

Couldn't test against it since it's not released yet (and thus
there is no h3ron_h3_sys that binds to it). Not a big deal since I
shouldn't exclusively rely on tests against H3 to ensure my correctness.

Instead I have a little tool (which is equivalent to the Python notebook
linked in the PR) that generated a golden file and I test against it.

Author: grim7reaper

CHANGELOG.md

@@ -14,6 +14,10 @@ Possible sections are:
 <!-- next-header -->
 ## [Unreleased] - ReleaseDate
 
+### Fixed
+
+- update precomputed average edge lengths (they were underestimated).
+
 ## [0.3.4] - 2023-07-28
 
 ### Fixed

Cargo.toml

@@ -27,6 +27,7 @@ pre-release-replacements = [
 default = []
 geo = ["dep:geo", "dep:geojson"]
 serde = ["dep:serde", "dep:serde_repr"]
+tools = ["polyfit-rs"]
 
 [dependencies]
 ahash = { version = "0.8", default-features = false, features = ["std", "compile-time-rng"] }
@@ -37,6 +38,7 @@ either = { version = "1.0", default-features = false }
 float_eq = { version = "1.0", default-features = false }
 geo = { version = "0.26", optional = true, default-features = false }
 geojson = { version = "0.24", optional = true, default-features = false, features = ["geo-types"] }
+polyfit-rs = { version = "0.2", optional = true, default-features = false }
 serde = { version = "1.0", optional = true, default-features = false, features = ["derive"] }
 serde_repr = { version = "0.1", optional = true, default-features = false }
 
@@ -50,6 +52,11 @@ h3ron-h3-sys = { version = "0.16", default-features = false }
 # Cf. https://matklad.github.io/2021/02/27/delete-cargo-integration-tests.html
 doctest = false
 
+[[bin]]
+name = "average_edge_length"
+path = "tools/average_edge_length.rs"
+required-features = ["tools"]
+
 [[bench]]
 harness = false
 name = "h3"

dataset/avgEdgeLen.txt

@@ -0,0 +1,16 @@
+0.20110729345570325,1281.2560107413644,1281256.0107413644
+0.07582111043884765,483.0568390711111,483056.8390711111
+0.02864742595735945,182.51295648916735,182512.95648916735
+0.01082705133253538,68.97922178775585,68979.22178775584
+0.00409225087020209,26.07175968017739,26071.75968017739
+0.0015467085046591636,9.854090989971207,9854.090989971206
+0.0005846065718298453,3.7245326671400765,3724.5326671400767
+0.0002207619176534713,1.4064757626435986,1406.4757626435987
+0.0000834113029497395,0.5314140100625567,531.4140100625567
+0.00003151560528974152,0.20078614761193547,200.78614761193546
+0.000011907659293816194,0.07586378286883358,75.86378286883358
+0.000004499115550979479,0.02866389748307224,28.66389748307224
+0.000001699917695123959,0.010830187842605124,10.830187842605124
+0.0000006422862754806202,0.004092010473292413,4.092010473292413
+0.0000002426774312980401,0.001546099657446663,1.546099657446663
+0.00000009169172362798202,0.0005841686296646656,0.5841686296646657

src/lib.rs

@@ -282,7 +282,7 @@ const CCW: bool = true;
 const CW: bool = false;
 
 /// Earth radius in kilometers using WGS84 authalic radius.
-const EARTH_RADIUS_KM: f64 = 6371.007180918475_f64;
+pub const EARTH_RADIUS_KM: f64 = 6371.007180918475_f64;
 
 /// Number of pentagon per resolution.
 const NUM_PENTAGONS: u8 = 12;

src/resolution.rs

@@ -241,22 +241,22 @@ impl Resolution {
     #[must_use]
     pub const fn edge_length_rads(self) -> f64 {
         match self {
-            Self::Zero => 0.17386773543713177,
-            Self::One => 0.06571582696594004,
-            Self::Two => 0.024838247910621048,
-            Self::Three => 0.00938797528264242,
-            Self::Four => 0.0035483211300887216,
-            Self::Five => 0.0013411393259123903,
-            Self::Six => 0.000506903018673795,
-            Self::Seven => 0.00019159133310284987,
-            Self::Eight => 7.241471731216742e-5,
-            Self::Nine => 2.7370188582154633e-5,
-            Self::Ten => 1.0344958831218647e-5,
-            Self::Eleven => 3.909987901851459e-6,
-            Self::Twelve => 1.4778708817343719e-6,
-            Self::Thirteen => 5.587645562011106e-7,
-            Self::Fourteen => 2.1167375294114534e-7,
-            Self::Fifteen => 8.000508954480841e-8,
+            Self::Zero => 0.20110729345570325,
+            Self::One => 0.07582111043884765,
+            Self::Two => 0.02864742595735945,
+            Self::Three => 0.01082705133253538,
+            Self::Four => 0.00409225087020209,
+            Self::Five => 0.0015467085046591636,
+            Self::Six => 0.0005846065718298453,
+            Self::Seven => 0.0002207619176534713,
+            Self::Eight => 0.0000834113029497395,
+            Self::Nine => 0.00003151560528974152,
+            Self::Ten => 0.000011907659293816194,
+            Self::Eleven => 0.000004499115550979479,
+            Self::Twelve => 0.000001699917695123959,
+            Self::Thirteen => 0.0000006422862754806202,
+            Self::Fourteen => 0.0000002426774312980401,
+            Self::Fifteen => 0.00000009169172362798202,
         }
     }
 
@@ -271,22 +271,22 @@ impl Resolution {
     #[must_use]
     pub const fn edge_length_km(self) -> f64 {
         match self {
-            Self::Zero => 1107.712591,
-            Self::One => 418.6760055,
-            Self::Two => 158.2446558,
-            Self::Three => 59.81085794,
-            Self::Four => 22.6063794,
-            Self::Five => 8.544408276,
-            Self::Six => 3.229482772,
-            Self::Seven => 1.220629759,
-            Self::Eight => 0.461354684,
-            Self::Nine => 0.174375668,
-            Self::Ten => 0.065907807,
-            Self::Eleven => 0.024910561,
-            Self::Twelve => 0.009415526,
-            Self::Thirteen => 0.003559893,
-            Self::Fourteen => 0.001348575,
-            Self::Fifteen => 0.000509713,
+            Self::Zero => 1281.2560107413644,
+            Self::One => 483.0568390711111,
+            Self::Two => 182.51295648916735,
+            Self::Three => 68.97922178775585,
+            Self::Four => 26.07175968017739,
+            Self::Five => 9.854090989971207,
+            Self::Six => 3.7245326671400765,
+            Self::Seven => 1.4064757626435986,
+            Self::Eight => 0.5314140100625567,
+            Self::Nine => 0.20078614761193547,
+            Self::Ten => 0.07586378286883358,
+            Self::Eleven => 0.02866389748307224,
+            Self::Twelve => 0.010830187842605124,
+            Self::Thirteen => 0.004092010473292413,
+            Self::Fourteen => 0.001546099657446663,
+            Self::Fifteen => 0.0005841686296646656,
         }
     }
 
@@ -303,22 +303,22 @@ impl Resolution {
     #[allow(clippy::inconsistent_digit_grouping)]
     pub const fn edge_length_m(self) -> f64 {
         match self {
-            Self::Zero => 1_107_712.591,
-            Self::One => 418_676.0055,
-            Self::Two => 158_244.6558,
-            Self::Three => 59_810.85794,
-            Self::Four => 22_606.3794,
-            Self::Five => 8544.408276,
-            Self::Six => 3229.482772,
-            Self::Seven => 1220.629759,
-            Self::Eight => 461.3546837,
-            Self::Nine => 174.3756681,
-            Self::Ten => 65.90780749,
-            Self::Eleven => 24.9105614,
-            Self::Twelve => 9.415526211,
-            Self::Thirteen => 3.559893033,
-            Self::Fourteen => 1.348574562,
-            Self::Fifteen => 0.509713273,
+            Self::Zero => 1281256.0107413644,
+            Self::One => 483056.8390711111,
+            Self::Two => 182512.95648916735,
+            Self::Three => 68979.22178775584,
+            Self::Four => 26071.75968017739,
+            Self::Five => 9854.090989971206,
+            Self::Six => 3724.5326671400767,
+            Self::Seven => 1406.4757626435987,
+            Self::Eight => 531.4140100625567,
+            Self::Nine => 200.78614761193546,
+            Self::Ten => 75.86378286883358,
+            Self::Eleven => 28.66389748307224,
+            Self::Twelve => 10.830187842605124,
+            Self::Thirteen => 4.092010473292413,
+            Self::Fourteen => 1.546099657446663,
+            Self::Fifteen => 0.5841686296646657,
         }
     }
 

tests/api/avg_edge_len.rs

@@ -0,0 +1,41 @@
+use h3o::Resolution;
+use std::{
+    fs::File,
+    io::{BufRead, BufReader},
+    path::PathBuf,
+};
+
+#[test]
+fn golden_file() {
+    // Load the file generated by tools/average_edge_length
+    let mut path = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+    path.push("dataset/avgEdgeLen.txt");
+
+    let file = File::open(path).expect("open test dataset");
+    let reader = BufReader::new(file);
+    let resolutions = Resolution::range(Resolution::Zero, Resolution::Fifteen);
+
+    for (resolution, line) in resolutions.zip(reader.lines()) {
+        let line = line.expect("test input");
+        let parts = line.split(',').collect::<Vec<&str>>();
+        let avg_rad = parts[0].parse::<f64>().expect("edge len in radians");
+        let avg_km = parts[1].parse::<f64>().expect("edge len in kilometers");
+        let avg_m = parts[2].parse::<f64>().expect("edge len in meters");
+
+        assert_eq!(
+            resolution.edge_length_rads(),
+            avg_rad,
+            "avg edge len rad at {resolution}"
+        );
+        assert_eq!(
+            resolution.edge_length_km(),
+            avg_km,
+            "avg edge len km at {resolution}"
+        );
+        assert_eq!(
+            resolution.edge_length_m(),
+            avg_m,
+            "avg edge len m at {resolution}"
+        );
+    }
+}

tests/api/mod.rs

@@ -1,3 +1,4 @@
+mod avg_edge_len;
 mod base_cell;
 mod boundary;
 mod cell_index;

tests/h3/get_hexagon_edge_length_avg_km.rs

@@ -383,32 +383,6 @@ pub fn get_hexagon_area_avg_m2(resolution: Resolution) -> f64 {
     out
 }
 
-/// Expose `getHexagonEdgeLengthAvgKm`.
-pub fn get_hexagon_edge_length_avg_km(resolution: Resolution) -> f64 {
-    let resolution = u8::from(resolution);
-    let mut out: f64 = 0.;
-    unsafe {
-        let res = h3ron_h3_sys::getHexagonEdgeLengthAvgKm(
-            resolution.into(),
-            &mut out,
-        );
-        assert_eq!(res, 0, "getHexagonEdgeLengthAvgKm");
-    }
-    out
-}
-
-/// Expose `getHexagonEdgeLengthAvgM`.
-pub fn get_hexagon_edge_length_avg_m(resolution: Resolution) -> f64 {
-    let resolution = u8::from(resolution);
-    let mut out: f64 = 0.;
-    unsafe {
-        let res =
-            h3ron_h3_sys::getHexagonEdgeLengthAvgM(resolution.into(), &mut out);
-        assert_eq!(res, 0, "getHexagonEdgeLengthAvgM");
-    }
-    out
-}
-
 /// Expose `getIcosahedronFaces`.
 pub fn get_icosahedron_faces(index: CellIndex) -> Vec<Face> {
     let max_count = max_face_count(index);

tests/h3/get_hexagon_edge_length_avg_m.rs

@@ -27,9 +27,6 @@ mod get_directed_edge_origin;
 mod get_hexagon_area_avg_km2;
 mod get_hexagon_area_avg_m2;
 mod get_hexagon_area_avg_rads2;
-mod get_hexagon_edge_length_avg_km;
-mod get_hexagon_edge_length_avg_m;
-mod get_hexagon_edge_length_avg_rads;
 mod get_icosahedron_faces;
 mod get_num_cells;
 mod get_pentagons;