@khanacademy/kmath 0.1.11 → 0.1.13

package/src/logo.ts

@@ -1,39 +0,0 @@
-/* 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

@@ -1,104 +0,0 @@
-/**
- * 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

@@ -1,102 +0,0 @@
-/**
- * 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

@@ -1,24 +0,0 @@
-/**
- * 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

@@ -1,248 +0,0 @@
-/**
- * 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

@@ -1,10 +0,0 @@
-// 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

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