Added kpoint.compare for sorting arrays of points

Summary:
Added a kpoint.compare function to be used with Array::sort
Made kvector.equal more obviously correct for vectors of differing lengths
(technically it worked before, but relied upon 0 - undefined returning NaN)

Test Plan: Added unit tests

Reviewers: alex

Reviewed By: alex

CC: alpert

Differential Revision: http://phabricator.khanacademy.org/D5475

Author: Jack Toole

khan-exercise.js

@@ -298,7 +298,7 @@ window.Khan = (function() {
             "matrix-input": ["../third_party/jquery.cursor-position"],
             "chemistry": ["math-format"],
             "kvector": ["knumber"],
-            "kpoint": ["kvector"],
+            "kpoint": ["kvector", "knumber"],
             "kline": ["kpoint", "kvector"],
             "constructions": ["kmatrix"]
         },

test/index.html

@@ -69,6 +69,7 @@
     <script src="../utils/kvector.js"></script>
     <script src="kvector.js"></script>
     <script src="../utils/kpoint.js"></script>
+    <script src="kpoint.js"></script>
     <script src="../utils/kline.js"></script>
     <script src="kline.js"></script>
     <script src="../utils/answer-types.js"></script>

test/kpoint.js

@@ -0,0 +1,60 @@
+(function() {
+    module("kpoint");
+
+    var point = KhanUtil.kpoint;
+
+    asyncTest('point.compare should return positive if the first element is larger', 1, function() {
+        var result = point.compare([5, 2], [3, 4]);
+        strictEqual(result > 0, true);
+        start();
+    });
+
+    asyncTest('point.compare should return negative if the first element is smaller', 1, function() {
+        var result = point.compare([2, 2], [4, 0]);
+        strictEqual(result < 0, true);
+        start();
+    });
+
+    asyncTest('point.compare should return positive if the second element is larger', 1, function() {
+        var result = point.compare([5, 2], [5, 1]);
+        strictEqual(result > 0, true);
+        start();
+    });
+
+    asyncTest('point.compare should return negative if the second element is smaller', 1, function() {
+        var result = point.compare([2, 2], [2, 4]);
+        strictEqual(result < 0, true);
+        start();
+    });
+
+    asyncTest('point.compare should return positive if the third element is larger', 1, function() {
+        var result = point.compare([5, 3, -2], [5, 3, -4]);
+        strictEqual(result > 0, true);
+        start();
+    });
+
+    asyncTest('point.compare should return negative if the third element is smaller', 1, function() {
+        var result = point.compare([2, -1, -4], [2, -1, -2]);
+        strictEqual(result < 0, true);
+        start();
+    });
+
+    asyncTest('point.compare should return 0 if the vectors are equal', 1, function() {
+        var result = point.compare([2, 4, 3], [2, 4, 3]);
+        strictEqual(result, 0);
+        start();
+    });
+
+    asyncTest('point.compare should return negative if v1 is shorter than v2', 1, function() {
+        var result = point.compare([2, 4], [2, 4, 3]);
+        strictEqual(result < 0, true);
+        start();
+    });
+
+    asyncTest('point.compare should return positive if v1 is longer than v2', 1, function() {
+        var result = point.compare([2, 4, -2], [2, 2]);
+        strictEqual(result > 0, true);
+        start();
+    });
+
+})();

test/kvector.js

@@ -93,6 +93,12 @@
         start();
     });
 
+    asyncTest('vector.equal should return false on a 2D and 3D vector with a trailing 0', 1, function() {
+        var result = vector.equal([6, 3, 0], [6, 3]);
+        strictEqual(result, false);
+        start();
+    });
+
     asyncTest("vector.collinear should return true on two collinear vectors of "
             + "the same magnitude but different direction", 1, function() {
         var result = vector.collinear([3, 3], [-3, -3]);

utils/knumber.js

@@ -14,6 +14,11 @@ var knumber = KhanUtil.knumber = {
     MACHINE_EPSILON: MACHINE_EPSILON,
 
     equal: function(x, y, tolerance) {
+        // Checking for undefined makes this function behave nicely
+        // with vectors of different lengths that are _.zip'd together
+        if (x == null || y == null) {
+            return x === y;
+        }
         if (tolerance == null) {
             tolerance = DEFAULT_TOLERANCE;
         }

utils/kpoint.js

@@ -6,8 +6,10 @@
 (function(KhanUtil) {
 
 var kvector = KhanUtil.kvector;
+var knumber = KhanUtil.knumber;
 $.fn["kpointLoad"] = function() {
     kvector = KhanUtil.kvector;
+    knumber = KhanUtil.knumber;
     addKpointExtensions();
 };
 
@@ -63,6 +65,27 @@ var kpoint = KhanUtil.kpoint = {
         var projectedPv = kvector.projection(pv, lv);
         var reflectedPv = kvector.subtract(kvector.scale(projectedPv, 2), pv);
         return kvector.add(line[0], reflectedPv);
+    },
+
+    /**
+     * Compares two points, returning -1, 0, or 1, for use with
+     * Array.prototype.sort
+     *
+     * Note: This technically doesn't satisfy the total-ordering
+     * requirements of Array.prototype.sort unless equalityTolerance
+     * is 0. In some cases very close points that compare within a
+     * few equalityTolerances could appear in the wrong order.
+     */
+    compare: function(point1, point2, equalityTolerance) {
+        if (point1.length !== point2.length) {
+            return point1.length - point2.length;
+        }
+        for (var i = 0; i < point1.length; i++) {
+            if (!knumber.equal(point1[i], point2[i], equalityTolerance)) {
+                return point1[i] - point2[i];
+            }
+        }
+        return 0;
     }
 };
 

utils/kvector.js

@@ -68,8 +68,12 @@ var kvector = KhanUtil.kvector = {
     },
 
     equal: function(v1, v2, tolerance) {
+        // _.zip will nicely deal with the lengths, going through
+        // the length of the longest vector. knumber.equal then
+        // returns false for any number compared to the undefined
+        // passed in if one of the vectors is shorter.
         return _.all(_.zip(v1, v2), function(pair) {
-            return knumber.equal.call(knumber, pair[0], pair[1], tolerance);
+            return knumber.equal(pair[0], pair[1], tolerance);
         });
     },