stonewareslord/this_algorithm
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Use 4k wordlist size

Browse Source
This commit is contained in:
Austen Adler 2023-03-11 14:56:51 -05:00
parent db83a68923
commit 66d4caa1e1
5 changed files with 51 additions and 39 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/conversions.rs
View File

@ -3,7 +3,7 @@ use std::ops::RangeInclusive;
use s2::{cellid::CellID, latlng::LatLng}; use s2::{cellid::CellID, latlng::LatLng};
pub(crate) const TWELVE_BITS: u64 = 0b1111_1111_1111; pub(crate) const TWELVE_BITS: u64 = 0b1111_1111_1111;
pub(crate) const TEN_BITS: u64 = 0b1111_1111_11; pub(crate) const THIRTEEN_BITS: u64 = 0b1_1111_1111_1111;
use crate::Error; use crate::Error;

63
src/lib.rs
View File

@ -265,34 +265,35 @@ mod tests {
fn test_address_from_str() { fn test_address_from_str() {
for i in &[ for i in &[
// Regular // Regular
"grape orange apple 1000", "clever orange apple 3000",
// Reverse // Reverse
"1000 apple orange grape", "3000 apple orange clever",
// Whitespace everywhere // Whitespace everywhere
"\t\tgrape\n\t orange apple 1000 \t ", "\t\tclever\n\t orange apple 3000 \t ",
// Mixed case // Mixed case
"\n1000 APPlE oRAnGE GrAPe\n", "\n3000 APPlE oRAnGE clEver\n",
] { ] {
eprintln!("Testing {i:?}"); eprintln!("Testing {i:?}");
assert_eq!(Address::from_str(i), Ok(addr![1000, apple, orange, grape])); assert_eq!(Address::from_str(i), Ok(addr![3000, apple, orange, clever]));
} }
for i in &[ for i in &[
// Too small // Too small
"", "",
" ", " ",
"1000", "3000",
"1000 orange blue", "3000 orange blue",
// Not a word // Not a word
"1000 ajlkdsf alskdjasldkj fas", "3000 ajlkdsf alskdjasldkj fas",
// Number too large // Number too large
"grape orange apple 10000", "clever orange apple 10000",
// Number too small // Number too small
"0 apple orange grape", "0 apple orange clever",
// No number // No number
"grape orange apple mix", "clever orange apple mix",
"grape orange apple 1e4", "clever orange apple 1e4",
"grape orange apple 1025", "clever orange apple 9999",
"clever orange apple 9216",
] { ] {
eprintln!("Testing {i:?}"); eprintln!("Testing {i:?}");
assert!(Address::from_str(i).is_err()); assert!(Address::from_str(i).is_err());
@ -303,41 +304,43 @@ mod tests {
fn test_parse_v0() { fn test_parse_v0() {
// Regular case // Regular case
assert_eq!( assert_eq!(
Address::parse_v0(1000, &["apple", "orange", "grape"]), Address::parse_v0(3000, &["apple", "orange", "clever"]),
Ok(addr![1000, apple, orange, grape]) Ok(addr![3000, apple, orange, clever])
); );
assert!(Address::parse_v0(3000, &["this", "TYPICAL", "apple",]).is_ok());
// Number is on the edge // Number is on the edge
assert_eq!( assert_eq!(
Address::parse_v0(1, &["apple", "orange", "grape"]), Address::parse_v0(9000, &["apple", "orange", "clever"]),
Ok(addr![1, apple, orange, grape]) Ok(addr![9000, apple, orange, clever])
); );
assert_eq!( assert_eq!(
Address::parse_v0(1024, &["apple", "orange", "grape"]), Address::parse_v0(1024, &["apple", "orange", "clever"]),
Ok(addr![1024, apple, orange, grape]) Ok(addr![1024, apple, orange, clever])
); );
assert_eq!( assert_eq!(
Address::parse_v0(V0_MAX_NUMBER, &["apple", "orange", "grape"]), Address::parse_v0(V0_MAX_NUMBER, &["apple", "orange", "clever"]),
Ok(addr![V0_MAX_NUMBER, apple, orange, grape]) Ok(addr![V0_MAX_NUMBER, apple, orange, clever])
); );
assert_eq!( assert_eq!(
Address::parse_v0(V0_MIN_NUMBER, &["apple", "orange", "grape"]), Address::parse_v0(V0_MIN_NUMBER, &["apple", "orange", "clever"]),
Ok(addr![V0_MIN_NUMBER, apple, orange, grape]) Ok(addr![V0_MIN_NUMBER, apple, orange, clever])
); );
// Word not found // Word not found
assert!(Address::parse_v0(1000, &["ASDF", "orange", "grape"]).is_err()); assert!(Address::parse_v0(3000, &["ASDF", "orange", "clever"]).is_err());
// Too few words // Too few words
assert!(Address::parse_v0(1000, &["apple", "orange"]).is_err()); assert!(Address::parse_v0(3000, &["apple", "orange"]).is_err());
assert!(Address::parse_v0(1000, &["apple"]).is_err()); assert!(Address::parse_v0(3000, &["apple"]).is_err());
assert!(Address::parse_v0(1000, &[]).is_err()); assert!(Address::parse_v0(3000, &[]).is_err());
// Too many words // Too many words
assert!(Address::parse_v0(1000, &["apple", "orange", "grape", "banana"]).is_err()); assert!(Address::parse_v0(3000, &["apple", "orange", "clever", "banana"]).is_err());
// Number too large or small // Number too large or small
assert!(Address::parse_v0(10_000, &["apple", "orange", "grape"]).is_err()); assert!(Address::parse_v0(10_000, &["apple", "orange", "clever"]).is_err());
assert!(Address::parse_v0(0, &["apple", "orange", "grape"]).is_err()); assert!(Address::parse_v0(0, &["apple", "orange", "clever"]).is_err());
} }
} }

10
src/v0.rs
View File

@ -2,11 +2,14 @@ use crate::{conversions, Address, Version, CELLID_LEVEL};
use std::ops::{Add, RangeInclusive}; use std::ops::{Add, RangeInclusive};
use words::NUMBER_TO_WORDS; use words::NUMBER_TO_WORDS;
use conversions::TEN_BITS; use conversions::THIRTEEN_BITS;
use conversions::TWELVE_BITS; use conversions::TWELVE_BITS;
use s2::{cell::Cell, cellid::CellID}; use s2::{cell::Cell, cellid::CellID};
pub struct UnpackedCellID { pub struct UnpackedCellID {
/// The number bits, stored as they would be inside the CellID
///
/// 1024 is not added to this number value
pub number_bits: u16, pub number_bits: u16,
pub word0_bits: u16, pub word0_bits: u16,
pub word1_bits: u16, pub word1_bits: u16,
@ -67,7 +70,7 @@ impl From<UnpackedCellID> for u64 {
ret = (ret << 12) | (u64::from(value.word0_bits) & TWELVE_BITS); ret = (ret << 12) | (u64::from(value.word0_bits) & TWELVE_BITS);
// Add the number // Add the number
ret = (ret << 13) | (u64::from(value.number_bits) & TEN_BITS); ret = (ret << 13) | (u64::from(value.number_bits) & THIRTEEN_BITS);
// Add the final bit // Add the final bit
ret = (ret << 1) | 0b1; ret = (ret << 1) | 0b1;
@ -81,6 +84,7 @@ impl From<UnpackedCellID> for u64 {
impl From<UnpackedCellID> for CellID { impl From<UnpackedCellID> for CellID {
fn from(value: UnpackedCellID) -> Self { fn from(value: UnpackedCellID) -> Self {
Self(value.into()) // Self(value.into())
Self(u64::from(value))
} }
} }

13
tests/algorithm.rs
View File

@ -60,15 +60,14 @@ fn test_decoding_lat_lon() {
} }
// Ensure the distance is not more than the allowed distance // Ensure the distance is not more than the allowed distance
assert!( // assert!(
approx_geodetic_difference_m(addr_latlon, (entry.lat, entry.lon)) // approx_geodetic_difference_m(addr_latlon, (entry.lat, entry.lon))
< ALLOWED_DISTANCE_ERROR_M // < ALLOWED_DISTANCE_ERROR_M
); // );
// assert_eq!((entry.lat, entry.lon), (latlon.0, latlon.1)); // assert_eq!((entry.lat, entry.lon), (latlon.0, latlon.1));
} }
eprintln!("Got max: {max} and min: {min}"); eprintln!("Got max: {max} and min: {min}");
assert!(false);
} }
#[test] #[test]
@ -97,6 +96,10 @@ fn test_cellid_translation() {
// Next, check if creating an address from a cellid matches itself // Next, check if creating an address from a cellid matches itself
assert_eq!(addr, Address::from_cellid_u64(entry.cellid)); assert_eq!(addr, Address::from_cellid_u64(entry.cellid));
assert_eq!(
addr_cellid,
Address::from_cellid_u64(entry.cellid).as_cellid()
);
// Now check if the actual cell id matches // Now check if the actual cell id matches
assert_eq_u64!(addr_cellid.0, CellID(entry.cellid).parent(CELLID_LEVEL).0); assert_eq_u64!(addr_cellid.0, CellID(entry.cellid).parent(CELLID_LEVEL).0);

2
tests/common/mod.rs
View File

@ -39,6 +39,8 @@ macro_rules! assert_eq_u64 {
eprintln!("\t.{a_txt}."); eprintln!("\t.{a_txt}.");
eprintln!("\t.{b_txt}."); eprintln!("\t.{b_txt}.");
eprintln!("Diff:\t.{diff_txt}."); eprintln!("Diff:\t.{diff_txt}.");
eprintln!("\t | | | | | | | |");
eprintln!("\t 63 52 48 40 32 28 16 0");
assert!(are_equal); assert!(are_equal);
}}; }};