@khanacademy/kmath 0.0.8 → 0.1.1

package/.babelrc.js

@@ -5,4 +5,4 @@
  *
  * We should remove this when jest is fixed.
  */
-module.exports = require("../../config/build/babel.config.js");
+module.exports = require("../../config/build/babel.config");

package/.eslintrc.js

@@ -1,3 +1,4 @@
+/* eslint-disable @typescript-eslint/no-var-requires */
 /* eslint-disable import/no-commonjs */
 const path = require("path");
 

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @khanacademy/kmath
 
+## 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

package/dist/es/index.js

@@ -4,9 +4,10 @@ import _ from 'underscore';
  * Number Utils
  * A number is a js-number, e.g. 5.12
  */
-var DEFAULT_TOLERANCE = 1e-9; // TODO: Should this just be Number.Epsilon
+const DEFAULT_TOLERANCE = 1e-9;
 
-var EPSILON = Math.pow(2, -42);
+// TODO: Should this just be Number.Epsilon
+const EPSILON = Math.pow(2, -42);
 function is$2(x) {
   return _.isNumber(x) && !_.isNaN(x);
 }
@@ -15,34 +16,31 @@ function equal$4(x, y, tolerance) {
   // 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
-
-
+  }
+  // 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;
 }
-function sign(x, tolerance)
-/* Should be: 0 | 1 | -1 */
-{
+function sign(x, tolerance) /* Should be: 0 | 1 | -1 */{
   return equal$4(x, 0, tolerance) ? 0 : Math.abs(x) / x;
 }
 function isInteger(num, tolerance) {
   return equal$4(Math.round(num), num, tolerance);
-} // Round a number to a certain number of decimal places
+}
 
+// Round a number to a certain number of decimal places
 function round$2(num, precision) {
-  var factor = Math.pow(10, precision);
+  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
+}
 
+// Round num to the nearest multiple of increment
+// i.e. roundTo(83, 5) -> 85
 function roundTo$2(num, increment) {
   return Math.round(num / increment) * increment;
 }
