@khanacademy/kmath 0.0.0-PR973-20240207193807 → 0.0.0-PR973-20240207194831

package/.babelrc.js

@@ -0,0 +1,8 @@
+/**
+ * HACK(somewhatabstract): Due to https://github.com/facebook/jest/issues/11741,
+ * we need to have this file, or updating inline snapshots can fail rather
+ * cryptically.
+ *
+ * We should remove this when jest is fixed.
+ */
+module.exports = require("../../config/build/babel.config");

package/.eslintrc.js

@@ -0,0 +1,12 @@
+/* eslint-disable @typescript-eslint/no-var-requires */
+/* eslint-disable import/no-commonjs */
+const path = require("path");
+
+module.exports = {
+    rules: {
+        "import/no-extraneous-dependencies": [
+            "error",
+            {packageDir: [__dirname, path.join(__dirname, "../../")]},
+        ],
+    },
+};

package/CHANGELOG.md

@@ -0,0 +1,130 @@
+# @khanacademy/kmath
+
+## 0.0.0-PR973-20240207194831
+
+### Patch Changes
+
+-   [#973](https://github.com/Khan/perseus/pull/973) [`2ffc6971`](https://github.com/Khan/perseus/commit/2ffc6971e7003cbc64a8a3988337c6ca6019c9db) Thanks [@jeremywiebe](https://github.com/jeremywiebe)! - Include 'types' key in package.json and move types to 'types' package subdirectory
+
+-   Updated dependencies [[`2ffc6971`](https://github.com/Khan/perseus/commit/2ffc6971e7003cbc64a8a3988337c6ca6019c9db)]:
+    -   @khanacademy/perseus-core@0.0.0-PR973-20240207194831
+
+## 0.1.12
+
+### Patch Changes
+
+-   [#971](https://github.com/Khan/perseus/pull/971) [`90ff7a48`](https://github.com/Khan/perseus/commit/90ff7a483b01552a556c7852427e98153cc20417) Thanks [@benchristel](https://github.com/benchristel)! - Remove source files from the distributed NPM package
+
+-   Updated dependencies [[`90ff7a48`](https://github.com/Khan/perseus/commit/90ff7a483b01552a556c7852427e98153cc20417)]:
+    -   @khanacademy/perseus-core@1.4.2
+
+## 0.1.11
+
+### Patch Changes
+
+-   [#964](https://github.com/Khan/perseus/pull/964) [`d8fbc251`](https://github.com/Khan/perseus/commit/d8fbc25170bd671ad984893553f79f44e3a0d048) Thanks [@benchristel](https://github.com/benchristel)! - Internal: Refactor Movable to be an ES6 class
+
+## 0.1.10
+
+### Patch Changes
+
+-   [#954](https://github.com/Khan/perseus/pull/954) [`43820ff9`](https://github.com/Khan/perseus/commit/43820ff9ce391682b951279a4c6fb9e3db966eb9) Thanks [@benchristel](https://github.com/benchristel)! - Internal: Fix @ts-expect-errors related to Graphie
+
+## 0.1.9
+
+### Patch Changes
+
+-   [#949](https://github.com/Khan/perseus/pull/949) [`59ce1e09`](https://github.com/Khan/perseus/commit/59ce1e0990cecd1123d7b9a671b032fcd03ce1b1) Thanks [@benchristel](https://github.com/benchristel)! - Internal: use built-in JS functions instead of underscore
+
+## 0.1.8
+
+### Patch Changes
+
+-   Updated dependencies [[`1f4e17ba`](https://github.com/Khan/perseus/commit/1f4e17ba77e1491523813655af18a70285a25989), [`8857950b`](https://github.com/Khan/perseus/commit/8857950bdeeb6e13bc3766b1c6545289b21cbe2a)]:
+    -   @khanacademy/perseus-core@1.4.1
+
+## 0.1.7
+
+### Patch Changes
+
+-   [#814](https://github.com/Khan/perseus/pull/814) [`105d2060`](https://github.com/Khan/perseus/commit/105d20603d935d35cff237b17f0bfb57ca751e4c) Thanks [@jeremywiebe](https://github.com/jeremywiebe)! - Minor build change to how we provide Typescript type definitions (should be no change to build output).
+
+-   Updated dependencies [[`a91c84fe`](https://github.com/Khan/perseus/commit/a91c84fe53827ff4333220777a9918882b7fe9f0), [`105d2060`](https://github.com/Khan/perseus/commit/105d20603d935d35cff237b17f0bfb57ca751e4c)]:
+    -   @khanacademy/perseus-core@1.4.0
+
+## 0.1.6
+
+### Patch Changes
+
+-   Updated dependencies [[`79403e06`](https://github.com/Khan/perseus/commit/79403e06eedb597d7818d6c858bbba6f51ff3fe1)]:
+    -   @khanacademy/perseus-core@1.3.0
+
+## 0.1.5
+
+### Patch Changes
+
+-   Updated dependencies [[`376eb0e4`](https://github.com/Khan/perseus/commit/376eb0e4aaaa4c7a90fd6107a84bb74d382b077c)]:
+    -   @khanacademy/perseus-core@1.2.0
+
+## 0.1.4
+
+### Patch Changes
+
+-   Updated dependencies [22a9c408]
+    -   @khanacademy/perseus-core@1.1.2
+
+## 0.1.3
+
+### Patch Changes
+
+-   55d4cd00: Print package name and version when loaded in the page
+-   Updated dependencies [55d4cd00]
+    -   @khanacademy/perseus-core@1.1.1
+
+## 0.1.2
+
+### Patch Changes
+
+-   ce5e6297: Upgrade wonder-blocks deps to package versions without Flow types
+
+## 0.1.1
+
+### Patch Changes
+
+-   1f062e98: Bump all package versions since the build settings have been updated
+
+## 0.1.0
+
+### Minor Changes
+
+-   53fd3768: Migrate source code to TypeScript
+
+## 0.0.8
+
+### Patch Changes
+
+-   f567f660: Update the eslint config to look at both the package.json for the package and the one from the root
+
+## 0.0.7
+
+### Patch Changes
+
+-   bf180fe1: Fix our use of import/no-extraneous-dependencies
+
+## 0.0.6
+
+### Patch Changes
+
+-   98d283ff: Fix storybook
+
+## 0.0.5
+
+### Patch Changes
+
+-   1c1f7717: Enhance Flow types for kmath's vector and point
+
+## 0.0.4
+
+### Patch Changes
+
+-   a46d62bf: Remove .tgz file that shouldn't be packaged

package/logo.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" version="1.1" width="400" height="400" viewBox="0 0 400 400"><defs/><ellipse cx="200" cy="200" rx="200" ry="200" fill="#28ae7b" stroke="none" style="stroke-width: 2px" stroke-width="2"/><path fill="#ffffff" stroke="#ffffff" d="M 293.05,242.4 C 295.7,226.5 324.85,202.65 332.8,200 C 324.85,197.35 295.7,173.5 293.05,157.6" transform="" style="stroke-width: 25px;stroke-linejoin: round;stroke-linecap: round" stroke-width="25" stroke-linejoin="round" stroke-linecap="round"/><path fill="#ffffff" stroke="#ffffff" d="M 80,200 S 80,200 332.05,200" style="stroke-width: 25px" stroke-width="25"/><path fill="#ffffff" stroke="#ffffff" d="M 200,320 L 200,80" style="stroke-width: 25px" stroke-width="25"/></svg>

package/package.json

@@ -3,7 +3,7 @@
     "description": "Khan Academy's Javascript Numeric Math Utilities",
     "author": "Khan Academy",
     "license": "MIT",
-    "version": "0.0.0-PR973-20240207193807",
+    "version": "0.0.0-PR973-20240207194831",
     "publishConfig": {
         "access": "public"
     },
@@ -18,14 +18,11 @@
     "main": "dist/index.js",
     "source": "src/index.ts",
     "types": "dist/types/index.d.ts",
-    "files": [
-        "dist"
-    ],
     "scripts": {
         "test": "bash -c 'yarn --silent --cwd \"../..\" test ${@:0} $($([[ ${@: -1} = -* ]] || [[ ${@: -1} = bash ]]) && echo $PWD)'"
     },
     "dependencies": {
-        "@khanacademy/perseus-core": "0.0.0-PR973-20240207193807"
+        "@khanacademy/perseus-core": "0.0.0-PR973-20240207194831"
     },
     "devDependencies": {
         "perseus-build-settings": "^0.3.0",

package/src/__tests__/line.test.ts

@@ -0,0 +1,117 @@
+import * as line from "../line";
+
+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.ts

@@ -0,0 +1,119 @@
+import {describe, it} from "@jest/globals";
+
+import * as number from "../number";
+
+describe("knumber", function () {
+    it.each([3, Math.PI, 6.28, 5e10, 1 / 0])("is a number: %s", (num: any) => {
+        expect(number.is(num)).toBe(true);
+    });
+
+    it.each(["10", 0 / 0, NaN])("is not a number:%s", (num: any) => {
+        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.ts

@@ -0,0 +1,48 @@
+import * as point from "../point";
+
+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.ts

@@ -0,0 +1,145 @@
+import * as vector from "../vector";
+
+describe("kvector", function () {
+    it("vector.zip should return empty given empty", function () {
+        expect(vector.zip([], [])).toEqual([]);
+    });
+
+    it("vector.zip should create vectors from x and y coords", function () {
+        expect(vector.zip([1, 2], [3, 4])).toEqual([
+            [1, 3],
+            [2, 4],
+        ]);
+    });
+
+    it("vector.zip should ignore extra xs", function () {
+        expect(vector.zip([1, 2, 9], [3, 4])).toEqual([
+            [1, 3],
+            [2, 4],
+        ]);
+    });
+
+    it("vector.zip should ignore extra ys", function () {
+        expect(vector.zip([1, 2], [3, 4, 9])).toEqual([
+            [1, 3],
+            [2, 4],
+        ]);
+    });
+
+    it("vector.map should transform a 2D vector", function () {
+        const double = (x) => x * 2;
+        expect(vector.map([3, 4], double)).toEqual([6, 8]);
+    });
+
+    it("vector.map should pass the index of each element to the callback", function () {
+        expect(vector.map([3, 4], (_, i) => i)).toEqual([0, 1]);
+    });
+
+    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.ts

@@ -0,0 +1,7 @@
+export {libVersion} from "./version";
+
+export * as number from "./number";
+export * as vector from "./vector";
+export * as point from "./point";
+export * as line from "./line";
+export * as ray from "./ray";

package/src/line.ts

@@ -0,0 +1,42 @@
+/**
+ * Line Utils
+ * A line is an array of two points e.g. [[-5, 0], [5, 0]].
+ */
+
+import * as kpoint from "./point";
+import * as kvector from "./vector";
+
+import type {Point} from "./point";
+
+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): 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.ts

@@ -0,0 +1,39 @@
+/* eslint-disable import/no-default-export */
+// 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
+
+declare let init: any;
+declare let ellipse: any;
+declare let line: any;
+
+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.ts

@@ -0,0 +1,104 @@
+/**
+ * Number Utils
+ * A number is a js-number, e.g. 5.12
+ */
+
+import _ from "underscore";
+
+export const DEFAULT_TOLERANCE = 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,
+    // can't be 0
+    tolerance: number = EPSILON,
+    maxDenominator = 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];
+}

package/src/point.ts

@@ -0,0 +1,102 @@
+/**
+ * Point Utils
+ * A point is an array of two numbers e.g. [0, 0].
+ */
+
+import * as knumber from "./number";
+import * as kvector from "./vector";
+
+// A point, in 2D, 3D, or nD space.
+export type Point = ReadonlyArray<number>;
+
+// Rotate point (around origin unless a center is specified)
+export function rotateRad(point: Point, theta: number, center?: Point): Point {
+    if (center === undefined) {
+        return kvector.rotateRad(point, theta);
+    } else {
+        return kvector.add(
+            center,
+            kvector.rotateRad(kvector.subtract(point, center), theta),
+        );
+    }
+}
+
+export function rotateDeg(point: Point, theta: number, center?: Point): Point {
+    if (center === undefined) {
+        return kvector.rotateDeg(point, theta);
+    } else {
+        return kvector.add(
+            center,
+            kvector.rotateDeg(kvector.subtract(point, center), theta),
+        );
+    }
+}
+
+// Distance between two points
+export function distanceToPoint(point1: Point, point2: Point): number {
+    return kvector.length(kvector.subtract(point1, point2));
+}
+
+// Distance between point and line
+export function distanceToLine(point: Point, line: [Point, Point]): number {
+    const lv = kvector.subtract(line[1], line[0]);
+    const pv = kvector.subtract(point, line[0]);
+    const projectedPv = kvector.projection(pv, lv);
+    const distancePv = kvector.subtract(projectedPv, pv);
+    return kvector.length(distancePv);
+}
+
+// Reflect point over line
+export function reflectOverLine<P extends Point>(point: P, line: [P, P]): P {
+    const lv = kvector.subtract(line[1], line[0]);
+    const pv = kvector.subtract(point, line[0]);
+    const projectedPv = kvector.projection(pv, lv);
+    const 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.
+ */
+export function compare(
+    point1: Point,
+    point2: Point,
+    equalityTolerance?: number,
+): number /* TODO: convert to -1 | 0 | 1 type */ {
+    if (point1.length !== point2.length) {
+        return point1.length - point2.length;
+    }
+    for (let i = 0; i < point1.length; i++) {
+        if (!knumber.equal(point1[i], point2[i], equalityTolerance)) {
+            return point1[i] - point2[i];
+        }
+    }
+    return 0;
+}
+
+// Check if a value is a point
+export const is = kvector.is;
+
+// Add and subtract vector(s)
+export const addVector = kvector.add;
+export const addVectors = kvector.add;
+export const subtractVector = kvector.subtract;
+export const equal = kvector.equal;
+
+// Convert from cartesian to polar and back
+export const polarRadFromCart = kvector.polarRadFromCart;
+export const polarDegFromCart = kvector.polarDegFromCart;
+export const cartFromPolarRad = kvector.cartFromPolarRad;
+export const cartFromPolarDeg = kvector.cartFromPolarDeg;
+
+// Rounding
+export const round = kvector.round;
+export const roundTo = kvector.roundTo;
+export const floorTo = kvector.floorTo;
+export const ceilTo = kvector.ceilTo;

package/src/ray.ts

@@ -0,0 +1,24 @@
+/**
+ * Ray Utils
+ * A ray (→) is an array of an endpoint and another point along the ray.
+ * For example, [[0, 0], [1, 0]] is the ray starting at the origin and
+ * traveling along the positive x-axis.
+ */
+
+import * as kpoint from "./point";
+import * as kvector from "./vector";
+
+import type {Point} from "./point";
+
+export type Ray = [Point, Point];
+
+export function equal(ray1: Ray, ray2: Ray, tolerance?: number): boolean {
+    // Compare the directions of the rays
+    const v1 = kvector.subtract(ray1[1], ray1[0]);
+    const v2 = kvector.subtract(ray2[1], ray2[0]);
+
+    const sameOrigin = kpoint.equal(ray1[0], ray2[0]);
+    const codirectional = kvector.codirectional(v1, v2, tolerance);
+
+    return sameOrigin && codirectional;
+}

package/src/vector.ts

@@ -0,0 +1,248 @@
+/**
+ * Vector Utils
+ * A vector is an array of numbers e.g. [0, 3, 4].
+ */
+
+import * as knumber from "./number";
+
+type Vector = ReadonlyArray<number>;
+
+function arraySum(array: ReadonlyArray<number>): number {
+    return array.reduce((memo, arg) => memo + arg, 0);
+}
+
+function arrayProduct(array: ReadonlyArray<number>): number {
+    return array.reduce((memo, arg) => memo * arg, 1);
+}
+
+export function zip<T>(xs: ReadonlyArray<T>, ys: ReadonlyArray<T>): [T, T][];
+export function zip<T>(...arrays: ReadonlyArray<T>[]): T[][];
+export function zip<T>(...arrays: ReadonlyArray<T>[]): T[][] {
+    const n = Math.min(...arrays.map((a) => a.length));
+    const results: T[][] = [];
+    for (let i = 0; i < n; i++) {
+        results.push(arrays.map((a) => a[i]));
+    }
+    return results;
+}
+
+export function map<T, U>(pair: [T, T], f: (a: T, i: number) => U): [U, U] {
+    return [f(pair[0], 0), f(pair[1], 1)];
+}
+
+/**
+ * Checks if the given vector contains only numbers and, optionally, is of the
+ * right dimension (length).
+ *
+ * is([1, 2, 3]) -> true
+ * is([1, "Hello", 3]) -> false
+ * is([1, 2, 3], 1) -> false
+ */
+export function is(vec: unknown, dimension: 2): vec is [number, number];
+export function is(vec: unknown, dimension?: number): vec is Vector;
+export function is(vec: unknown, dimension?: number) {
+    if (!Array.isArray(vec)) {
+        return false;
+    }
+    if (dimension !== undefined && vec.length !== dimension) {
+        return false;
+    }
+    return vec.every(knumber.is);
+}
+
+// Normalize to a unit vector
+export function normalize<V extends Vector>(v: V): V {
+    return scale(v, 1 / length(v));
+}
+
+// Length/magnitude of a vector
+export function length(v: Vector): number {
+    return Math.sqrt(dot(v, v));
+}
+// Dot product of two vectors
+export function dot(a: Vector, b: Vector): number {
+    const zipped = zip(a, b);
+    const multiplied = zipped.map(arrayProduct);
+    return arraySum(multiplied);
+}
+
+/* vector-add multiple [x, y] coords/vectors
+ *
+ * add([1, 2], [3, 4]) -> [4, 6]
+ */
+export function add<V extends Vector>(...vecs: ReadonlyArray<V>): V {
+    const zipped = zip(...vecs);
+    // @ts-expect-error - TS2322 - Type 'number[]' is not assignable to type 'V'.
+    return zipped.map(arraySum);
+}
+
+export function subtract<V extends Vector>(v1: V, v2: V): V {
+    // @ts-expect-error - TS2322 - Type 'number[]' is not assignable to type 'V'.
+    return zip(v1, v2).map((dim) => dim[0] - dim[1]);
+}
+
+export function negate<V extends Vector>(v: V): V {
+    // @ts-expect-error - TS2322 - Type 'number[]' is not assignable to type 'V'.
+    return v.map((x) => {
+        return -x;
+    });
+}
+
+// Scale a vector
+export function scale<V extends Vector>(v1: V, scalar: number): V {
+    // @ts-expect-error - TS2322 - Type 'number[]' is not assignable to type 'V'.
+    return v1.map((x) => {
+        return x * scalar;
+    });
+}
+
+export function equal(v1: Vector, v2: Vector, tolerance?: number): boolean {
+    return (
+        v1.length === v2.length &&
+        zip(v1, v2).every((pair) => knumber.equal(pair[0], pair[1], tolerance))
+    );
+}
+
+export function codirectional(
+    v1: Vector,
+    v2: Vector,
+    tolerance?: number,
+): boolean {
+    // The origin is trivially codirectional with all other vectors.
+    // This gives nice semantics for codirectionality between points when
+    // comparing their difference vectors.
+    if (
+        knumber.equal(length(v1), 0, tolerance) ||
+        knumber.equal(length(v2), 0, tolerance)
+    ) {
+        return true;
+    }
+
+    v1 = normalize(v1);
+    v2 = normalize(v2);
+
+    return equal(v1, v2, tolerance);
+}
+
+export function collinear(v1: Vector, v2: Vector, tolerance?: number): boolean {
+    return (
+        codirectional(v1, v2, tolerance) ||
+        codirectional(v1, negate(v2), tolerance)
+    );
+}
+
+// TODO(jeremy) These coordinate conversion functions really only handle 2D points (ie. [number, number])
+
+// Convert a cartesian coordinate into a radian polar coordinate
+export function polarRadFromCart(
+    v: ReadonlyArray<number>,
+): ReadonlyArray<number> {
+    const radius = length(v);
+    let theta = Math.atan2(v[1], v[0]);
+
+    // Convert angle range from [-pi, pi] to [0, 2pi]
+    if (theta < 0) {
+        theta += 2 * Math.PI;
+    }
+
+    return [radius, theta];
+}
+
+// Converts a cartesian coordinate into a degree polar coordinate
+export function polarDegFromCart(
+    v: ReadonlyArray<number>,
+): ReadonlyArray<number> /* TODO: convert to tuple/Point */ {
+    const polar = polarRadFromCart(v);
+    return [polar[0], (polar[1] * 180) / Math.PI];
+}
+
+/* Convert a polar coordinate into a cartesian coordinate
+ *
+ * Examples:
+ * cartFromPolarRad(5, Math.PI)
+ */
+export function cartFromPolarRad(
+    radius: number,
+    theta = 0,
+): ReadonlyArray<number> /* TODO: convert to tuple/Point */ {
+    return [radius * Math.cos(theta), radius * Math.sin(theta)];
+}
+
+/* Convert a polar coordinate into a cartesian coordinate
+ *
+ * Examples:
+ * cartFromPolarDeg(5, 30)
+ */
+export function cartFromPolarDeg(
+    radius: number,
+    theta = 0,
+): ReadonlyArray<number> {
+    return cartFromPolarRad(radius, (theta * Math.PI) / 180);
+}
+
+// Rotate vector
+export function rotateRad(
+    v: ReadonlyArray<number>,
+    theta: number,
+): ReadonlyArray<number> {
+    const polar = polarRadFromCart(v);
+    const angle = polar[1] + theta;
+    return cartFromPolarRad(polar[0], angle);
+}
+
+export function rotateDeg(
+    v: ReadonlyArray<number>,
+    theta: number,
+): ReadonlyArray<number> {
+    const polar = polarDegFromCart(v);
+    const angle = polar[1] + theta;
+    return cartFromPolarDeg(polar[0], angle);
+}
+
+// Angle between two vectors
+export function angleRad(v1: Vector, v2: Vector): number {
+    return Math.acos(dot(v1, v2) / (length(v1) * length(v2)));
+}
+
+export function angleDeg(v1: Vector, v2: Vector): number {
+    return (angleRad(v1, v2) * 180) / Math.PI;
+}
+
+// Vector projection of v1 onto v2
+export function projection<V extends Vector>(v1: V, v2: V): V {
+    const scalar = dot(v1, v2) / dot(v2, v2);
+    return scale(v2, scalar);
+}
+
+// Round each number to a certain number of decimal places
+export function round<V extends Vector>(vec: V, precision: V | number): V {
+    // @ts-expect-error - TS2322 - Type 'number[]' is not assignable to type 'V'.
+    return vec.map((elem, i) => knumber.round(elem, precision[i] || precision));
+}
+
+// Round each number to the nearest increment
+export function roundTo(
+    coord: [number, number],
+    increment: [number, number] | number,
+): [number, number];
+export function roundTo<V extends Vector>(vec: V, increment: V | number): V;
+export function roundTo<V extends Vector>(vec: V, increment: V | number): V {
+    // @ts-expect-error - TS2322 - Type 'number[]' is not assignable to type 'V'.
+    return vec.map((elem, i) =>
+        knumber.roundTo(elem, increment[i] || increment),
+    );
+}
+
+export function floorTo<V extends Vector>(vec: V, increment: V | number): V {
+    // @ts-expect-error - TS2322 - Type 'number[]' is not assignable to type 'V'.
+    return vec.map((elem, i) =>
+        knumber.floorTo(elem, increment[i] || increment),
+    );
+}
+
+export function ceilTo<V extends Vector>(vec: V, increment: V | number): V {
+    // @ts-expect-error - TS2322 - Type 'number[]' is not assignable to type 'V'.
+    return vec.map((elem, i) =>
+        knumber.ceilTo(elem, increment[i] || increment),
+    );
+}

package/src/version.ts

@@ -0,0 +1,10 @@
+// This file is processed by a Rollup plugin (replace) to inject the production
+// version number during the release build.
+// In dev, you'll never see the version number.
+
+import {addLibraryVersionToPerseusDebug} from "@khanacademy/perseus-core";
+
+const libName = "@khanacademy/kmath";
+export const libVersion = "__lib_version__";
+
+addLibraryVersionToPerseusDebug(libName, libVersion);

package/tsconfig-build.json

@@ -0,0 +1,10 @@
+{
+    "extends": "../tsconfig-shared.json",
+    "compilerOptions": {
+        "outDir": "./dist/types",
+        "rootDir": "src",
+    },
+    "references": [
+        {"path": "../perseus-core/tsconfig-build.json"}
+    ]
+}