@khanacademy/kmath 0.0.3

package/src/__tests__/line.test.js

@@ -0,0 +1,119 @@
+// @flow
+
+import * as line from "../line.js";
+
+describe("kline", function () {
+    it("finds distance to point", () => {
+        const result = line.distanceToPoint(
+            [
+                [-5, 0],
+                [5, 0],
+            ],
+            [0, 5],
+        );
+        expect(result).toBe(5);
+    });
+
+    it("reflects a point", () => {
+        const result = line.reflectPoint(
+            [
+                [-5, -5],
+                [5, 5],
+            ],
+            [0, 5],
+        );
+        expect(result).toEqual([5, 0]);
+    });
+
+    it("finds the midpoint", () => {
+        const result = line.midpoint([
+            [-5, -5],
+            [5, 5],
+        ]);
+        expect(result).toEqual([0, 0]);
+    });
+
+    it("two identical lines should be equal", function () {
+        const result = line.equal(
+            [
+                [1, 1],
+                [3, 3],
+            ],
+            [
+                [1, 1],
+                [3, 3],
+            ],
+        );
+        expect(result).toBe(true);
+    });
+
+    it("two parallel lines should not be equal", function () {
+        const result = line.equal(
+            [
+                [1, 1],
+                [3, 3],
+            ],
+            [
+                [1, 2],
+                [3, 4],
+            ],
+        );
+        expect(result).toBe(false);
+    });
+
+    it("two intersecting lines should not be equal", function () {
+        const result = line.equal(
+            [
+                [1, 1],
+                [3, 3],
+            ],
+            [
+                [1, 1],
+                [3, 4],
+            ],
+        );
+        expect(result).toBe(false);
+    });
+
+    it("two collinear lines should be equal #1", function () {
+        const result = line.equal(
+            [
+                [1, 1],
+                [3, 3],
+            ],
+            [
+                [0, 0],
+                [5, 5],
+            ],
+        );
+        expect(result).toBe(true);
+    });
+
+    it("two collinear lines should be equal #2", function () {
+        const result = line.equal(
+            [
+                [4, 4],
+                [5, 5],
+            ],
+            [
+                [0, 0],
+                [1, 1],
+            ],
+        );
+        expect(result).toBe(true);
+    });
+
+    it("two collinear lines should be equal #3", function () {
+        const result = line.equal(
+            [
+                [0, 0],
+                [1, 1],
+            ],
+            [
+                [3, 3],
+                [6, 6],
+            ],
+        );
+        expect(result).toBe(true);
+    });
+});

package/src/__tests__/number.test.js