@@ -52,6 +50,7 @@ function floorTo$2(num, increment) {
 function ceilTo$2(num, increment) {
   return Math.ceil(num / increment) * increment;
 }
+
 /**
  * toFraction
  *
@@ -66,30 +65,27 @@ function ceilTo$2(num, increment) {
  * toFraction(0.66, 0.01) => [2/3]
  * toFraction(283 + 1/3) => [850, 3]
  */
-
-function toFraction(decimal) {
-  var tolerance = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : EPSILON;
-  var maxDenominator = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 1000;
+function toFraction(decimal,
+// can't be 0
+tolerance = EPSILON, maxDenominator = 1000) {
   // Initialize everything to compute successive terms of
   // continued-fraction approximations via recurrence relation
-  var n = [1, 0];
-  var d = [0, 1];
-  var a = Math.floor(decimal);
-  var rem = decimal - a;
-
+  let n = [1, 0];
+  let d = [0, 1];
+  let a = Math.floor(decimal);
+  let rem = decimal - a;
   while (d[0] <= maxDenominator) {
     if (equal$4(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"
-
+  }
 
+  // We failed to find a nice rational representation,
+  // so return an irrational "fraction"
   return [decimal, 1];
 }
 
@@ -112,14 +108,13 @@ var number = /*#__PURE__*/Object.freeze({
  * Vector Utils
  * A vector is an array of numbers e.g. [0, 3, 4].
  */
-
 function arraySum(array) {
   return array.reduce((memo, arg) => memo + arg, 0);
 }
-
 function arrayProduct(array) {
   return array.reduce((memo, arg) => memo * arg, 1);
 }
+
 /**
  * Checks if the given vector contains only numbers and, optionally, is of the
  * right dimension (length).
@@ -128,59 +123,55 @@ function arrayProduct(array) {
  * is([1, "Hello", 3]) -> false
  * is([1, 2, 3], 1) -> false
  */
-
-
 function is$1(vec, dimension) {
   if (!_.isArray(vec)) {
     return false;
   }
-
   if (dimension !== undefined && vec.length !== dimension) {
     return false;
   }
-
   return vec.every(is$2);
-} // Normalize to a unit vector
+}
 
+// Normalize to a unit vector
 function normalize(v) {
   return scale(v, 1 / length(v));
-} // Length/magnitude of a vector
+}
 
+// Length/magnitude of a vector
 function length(v) {
   return Math.sqrt(dot(v, v));
-} // Dot product of two vectors
-
+}
+// Dot product of two vectors
 function dot(a, b) {
-  // $FlowFixMe[incompatible-call] underscore doesn't like $ReadOnlyArray
-  var zipped = _.zip(a, b);
-
-  var multiplied = zipped.map(arrayProduct);
+  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]
  */
-
-function add() {
-  // $FlowFixMe[incompatible-call] underscore doesn't like $ReadOnlyArray
-  var zipped = _.zip(...arguments);
-
+function add(...vecs) {
+  const zipped = _.zip(...vecs);
+  // @ts-expect-error [FEI-5003] - TS2322 - Type 'number[]' is not assignable to type 'V'.
   return zipped.map(arraySum);
 }
 function subtract(v1, v2) {
-  // $FlowFixMe[incompatible-call] underscore doesn't like $ReadOnlyArray
+  // @ts-expect-error [FEI-5003] - TS2322 - Type 'number[]' is not assignable to type 'V'.
   return _.zip(v1, v2).map(dim => dim[0] - dim[1]);
 }
 function negate(v) {
-  // $FlowFixMe[incompatible-return] Flow's `.map()` libdef is lacking
+  // @ts-expect-error [FEI-5003] - TS2322 - Type 'number[]' is not assignable to type 'V'.
   return v.map(x => {
     return -x;
   });
-} // Scale a vector
+}
 
+// Scale a vector
 function scale(v1, scalar) {
-  // $FlowFixMe[incompatible-return] Flow's `.map()` libdef is lacking
+  // @ts-expect-error [FEI-5003] - TS2322 - Type 'number[]' is not assignable to type 'V'.
   return v1.map(x => {
     return x * scalar;
   });
@@ -190,7 +181,6 @@ function equal$3(v1, v2, tolerance) {
   // 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.
-  // $FlowFixMe[incompatible-call] underscore doesn't like $ReadOnlyArray
   return _.zip(v1, v2).every(pair => equal$4(pair[0], pair[1], tolerance));
 }
 function codirectional(v1, v2, tolerance) {
@@ -200,101 +190,106 @@ function codirectional(v1, v2, tolerance) {
   if (equal$4(length(v1), 0, tolerance) || equal$4(length(v2), 0, tolerance)) {
     return true;
   }
-
   v1 = normalize(v1);
   v2 = normalize(v2);
   return equal$3(v1, v2, tolerance);
 }
 function collinear(v1, v2, tolerance) {
   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
+}
+
+// TODO(jeremy) These coordinate conversion functions really only handle 2D points (ie. [number, number])
 
+// Convert a cartesian coordinate into a radian polar coordinate
 function polarRadFromCart$1(v) {
-  var radius = length(v);
-  var theta = Math.atan2(v[1], v[0]); // Convert angle range from [-pi, pi] to [0, 2pi]
+  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
+}
 
-function polarDegFromCart$1(v)
-/* TODO: convert to tuple/Point */
-{
-  var polar = polarRadFromCart$1(v);
+// Converts a cartesian coordinate into a degree polar coordinate
+function polarDegFromCart$1(v) /* TODO: convert to tuple/Point */{
+  const polar = polarRadFromCart$1(v);
   return [polar[0], polar[1] * 180 / Math.PI];
 }
+
 /* Convert a polar coordinate into a cartesian coordinate
  *
  * Examples:
  * cartFromPolarRad(5, Math.PI)
  */
-
-function cartFromPolarRad$1(radius)
-/* TODO: convert to tuple/Point */
-{
-  var theta = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+function cartFromPolarRad$1(radius, theta = 0) /* 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)
  */
-
-function cartFromPolarDeg$1(radius) {
-  var theta = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+function cartFromPolarDeg$1(radius, theta = 0) {
   return cartFromPolarRad$1(radius, theta * Math.PI / 180);
-} // Rotate vector
+}
 
+// Rotate vector
 function rotateRad$1(v, theta) {
-  var polar = polarRadFromCart$1(v);
-  var angle = polar[1] + theta;
+  const polar = polarRadFromCart$1(v);
+  const angle = polar[1] + theta;
   return cartFromPolarRad$1(polar[0], angle);
 }
 function rotateDeg$1(v, theta) {
-  var polar = polarDegFromCart$1(v);
-  var angle = polar[1] + theta;
+  const polar = polarDegFromCart$1(v);
+  const angle = polar[1] + theta;
   return cartFromPolarDeg$1(polar[0], angle);
-} // Angle between two vectors
+}
 
+// Angle between two vectors
 function angleRad(v1, v2) {
   return Math.acos(dot(v1, v2) / (length(v1) * length(v2)));
 }
 function angleDeg(v1, v2) {
   return angleRad(v1, v2) * 180 / Math.PI;
-} // Vector projection of v1 onto v2
+}
 
+// Vector projection of v1 onto v2
 function projection(v1, v2) {
-  var scalar = dot(v1, v2) / dot(v2, v2);
+  const scalar = dot(v1, v2) / dot(v2, v2);
   return scale(v2, scalar);
-} // Round each number to a certain number of decimal places
+}
 
+// Round each number to a certain number of decimal places
 function round$1(vec, precision) {
-  // $FlowFixMe[incompatible-return] Flow's `.map()` libdef is lacking
-  return vec.map((elem, i) => // $FlowFixMe[prop-missing]
+  // @ts-expect-error [FEI-5003] - TS2322 - Type 'number[]' is not assignable to type 'V'.
+  return vec.map((elem, i) =>
+  // $FlowFixMe[prop-missing]
   // $FlowFixMe[incompatible-call]
   round$2(elem, precision[i] || precision));
-} // Round each number to the nearest increment
+}
 
+// Round each number to the nearest increment
 function roundTo$1(vec, increment) {
-  // $FlowFixMe[incompatible-return] Flow's `.map()` libdef is lacking
-  return vec.map((elem, i) => // $FlowFixMe[prop-missing]
+  // @ts-expect-error [FEI-5003] - TS2322 - Type 'number[]' is not assignable to type 'V'.
+  return vec.map((elem, i) =>
+  // $FlowFixMe[prop-missing]
   // $FlowFixMe[incompatible-call]
   roundTo$2(elem, increment[i] || increment));
 }
 function floorTo$1(vec, increment) {
-  // $FlowFixMe[incompatible-return] Flow's `.map()` libdef is lacking
-  return vec.map((elem, i) => // $FlowFixMe[prop-missing]
+  // @ts-expect-error [FEI-5003] - TS2322 - Type 'number[]' is not assignable to type 'V'.
+  return vec.map((elem, i) =>
+  // $FlowFixMe[prop-missing]
   // $FlowFixMe[incompatible-call]
   floorTo$2(elem, increment[i] || increment));
 }
 function ceilTo$1(vec, increment) {
-  // $FlowFixMe[incompatible-return] Flow's `.map()` libdef is lacking
-  return vec.map((elem, i) => // $FlowFixMe[prop-missing]
+  // @ts-expect-error [FEI-5003] - TS2322 - Type 'number[]' is not assignable to type 'V'.
+  return vec.map((elem, i) =>
+  // $FlowFixMe[prop-missing]
   // $FlowFixMe[incompatible-call]
   ceilTo$2(elem, increment[i] || increment));
 }
@@ -332,6 +327,8 @@ var vector = /*#__PURE__*/Object.freeze({
  * A point is an array of two numbers e.g. [0, 0].
  */
 
+// A point, in 2D, 3D, or nD space.
+
 // Rotate point (around origin unless a center is specified)
 function rotateRad(point, theta, center) {
   if (center === undefined) {
@@ -346,27 +343,31 @@ function rotateDeg(point, theta, center) {
   } else {
     return add(center, rotateDeg$1(subtract(point, center), theta));
   }
-} // Distance between two points
+}
 
+// Distance between two points
 function distanceToPoint$1(point1, point2) {
   return length(subtract(point1, point2));
-} // Distance between point and line
+}
 
+// Distance between point and line
 function distanceToLine(point, line) {
-  var lv = subtract(line[1], line[0]);
-  var pv = subtract(point, line[0]);
-  var projectedPv = projection(pv, lv);
-  var distancePv = subtract(projectedPv, pv);
+  const lv = subtract(line[1], line[0]);
+  const pv = subtract(point, line[0]);
+  const projectedPv = projection(pv, lv);
+  const distancePv = subtract(projectedPv, pv);
   return length(distancePv);
-} // Reflect point over line
+}
 
+// Reflect point over line
 function reflectOverLine(point, line) {
-  var lv = subtract(line[1], line[0]);
-  var pv = subtract(point, line[0]);
-  var projectedPv = projection(pv, lv);
-  var reflectedPv = subtract(scale(projectedPv, 2), pv);
+  const lv = subtract(line[1], line[0]);
+  const pv = subtract(point, line[0]);
+  const projectedPv = projection(pv, lv);
+  const reflectedPv = subtract(scale(projectedPv, 2), pv);
   return add(line[0], reflectedPv);
 }
+
 /**
  * Compares two points, returning -1, 0, or 1, for use with
  * Array.prototype.sort
@@ -376,39 +377,38 @@ function reflectOverLine(point, line) {
  * is 0. In some cases very close points that compare within a
  * few equalityTolerances could appear in the wrong order.
  */
-
-function compare(point1, point2, equalityTolerance)
-/* TODO: convert to -1 | 0 | 1 type */
-{
+function compare(point1, point2, equalityTolerance) /* TODO: convert to -1 | 0 | 1 type */{
   if (point1.length !== point2.length) {
     return point1.length - point2.length;
   }
-
-  for (var i = 0; i < point1.length; i++) {
+  for (let i = 0; i < point1.length; i++) {
     if (!equal$4(point1[i], point2[i], equalityTolerance)) {
       return point1[i] - point2[i];
     }
   }
-
   return 0;
-} // Check if a value is a point
+}
 
-var is = is$1; // Add and subtract vector(s)
+// Check if a value is a point
+const is = is$1;
 
-var addVector = add;
-var addVectors = add;
-var subtractVector = subtract;
-var equal$2 = equal$3; // Convert from cartesian to polar and back
+// Add and subtract vector(s)
+const addVector = add;
+const addVectors = add;
+const subtractVector = subtract;
+const equal$2 = equal$3;
 
-var polarRadFromCart = polarRadFromCart$1;
-var polarDegFromCart = polarDegFromCart$1;
-var cartFromPolarRad = cartFromPolarRad$1;
-var cartFromPolarDeg = cartFromPolarDeg$1; // Rounding
+// Convert from cartesian to polar and back
+const polarRadFromCart = polarRadFromCart$1;
+const polarDegFromCart = polarDegFromCart$1;
+const cartFromPolarRad = cartFromPolarRad$1;
+const cartFromPolarDeg = cartFromPolarDeg$1;
 
-var round = round$1;
-var roundTo = roundTo$1;
-var floorTo = floorTo$1;
-var ceilTo = ceilTo$1;
+// Rounding
+const round = round$1;
+const roundTo = roundTo$1;
+const floorTo = floorTo$1;
+const ceilTo = ceilTo$1;
 
 var point = /*#__PURE__*/Object.freeze({
     __proto__: null,
@@ -450,21 +450,18 @@ function equal$1(line1, line2, tolerance) {
   // TODO: A nicer implementation might just check collinearity of
   // vectors using underscore magick
   // Compare the directions of the lines
-  var v1 = subtract(line1[1], line1[0]);
-  var v2 = subtract(line2[1], line2[0]);
-
+  const v1 = subtract(line1[1], line1[0]);
+  const v2 = subtract(line2[1], line2[0]);
   if (!collinear(v1, v2, tolerance)) {
     return false;
-  } // If the start point is the same for the two lines, then they are the same
-
-
+  }
+  // If the start point is the same for the two lines, then they are the same
   if (equal$2(line1[0], line2[0])) {
     return true;
-  } // Make sure that the direction to get from line1 to
+  }
+  // Make sure that the direction to get from line1 to
   // line2 is the same as the direction of the lines
-
-
-  var line1ToLine2Vector = subtract(line2[0], line1[0]);
+  const line1ToLine2Vector = subtract(line2[0], line1[0]);
   return collinear(v1, line1ToLine2Vector, tolerance);
 }
 
@@ -484,10 +481,10 @@ var line = /*#__PURE__*/Object.freeze({
  */
 function equal(ray1, ray2, tolerance) {
   // Compare the directions of the rays
-  var v1 = subtract(ray1[1], ray1[0]);
-  var v2 = subtract(ray2[1], ray2[0]);
-  var sameOrigin = equal$2(ray1[0], ray2[0]);
-  var codirectional$1 = codirectional(v1, v2, tolerance);
+  const v1 = subtract(ray1[1], ray1[0]);
+  const v2 = subtract(ray2[1], ray2[0]);
+  const sameOrigin = equal$2(ray1[0], ray2[0]);
+  const codirectional$1 = codirectional(v1, v2, tolerance);
   return sameOrigin && codirectional$1;
 }