Merge branch 'main' into ruby_674_717

Author: drinckes

python/openlocationcode/openlocationcode.py

@@ -226,6 +226,7 @@ def isFull(code):
         return False
     return True
 
+
 def locationToIntegers(latitude, longitude):
     """
     Convert location in degrees into the integer representations.
@@ -239,14 +240,14 @@ def locationToIntegers(latitude, longitude):
     Return:
       A tuple of the [latitude, longitude] values as integers.
     """
-    latVal = int(round(latitude * FINAL_LAT_PRECISION_))
+    latVal = int(math.floor(latitude * FINAL_LAT_PRECISION_))
     latVal += LATITUDE_MAX_ * FINAL_LAT_PRECISION_
     if latVal < 0:
         latVal = 0
     elif latVal >= 2 * LATITUDE_MAX_ * FINAL_LAT_PRECISION_:
         latVal = 2 * LATITUDE_MAX_ * FINAL_LAT_PRECISION_ - 1
 
-    lngVal = int(round(longitude * FINAL_LNG_PRECISION_))
+    lngVal = int(math.floor(longitude * FINAL_LNG_PRECISION_))
     lngVal += LONGITUDE_MAX_ * FINAL_LNG_PRECISION_
     if lngVal < 0:
         # Python's % operator differs from other languages in that it returns
@@ -257,6 +258,7 @@ def locationToIntegers(latitude, longitude):
         lngVal = lngVal % (2 * LONGITUDE_MAX_ * FINAL_LNG_PRECISION_)
     return (latVal, lngVal)
 
+
 def encode(latitude, longitude, codeLength=PAIR_CODE_LENGTH_):
     """
     Encode a location into an Open Location Code.
@@ -274,21 +276,22 @@ def encode(latitude, longitude, codeLength=PAIR_CODE_LENGTH_):
       codeLength: The number of significant digits in the output code, not
           including any separator characters.
     """
-    if codeLength < MIN_DIGIT_COUNT_ or (codeLength < PAIR_CODE_LENGTH_ and
-                                         codeLength % 2 == 1):
-        raise ValueError('Invalid Open Location Code length - ' +
-                         str(codeLength))
-    codeLength = min(codeLength, MAX_DIGIT_COUNT_)
     (latInt, lngInt) = locationToIntegers(latitude, longitude)
     return encodeIntegers(latInt, lngInt, codeLength)
 
+
 def encodeIntegers(latVal, lngVal, codeLength):
     """
     Encode a location, as two integer values, into a code.
 
     This function is exposed for testing purposes and should not be called
     directly.
     """
+    if codeLength < MIN_DIGIT_COUNT_ or (codeLength < PAIR_CODE_LENGTH_ and
+                                         codeLength % 2 == 1):
+        raise ValueError('Invalid Open Location Code length - ' +
+                         str(codeLength))
+    codeLength = min(codeLength, MAX_DIGIT_COUNT_)
     # Initialise the code string.
     code = ''
 

python/openlocationcode_test.py

@@ -86,7 +86,14 @@ class TestEncoding(unittest.TestCase):
 
     def setUp(self):
         self.testdata = []
-        headermap = {0: 'lat', 1: 'lng', 2: 'length', 3: 'code'}
+        headermap = {
+            0: 'lat',
+            1: 'lng',
+            2: 'latInt',
+            3: 'lngInt',
+            4: 'length',
+            5: 'code'
+        }
         tests_fn = _TEST_DATA + '/encoding.csv'
         with open(tests_fn, mode='r', encoding='utf-8') as fin:
             for line in fin:
@@ -95,20 +102,48 @@ def setUp(self):
                 td = line.strip().split(',')
                 assert len(td) == len(
                     headermap), 'Wrong format of testing data: {0}'.format(line)
-                # first 3 keys should be numbers
-                for i in range(0, 3):
-                    td[i] = float(td[i])
+                # First two columns are floats, next three are integers.
+                td[0] = float(td[0])
+                td[1] = float(td[1])
+                td[2] = int(td[2])
+                td[3] = int(td[3])
+                td[4] = int(td[4])
                 self.testdata.append({
                     headermap[i]: v for i, v in enumerate(td)
                 })
 
-    def test_encoding(self):
+    def test_converting_degrees(self):
+        for td in self.testdata:
+            got = olc.locationToIntegers(td['lat'], td['lng'])
+            # Due to floating point precision limitations, we may get values 1 less than expected.
+            self.assertTrue(
+                td['latInt'] - 1 <= got[0] <= td['latInt'],
+                f'Latitude conversion {td["lat"]}: want {td["latInt"]} got {got[0]}'
+            )
+            self.assertTrue(
+                td['lngInt'] - 1 <= got[1] <= td['lngInt'],
+                f'Longitude conversion {td["lng"]}: want {td["lngInt"]} got {got[1]}'
+            )
+
+    def test_encoding_degrees(self):
+        # Allow a small proportion of errors due to floating point.
+        allowedErrorRate = 0.05
+        errors = 0
+        for td in self.testdata:
+            got = olc.encode(td['lat'], td['lng'], td['length'])
+            if got != td['code']:
+                print(
+                    f'olc.encode({td["lat"]}, {td["lng"]}, {td["length"]}) want {td["code"]}, got {got}'
+                )
+                errors += 1
+        self.assertLessEqual(errors / len(self.testdata), allowedErrorRate,
+                             "olc.encode error rate too high")
+
+    def test_encoding_integers(self):
         for td in self.testdata:
-            codelength = len(td['code']) - 1
-            if '0' in td['code']:
-                codelength = td['code'].index('0')
-            self.assertEqual(td['code'],
-                             olc.encode(td['lat'], td['lng'], codelength))
+            self.assertEqual(
+                td['code'],
+                olc.encodeIntegers(td['latInt'], td['lngInt'], td['length']))
 
 
 class TestDecoding(unittest.TestCase):