@@ -0,0 +1,119 @@
+// @flow
+
+import * as number from "../number.js";
+
+describe("knumber", function () {
+    it.each([3, Math.PI, 6.28, 5e10, 1 / 0])("is a number: %s", (num) => {
+        expect(number.is(num)).toBe(true);
+    });
+
+    it.each(["10", 0 / 0, NaN])("is not a number:%s", (num) => {
+        expect(number.is(num)).toBe(false);
+    });
+
+    it("two equal numbers should be equal", function () {
+        const result = number.equal(1 / 3, (1 / 90) * 30);
+        expect(result).toBe(true);
+    });
+
+    it("two different numbers should not be equal", function () {
+        const result = number.equal(1 / 3, 1.333333);
+        expect(result).toBe(false);
+    });
+
+    it("Infinity should equal Infinity", function () {
+        const result = number.equal(
+            Number.POSITIVE_INFINITY,
+            Number.POSITIVE_INFINITY,
+        );
+        expect(result).toBe(true);
+    });
+
+    it("+Infinity should not equal -Infinity", function () {
+        const result = number.equal(
+            Number.POSITIVE_INFINITY,
+            Number.NEGATIVE_INFINITY,
+        );
+        expect(result).toBe(false);
+    });
+
+    it("sign(0) should be 0", function () {
+        expect(number.sign(0)).toBe(0);
+    });
+
+    it("sign(-0.0) should be 0", function () {
+        expect(number.sign(-0.0)).toBe(0);
+    });
+
+    it("sign(3.2) should be 1", function () {
+        expect(number.sign(3.2)).toBe(1);
+    });
+
+    it("sign(-2.8) should be -1", function () {
+        expect(number.sign(-2.8)).toBe(-1);
+    });
+
+    it("isInteger(-2.8) should be false", function () {
+        expect(number.isInteger(-2.8)).toBe(false);
+    });
+
+    it("isInteger(-2) should be true", function () {
+        expect(number.isInteger(-2)).toBe(true);
+    });
+
+    it("isInteger(10.0) should be true", () => {
+        expect(number.isInteger(10)).toBe(true);
+    });
+
+    it("rounds to correct precision", () => {
+        expect(number.round(0.06793, 4)).toBe(0.0679);
+        expect(number.round(0.06793, 3)).toBe(0.068);
+    });
+
+    it("rounds to correct interval", () => {
+        expect(number.roundTo(83, 5)).toBe(85);
+        expect(number.roundTo(2.3, 0.5)).toBe(2.5);
+    });
+
+    it("floors to the correct interval", () => {
+        expect(number.floorTo(83, 5)).toBe(80);
+        expect(number.floorTo(2.3, 0.5)).toBe(2);
+    });
+
+    it("ceils to the correct interval", () => {
+        expect(number.ceilTo(81, 5)).toBe(85);
+        expect(number.ceilTo(2.1, 0.5)).toBe(2.5);
+    });
+
+    it("toFraction(-2) should be -2/1", function () {
+        expect(number.toFraction(-2)).toStrictEqual([-2, 1]);
+    });
+
+    it("toFraction(-2.5) should be -5/2", function () {
+        expect(number.toFraction(-2.5)).toStrictEqual([-5, 2]);
+    });
+
+    it("toFraction(2/3) should be 2/3", function () {
+        expect(number.toFraction(2 / 3)).toStrictEqual([2, 3]);
+    });
+
+    it("toFraction(283.33...) should be 850/3", function () {
+        expect(number.toFraction(283 + 1 / 3)).toStrictEqual([850, 3]);
+    });
+
+    it("toFraction(0) should be 0/1", function () {
+        expect(number.toFraction(0)).toStrictEqual([0, 1]);
+    });
+
+    it("toFraction(pi) should be pi/1", function () {
+        expect(number.toFraction(Math.PI)).toStrictEqual([Math.PI, 1]);
+    });
+
+    it("toFraction(0.66) should be 33/50", function () {
+        expect(number.toFraction(0.66)).toStrictEqual([33, 50]);
+    });
+
+    it("toFraction(0.66, 0.01) should be 2/3", function () {
+        expect(number.toFraction(0.66, 0.01)).toStrictEqual([2, 3]);
+    });
+});

package/src/__tests__/point.test.js

@@ -0,0 +1,50 @@
+// @flow
+
+import * as point from "../point.js";
+
+describe("kpoint", function () {
+    it("point.compare should return positive if the first element is larger", function () {
+        const result = point.compare([5, 2], [3, 4]);
+        expect(result).toBeGreaterThan(0);
+    });
+
+    it("point.compare should return negative if the first element is smaller", function () {
+        const result = point.compare([2, 2], [4, 0]);
+        expect(result).toBeLessThan(0);
+    });
+
+    it("point.compare should return positive if the second element is larger", function () {
+        const result = point.compare([5, 2], [5, 1]);
+        expect(result).toBeGreaterThan(0);
+    });
+
+    it("point.compare should return negative if the second element is smaller", function () {
+        const result = point.compare([2, 2], [2, 4]);
+        expect(result).toBeLessThan(0);
+    });
+
+    it("point.compare should return positive if the third element is larger", function () {
+        const result = point.compare([5, 3, -2], [5, 3, -4]);
+        expect(result).toBeGreaterThan(0);
+    });
+
+    it("point.compare should return negative if the third element is smaller", function () {
+        const result = point.compare([2, -1, -4], [2, -1, -2]);
+        expect(result).toBeLessThan(0);
+    });
+
+    it("point.compare should return 0 if the vectors are equal", function () {
+        const result = point.compare([2, 4, 3], [2, 4, 3]);
+        expect(result).toBe(0);
+    });
+
+    it("point.compare should return negative if v1 is shorter than v2", function () {
+        const result = point.compare([2, 4], [2, 4, 3]);
+        expect(result).toBeLessThan(0);
+    });
+
+    it("point.compare should return positive if v1 is longer than v2", function () {
+        const result = point.compare([2, 4, -2], [2, 2]);
+        expect(result).toBeGreaterThan(0);
+    });
+});

package/src/__tests__/vector.test.js

