Fix toFraction

Summary:
Evidentally 283.33 % 1 = .3299999999999841

Also, using our previous method, 1/1000 took 1000 steps to get to.

This adds (a) a fix to that, (b) a worst case running time of 100 steps

Anything beyond that is a useless fraction.

It accounts for all fractions where n < d < 100
```
for (var x = 1; x < 100; x++) {
  for (var y = x+1; y < 100; y++) {
    var z = KhanUtil.toFraction(x/y);
    if(x/y !== z[0]/z[1]) {
      console.log(x, y, z);
    }
  }
}
```

The first non-exact fraction is for d >= 141

Test Plan:
Try out:
(1) 283.333333333333333
(2) 283.33
(3) .0001

Reviewers: brianmerlob

Reviewed By: brianmerlob

Subscribers: alpert

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

Author: Jack Toole

test/knumber.js

@@ -35,4 +35,54 @@
         start();
     });
 
+    asyncTest('isInteger(-2.8) should be false', 1, function() {
+        strictEqual(number.isInteger(-2.8), false);
+        start();
+    });
+
+    asyncTest('isInteger(-2) should be true', 1, function() {
+        strictEqual(number.isInteger(-2), true);
+        start();
+    });
+
+    asyncTest('toFraction(-2) should be -2/1', 1, function() {
+        deepEqual(number.toFraction(-2), [-2, 1]);
+        start();
+    });
+
+    asyncTest('toFraction(-2.5) should be -5/2', 1, function() {
+        deepEqual(number.toFraction(-2.5), [-5, 2]);
+        start();
+    });
+
+    asyncTest('toFraction(2/3) should be 2/3', 1, function() {
+        deepEqual(number.toFraction(2/3), [2, 3]);
+        start();
+    });
+
+    asyncTest('toFraction(283.33...) should be 850/3', 1, function() {
+        deepEqual(number.toFraction(283 + 1/3), [850, 3]);
+        start();
+    });
+
+    asyncTest('toFraction(0) should be 0/1', 1, function() {
+        deepEqual(number.toFraction(0), [0, 1]);
+        start();
+    });
+
+    asyncTest('toFraction(pi) should be pi/1', 1, function() {
+        deepEqual(number.toFraction(Math.PI), [Math.PI, 1]);
+        start();
+    });
+
+    asyncTest('toFraction(0.66) should be 33/50', 1, function() {
+        deepEqual(number.toFraction(0.66), [33, 50]);
+        start();
+    });
+
+    asyncTest('toFraction(0.66, 0.01) should be 2/3', 1, function() {
+        deepEqual(number.toFraction(0.66, 0.01), [2, 3]);
+        start();
+    });
+
 })();

utils/knumber.js

@@ -5,12 +5,12 @@
 define(function(require) {
 
 var DEFAULT_TOLERANCE = 1e-9;
-var MACHINE_EPSILON = Math.pow(2, -42);
+var EPSILON = Math.pow(2, -42);
 
 var knumber = KhanUtil.knumber = {
 
     DEFAULT_TOLERANCE: DEFAULT_TOLERANCE,
-    MACHINE_EPSILON: MACHINE_EPSILON,
+    EPSILON: EPSILON,
 
     is: function(x) {
         return _.isNumber(x) && !_.isNaN(x);
@@ -50,6 +50,49 @@ var knumber = KhanUtil.knumber = {
 
     ceilTo: function(num, increment) {
         return Math.ceil(num / increment) * increment;
+    },
+
+    isInteger: function(num, tolerance) {
+        return knumber.equal(Math.round(num), num, tolerance);
+    },
+
+    /**
+     * toFraction
+     *
+     * Returns a [numerator, denominator] array rational representation
+     * of `decimal`
+     *
+     * See http://en.wikipedia.org/wiki/Continued_fraction for implementation
+     * details
+     *
+     * toFraction(4/8) => [1, 2]
+     * toFraction(0.66) => [33, 50]
+     * toFraction(0.66, 0.01) => [2/3]
+     * toFraction(283 + 1/3) => [850, 3]
+     */
+    toFraction: function(decimal, tolerance, max_denominator) {
+        max_denominator = max_denominator || 1000;
+        tolerance = tolerance || EPSILON; // can't be 0
+
+        // Initialize everything to compute successive terms of
+        // continued-fraction approximations via recurrence relation
+        var n = [1, 0], d = [0, 1];
+        var a = Math.floor(decimal), t;
+        var rem = decimal - a;
+
+        while (d[0] <= max_denominator) {
+            if (knumber.equal(n[0] / d[0], decimal, tolerance)) {
+                return [n[0], d[0]];
+            }
+            n = [a*n[0] + n[1], n[0]];
+            d = [a*d[0] + d[1], d[0]];
+            a = Math.floor(1 / rem);
+            rem = 1/rem - a;
+        }
+
+        // We failed to find a nice rational representation,
+        // so return an irrational "fraction"
+        return [decimal, 1];
     }
 };