Publish

3 files changed, 648 insertions, 0 deletions

diff --git a/vespajlib/src/test/java/com/yahoo/geo/BoundingBoxParserTestCase.java b/vespajlib/src/test/java/com/yahoo/geo/BoundingBoxParserTestCase.java
new file mode 100644
index 00000000000..47a8ade2235
--- /dev/null
+++ b/vespajlib/src/test/java/com/yahoo/geo/BoundingBoxParserTestCase.java
@@ -0,0 +1,162 @@
+// Copyright 2016 Yahoo Inc. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
+package com.yahoo.geo;
+
+/**
+ * Tests for the BoundingBoxParser class.
+ *
+ * @author Arne J
+ */
+public class BoundingBoxParserTestCase extends junit.framework.TestCase {
+
+    private BoundingBoxParser parser;
+
+    public BoundingBoxParserTestCase(String name) {
+        super(name);
+    }
+
+    private void allZero(BoundingBoxParser data) {
+        assertEquals(0d, data.n);
+        assertEquals(0d, data.s);
+        assertEquals(0d, data.e);
+        assertEquals(0d, data.w);
+    }
+
+    private void all1234(BoundingBoxParser data) {
+        assertEquals(1d, data.n);
+        assertEquals(2d, data.s);
+        assertEquals(3d, data.e);
+        assertEquals(4d, data.w);
+    }
+
+    /**
+     * Tests different inputs that should all produce 0
+     */
+    public void testZero() {
+        parser = new BoundingBoxParser("n=0,s=0,e=0,w=0");
+        allZero(parser);
+        parser = new BoundingBoxParser("N=0,S=0,E=0,W=0");
+        allZero(parser);
+        parser = new BoundingBoxParser("NORTH=0,SOUTH=0,EAST=0,WEST=0");
+        allZero(parser);
+        parser = new BoundingBoxParser("north=0,south=0,east=0,west=0");
+        allZero(parser);
+        parser = new BoundingBoxParser("n=0.0,s=0.0e-17,e=0.0e0,w=0.0e100");
+        allZero(parser);
+        parser = new BoundingBoxParser("s:0.0,w:0.0,n:0.0,e:0.0");
+        allZero(parser);
+        parser = new BoundingBoxParser("s:0.0,w:0.0,n:0.0,e:0.0");
+        allZero(parser);
+    }
+
+    public void testOneTwoThreeFour() {
+        parser = new BoundingBoxParser("n=1,s=2,e=3,w=4");
+        all1234(parser);
+        parser = new BoundingBoxParser("n=1.0,s=2.0,e=3.0,w=4.0");
+        all1234(parser);
+        parser = new BoundingBoxParser("s=2,w=4,n=1,e=3");
+        all1234(parser);
+        parser = new BoundingBoxParser("N=1,S=2,E=3,W=4");
+        all1234(parser);
+        parser = new BoundingBoxParser("S=2,W=4,N=1,E=3");
+        all1234(parser);
+        parser = new BoundingBoxParser("north=1.0,south=2.0,east=3.0,west=4.0");
+        all1234(parser);
+        parser = new BoundingBoxParser("South=2.0 West=4.0 North=1.0 East=3.0");
+        all1234(parser);
+    }
+
+    /**
+     * Tests various legal inputs and print the output
+     */
+    public void testPrint() {
+        String here = "n=63.418417 E=10.433033 S=37.7 W=-122.02";
+        parser = new BoundingBoxParser(here);
+        System.out.println(here+" -> "+parser);
+    }
+
+    public void testGeoPlanetExample() {
+        /* example XML:
+           <boundingBox>  
+               <southWest>  
+                   <latitude>40.183868</latitude>  
+                   <longitude>-74.819519</longitude>  
+               </southWest>  
+               <northEast>  
+                   <latitude>40.248291</latitude>  
+                   <longitude>-74.728798</longitude>  
+               </northEast>  
+           </boundingBox>  
+
+           can be input as:
+
+           s=40.183868,w=-74.819519,n=40.248291,e=-74.728798
+        */
+        parser = new BoundingBoxParser("south=40.183868,west=-74.819519,north=40.248291,east=-74.728798");
+        assertEquals(40.183868d,  parser.s, 0.0000001);
+        assertEquals(-74.819519d, parser.w, 0.0000001);
+        assertEquals(40.248291d,  parser.n, 0.0000001);
+        assertEquals(-74.728798d, parser.e, 0.0000001);
+    }
+
+    public void testGwsExample() {
+        /* example XML:
+           <boundingbox>
+             <north>37.44899</north><south>37.3323</south><east>-121.98241</east><west>-122.06566</west>
+           </boundingbox>
+           can be input as: north:37.44899 south:37.3323, east:-121.98241 west:-122.06566
+        */
+        parser = new BoundingBoxParser(" north:37.44899 south:37.3323, east:-121.98241 west:-122.06566 ");
+        assertEquals(37.44899d,   parser.n, 0.000001);
+        assertEquals(37.33230d,   parser.s, 0.000001);
+        assertEquals(-121.98241d, parser.e, 0.000001);
+        assertEquals(-122.06566d, parser.w, 0.000001);
+    }
+
+    /**
+     * Tests various inputs that contain syntax errors.
+     */
+    public void testInputErrors() {
+        String message = "";
+        try {
+            parser = new BoundingBoxParser("n=10.11,e=2.02");
+        } catch (IllegalArgumentException e) {
+            message = e.getMessage();
+        }
+        assertEquals("Missing bounding box limits, n=true s=false e=true w=false", message);
+
+        try {
+            parser = new BoundingBoxParser("n=11.01,s=10.11,e=xyzzy,w=-122.2");
+        } catch (IllegalArgumentException e) {
+            message = e.getMessage();
+        }
+        assertEquals("Could not parse e limit 'xyzzy' as a number", message);
+
+        try {
+            parser = new BoundingBoxParser("n=11.01,n=10.11,e=-122.0,w=-122.2");
+        } catch (IllegalArgumentException e) {
+            message = e.getMessage();
+        }
+        assertEquals("multiple limits for 'n' boundary", message);
+
+        try {
+            parser = new BoundingBoxParser("s=11.01,s=10.11,e=-122.0,w=-122.2");
+        } catch (IllegalArgumentException e) {
+            message = e.getMessage();
+        }
+        assertEquals("multiple limits for 's' boundary", message);
+
+        try {
+            parser = new BoundingBoxParser("n=11.01,s=10.11,e=-122.0,e=-122.2");
+        } catch (IllegalArgumentException e) {
+            message = e.getMessage();
+        }
+        assertEquals("multiple limits for 'e' boundary", message);
+
+        try {
+            parser = new BoundingBoxParser("n=11.01,s=10.11,w=-122.0,w=-122.2");
+        } catch (IllegalArgumentException e) {
+            message = e.getMessage();
+        }
+        assertEquals("multiple limits for 'w' boundary", message);
+    }
+}
diff --git a/vespajlib/src/test/java/com/yahoo/geo/DegreesParserTestCase.java b/vespajlib/src/test/java/com/yahoo/geo/DegreesParserTestCase.java
new file mode 100644
index 00000000000..ed6fed5cbc7
--- /dev/null
+++ b/vespajlib/src/test/java/com/yahoo/geo/DegreesParserTestCase.java
@@ -0,0 +1,282 @@
+// Copyright 2016 Yahoo Inc. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
+package com.yahoo.geo;
+
+/**
+ * Tests for the DegreesParser class.
+ *
+ * @author <a href="mailto:gunnarga@yahoo-inc.com">Gunnar Gauslaa Bergem</a>
+ */
+public class DegreesParserTestCase extends junit.framework.TestCase {
+
+    private DegreesParser parser;
+
+    public DegreesParserTestCase(String name) {
+        super(name);
+    }
+
+    /**
+     * Tests different inputs that should all produce 0 or -0.
+     */
+    public void testZero() {
+        parser = new DegreesParser("N0;E0");
+        assertEquals(0d, parser.latitude);
+        assertEquals(0d, parser.longitude);
+        parser = new DegreesParser("S0;W0");
+        assertEquals(-0d, parser.latitude);
+        assertEquals(-0d, parser.longitude);
+        parser = new DegreesParser("N0.0;E0.0");
+        assertEquals(0d, parser.latitude);
+        assertEquals(0d, parser.longitude);
+        parser = new DegreesParser("S0.0;W0.0");
+        assertEquals(-0d, parser.latitude);
+        assertEquals(-0d, parser.longitude);
+        parser = new DegreesParser("N0\u00B00'0;E0\u00B00'0");
+        assertEquals(0d, parser.latitude);
+        assertEquals(0d, parser.longitude);
+        parser = new DegreesParser("S0\u00B00'0;W0\u00B00'0");
+        assertEquals(-0d, parser.latitude);
+        assertEquals(-0d, parser.longitude);
+        parser = new DegreesParser("S0o0'0;W0o0'0");
+        assertEquals(-0d, parser.latitude);
+        assertEquals(-0d, parser.longitude);
+    }
+
+    /**
+     * Tests various legal inputs and print the output
+     */
+    public void testPrint() {
+        String here = "63N025.105;010E25.982";
+        parser = new DegreesParser(here);
+        System.out.println(here+" -> "+parser.latitude+"/"+parser.longitude+" (lat/long)");
+
+        here = "N63.418417 E10.433033";
+        parser = new DegreesParser(here);
+        System.out.println(here+" -> "+parser.latitude+"/"+parser.longitude+" (lat/long)");
+
+        here = "N63o025.105;E010o25.982";
+        parser = new DegreesParser(here);
+        System.out.println(here+" -> "+parser.latitude+"/"+parser.longitude+" (lat/long)");
+
+        here = "N63.418417;E10.433033";
+        parser = new DegreesParser(here);
+        System.out.println(here+" -> "+parser.latitude+"/"+parser.longitude+" (lat/long)");
+
+        here = "63.418417N;10.433033E";
+        parser = new DegreesParser(here);
+        System.out.println(here+" -> "+parser.latitude+"/"+parser.longitude+" (lat/long)");
+
+        here = "N37.417075;W122.025358";
+        parser = new DegreesParser(here);
+        System.out.println(here+" -> "+parser.latitude+"/"+parser.longitude+" (lat/long)");
+
+        here = "N37\u00B024.983;W122\u00B001.481";
+        parser = new DegreesParser(here);
+        System.out.println(here+" -> "+parser.latitude+"/"+parser.longitude+" (lat/long)");
+    }
+
+    /**
+     * Tests inputs that are close to 0.
+     */
+    public void testNearZero() {
+        parser = new DegreesParser("N0.0001;E0.0001");
+        assertEquals(0.0001, parser.latitude);
+        assertEquals(0.0001, parser.longitude);
+        parser = new DegreesParser("S0.0001;W0.0001");
+        assertEquals(-0.0001, parser.latitude);
+        assertEquals(-0.0001, parser.longitude);
+
+        parser = new DegreesParser("N0.000001;E0.000001");
+        assertEquals(0.000001, parser.latitude);
+        assertEquals(0.000001, parser.longitude);
+        parser = new DegreesParser("S0.000001;W0.000001");
+        assertEquals(-0.000001, parser.latitude);
+        assertEquals(-0.000001, parser.longitude);
+
+        parser = new DegreesParser("N0\u00B00'1;E0\u00B00'1");
+        assertEquals(1/3600d, parser.latitude);
+        assertEquals(1/3600d, parser.longitude);
+        parser = new DegreesParser("S0\u00B00'1;W0\u00B00'1");
+        assertEquals(-1/3600d, parser.latitude);
+        assertEquals(-1/3600d, parser.longitude);
+    }
+
+    /**
+     * Tests inputs that are close to latitude 90/-90 degrees and longitude 180/-180 degrees.
+     */
+    public void testNearBoundary() {
+
+        parser = new DegreesParser("N89.9999;E179.9999");
+        assertEquals(89.9999, parser.latitude);
+        assertEquals(179.9999, parser.longitude);
+        parser = new DegreesParser("S89.9999;W179.9999");
+        assertEquals(-89.9999, parser.latitude);
+        assertEquals(-179.9999, parser.longitude);
+
+        parser = new DegreesParser("N89.999999;E179.999999");
+        assertEquals(89.999999, parser.latitude);
+        assertEquals(179.999999, parser.longitude);
+        parser = new DegreesParser("S89.999999;W179.999999");
+        assertEquals(-89.999999, parser.latitude);
+        assertEquals(-179.999999, parser.longitude);
+
+        parser = new DegreesParser("N89\u00B059'59;E179\u00B059'59");
+        assertEquals(89+59/60d+59/3600d, parser.latitude);
+        assertEquals(179+59/60d+59/3600d, parser.longitude);
+        parser = new DegreesParser("S89\u00B059'59;W179\u00B059'59");
+        assertEquals(-(89+59/60d+59/3600d), parser.latitude);
+        assertEquals(-(179+59/60d+59/3600d), parser.longitude);
+    }
+
+    /**
+     * Tests inputs that are on latitude 90/-90 degrees and longitude 180/-180 degrees.
+     */
+    public void testOnBoundary() {
+        parser = new DegreesParser("N90;E180");
+        assertEquals(90d, parser.latitude);
+        assertEquals(180d, parser.longitude);
+        parser = new DegreesParser("S90;W180");
+        assertEquals(-90d, parser.latitude);
+        assertEquals(-180d, parser.longitude);
+
+        parser = new DegreesParser("N90\u00B00'0;E180\u00B00'0");
+        assertEquals(90d, parser.latitude);
+        assertEquals(180d, parser.longitude);
+        parser = new DegreesParser("S90\u00B00'0;W180\u00B00'0");
+        assertEquals(-90d, parser.latitude);
+        assertEquals(-180d, parser.longitude);
+    }
+
+    /**
+     * Tests inputs that are above latitude 90/-90 degrees and longitude 180/-180 degrees.
+      */
+    public void testAboveBoundary() {
+        String message = "";
+        try {
+            parser = new DegreesParser("N90.0001;E0");
+        } catch (IllegalArgumentException e) {
+            message = e.getMessage();
+        }
+        assertEquals("out of range [-90,+90]: 90.0001", message);
+        try {
+            parser = new DegreesParser("S90.0001;E0");
+        } catch (IllegalArgumentException e) {
+            message = e.getMessage();
+        }
+        assertEquals("out of range [-90,+90]: -90.0001", message);
+        try {
+            parser = new DegreesParser("N0;E180.0001");
+        } catch (IllegalArgumentException e) {
+            message = e.getMessage();
+        }
+        assertEquals("out of range [-180,+180]: 180.0001", message);
+        try {
+            parser = new DegreesParser("N0;W180.0001");
+        } catch (IllegalArgumentException e) {
+            message = e.getMessage();
+        }
+        assertEquals("out of range [-180,+180]: -180.0001", message);
+        try {
+            parser = new DegreesParser("N90.000001;E0");
+        } catch (IllegalArgumentException e) {
+            message = e.getMessage();
+        }
+        assertEquals("out of range [-90,+90]: 90.000001", message);
+        try {
+            parser = new DegreesParser("S90.000001;E0");
+        } catch (IllegalArgumentException e) {
+            message = e.getMessage();
+        }
+        assertEquals("out of range [-90,+90]: -90.000001", message);
+        try {
+            parser = new DegreesParser("N0;E180.000001");
+        } catch (IllegalArgumentException e) {
+            message = e.getMessage();
+        }
+        assertEquals("out of range [-180,+180]: 180.000001", message);
+        try {
+            parser = new DegreesParser("N0;W180.000001");
+        } catch (IllegalArgumentException e) {
+            message = e.getMessage();
+        }
+        assertEquals("out of range [-180,+180]: -180.000001", message);
+    }
+
+    /**
+     * Tests various inputs that contain syntax errors.
+     */
+    public void testInputErrors() {
+        String message = "";
+        try {
+            parser = new DegreesParser("N90;S90");
+        } catch (IllegalArgumentException e) {
+            message = e.getMessage();
+        }
+        assertEquals("found latitude (N or S) twice", message);
+        try {
+            parser = new DegreesParser("E120;W120");
+        } catch (IllegalArgumentException e) {
+            message = e.getMessage();
+        }
+        assertEquals("found longitude (E or W) twice", message);
+        try {
+            parser = new DegreesParser("N90;90");
+        } catch (IllegalArgumentException e) {
+            message = e.getMessage();
+        }
+        assertEquals("end of field without any compass direction seen", message);
+        try {
+            parser = new DegreesParser("N90;E");
+        } catch (IllegalArgumentException e) {
+            message = e.getMessage();
+        }
+        assertEquals("end of field without any number seen", message);
+        try {
+            parser = new DegreesParser(";");
+        } catch (IllegalArgumentException e) {
+            message = e.getMessage();
+        }
+        assertEquals("end of field without any compass direction seen", message);
+        try {
+            parser = new DegreesParser("25;60");
+        } catch (IllegalArgumentException e) {
+            message = e.getMessage();
+        }
+        assertEquals("end of field without any compass direction seen", message);
+        try {
+            parser = new DegreesParser("NW25;SW60");
+        } catch (IllegalArgumentException e) {
+            message = e.getMessage();
+        }
+        assertEquals("already set direction once, cannot add direction: W", message);
+        try {
+            parser = new DegreesParser("N16.25\u00B0;W60");
+        } catch (IllegalArgumentException e) {
+            message = e.getMessage();
+        }
+        assertEquals("cannot have fractional degrees before degrees sign", message);
+        try {
+            parser = new DegreesParser("N16\u00B022.40';W60");
+        } catch (IllegalArgumentException e) {
+            message = e.getMessage();
+        }
+        assertEquals("cannot have fractional minutes before minutes sign", message);
+        try {
+            parser = new DegreesParser("");
+        } catch (IllegalArgumentException e) {
+            message = e.getMessage();
+        }
+        assertEquals("end of field without any compass direction seen", message);
+        try {
+            parser = new DegreesParser("Yahoo!");
+        } catch (IllegalArgumentException e) {
+            message = e.getMessage();
+        }
+        assertEquals("invalid character: Y", message);
+        try {
+            parser = new DegreesParser("N63O025.105;E010O25.982");
+        } catch (IllegalArgumentException e) {
+            message = e.getMessage();
+        }
+        assertEquals("invalid character: O", message);
+    }
+}
diff --git a/vespajlib/src/test/java/com/yahoo/geo/ZCurveTestCase.java b/vespajlib/src/test/java/com/yahoo/geo/ZCurveTestCase.java
new file mode 100644
index 00000000000..b5536fca510
--- /dev/null
+++ b/vespajlib/src/test/java/com/yahoo/geo/ZCurveTestCase.java
@@ -0,0 +1,204 @@
+// Copyright 2016 Yahoo Inc. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
+package com.yahoo.geo;
+
+/**
+ * Tests for the ZCurve class.
+ *
+ * @author gjoranv
+ */
+public class ZCurveTestCase extends junit.framework.TestCase {
+
+    public ZCurveTestCase(String name) {
+        super(name);
+    }
+
+    /**
+      * Verify that encoded values return the expected bit pattern
+      */
+     public void testEncoding() {
+        int x = 0;
+        int y = 0;
+        long z = ZCurve.encode(x, y);
+        assertEquals(0, z);
+
+        x = Integer.MAX_VALUE;
+        y = Integer.MAX_VALUE;
+        z = ZCurve.encode(x, y);
+        assertEquals(0x3fffffffffffffffL, z);
+
+        x = Integer.MIN_VALUE;
+        y = Integer.MIN_VALUE;
+        z = ZCurve.encode(x, y);
+        assertEquals(0xc000000000000000L, z);
+
+        x = Integer.MIN_VALUE;
+        y = Integer.MAX_VALUE;
+        z = ZCurve.encode(x, y);
+        assertEquals(0x6aaaaaaaaaaaaaaaL, z);
+
+        x = -1;
+        y = -1;
+        z = ZCurve.encode(x, y);
+        assertEquals(0xffffffffffffffffL, z);
+
+        x = Integer.MAX_VALUE / 2;
+        y = Integer.MIN_VALUE / 2;
+        z = ZCurve.encode(x, y);
+        assertEquals(0xa555555555555555L, z);
+     }
+
+    /**
+     * Verify that decoded values are equal to inputs in different cases
+     */
+    public void testDecoding() {
+        int x = 0;
+        int y = 0;
+        long z = ZCurve.encode(x, y);
+        int[] xy = ZCurve.decode(z);
+        assertEquals(x, xy[0]);
+        assertEquals(y, xy[1]);
+
+        x = Integer.MAX_VALUE;
+        y = Integer.MAX_VALUE;
+        z = ZCurve.encode(x, y);
+        xy = ZCurve.decode(z);
+        assertEquals(x, xy[0]);
+        assertEquals(y, xy[1]);
+
+        x = Integer.MIN_VALUE;
+        y = Integer.MIN_VALUE;
+        z = ZCurve.encode(x, y);
+        xy = ZCurve.decode(z);
+        assertEquals(x, xy[0]);
+        assertEquals(y, xy[1]);
+
+        x = Integer.MIN_VALUE;
+        y = Integer.MAX_VALUE;
+        z = ZCurve.encode(x, y);
+        xy = ZCurve.decode(z);
+        assertEquals(x, xy[0]);
+        assertEquals(y, xy[1]);
+
+        x = -18;
+        y = 1333;
+        z = ZCurve.encode(x, y);
+        xy = ZCurve.decode(z);
+        assertEquals(x, xy[0]);
+        assertEquals(y, xy[1]);
+
+        x = -1333;
+        y = 18;
+        z = ZCurve.encode(x, y);
+        xy = ZCurve.decode(z);
+        assertEquals(x, xy[0]);
+        assertEquals(y, xy[1]);
+    }
+
+
+
+    /**
+     * Verify that encoded values return the expected bit pattern
+     */
+    public void testEncoding_slow() {
+        int x = 0;
+        int y = 0;
+        long z = ZCurve.encode_slow(x, y);
+        assertEquals(0, z);
+
+        x = Integer.MIN_VALUE;
+        y = Integer.MIN_VALUE;
+        z = ZCurve.encode_slow(x, y);
+        assertEquals(0xc000000000000000L, z);
+
+        x = Integer.MIN_VALUE;
+        y = Integer.MAX_VALUE;
+        z = ZCurve.encode_slow(x, y);
+        assertEquals(0x6aaaaaaaaaaaaaaaL, z);
+
+        x = Integer.MAX_VALUE;
+        y = Integer.MAX_VALUE;
+        z = ZCurve.encode_slow(x, y);
+        assertEquals(0x3fffffffffffffffL, z);
+
+        x = -1;
+        y = -1;
+        z = ZCurve.encode_slow(x, y);
+        assertEquals(0xffffffffffffffffL, z);
+
+        x = Integer.MAX_VALUE / 2;
+        y = Integer.MIN_VALUE / 2;
+        z = ZCurve.encode_slow(x, y);
+        assertEquals(0xa555555555555555L, z);
+    }
+
+    /**
+     * Verify that decoded values are equal to inputs in different cases
+     */
+    public void testDecoding_slow() {
+        int x = 0;
+        int y = 0;
+        long z = ZCurve.encode_slow(x, y);
+        int[] xy = ZCurve.decode_slow(z);
+        assertEquals(xy[0], x);
+        assertEquals(xy[1], y);
+
+        x = Integer.MAX_VALUE;
+        y = Integer.MAX_VALUE;
+        z = ZCurve.encode_slow(x, y);
+        xy = ZCurve.decode_slow(z);
+        assertEquals(xy[0], x);
+        assertEquals(xy[1], y);
+
+        x = Integer.MIN_VALUE;
+        y = Integer.MIN_VALUE;
+        z = ZCurve.encode_slow(x, y);
+        xy = ZCurve.decode_slow(z);
+        assertEquals(xy[0], x);
+        assertEquals(xy[1], y);
+
+        x = Integer.MIN_VALUE;
+        y = Integer.MAX_VALUE;
+        z = ZCurve.encode_slow(x, y);
+        xy = ZCurve.decode_slow(z);
+        assertEquals(xy[0], x);
+        assertEquals(xy[1], y);
+
+        x = -18;
+        y = 1333;
+        z = ZCurve.encode_slow(x, y);
+        xy = ZCurve.decode_slow(z);
+        assertEquals(xy[0], x);
+        assertEquals(xy[1], y);
+
+        x = -1333;
+        y = 18;
+        z = ZCurve.encode_slow(x, y);
+        xy = ZCurve.decode_slow(z);
+        assertEquals(xy[0], x);
+        assertEquals(xy[1], y);
+    }
+
+    public void testBenchmarkEncoding() {
+        int limit = 2000000;
+
+        long z1 = 0L;
+        long start = System.currentTimeMillis();
+        for (int i=0; i<limit; i++) {
+            z1 += ZCurve.encode(i,-i);
+        }
+        long elapsed = System.currentTimeMillis() - start;
+        System.out.println("Fast method: elapsed time: " + elapsed + " ms");
+        System.out.println("Per encoding: " + elapsed/(1.0*limit) * 1000000 + " ns");
+
+        long z2 = 0L;
+        start = System.currentTimeMillis();
+        for (int i=0; i<limit; i++) {
+            z2 += ZCurve.encode_slow(i,-i);
+        }
+        elapsed = System.currentTimeMillis() - start;
+        System.out.println("Slow method: elapsed time: " + elapsed + " ms");
+        System.out.println("Per encoding: " + elapsed/(1.0*limit) * 1000000 + " ns");
+        assertEquals(z1, z2);
+    }
+
+}