@@ -0,0 +1,113 @@
+// @flow
+
+import * as vector from "../vector.js";
+
+describe("kvector", function () {
+    it("vector.add should add two 2D vectors", function () {
+        const result = vector.add([1, 2], [3, 4]);
+        expect(result).toStrictEqual([4, 6]);
+    });
+
+    it("vector.add should add two 3D vectors", function () {
+        const result = vector.add([1, 2, 3], [4, 5, 6]);
+        expect(result).toStrictEqual([5, 7, 9]);
+    });
+
+    it("vector.add should add three 2D vectors", function () {
+        const result = vector.add([1, 2], [3, 4], [5, 6]);
+        expect(result).toStrictEqual([9, 12]);
+    });
+
+    it("vector.subtract should subtract two 2D vectors", function () {
+        const result = vector.subtract([1, 2], [3, 4]);
+        expect(result).toStrictEqual([-2, -2]);
+    });
+
+    it("vector.subtract should subtract two 3D vectors", function () {
+        const result = vector.subtract([1, 2, 3], [4, 5, 6]);
+        expect(result).toStrictEqual([-3, -3, -3]);
+    });
+
+    it("vector.dot should take the dot product of 2 2D vectors", function () {
+        const result = vector.dot([1, 2], [3, 4]);
+        expect(result).toBe(3 + 8);
+    });
+
+    it("vector.dot should take the dot product of 2 3D vectors", function () {
+        const result = vector.dot([1, 2, 3], [4, 5, 6]);
+        expect(result).toBe(4 + 10 + 18);
+    });
+
+    it("vector.scale should scale a 2D vector", function () {
+        const result = vector.scale([4, 2], 0.5);
+        expect(result).toStrictEqual([2, 1]);
+    });
+
+    it("vector.scale should scale a 3D vector", function () {
+        const result = vector.scale([1, 2, 3], 2);
+        expect(result).toStrictEqual([2, 4, 6]);
+    });
+
+    it("vector.length should take the length of a 2D vector", function () {
+        const result = vector.length([3, 4]);
+        expect(result).toBe(5);
+    });
+
+    it("vector.length should take the length of a 3D vector", function () {
+        const result = vector.length([4, 0, 3]);
+        expect(result).toBe(5);
+    });
+
+    it("vector.equal should return true on two equal 3D vectors", function () {
+        const result = vector.equal([6, 3, 4], [6, 3, 4]);
+        expect(result).toBe(true);
+    });
+
+    it("vector.equal should return false on two inequal 3D vectors", function () {
+        const result = vector.equal([6, 3, 4], [6, 4, 4]);
+        expect(result).toBe(false);
+    });
+
+    it("vector.equal should return false on a 2D and 3D vector", function () {
+        const result = vector.equal([6, 4], [6, 4, 4]);
+        expect(result).toBe(false);
+    });
+
+    it("vector.equal should return false on a 2D and 3D vector", function () {
+        const result = vector.equal([6, 3, 4], [6, 3]);
+        expect(result).toBe(false);
+    });
+
+    it("vector.equal should return false on a 2D and 3D vector with a trailing 0", function () {
+        const result = vector.equal([6, 3, 0], [6, 3]);
+        expect(result).toBe(false);
+    });
+
+    it(
+        "vector.collinear should return true on two collinear vectors of " +
+            "the same magnitude but different direction",
+        function () {
+            const result = vector.collinear([3, 3], [-3, -3]);
+            expect(result).toBe(true);
+        },
+    );
+
+    it(
+        "vector.collinear should return true on two collinear vectors of " +
+            "different magnitudes",
+        function () {
+            const result = vector.collinear([2, 1], [6, 3]);
+            expect(result).toBe(true);
+        },
+    );
+
+    it("vector.collinear should return false on non-collinear vectors", function () {
+        const result = vector.collinear([1, 2], [-1, 2]);
+        expect(result).toBe(false);
+    });
+
+    it("vector.negate of [-2, 2] is [2, -2]", function () {
+        const result = vector.negate([-2, 2]);
+        expect(result).toStrictEqual([2, -2]);
+    });
+});

package/src/index.js

@@ -0,0 +1,7 @@
+// @flow
+
+export * as number from "./number.js";
+export * as vector from "./vector.js";
+export * as point from "./point.js";
+export * as line from "./line.js";
+export * as ray from "./ray.js";

package/src/line.js

