@khanacademy/kmath 0.0.5 → 0.0.6

package/dist/index.js

@@ -1,2 +1,512 @@
-"use strict";function t(t){return t&&"object"==typeof t&&"default"in t?t:{default:t}}Object.defineProperty(exports,"__esModule",{value:!0});var n=t(require("underscore"));const r=Math.pow(2,-42);function e(t){return n.default.isNumber(t)&&!n.default.isNaN(t)}function o(t,n,r){return null==t||null==n?t===n:t===n||(null==r&&(r=1e-9),Math.abs(t-n)<r)}function u(t,n){const r=Math.pow(10,n);return Math.round(t*r)/r}function a(t,n){return Math.round(t/n)*n}function c(t,n){return Math.floor(t/n)*n}function i(t,n){return Math.ceil(t/n)*n}var f=Object.freeze({__proto__:null,DEFAULT_TOLERANCE:1e-9,EPSILON:r,is:e,equal:o,sign:function(t,n){return o(t,0,n)?0:Math.abs(t)/t},isInteger:function(t,n){return o(Math.round(t),t,n)},round:u,roundTo:a,floorTo:c,ceilTo:i,toFraction:function(t){let n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:r,e=arguments.length>2&&void 0!==arguments[2]?arguments[2]:1e3,u=[1,0],a=[0,1],c=Math.floor(t),i=t-c;for(;a[0]<=e;){if(o(u[0]/a[0],t,n))return[u[0],a[0]];u=[c*u[0]+u[1],u[0]],a=[c*a[0]+a[1],a[0]],c=Math.floor(1/i),i=1/i-c}return[t,1]}});function l(t){return t.reduce(((t,n)=>t+n),0)}function d(t){return t.reduce(((t,n)=>t*n),1)}function s(t,r){return!!n.default.isArray(t)&&((void 0===r||t.length===r)&&t.every(e))}function p(t){return v(t,1/h(t))}function h(t){return Math.sqrt(g(t,t))}function g(t,r){return l(n.default.zip(t,r).map(d))}function _(){const t=n.default.zip(...arguments);return t.map(l)}function m(t,r){return n.default.zip(t,r).map((t=>t[0]-t[1]))}function M(t){return t.map((t=>-t))}function v(t,n){return t.map((t=>t*n))}function T(t,r,e){return n.default.zip(t,r).every((t=>o(t[0],t[1],e)))}function b(t,n,r){return!(!o(h(t),0,r)&&!o(h(n),0,r))||T(t=p(t),n=p(n),r)}function P(t,n,r){return b(t,n,r)||b(t,M(n),r)}function z(t){const n=h(t);let r=Math.atan2(t[1],t[0]);return r<0&&(r+=2*Math.PI),[n,r]}function F(t){const n=z(t);return[n[0],180*n[1]/Math.PI]}function O(t){let n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:0;return[t*Math.cos(n),t*Math.sin(n)]}function j(t){let n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:0;return O(t,n*Math.PI/180)}function D(t,n){const r=z(t),e=r[1]+n;return O(r[0],e)}function R(t,n){const r=F(t),e=r[1]+n;return j(r[0],e)}function q(t,n){return Math.acos(g(t,n)/(h(t)*h(n)))}function x(t,n){return v(n,g(t,n)/g(n,n))}function y(t,n){return t.map(((t,r)=>u(t,n[r]||n)))}function I(t,n){return t.map(((t,r)=>a(t,n[r]||n)))}function C(t,n){return t.map(((t,r)=>c(t,n[r]||n)))}function L(t,n){return t.map(((t,r)=>i(t,n[r]||n)))}var N=Object.freeze({__proto__:null,is:s,normalize:p,length:h,dot:g,add:_,subtract:m,negate:M,scale:v,equal:T,codirectional:b,collinear:P,polarRadFromCart:z,polarDegFromCart:F,cartFromPolarRad:O,cartFromPolarDeg:j,rotateRad:D,rotateDeg:R,angleRad:q,angleDeg:function(t,n){return 180*q(t,n)/Math.PI},projection:x,round:y,roundTo:I,floorTo:C,ceilTo:L});function E(t,n){const r=m(n[1],n[0]),e=m(t,n[0]);return h(m(x(e,r),e))}function A(t,n){const r=m(n[1],n[0]),e=m(t,n[0]),o=m(v(x(e,r),2),e);return _(n[0],o)}const V=s,w=_,S=_,U=m,k=T,B=z,G=F,H=O,J=j,K=y,Q=I,W=C,X=L;var Y=Object.freeze({__proto__:null,rotateRad:function(t,n,r){return void 0===r?D(t,n):_(r,D(m(t,r),n))},rotateDeg:function(t,n,r){return void 0===r?R(t,n):_(r,R(m(t,r),n))},distanceToPoint:function(t,n){return h(m(t,n))},distanceToLine:E,reflectOverLine:A,compare:function(t,n,r){if(t.length!==n.length)return t.length-n.length;for(let e=0;e<t.length;e++)if(!o(t[e],n[e],r))return t[e]-n[e];return 0},is:V,addVector:w,addVectors:S,subtractVector:U,equal:k,polarRadFromCart:B,polarDegFromCart:G,cartFromPolarRad:H,cartFromPolarDeg:J,round:K,roundTo:Q,floorTo:W,ceilTo:X});var Z=Object.freeze({__proto__:null,distanceToPoint:function(t,n){return E(n,t)},reflectPoint:function(t,n){return A(n,t)},midpoint:function(t){return[(t[0][0]+t[1][0])/2,(t[0][1]+t[1][1])/2]},equal:function(t,n,r){const e=m(t[1],t[0]);return!!P(e,m(n[1],n[0]),r)&&(!!k(t[0],n[0])||P(e,m(n[0],t[0]),r))}});var $=Object.freeze({__proto__:null,equal:function(t,n,r){const e=m(t[1],t[0]),o=m(n[1],n[0]),u=k(t[0],n[0]),a=b(e,o,r);return u&&a}});exports.line=Z,exports.number=f,exports.point=Y,exports.ray=$,exports.vector=N;
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _ = require('underscore');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var ___default = /*#__PURE__*/_interopDefaultLegacy(_);
+
+/**
+ * Number Utils
+ * A number is a js-number, e.g. 5.12
+ */
+const DEFAULT_TOLERANCE = 1e-9; // TODO: Should this just be Number.Epsilon
+
+const EPSILON = Math.pow(2, -42);
+function is$2(x) {
+  return ___default["default"].isNumber(x) && !___default["default"].isNaN(x);
+}
+function equal$4(x, y, tolerance) {
+  // 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;
+}
+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
+
+function round$2(num, 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
+
+function roundTo$2(num, increment) {
+  return Math.round(num / increment) * increment;
+}
+function floorTo$2(num, increment) {
+  return Math.floor(num / increment) * increment;
+}
+function ceilTo$2(num, increment) {
+  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]
+ */
+
+function toFraction(decimal) {
+  let tolerance = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : EPSILON;
+  let maxDenominator = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 1000;
+  // 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$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"
+
+
+  return [decimal, 1];
+}
+
+var number = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    DEFAULT_TOLERANCE: DEFAULT_TOLERANCE,
+    EPSILON: EPSILON,
+    is: is$2,
+    equal: equal$4,
+    sign: sign,
+    isInteger: isInteger,
+    round: round$2,
+    roundTo: roundTo$2,
+    floorTo: floorTo$2,
+    ceilTo: ceilTo$2,
+    toFraction: toFraction
+});
+
+/**
+ * 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).
+ *
+ * is([1, 2, 3]) -> true
+ * is([1, "Hello", 3]) -> false
+ * is([1, 2, 3], 1) -> false
+ */
+
+
+function is$1(vec, dimension) {
+  if (!___default["default"].isArray(vec)) {
+    return false;
+  }
+
+  if (dimension !== undefined && vec.length !== dimension) {
+    return false;
+  }
+
+  return vec.every(is$2);
+} // Normalize to a unit vector
+
+function normalize(v) {
+  return scale(v, 1 / length(v));
+} // Length/magnitude of a vector
+
+function length(v) {
+  return Math.sqrt(dot(v, v));
+} // Dot product of two vectors
+
+function dot(a, b) {
+  // $FlowFixMe[incompatible-call] underscore doesn't like $ReadOnlyArray
+  const zipped = ___default["default"].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
+  const zipped = ___default["default"].zip(...arguments);
+
+  return zipped.map(arraySum);
+}
+function subtract(v1, v2) {
+  // $FlowFixMe[incompatible-call] underscore doesn't like $ReadOnlyArray
+  return ___default["default"].zip(v1, v2).map(dim => dim[0] - dim[1]);
+}
+function negate(v) {
+  // $FlowFixMe[incompatible-return] Flow's `.map()` libdef is lacking
+  return v.map(x => {
+    return -x;
+  });
+} // Scale a vector
+
+function scale(v1, scalar) {
+  // $FlowFixMe[incompatible-return] Flow's `.map()` libdef is lacking
+  return v1.map(x => {
+    return x * scalar;
+  });
+}
+function equal$3(v1, v2, tolerance) {
+  // _.zip will nicely deal with the lengths, going through
+  // 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 ___default["default"].zip(v1, v2).every(pair => equal$4(pair[0], pair[1], tolerance));
+}
+function codirectional(v1, v2, tolerance) {
+  // The origin is trivially codirectional with all other vectors.
+  // This gives nice semantics for codirectionality between points when
+  // comparing their difference vectors.
+  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
+
+function polarRadFromCart$1(v) {
+  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 */
+{
+  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 */
+{
+  let theta = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+  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) {
+  let theta = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+  return cartFromPolarRad$1(radius, theta * Math.PI / 180);
+} // Rotate vector
+
+function rotateRad$1(v, theta) {
+  const polar = polarRadFromCart$1(v);
+  const angle = polar[1] + theta;
+  return cartFromPolarRad$1(polar[0], angle);
+}
+function rotateDeg$1(v, theta) {
+  const polar = polarDegFromCart$1(v);
+  const angle = polar[1] + theta;
+  return cartFromPolarDeg$1(polar[0], angle);
+} // 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
+
+function projection(v1, v2) {
+  const scalar = dot(v1, v2) / dot(v2, v2);
+  return scale(v2, scalar);
+} // 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]
+  // $FlowFixMe[incompatible-call]
+  round$2(elem, precision[i] || precision));
+} // 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]
+  // $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]
+  // $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]
+  // $FlowFixMe[incompatible-call]
+  ceilTo$2(elem, increment[i] || increment));
+}
+
+var vector = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    is: is$1,
+    normalize: normalize,
+    length: length,
+    dot: dot,
+    add: add,
+    subtract: subtract,
+    negate: negate,
+    scale: scale,
+    equal: equal$3,
+    codirectional: codirectional,
+    collinear: collinear,
+    polarRadFromCart: polarRadFromCart$1,
+    polarDegFromCart: polarDegFromCart$1,
+    cartFromPolarRad: cartFromPolarRad$1,
+    cartFromPolarDeg: cartFromPolarDeg$1,
+    rotateRad: rotateRad$1,
+    rotateDeg: rotateDeg$1,
+    angleRad: angleRad,
+    angleDeg: angleDeg,
+    projection: projection,
+    round: round$1,
+    roundTo: roundTo$1,
+    floorTo: floorTo$1,
+    ceilTo: ceilTo$1
+});
+
+/**
+ * Point Utils
+ * A point is an array of two numbers e.g. [0, 0].
+ */
+
+// Rotate point (around origin unless a center is specified)
+function rotateRad(point, theta, center) {
+  if (center === undefined) {
+    return rotateRad$1(point, theta);
+  } else {
+    return add(center, rotateRad$1(subtract(point, center), theta));
+  }
+}
+function rotateDeg(point, theta, center) {
+  if (center === undefined) {
+    return rotateDeg$1(point, theta);
+  } else {
+    return add(center, rotateDeg$1(subtract(point, center), theta));
+  }
+} // Distance between two points
+
+function distanceToPoint$1(point1, point2) {
+  return length(subtract(point1, point2));
+} // Distance between point and line
+
+function distanceToLine(point, line) {
+  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
+
+function reflectOverLine(point, line) {
+  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
+ *
+ * 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.
+ */
+
+function compare(point1, point2, equalityTolerance)
+/* 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 (!equal$4(point1[i], point2[i], equalityTolerance)) {
+      return point1[i] - point2[i];
+    }
+  }
+
+  return 0;
+} // Check if a value is a point
+
+const is = is$1; // Add and subtract vector(s)
+
+const addVector = add;
+const addVectors = add;
+const subtractVector = subtract;
+const equal$2 = equal$3; // Convert from cartesian to polar and back
+
+const polarRadFromCart = polarRadFromCart$1;
+const polarDegFromCart = polarDegFromCart$1;
+const cartFromPolarRad = cartFromPolarRad$1;
+const cartFromPolarDeg = cartFromPolarDeg$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,
+    rotateRad: rotateRad,
+    rotateDeg: rotateDeg,
+    distanceToPoint: distanceToPoint$1,
+    distanceToLine: distanceToLine,
+    reflectOverLine: reflectOverLine,
+    compare: compare,
+    is: is,
+    addVector: addVector,
+    addVectors: addVectors,
+    subtractVector: subtractVector,
+    equal: equal$2,
+    polarRadFromCart: polarRadFromCart,
+    polarDegFromCart: polarDegFromCart,
+    cartFromPolarRad: cartFromPolarRad,
+    cartFromPolarDeg: cartFromPolarDeg,
+    round: round,
+    roundTo: roundTo,
+    floorTo: floorTo,
+    ceilTo: ceilTo
+});
+
+/**
+ * Line Utils
+ * A line is an array of two points e.g. [[-5, 0], [5, 0]].
+ */
+function distanceToPoint(line, point$1) {
+  return distanceToLine(point$1, line);
+}
+function reflectPoint(line, point$1) {
+  return reflectOverLine(point$1, line);
+}
+function midpoint(line) {
+  return [(line[0][0] + line[1][0]) / 2, (line[0][1] + line[1][1]) / 2];
+}
+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
+  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 (equal$2(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 = subtract(line2[0], line1[0]);
+  return collinear(v1, line1ToLine2Vector, tolerance);
+}
+
+var line = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    distanceToPoint: distanceToPoint,
+    reflectPoint: reflectPoint,
+    midpoint: midpoint,
+    equal: equal$1
+});
+
+/**
+ * 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.
+ */
+function equal(ray1, ray2, tolerance) {
+  // Compare the directions of the rays
+  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;
+}
+
+var ray = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    equal: equal
+});
+
+exports.line = line;
+exports.number = number;
+exports.point = point;
+exports.ray = ray;
+exports.vector = vector;
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":["../src/number.js","../src/vector.js","../src/point.js","../src/line.js","../src/ray.js"],"sourcesContent":["// @flow\n/**\n * Number Utils\n * A number is a js-number, e.g. 5.12\n */\n\nimport _ from \"underscore\";\n\nexport const DEFAULT_TOLERANCE: number = 1e-9;\n\n// TODO: Should this just be Number.Epsilon\nexport const EPSILON: number = Math.pow(2, -42);\n\nexport function is(x: any): boolean {\n    return _.isNumber(x) && !_.isNaN(x);\n}\n\nexport function equal(x: number, y: number, tolerance?: number): boolean {\n    // Checking for undefined makes this function behave nicely\n    // with vectors of different lengths that are _.zip'd together\n    if (x == null || y == null) {\n        return x === y;\n    }\n    // We check === here so that +/-Infinity comparisons work correctly\n    if (x === y) {\n        return true;\n    }\n    if (tolerance == null) {\n        tolerance = DEFAULT_TOLERANCE;\n    }\n    return Math.abs(x - y) < tolerance;\n}\n\nexport function sign(\n    x: number,\n    tolerance?: number,\n): number /* Should be: 0 | 1 | -1 */ {\n    return equal(x, 0, tolerance) ? 0 : Math.abs(x) / x;\n}\n\nexport function isInteger(num: number, tolerance?: number): boolean {\n    return equal(Math.round(num), num, tolerance);\n}\n\n// Round a number to a certain number of decimal places\nexport function round(num: number, precision: number): number {\n    const factor = Math.pow(10, precision);\n    return Math.round(num * factor) / factor;\n}\n\n// Round num to the nearest multiple of increment\n// i.e. roundTo(83, 5) -> 85\nexport function roundTo(num: number, increment: number): number {\n    return Math.round(num / increment) * increment;\n}\n\nexport function floorTo(num: number, increment: number): number {\n    return Math.floor(num / increment) * increment;\n}\n\nexport function ceilTo(num: number, increment: number): number {\n    return Math.ceil(num / increment) * increment;\n}\n\n/**\n * toFraction\n *\n * Returns a [numerator, denominator] array rational representation\n * of `decimal`\n *\n * See http://en.wikipedia.org/wiki/Continued_fraction for implementation\n * details\n *\n * toFraction(4/8) => [1, 2]\n * toFraction(0.66) => [33, 50]\n * toFraction(0.66, 0.01) => [2/3]\n * toFraction(283 + 1/3) => [850, 3]\n */\nexport function toFraction(\n    decimal: number,\n    tolerance: number = EPSILON, // can't be 0\n    maxDenominator: number = 1000,\n): [number, number] {\n    // Initialize everything to compute successive terms of\n    // continued-fraction approximations via recurrence relation\n    let n = [1, 0];\n    let d = [0, 1];\n    let a = Math.floor(decimal);\n    let rem = decimal - a;\n\n    while (d[0] <= maxDenominator) {\n        if (equal(n[0] / d[0], decimal, tolerance)) {\n            return [n[0], d[0]];\n        }\n        n = [a * n[0] + n[1], n[0]];\n        d = [a * d[0] + d[1], d[0]];\n        a = Math.floor(1 / rem);\n        rem = 1 / rem - a;\n    }\n\n    // We failed to find a nice rational representation,\n    // so return an irrational \"fraction\"\n    return [decimal, 1];\n}\n","// @flow\n/**\n * Vector Utils\n * A vector is an array of numbers e.g. [0, 3, 4].\n */\n\nimport _ from \"underscore\";\nimport * as knumber from \"./number.js\";\n\ntype Vector = $ReadOnlyArray<number>;\n\nfunction arraySum(array: $ReadOnlyArray<number>): number {\n    return array.reduce((memo, arg) => memo + arg, 0);\n}\n\nfunction arrayProduct(array: $ReadOnlyArray<number>): number {\n    return array.reduce((memo, arg) => memo * arg, 1);\n}\n\n/**\n * Checks if the given vector contains only numbers and, optionally, is of the\n * right dimension (length).\n *\n * is([1, 2, 3]) -> true\n * is([1, \"Hello\", 3]) -> false\n * is([1, 2, 3], 1) -> false\n */\nexport function is<T>(vec: $ReadOnlyArray<T>, dimension?: number): boolean {\n    if (!_.isArray(vec)) {\n        return false;\n    }\n    if (dimension !== undefined && vec.length !== dimension) {\n        return false;\n    }\n    return vec.every(knumber.is);\n}\n\n// Normalize to a unit vector\nexport function normalize<V: Vector>(v: V): V {\n    return scale(v, 1 / length(v));\n}\n\n// Length/magnitude of a vector\nexport function length(v: Vector): number {\n    return Math.sqrt(dot(v, v));\n}\n// Dot product of two vectors\nexport function dot(a: Vector, b: Vector): number {\n    // $FlowFixMe[incompatible-call] underscore doesn't like $ReadOnlyArray\n    const zipped = _.zip(a, b);\n    const multiplied = zipped.map(arrayProduct);\n    return arraySum(multiplied);\n}\n\n/* vector-add multiple [x, y] coords/vectors\n *\n * add([1, 2], [3, 4]) -> [4, 6]\n */\nexport function add<V: Vector>(...vecs: $ReadOnlyArray<V>): V {\n    // $FlowFixMe[incompatible-call] underscore doesn't like $ReadOnlyArray\n    const zipped = _.zip(...vecs);\n    return zipped.map(arraySum);\n}\n\nexport function subtract<V: Vector>(v1: V, v2: V): V {\n    // $FlowFixMe[incompatible-call] underscore doesn't like $ReadOnlyArray\n    return _.zip(v1, v2).map((dim) => dim[0] - dim[1]);\n}\n\nexport function negate<V: Vector>(v: V): V {\n    // $FlowFixMe[incompatible-return] Flow's `.map()` libdef is lacking\n    return v.map((x) => {\n        return -x;\n    });\n}\n\n// Scale a vector\nexport function scale<V: Vector>(v1: V, scalar: number): V {\n    // $FlowFixMe[incompatible-return] Flow's `.map()` libdef is lacking\n    return v1.map((x) => {\n        return x * scalar;\n    });\n}\n\nexport function equal(v1: Vector, v2: Vector, tolerance?: number): boolean {\n    // _.zip will nicely deal with the lengths, going through\n    // the length of the longest vector. knumber.equal then\n    // returns false for any number compared to the undefined\n    // passed in if one of the vectors is shorter.\n    // $FlowFixMe[incompatible-call] underscore doesn't like $ReadOnlyArray\n    return _.zip(v1, v2).every((pair) =>\n        knumber.equal(pair[0], pair[1], tolerance),\n    );\n}\n\nexport function codirectional(\n    v1: Vector,\n    v2: Vector,\n    tolerance?: number,\n): boolean {\n    // The origin is trivially codirectional with all other vectors.\n    // This gives nice semantics for codirectionality between points when\n    // comparing their difference vectors.\n    if (\n        knumber.equal(length(v1), 0, tolerance) ||\n        knumber.equal(length(v2), 0, tolerance)\n    ) {\n        return true;\n    }\n\n    v1 = normalize(v1);\n    v2 = normalize(v2);\n\n    return equal(v1, v2, tolerance);\n}\n\nexport function collinear(v1: Vector, v2: Vector, tolerance?: number): boolean {\n    return (\n        codirectional(v1, v2, tolerance) ||\n        codirectional(v1, negate(v2), tolerance)\n    );\n}\n\n// Convert a cartesian coordinate into a radian polar coordinate\nexport function polarRadFromCart(\n    v: $ReadOnlyArray<number>,\n): $ReadOnlyArray<number> {\n    const radius = length(v);\n    let theta = Math.atan2(v[1], v[0]);\n\n    // Convert angle range from [-pi, pi] to [0, 2pi]\n    if (theta < 0) {\n        theta += 2 * Math.PI;\n    }\n\n    return [radius, theta];\n}\n\n// Converts a cartesian coordinate into a degree polar coordinate\nexport function polarDegFromCart(\n    v: $ReadOnlyArray<number>,\n): $ReadOnlyArray<number> /* TODO: convert to tuple/Point */ {\n    const polar = polarRadFromCart(v);\n    return [polar[0], (polar[1] * 180) / Math.PI];\n}\n\n/* Convert a polar coordinate into a cartesian coordinate\n *\n * Examples:\n * cartFromPolarRad(5, Math.PI)\n * cartFromPolarRad([5, Math.PI])\n */\nexport function cartFromPolarRad(\n    radius: number,\n    theta?: number = 0,\n): $ReadOnlyArray<number> /* TODO: convert to tuple/Point */ {\n    return [radius * Math.cos(theta), radius * Math.sin(theta)];\n}\n\n/* Convert a polar coordinate into a cartesian coordinate\n *\n * Examples:\n * cartFromPolarDeg(5, 30)\n * cartFromPolarDeg([5, 30])\n */\nexport function cartFromPolarDeg(\n    radius: number,\n    theta?: number = 0,\n): $ReadOnlyArray<number> {\n    return cartFromPolarRad(radius, (theta * Math.PI) / 180);\n}\n\n// Rotate vector\nexport function rotateRad(\n    v: $ReadOnlyArray<number>,\n    theta: number,\n): $ReadOnlyArray<number> {\n    const polar = polarRadFromCart(v);\n    const angle = polar[1] + theta;\n    return cartFromPolarRad(polar[0], angle);\n}\n\nexport function rotateDeg(\n    v: $ReadOnlyArray<number>,\n    theta: number,\n): $ReadOnlyArray<number> {\n    const polar = polarDegFromCart(v);\n    const angle = polar[1] + theta;\n    return cartFromPolarDeg(polar[0], angle);\n}\n\n// Angle between two vectors\nexport function angleRad(\n    v1: $ReadOnlyArray<number>,\n    v2: $ReadOnlyArray<number>,\n): number {\n    return Math.acos(dot(v1, v2) / (length(v1) * length(v2)));\n}\n\nexport function angleDeg(\n    v1: $ReadOnlyArray<number>,\n    v2: $ReadOnlyArray<number>,\n): number {\n    return (angleRad(v1, v2) * 180) / Math.PI;\n}\n\n// Vector projection of v1 onto v2\nexport function projection(\n    v1: $ReadOnlyArray<number>,\n    v2: $ReadOnlyArray<number>,\n): $ReadOnlyArray<number> {\n    const scalar = dot(v1, v2) / dot(v2, v2);\n    return scale(v2, scalar);\n}\n\n// Round each number to a certain number of decimal places\nexport function round<V: Vector>(vec: V, precision: V | number): V {\n    // $FlowFixMe[incompatible-return] Flow's `.map()` libdef is lacking\n    return vec.map((elem, i) =>\n        // $FlowFixMe[prop-missing]\n        // $FlowFixMe[incompatible-call]\n        knumber.round(elem, precision[i] || precision),\n    );\n}\n\n// Round each number to the nearest increment\nexport function roundTo<V: Vector>(vec: V, increment: V | number): V {\n    // $FlowFixMe[incompatible-return] Flow's `.map()` libdef is lacking\n    return vec.map((elem, i) =>\n        // $FlowFixMe[prop-missing]\n        // $FlowFixMe[incompatible-call]\n        knumber.roundTo(elem, increment[i] || increment),\n    );\n}\n\nexport function floorTo<V: Vector>(vec: V, increment: V | number): V {\n    // $FlowFixMe[incompatible-return] Flow's `.map()` libdef is lacking\n    return vec.map((elem, i) =>\n        // $FlowFixMe[prop-missing]\n        // $FlowFixMe[incompatible-call]\n        knumber.floorTo(elem, increment[i] || increment),\n    );\n}\n\nexport function ceilTo<V: Vector>(vec: V, increment: V | number): V {\n    // $FlowFixMe[incompatible-return] Flow's `.map()` libdef is lacking\n    return vec.map((elem, i) =>\n        // $FlowFixMe[prop-missing]\n        // $FlowFixMe[incompatible-call]\n        knumber.ceilTo(elem, increment[i] || increment),\n    );\n}\n","// @flow\n/**\n * Point Utils\n * A point is an array of two numbers e.g. [0, 0].\n */\n\nimport _ from \"underscore\";\n\nimport * as kvector from \"./vector.js\";\nimport * as knumber from \"./number.js\";\n\n// A point, in 2D, 3D, or nD space.\nexport type Point = $ReadOnlyArray<number>;\n\n// Rotate point (around origin unless a center is specified)\nexport function rotateRad(point: Point, theta: number, center: Point): Point {\n    if (center === undefined) {\n        return kvector.rotateRad(point, theta);\n    } else {\n        return kvector.add(\n            center,\n            kvector.rotateRad(kvector.subtract(point, center), theta),\n        );\n    }\n}\n\nexport function rotateDeg(point: Point, theta: number, center: Point): Point {\n    if (center === undefined) {\n        return kvector.rotateDeg(point, theta);\n    } else {\n        return kvector.add(\n            center,\n            kvector.rotateDeg(kvector.subtract(point, center), theta),\n        );\n    }\n}\n\n// Distance between two points\nexport function distanceToPoint(point1: Point, point2: Point): number {\n    return kvector.length(kvector.subtract(point1, point2));\n}\n\n// Distance between point and line\nexport function distanceToLine(point: Point, line: [Point, Point]): number {\n    const lv = kvector.subtract(line[1], line[0]);\n    const pv = kvector.subtract(point, line[0]);\n    const projectedPv = kvector.projection(pv, lv);\n    const distancePv = kvector.subtract(projectedPv, pv);\n    return kvector.length(distancePv);\n}\n\n// Reflect point over line\nexport function reflectOverLine(point: Point, line: [Point, Point]): Point {\n    const lv = kvector.subtract(line[1], line[0]);\n    const pv = kvector.subtract(point, line[0]);\n    const projectedPv = kvector.projection(pv, lv);\n    const reflectedPv = kvector.subtract(kvector.scale(projectedPv, 2), pv);\n    return kvector.add(line[0], reflectedPv);\n}\n\n/**\n * Compares two points, returning -1, 0, or 1, for use with\n * Array.prototype.sort\n *\n * Note: This technically doesn't satisfy the total-ordering\n * requirements of Array.prototype.sort unless equalityTolerance\n * is 0. In some cases very close points that compare within a\n * few equalityTolerances could appear in the wrong order.\n */\nexport function compare(\n    point1: Point,\n    point2: Point,\n    equalityTolerance?: number,\n): number /* TODO: convert to -1 | 0 | 1 type */ {\n    if (point1.length !== point2.length) {\n        return point1.length - point2.length;\n    }\n    for (let i = 0; i < point1.length; i++) {\n        if (!knumber.equal(point1[i], point2[i], equalityTolerance)) {\n            return point1[i] - point2[i];\n        }\n    }\n    return 0;\n}\n\n// Check if a value is a point\nexport const is = kvector.is;\n\n// Add and subtract vector(s)\nexport const addVector = kvector.add;\nexport const addVectors = kvector.add;\nexport const subtractVector = kvector.subtract;\nexport const equal = kvector.equal;\n\n// Convert from cartesian to polar and back\nexport const polarRadFromCart = kvector.polarRadFromCart;\nexport const polarDegFromCart = kvector.polarDegFromCart;\nexport const cartFromPolarRad = kvector.cartFromPolarRad;\nexport const cartFromPolarDeg = kvector.cartFromPolarDeg;\n\n// Rounding\nexport const round = kvector.round;\nexport const roundTo = kvector.roundTo;\nexport const floorTo = kvector.floorTo;\nexport const ceilTo = kvector.ceilTo;\n","// @flow\n/**\n * Line Utils\n * A line is an array of two points e.g. [[-5, 0], [5, 0]].\n */\n\nimport * as kpoint from \"./point.js\";\nimport * as kvector from \"./vector.js\";\n\nimport type {Point} from \"./point.js\";\n\nexport type Line = [Point, Point];\n\nexport function distanceToPoint(line: Line, point: Point): number {\n    return kpoint.distanceToLine(point, line);\n}\n\nexport function reflectPoint(line: Line, point: Point): Point {\n    return kpoint.reflectOverLine(point, line);\n}\n\nexport function midpoint(line: Line): Point {\n    return [(line[0][0] + line[1][0]) / 2, (line[0][1] + line[1][1]) / 2];\n}\n\nexport function equal(line1: Line, line2: Line, tolerance?: number): boolean {\n    // TODO: A nicer implementation might just check collinearity of\n    // vectors using underscore magick\n    // Compare the directions of the lines\n    const v1 = kvector.subtract(line1[1], line1[0]);\n    const v2 = kvector.subtract(line2[1], line2[0]);\n    if (!kvector.collinear(v1, v2, tolerance)) {\n        return false;\n    }\n    // If the start point is the same for the two lines, then they are the same\n    if (kpoint.equal(line1[0], line2[0])) {\n        return true;\n    }\n    // Make sure that the direction to get from line1 to\n    // line2 is the same as the direction of the lines\n    const line1ToLine2Vector = kvector.subtract(line2[0], line1[0]);\n    return kvector.collinear(v1, line1ToLine2Vector, tolerance);\n}\n","// @flow\n/**\n * Ray Utils\n * A ray (→) is an array of an endpoint and another point along the ray.\n * For example, [[0, 0], [1, 0]] is the ray starting at the origin and\n * traveling along the positive x-axis.\n */\n\nimport * as kvector from \"./vector.js\";\nimport * as kpoint from \"./point.js\";\n\nimport type {Point} from \"./point\";\n\nexport type Ray = [Point, Point];\n\nexport function equal(ray1: Ray, ray2: Ray, tolerance: number): boolean {\n    // Compare the directions of the rays\n    const v1 = kvector.subtract(ray1[1], ray1[0]);\n    const v2 = kvector.subtract(ray2[1], ray2[0]);\n\n    const sameOrigin = kpoint.equal(ray1[0], ray2[0]);\n    const codirectional = kvector.codirectional(v1, v2, tolerance);\n\n    return sameOrigin && codirectional;\n}\n"],"names":["EPSILON","Math","pow","is","x","_","isNumber","isNaN","equal","y","tolerance","abs","round","num","precision","factor","roundTo","increment","floorTo","floor","ceilTo","ceil","decimal","maxDenominator","n","d","a","rem","arraySum","array","reduce","memo","arg","arrayProduct","vec","dimension","isArray","undefined","length","every","knumber","normalize","v","scale","sqrt","dot","b","zip","map","add","zipped","subtract","v1","v2","dim","negate","scalar","pair","codirectional","collinear","polarRadFromCart","radius","theta","atan2","PI","polarDegFromCart","polar","cartFromPolarRad","cos","sin","cartFromPolarDeg","rotateRad","angle","rotateDeg","angleRad","acos","projection","elem","i","distanceToLine","point","line","lv","kvector","pv","reflectOverLine","reflectedPv","addVector","addVectors","subtractVector","center","point1","point2","equalityTolerance","kpoint","line1","line2","ray1","ray2","sameOrigin"],"mappings":"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"}
+{"version":3,"file":"index.js","sources":["../src/number.js","../src/vector.js","../src/point.js","../src/line.js","../src/ray.js"],"sourcesContent":["// @flow\n/**\n * Number Utils\n * A number is a js-number, e.g. 5.12\n */\n\nimport _ from \"underscore\";\n\nexport const DEFAULT_TOLERANCE: number = 1e-9;\n\n// TODO: Should this just be Number.Epsilon\nexport const EPSILON: number = Math.pow(2, -42);\n\nexport function is(x: any): boolean {\n    return _.isNumber(x) && !_.isNaN(x);\n}\n\nexport function equal(x: number, y: number, tolerance?: number): boolean {\n    // Checking for undefined makes this function behave nicely\n    // with vectors of different lengths that are _.zip'd together\n    if (x == null || y == null) {\n        return x === y;\n    }\n    // We check === here so that +/-Infinity comparisons work correctly\n    if (x === y) {\n        return true;\n    }\n    if (tolerance == null) {\n        tolerance = DEFAULT_TOLERANCE;\n    }\n    return Math.abs(x - y) < tolerance;\n}\n\nexport function sign(\n    x: number,\n    tolerance?: number,\n): number /* Should be: 0 | 1 | -1 */ {\n    return equal(x, 0, tolerance) ? 0 : Math.abs(x) / x;\n}\n\nexport function isInteger(num: number, tolerance?: number): boolean {\n    return equal(Math.round(num), num, tolerance);\n}\n\n// Round a number to a certain number of decimal places\nexport function round(num: number, precision: number): number {\n    const factor = Math.pow(10, precision);\n    return Math.round(num * factor) / factor;\n}\n\n// Round num to the nearest multiple of increment\n// i.e. roundTo(83, 5) -> 85\nexport function roundTo(num: number, increment: number): number {\n    return Math.round(num / increment) * increment;\n}\n\nexport function floorTo(num: number, increment: number): number {\n    return Math.floor(num / increment) * increment;\n}\n\nexport function ceilTo(num: number, increment: number): number {\n    return Math.ceil(num / increment) * increment;\n}\n\n/**\n * toFraction\n *\n * Returns a [numerator, denominator] array rational representation\n * of `decimal`\n *\n * See http://en.wikipedia.org/wiki/Continued_fraction for implementation\n * details\n *\n * toFraction(4/8) => [1, 2]\n * toFraction(0.66) => [33, 50]\n * toFraction(0.66, 0.01) => [2/3]\n * toFraction(283 + 1/3) => [850, 3]\n */\nexport function toFraction(\n    decimal: number,\n    tolerance: number = EPSILON, // can't be 0\n    maxDenominator: number = 1000,\n): [number, number] {\n    // Initialize everything to compute successive terms of\n    // continued-fraction approximations via recurrence relation\n    let n = [1, 0];\n    let d = [0, 1];\n    let a = Math.floor(decimal);\n    let rem = decimal - a;\n\n    while (d[0] <= maxDenominator) {\n        if (equal(n[0] / d[0], decimal, tolerance)) {\n            return [n[0], d[0]];\n        }\n        n = [a * n[0] + n[1], n[0]];\n        d = [a * d[0] + d[1], d[0]];\n        a = Math.floor(1 / rem);\n        rem = 1 / rem - a;\n    }\n\n    // We failed to find a nice rational representation,\n    // so return an irrational \"fraction\"\n    return [decimal, 1];\n}\n","// @flow\n/**\n * Vector Utils\n * A vector is an array of numbers e.g. [0, 3, 4].\n */\n\nimport _ from \"underscore\";\n\nimport * as knumber from \"./number.js\";\n\ntype Vector = $ReadOnlyArray<number>;\n\nfunction arraySum(array: $ReadOnlyArray<number>): number {\n    return array.reduce((memo, arg) => memo + arg, 0);\n}\n\nfunction arrayProduct(array: $ReadOnlyArray<number>): number {\n    return array.reduce((memo, arg) => memo * arg, 1);\n}\n\n/**\n * Checks if the given vector contains only numbers and, optionally, is of the\n * right dimension (length).\n *\n * is([1, 2, 3]) -> true\n * is([1, \"Hello\", 3]) -> false\n * is([1, 2, 3], 1) -> false\n */\nexport function is<T>(vec: $ReadOnlyArray<T>, dimension?: number): boolean {\n    if (!_.isArray(vec)) {\n        return false;\n    }\n    if (dimension !== undefined && vec.length !== dimension) {\n        return false;\n    }\n    return vec.every(knumber.is);\n}\n\n// Normalize to a unit vector\nexport function normalize<V: Vector>(v: V): V {\n    return scale(v, 1 / length(v));\n}\n\n// Length/magnitude of a vector\nexport function length(v: Vector): number {\n    return Math.sqrt(dot(v, v));\n}\n// Dot product of two vectors\nexport function dot(a: Vector, b: Vector): number {\n    // $FlowFixMe[incompatible-call] underscore doesn't like $ReadOnlyArray\n    const zipped = _.zip(a, b);\n    const multiplied = zipped.map(arrayProduct);\n    return arraySum(multiplied);\n}\n\n/* vector-add multiple [x, y] coords/vectors\n *\n * add([1, 2], [3, 4]) -> [4, 6]\n */\nexport function add<V: Vector>(...vecs: $ReadOnlyArray<V>): V {\n    // $FlowFixMe[incompatible-call] underscore doesn't like $ReadOnlyArray\n    const zipped = _.zip(...vecs);\n    return zipped.map(arraySum);\n}\n\nexport function subtract<V: Vector>(v1: V, v2: V): V {\n    // $FlowFixMe[incompatible-call] underscore doesn't like $ReadOnlyArray\n    return _.zip(v1, v2).map((dim) => dim[0] - dim[1]);\n}\n\nexport function negate<V: Vector>(v: V): V {\n    // $FlowFixMe[incompatible-return] Flow's `.map()` libdef is lacking\n    return v.map((x) => {\n        return -x;\n    });\n}\n\n// Scale a vector\nexport function scale<V: Vector>(v1: V, scalar: number): V {\n    // $FlowFixMe[incompatible-return] Flow's `.map()` libdef is lacking\n    return v1.map((x) => {\n        return x * scalar;\n    });\n}\n\nexport function equal(v1: Vector, v2: Vector, tolerance?: number): boolean {\n    // _.zip will nicely deal with the lengths, going through\n    // the length of the longest vector. knumber.equal then\n    // returns false for any number compared to the undefined\n    // passed in if one of the vectors is shorter.\n    // $FlowFixMe[incompatible-call] underscore doesn't like $ReadOnlyArray\n    return _.zip(v1, v2).every((pair) =>\n        knumber.equal(pair[0], pair[1], tolerance),\n    );\n}\n\nexport function codirectional(\n    v1: Vector,\n    v2: Vector,\n    tolerance?: number,\n): boolean {\n    // The origin is trivially codirectional with all other vectors.\n    // This gives nice semantics for codirectionality between points when\n    // comparing their difference vectors.\n    if (\n        knumber.equal(length(v1), 0, tolerance) ||\n        knumber.equal(length(v2), 0, tolerance)\n    ) {\n        return true;\n    }\n\n    v1 = normalize(v1);\n    v2 = normalize(v2);\n\n    return equal(v1, v2, tolerance);\n}\n\nexport function collinear(v1: Vector, v2: Vector, tolerance?: number): boolean {\n    return (\n        codirectional(v1, v2, tolerance) ||\n        codirectional(v1, negate(v2), tolerance)\n    );\n}\n\n// TODO(jeremy) These coordinate conversion functions really only handle 2D points (ie. [number, number])\n\n// Convert a cartesian coordinate into a radian polar coordinate\nexport function polarRadFromCart(\n    v: $ReadOnlyArray<number>,\n): $ReadOnlyArray<number> {\n    const radius = length(v);\n    let theta = Math.atan2(v[1], v[0]);\n\n    // Convert angle range from [-pi, pi] to [0, 2pi]\n    if (theta < 0) {\n        theta += 2 * Math.PI;\n    }\n\n    return [radius, theta];\n}\n\n// Converts a cartesian coordinate into a degree polar coordinate\nexport function polarDegFromCart(\n    v: $ReadOnlyArray<number>,\n): $ReadOnlyArray<number> /* TODO: convert to tuple/Point */ {\n    const polar = polarRadFromCart(v);\n    return [polar[0], (polar[1] * 180) / Math.PI];\n}\n\n/* Convert a polar coordinate into a cartesian coordinate\n *\n * Examples:\n * cartFromPolarRad(5, Math.PI)\n */\nexport function cartFromPolarRad(\n    radius: number,\n    theta?: number = 0,\n): $ReadOnlyArray<number> /* TODO: convert to tuple/Point */ {\n    return [radius * Math.cos(theta), radius * Math.sin(theta)];\n}\n\n/* Convert a polar coordinate into a cartesian coordinate\n *\n * Examples:\n * cartFromPolarDeg(5, 30)\n */\nexport function cartFromPolarDeg(\n    radius: number,\n    theta?: number = 0,\n): $ReadOnlyArray<number> {\n    return cartFromPolarRad(radius, (theta * Math.PI) / 180);\n}\n\n// Rotate vector\nexport function rotateRad(\n    v: $ReadOnlyArray<number>,\n    theta: number,\n): $ReadOnlyArray<number> {\n    const polar = polarRadFromCart(v);\n    const angle = polar[1] + theta;\n    return cartFromPolarRad(polar[0], angle);\n}\n\nexport function rotateDeg(\n    v: $ReadOnlyArray<number>,\n    theta: number,\n): $ReadOnlyArray<number> {\n    const polar = polarDegFromCart(v);\n    const angle = polar[1] + theta;\n    return cartFromPolarDeg(polar[0], angle);\n}\n\n// Angle between two vectors\nexport function angleRad(v1: Vector, v2: Vector): number {\n    return Math.acos(dot(v1, v2) / (length(v1) * length(v2)));\n}\n\nexport function angleDeg(v1: Vector, v2: Vector): number {\n    return (angleRad(v1, v2) * 180) / Math.PI;\n}\n\n// Vector projection of v1 onto v2\nexport function projection<V: Vector>(v1: V, v2: V): V {\n    const scalar = dot(v1, v2) / dot(v2, v2);\n    return scale(v2, scalar);\n}\n\n// Round each number to a certain number of decimal places\nexport function round<V: Vector>(vec: V, precision: V | number): V {\n    // $FlowFixMe[incompatible-return] Flow's `.map()` libdef is lacking\n    return vec.map((elem, i) =>\n        // $FlowFixMe[prop-missing]\n        // $FlowFixMe[incompatible-call]\n        knumber.round(elem, precision[i] || precision),\n    );\n}\n\n// Round each number to the nearest increment\nexport function roundTo<V: Vector>(vec: V, increment: V | number): V {\n    // $FlowFixMe[incompatible-return] Flow's `.map()` libdef is lacking\n    return vec.map((elem, i) =>\n        // $FlowFixMe[prop-missing]\n        // $FlowFixMe[incompatible-call]\n        knumber.roundTo(elem, increment[i] || increment),\n    );\n}\n\nexport function floorTo<V: Vector>(vec: V, increment: V | number): V {\n    // $FlowFixMe[incompatible-return] Flow's `.map()` libdef is lacking\n    return vec.map((elem, i) =>\n        // $FlowFixMe[prop-missing]\n        // $FlowFixMe[incompatible-call]\n        knumber.floorTo(elem, increment[i] || increment),\n    );\n}\n\nexport function ceilTo<V: Vector>(vec: V, increment: V | number): V {\n    // $FlowFixMe[incompatible-return] Flow's `.map()` libdef is lacking\n    return vec.map((elem, i) =>\n        // $FlowFixMe[prop-missing]\n        // $FlowFixMe[incompatible-call]\n        knumber.ceilTo(elem, increment[i] || increment),\n    );\n}\n","// @flow\n/**\n * Point Utils\n * A point is an array of two numbers e.g. [0, 0].\n */\n\nimport _ from \"underscore\";\n\nimport * as knumber from \"./number.js\";\nimport * as kvector from \"./vector.js\";\n\n// A point, in 2D, 3D, or nD space.\nexport type Point = $ReadOnlyArray<number>;\n\n// Rotate point (around origin unless a center is specified)\nexport function rotateRad(point: Point, theta: number, center?: Point): Point {\n    if (center === undefined) {\n        return kvector.rotateRad(point, theta);\n    } else {\n        return kvector.add(\n            center,\n            kvector.rotateRad(kvector.subtract(point, center), theta),\n        );\n    }\n}\n\nexport function rotateDeg(point: Point, theta: number, center?: Point): Point {\n    if (center === undefined) {\n        return kvector.rotateDeg(point, theta);\n    } else {\n        return kvector.add(\n            center,\n            kvector.rotateDeg(kvector.subtract(point, center), theta),\n        );\n    }\n}\n\n// Distance between two points\nexport function distanceToPoint(point1: Point, point2: Point): number {\n    return kvector.length(kvector.subtract(point1, point2));\n}\n\n// Distance between point and line\nexport function distanceToLine(point: Point, line: [Point, Point]): number {\n    const lv = kvector.subtract(line[1], line[0]);\n    const pv = kvector.subtract(point, line[0]);\n    const projectedPv = kvector.projection(pv, lv);\n    const distancePv = kvector.subtract(projectedPv, pv);\n    return kvector.length(distancePv);\n}\n\n// Reflect point over line\nexport function reflectOverLine<P: Point>(point: P, line: [P, P]): P {\n    const lv = kvector.subtract(line[1], line[0]);\n    const pv = kvector.subtract(point, line[0]);\n    const projectedPv = kvector.projection(pv, lv);\n    const reflectedPv = kvector.subtract(kvector.scale(projectedPv, 2), pv);\n    return kvector.add(line[0], reflectedPv);\n}\n\n/**\n * Compares two points, returning -1, 0, or 1, for use with\n * Array.prototype.sort\n *\n * Note: This technically doesn't satisfy the total-ordering\n * requirements of Array.prototype.sort unless equalityTolerance\n * is 0. In some cases very close points that compare within a\n * few equalityTolerances could appear in the wrong order.\n */\nexport function compare(\n    point1: Point,\n    point2: Point,\n    equalityTolerance?: number,\n): number /* TODO: convert to -1 | 0 | 1 type */ {\n    if (point1.length !== point2.length) {\n        return point1.length - point2.length;\n    }\n    for (let i = 0; i < point1.length; i++) {\n        if (!knumber.equal(point1[i], point2[i], equalityTolerance)) {\n            return point1[i] - point2[i];\n        }\n    }\n    return 0;\n}\n\n// Check if a value is a point\nexport const is = kvector.is;\n\n// Add and subtract vector(s)\nexport const addVector = kvector.add;\nexport const addVectors = kvector.add;\nexport const subtractVector = kvector.subtract;\nexport const equal = kvector.equal;\n\n// Convert from cartesian to polar and back\nexport const polarRadFromCart = kvector.polarRadFromCart;\nexport const polarDegFromCart = kvector.polarDegFromCart;\nexport const cartFromPolarRad = kvector.cartFromPolarRad;\nexport const cartFromPolarDeg = kvector.cartFromPolarDeg;\n\n// Rounding\nexport const round = kvector.round;\nexport const roundTo = kvector.roundTo;\nexport const floorTo = kvector.floorTo;\nexport const ceilTo = kvector.ceilTo;\n","// @flow\n/**\n * Line Utils\n * A line is an array of two points e.g. [[-5, 0], [5, 0]].\n */\n\nimport * as kpoint from \"./point.js\";\nimport * as kvector from \"./vector.js\";\n\nimport type {Point} from \"./point.js\";\n\nexport type Line = [Point, Point];\n\nexport function distanceToPoint(line: Line, point: Point): number {\n    return kpoint.distanceToLine(point, line);\n}\n\nexport function reflectPoint(line: Line, point: Point): Point {\n    return kpoint.reflectOverLine(point, line);\n}\n\nexport function midpoint(line: Line): Point {\n    return [(line[0][0] + line[1][0]) / 2, (line[0][1] + line[1][1]) / 2];\n}\n\nexport function equal(line1: Line, line2: Line, tolerance?: number): boolean {\n    // TODO: A nicer implementation might just check collinearity of\n    // vectors using underscore magick\n    // Compare the directions of the lines\n    const v1 = kvector.subtract(line1[1], line1[0]);\n    const v2 = kvector.subtract(line2[1], line2[0]);\n    if (!kvector.collinear(v1, v2, tolerance)) {\n        return false;\n    }\n    // If the start point is the same for the two lines, then they are the same\n    if (kpoint.equal(line1[0], line2[0])) {\n        return true;\n    }\n    // Make sure that the direction to get from line1 to\n    // line2 is the same as the direction of the lines\n    const line1ToLine2Vector = kvector.subtract(line2[0], line1[0]);\n    return kvector.collinear(v1, line1ToLine2Vector, tolerance);\n}\n","// @flow\n/**\n * Ray Utils\n * A ray (→) is an array of an endpoint and another point along the ray.\n * For example, [[0, 0], [1, 0]] is the ray starting at the origin and\n * traveling along the positive x-axis.\n */\n\nimport * as kpoint from \"./point.js\";\nimport * as kvector from \"./vector.js\";\n\nimport type {Point} from \"./point\";\n\nexport type Ray = [Point, Point];\n\nexport function equal(ray1: Ray, ray2: Ray, tolerance?: number): boolean {\n    // Compare the directions of the rays\n    const v1 = kvector.subtract(ray1[1], ray1[0]);\n    const v2 = kvector.subtract(ray2[1], ray2[0]);\n\n    const sameOrigin = kpoint.equal(ray1[0], ray2[0]);\n    const codirectional = kvector.codirectional(v1, v2, tolerance);\n\n    return sameOrigin && codirectional;\n}\n"],"names":["DEFAULT_TOLERANCE","EPSILON","Math","pow","is","x","_","isNumber","isNaN","equal","y","tolerance","abs","sign","isInteger","num","round","precision","factor","roundTo","increment","floorTo","floor","ceilTo","ceil","toFraction","decimal","maxDenominator","n","d","a","rem","arraySum","array","reduce","memo","arg","arrayProduct","vec","dimension","isArray","undefined","length","every","knumber","normalize","v","scale","sqrt","dot","b","zipped","zip","multiplied","map","add","subtract","v1","v2","dim","negate","scalar","pair","codirectional","collinear","polarRadFromCart","radius","theta","atan2","PI","polarDegFromCart","polar","cartFromPolarRad","cos","sin","cartFromPolarDeg","rotateRad","angle","rotateDeg","angleRad","acos","angleDeg","projection","elem","i","point","center","kvector","distanceToPoint","point1","point2","distanceToLine","line","lv","pv","projectedPv","distancePv","reflectOverLine","reflectedPv","compare","equalityTolerance","addVector","addVectors","subtractVector","kpoint","reflectPoint","midpoint","line1","line2","line1ToLine2Vector","ray1","ray2","sameOrigin"],"mappings":"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"}