java: use floor for conversion, add integer tests (#730)

* java: use floor for conversion, add integer tests

* syntax errors

* missing arguments

* fix rate check

* fix test data parsing

* fix string comparison and degree to integer args

* java formatting

Author: drinckes

java/src/main/java/com/google/openlocationcode/OpenLocationCode.java

@@ -188,13 +188,6 @@ public OpenLocationCode(String code) {
    * @throws IllegalArgumentException if the code length is not valid.
    */
   public OpenLocationCode(double latitude, double longitude, int codeLength) {
-    // Limit the maximum number of digits in the code.
-    codeLength = Math.min(codeLength, MAX_DIGIT_COUNT);
-    // Check that the code length requested is valid.
-    if (codeLength < PAIR_CODE_LENGTH && codeLength % 2 == 1 || codeLength < MIN_DIGIT_COUNT) {
-      throw new IllegalArgumentException("Illegal code length " + codeLength);
-    }
-
     // Compute the code.
     long[] integers = degreesToIntegers(latitude, longitude);
     this.code = encodeIntegers(integers[0], integers[1], codeLength);
@@ -207,8 +200,16 @@ public OpenLocationCode(double latitude, double longitude, int codeLength) {
    * @param lng The longitude as a positive integer.
    * @param codeLength The requested number of digits.
    * @return The OLC for the location.
+   * @throws IllegalArgumentException if the code length is not valid.
    */
-  private static String encodeIntegers(long lat, long lng, int codeLength) {
+  static String encodeIntegers(long lat, long lng, int codeLength) {
+    // Limit the maximum number of digits in the code.
+    codeLength = Math.min(codeLength, MAX_DIGIT_COUNT);
+    // Check that the code length requested is valid.
+    if (codeLength < PAIR_CODE_LENGTH && codeLength % 2 == 1 || codeLength < MIN_DIGIT_COUNT) {
+      throw new IllegalArgumentException("Illegal code length " + codeLength);
+    }
+
     // Store the code - we build it in reverse and reorder it afterwards.
     StringBuilder revCodeBuilder = new StringBuilder();
     // Compute the grid part of the code if necessary.
@@ -663,9 +664,9 @@ public static boolean isShortCode(String code) {
    * @param longitude The longitude in decimal degrees.
    * @return A list of [latitude, longitude] in clipped, normalised integer values.
    */
-  private static long[] degreesToIntegers(double latitude, double longitude) {
-    long lat = (long) roundAwayFromZero(latitude * LAT_INTEGER_MULTIPLIER);
-    long lng = (long) roundAwayFromZero(longitude * LNG_INTEGER_MULTIPLIER);
+  static long[] degreesToIntegers(double latitude, double longitude) {
+    long lat = (long) Math.floor(latitude * LAT_INTEGER_MULTIPLIER);
+    long lng = (long) Math.floor(longitude * LNG_INTEGER_MULTIPLIER);
 
     // Clip and normalise values.
     lat += LATITUDE_MAX * LAT_INTEGER_MULTIPLIER;
@@ -685,20 +686,6 @@ private static long[] degreesToIntegers(double latitude, double longitude) {
     return new long[] {lat, lng};
   }
 
-  /**
-   * Round numbers like C does. This implements rounding away from zero (see
-   * https://en.wikipedia.org/wiki/Rounding).
-   *
-   * @param num A number to round.
-   * @return The rounded value.
-   */
-  private static Long roundAwayFromZero(double num) {
-    if (num >= 0) {
-      return Math.round(num);
-    }
-    return -1 * Math.round(Math.abs(num));
-  }
-
   private static double clipLatitude(double latitude) {
     return Math.min(Math.max(latitude, -LATITUDE_MAX), LATITUDE_MAX);
   }

java/src/test/java/com/google/openlocationcode/EncodingTest.java

@@ -23,20 +23,24 @@ public class EncodingTest {
 
   private static class TestData {
 
-    private final double latitude;
-    private final double longitude;
+    private final double latitudeDegrees;
+    private final double longitudeDegrees;
+    private final long latitudeInteger;
+    private final long longitudeInteger;
     private final int length;
     private final String code;
 
     public TestData(String line) {
       String[] parts = line.split(",");
-      if (parts.length != 4) {
+      if (parts.length != 6) {
         throw new IllegalArgumentException("Wrong format of testing data.");
       }
-      this.latitude = Double.parseDouble(parts[0]);
-      this.longitude = Double.parseDouble(parts[1]);
-      this.length = Integer.parseInt(parts[2]);
-      this.code = parts[3];
+      this.latitudeDegrees = Double.parseDouble(parts[0]);
+      this.longitudeDegrees = Double.parseDouble(parts[1]);
+      this.latitudeInteger = Long.parseLong(parts[2]);
+      this.longitudeInteger = Long.parseLong(parts[3]);
+      this.length = Integer.parseInt(parts[4]);
+      this.code = parts[5];
     }
   }
 
@@ -56,14 +60,67 @@ public void setUp() throws Exception {
   }
 
   @Test
-  public void testEncodeFromLatLong() {
+  public void testEncodeFromDegrees() {
+    double allowedErrorRate = 0.05;
+    int failedEncodings = 0;
+    for (TestData testData : testDataList) {
+      String got =
+          OpenLocationCode.encode(
+              testData.latitudeDegrees, testData.longitudeDegrees, testData.length);
+      if (!testData.code.equals(got)) {
+        failedEncodings++;
+        System.out.printf(
+            "ENCODING DIFFERENCE: encode(%f,%f,%d) got %s, want %s\n",
+            testData.latitudeDegrees,
+            testData.longitudeDegrees,
+            testData.length,
+            got,
+            testData.code);
+      }
+    }
+    double gotRate = (double) failedEncodings / (double) testDataList.size();
+    Assert.assertTrue(
+        String.format(
+            "Too many encoding errors (actual rate %f, allowed rate %f), see ENCODING DIFFERENCE"
+                + " lines",
+            gotRate, allowedErrorRate),
+        gotRate <= allowedErrorRate);
+  }
+
+  @Test
+  public void testDegreesToIntegers() {
+    for (TestData testData : testDataList) {
+      long[] got =
+          OpenLocationCode.degreesToIntegers(testData.latitudeDegrees, testData.longitudeDegrees);
+      Assert.assertTrue(
+          String.format(
+              "degreesToIntegers(%f, %f) returned latitude %d, expected %d",
+              testData.latitudeDegrees,
+              testData.longitudeDegrees,
+              got[0],
+              testData.latitudeInteger),
+          got[0] == testData.latitudeInteger || got[0] == testData.latitudeInteger - 1);
+      Assert.assertTrue(
+          String.format(
+              "degreesToIntegers(%f, %f) returned longitude %d, expected %d",
+              testData.latitudeDegrees,
+              testData.longitudeDegrees,
+              got[1],
+              testData.longitudeInteger),
+          got[1] == testData.longitudeInteger || got[1] == testData.longitudeInteger - 1);
+    }
+  }
+
+  @Test
+  public void testEncodeFromIntegers() {
     for (TestData testData : testDataList) {
       Assert.assertEquals(
           String.format(
-              "Latitude %f, longitude %f and length %d were wrongly encoded.",
-              testData.latitude, testData.longitude, testData.length),
+              "Latitude %d, longitude %d and length %d were wrongly encoded.",
+              testData.latitudeInteger, testData.longitudeInteger, testData.length),
           testData.code,
-          OpenLocationCode.encode(testData.latitude, testData.longitude, testData.length));
+          OpenLocationCode.encodeIntegers(
+              testData.latitudeInteger, testData.longitudeInteger, testData.length));
     }
   }
 }