@@ -0,0 +1,46 @@
+// @flow
+/**
+ * Line Utils
+ * A line is an array of two points e.g. [[-5, 0], [5, 0]].
+ */
+
+import * as kpoint from "./point.js";
+import * as kvector from "./vector.js";
+
+import type {Point} from "./point.js";
+
+export type Line = [Point, Point];
+
+export function distanceToPoint(line: Line, point: Point): number {
+    return kpoint.distanceToLine(point, line);
+}
+
+export function reflectPoint(
+    line: Line,
+    point: Point,
+): $ReadOnlyArray<number> /* TODO: convert to Point */ {
+    return kpoint.reflectOverLine(point, line);
+}
+
+export function midpoint(line: Line): Point {
+    return [(line[0][0] + line[1][0]) / 2, (line[0][1] + line[1][1]) / 2];
+}
+
+export function equal(line1: Line, line2: Line, tolerance?: number): boolean {
+    // TODO: A nicer implementation might just check collinearity of
+    // vectors using underscore magick
+    // Compare the directions of the lines
+    const v1 = kvector.subtract(line1[1], line1[0]);
+    const v2 = kvector.subtract(line2[1], line2[0]);
+    if (!kvector.collinear(v1, v2, tolerance)) {
+        return false;
+    }
+    // If the start point is the same for the two lines, then they are the same
+    if (kpoint.equal(line1[0], line2[0])) {
+        return true;
+    }
+    // Make sure that the direction to get from line1 to
+    // line2 is the same as the direction of the lines
+    const line1ToLine2Vector = kvector.subtract(line2[0], line1[0]);
+    return kvector.collinear(v1, line1ToLine2Vector, tolerance);
+}

package/src/logo.js

@@ -0,0 +1,41 @@
+// This file describes the graphie source code of the kmath logo
+// currently used on khan.github.io.
+//
+// Also located at http://ka-perseus-graphie.s3.amazonaws.com/42ef3cbadc3e6464124533191728c3c5c55c7355.svg
+
+// eslint-disable-next-line flowtype/no-types-missing-file-annotation
+declare var init: $FlowFixMe;
+// eslint-disable-next-line flowtype/no-types-missing-file-annotation
+declare var ellipse: $FlowFixMe;
+// eslint-disable-next-line flowtype/no-types-missing-file-annotation
+declare var line: $FlowFixMe;
+
+const GREEN = "#28AE7B";
+
+export default () => {
+    init({
+        range: [
+            [0, 10],
+            [0, 10],
+        ],
+        scale: 40,
+    });
+
+    ellipse(5, 5, 5, {
+        stroke: null,
+        fill: GREEN,
+    });
+
+    line([2, 5], [8.5, 5], {
+        stroke: "WHITE",
+        fill: "WHITE",
+        strokeWidth: 25,
+        arrows: "->",
+    });
+
+    line([5, 2], [5, 8], {
+        stroke: "WHITE",
+        fill: "WHITE",
+        strokeWidth: 25,
+    });
+};

package/src/number.js

@@ -0,0 +1,104 @@
+// @flow
+/**
+ * Number Utils
+ * A number is a js-number, e.g. 5.12
+ */
+
+import _ from "underscore";
+
+export const DEFAULT_TOLERANCE: number = 1e-9;
+
+// TODO: Should this just be Number.Epsilon
+export const EPSILON: number = Math.pow(2, -42);
+
+export function is(x: any): boolean {
+    return _.isNumber(x) && !_.isNaN(x);
+}
+
+export function equal(x: number, y: number, tolerance?: number): boolean {
+    // 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;
+    }
+    // We check === here so that +/-Infinity comparisons work correctly
+    if (x === y) {
+        return true;
+    }
+    if (tolerance == null) {
+        tolerance = DEFAULT_TOLERANCE;
+    }
+    return Math.abs(x - y) < tolerance;
+}
+
+export function sign(
+    x: number,
+    tolerance?: number,
+): number /* Should be: 0 | 1 | -1 */ {
+    return equal(x, 0, tolerance) ? 0 : Math.abs(x) / x;
+}
+
+export function isInteger(num: number, tolerance?: number): boolean {
+    return equal(Math.round(num), num, tolerance);
+}
+
+// Round a number to a certain number of decimal places
+export function round(num: number, precision: number): number {
+    const factor = Math.pow(10, precision);
+    return Math.round(num * factor) / factor;
+}
+
+// Round num to the nearest multiple of increment
+// i.e. roundTo(83, 5) -> 85
+export function roundTo(num: number, increment: number): number {
+    return Math.round(num / increment) * increment;
+}
+
+export function floorTo(num: number, increment: number): number {
+    return Math.floor(num / increment) * increment;
+}
+
+export function ceilTo(num: number, increment: number): number {
+    return Math.ceil(num / increment) * increment;
+}
+
+/**
+ * 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]
+ */
+export function toFraction(
+    decimal: number,
+    tolerance: number = EPSILON, // can't be 0
+    maxDenominator: number = 1000,
+): [number, number] {
+    // Initialize everything to compute successive terms of
+    // continued-fraction approximations via recurrence relation
+    let n = [1, 0];
+    let d = [0, 1];
+    let a = Math.floor(decimal);
+    let rem = decimal - a;
+
+    while (d[0] <= maxDenominator) {
+        if (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];
+}