@khanacademy/kmath 0.0.4 → 0.0.6

package/dist/es/index.js

@@ -1,2 +1,500 @@
-import r from"underscore";var n=Math.pow(2,-42);function t(n){return r.isNumber(n)&&!r.isNaN(n)}function o(r,n,t){return null==r||null==n?r===n:r===n||(null==t&&(t=1e-9),Math.abs(r-n)<t)}function e(r,n){var t=Math.pow(10,n);return Math.round(r*t)/t}function u(r,n){return Math.round(r/n)*n}function a(r,n){return Math.floor(r/n)*n}function i(r,n){return Math.ceil(r/n)*n}var c=Object.freeze({__proto__:null,DEFAULT_TOLERANCE:1e-9,EPSILON:n,is:t,equal:o,sign:function(r,n){return o(r,0,n)?0:Math.abs(r)/r},isInteger:function(r,n){return o(Math.round(r),r,n)},round:e,roundTo:u,floorTo:a,ceilTo:i,toFraction:function(r){for(var t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:n,e=arguments.length>2&&void 0!==arguments[2]?arguments[2]:1e3,u=[1,0],a=[0,1],i=Math.floor(r),c=r-i;a[0]<=e;){if(o(u[0]/a[0],r,t))return[u[0],a[0]];u=[i*u[0]+u[1],u[0]],a=[i*a[0]+a[1],a[0]],c=1/c-(i=Math.floor(1/c))}return[r,1]}});function f(r){return r.reduce(((r,n)=>r+n),0)}function l(r){return r.reduce(((r,n)=>r*n),1)}function d(n,o){return!!r.isArray(n)&&((void 0===o||n.length===o)&&n.every(t))}function h(r){return _(r,1/v(r))}function v(r){return Math.sqrt(p(r,r))}function p(n,t){return f(r.zip(n,t).map(l))}function g(){var n=r.zip(...arguments);return n.map(f)}function m(n,t){return r.zip(n,t).map((r=>r[0]-r[1]))}function s(r){return r.map((r=>-r))}function _(r,n){return r.map((r=>r*n))}function M(n,t,e){return r.zip(n,t).every((r=>o(r[0],r[1],e)))}function T(r,n,t){return!(!o(v(r),0,t)&&!o(v(n),0,t))||M(r=h(r),n=h(n),t)}function P(r,n,t){return T(r,n,t)||T(r,s(n),t)}function b(r){var n=v(r),t=Math.atan2(r[1],r[0]);return t<0&&(t+=2*Math.PI),[n,t]}function z(r){var n=b(r);return[n[0],180*n[1]/Math.PI]}function F(r){var n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:0;return[r*Math.cos(n),r*Math.sin(n)]}function D(r){var n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:0;return F(r,n*Math.PI/180)}function O(r,n){var t=b(r),o=t[1]+n;return F(t[0],o)}function R(r,n){var t=z(r),o=t[1]+n;return D(t[0],o)}function j(r,n){return Math.acos(p(r,n)/(v(r)*v(n)))}function q(r,n){return _(n,p(r,n)/p(n,n))}function I(r,n){return r.map(((r,t)=>e(r,n[t]||n)))}function C(r,n){return r.map(((r,t)=>u(r,n[t]||n)))}function L(r,n){return r.map(((r,t)=>a(r,n[t]||n)))}function N(r,n){return r.map(((r,t)=>i(r,n[t]||n)))}var E=Object.freeze({__proto__:null,is:d,normalize:h,length:v,dot:p,add:g,subtract:m,negate:s,scale:_,equal:M,codirectional:T,collinear:P,polarRadFromCart:b,polarDegFromCart:z,cartFromPolarRad:F,cartFromPolarDeg:D,rotateRad:O,rotateDeg:R,angleRad:j,angleDeg:function(r,n){return 180*j(r,n)/Math.PI},projection:q,round:I,roundTo:C,floorTo:L,ceilTo:N});function y(r,n){var t=m(n[1],n[0]),o=m(r,n[0]);return v(m(q(o,t),o))}function A(r,n){var t=m(n[1],n[0]),o=m(r,n[0]),e=m(_(q(o,t),2),o);return g(n[0],e)}var V=d,w=g,x=g,S=m,U=M,k=b,B=z,G=F,H=D,J=I,K=C,Q=L,W=N,X=Object.freeze({__proto__:null,rotateRad:function(r,n,t){return void 0===t?O(r,n):g(t,O(m(r,t),n))},rotateDeg:function(r,n,t){return void 0===t?R(r,n):g(t,R(m(r,t),n))},distanceToPoint:function(r,n){return v(m(r,n))},distanceToLine:y,reflectOverLine:A,compare:function(r,n,t){if(r.length!==n.length)return r.length-n.length;for(var e=0;e<r.length;e++)if(!o(r[e],n[e],t))return r[e]-n[e];return 0},is:V,addVector:w,addVectors:x,subtractVector:S,equal:U,polarRadFromCart:k,polarDegFromCart:B,cartFromPolarRad:G,cartFromPolarDeg:H,round:J,roundTo:K,floorTo:Q,ceilTo:W});var Y=Object.freeze({__proto__:null,distanceToPoint:function(r,n){return y(n,r)},reflectPoint:function(r,n){return A(n,r)},midpoint:function(r){return[(r[0][0]+r[1][0])/2,(r[0][1]+r[1][1])/2]},equal:function(r,n,t){var o=m(r[1],r[0]);return!!P(o,m(n[1],n[0]),t)&&(!!U(r[0],n[0])||P(o,m(n[0],r[0]),t))}});var Z=Object.freeze({__proto__:null,equal:function(r,n,t){var o=m(r[1],r[0]),e=m(n[1],n[0]),u=U(r[0],n[0]),a=T(o,e,t);return u&&a}});export{Y as line,c as number,X as point,Z as ray,E as vector};
+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
+
+var EPSILON = Math.pow(2, -42);
+function is$2(x) {
+  return _.isNumber(x) && !_.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) {
+  var 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) {
+  var tolerance = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : EPSILON;
+  var maxDenominator = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 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;
+
+  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 (!_.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
+  var zipped = _.zip(a, b);
+
+  var 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);
+
+  return zipped.map(arraySum);
+}
+function subtract(v1, v2) {
+  // $FlowFixMe[incompatible-call] underscore doesn't like $ReadOnlyArray
+  return _.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 _.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) {
+  var radius = length(v);
+  var 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);
+  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;
+  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;
+  return cartFromPolarRad$1(radius, theta * Math.PI / 180);
+} // Rotate vector
+
+function rotateRad$1(v, theta) {
+  var polar = polarRadFromCart$1(v);
+  var 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;
+  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) {
+  var 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) {
+  var lv = subtract(line[1], line[0]);
+  var pv = subtract(point, line[0]);
+  var projectedPv = projection(pv, lv);
+  var distancePv = subtract(projectedPv, pv);
+  return length(distancePv);
+} // 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);
+  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 (var 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)
+
+var addVector = add;
+var addVectors = add;
+var subtractVector = subtract;
+var equal$2 = equal$3; // Convert from cartesian to polar and back
+
+var polarRadFromCart = polarRadFromCart$1;
+var polarDegFromCart = polarDegFromCart$1;
+var cartFromPolarRad = cartFromPolarRad$1;
+var cartFromPolarDeg = cartFromPolarDeg$1; // Rounding
+
+var round = round$1;
+var roundTo = roundTo$1;
+var floorTo = floorTo$1;
+var 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
+  var v1 = subtract(line1[1], line1[0]);
+  var 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
+
+
+  var 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
+  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);
+  return sameOrigin && codirectional$1;
+}
+
+var ray = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    equal: equal
+});
+
+export { line, number, point, ray, vector };
 //# sourceMappingURL=index.js.map

package/dist/es/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\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\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: $ReadOnlyArray<number>): $ReadOnlyArray<number> {\n    return scale(v, 1 / length(v));\n}\n\n// Length/magnitude of a vector\nexport function length(v: $ReadOnlyArray<number>): number {\n    return Math.sqrt(dot(v, v));\n}\n// Dot product of two vectors\nexport function dot(\n    a: $ReadOnlyArray<number>,\n    b: $ReadOnlyArray<number>,\n): 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(\n    ...vecs: $ReadOnlyArray<$ReadOnlyArray<number>>\n): $ReadOnlyArray<number> {\n    // $FlowFixMe[incompatible-call] underscore doesn't like $ReadOnlyArray\n    const zipped = _.zip(...vecs);\n    return zipped.map(arraySum);\n}\n\nexport function subtract(\n    v1: $ReadOnlyArray<number>,\n    v2: $ReadOnlyArray<number>,\n): $ReadOnlyArray<number> {\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: $ReadOnlyArray<number>): $ReadOnlyArray<number> {\n    return v.map((x) => {\n        return -x;\n    });\n}\n\n// Scale a vector\nexport function scale(\n    v1: $ReadOnlyArray<number>,\n    scalar: number,\n): $ReadOnlyArray<number> {\n    return v1.map((x) => {\n        return x * scalar;\n    });\n}\n\nexport function equal(\n    v1: $ReadOnlyArray<number>,\n    v2: $ReadOnlyArray<number>,\n    tolerance?: number,\n): 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: $ReadOnlyArray<number>,\n    v2: $ReadOnlyArray<number>,\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(\n    v1: $ReadOnlyArray<number>,\n    v2: $ReadOnlyArray<number>,\n    tolerance?: number,\n): 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(\n    vec: $ReadOnlyArray<number>,\n    precision: $ReadOnlyArray<number> | number,\n): $ReadOnlyArray<number> {\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(\n    vec: $ReadOnlyArray<number>,\n    increment: $ReadOnlyArray<number> | number,\n): $ReadOnlyArray<number> {\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(\n    vec: $ReadOnlyArray<number>,\n    increment: $ReadOnlyArray<number> | number,\n): $ReadOnlyArray<number> {\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(\n    vec: $ReadOnlyArray<number>,\n    increment: $ReadOnlyArray<number> | number,\n): $ReadOnlyArray<number> {\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(\n    point: Point,\n    line: [Point, Point],\n): $ReadOnlyArray<number> /* TODO: convert to 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(\n    line: Line,\n    point: Point,\n): $ReadOnlyArray<number> /* TODO: convert to 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":"0BAQO,IAGMA,EAAkBC,KAAKC,IAAI,GAAI,IAErC,SAASC,EAAGC,GACf,OAAOC,EAAEC,SAASF,KAAOC,EAAEE,MAAMH,GAG9B,SAASI,EAAMJ,EAAWK,EAAWC,GAGxC,OAAS,MAALN,GAAkB,MAALK,EACNL,IAAMK,EAGbL,IAAMK,IAGO,MAAbC,IACAA,EApBiC,MAsB9BT,KAAKU,IAAIP,EAAIK,GAAKC,GAetB,SAASE,EAAMC,EAAaC,GACzBC,IAAAA,EAASd,KAAKC,IAAI,GAAIY,GACrBb,OAAAA,KAAKW,MAAMC,EAAME,GAAUA,EAK/B,SAASC,EAAQH,EAAaI,GAC1BhB,OAAAA,KAAKW,MAAMC,EAAMI,GAAaA,EAGlC,SAASC,EAAQL,EAAaI,GAC1BhB,OAAAA,KAAKkB,MAAMN,EAAMI,GAAaA,EAGlC,SAASG,EAAOP,EAAaI,GACzBhB,OAAAA,KAAKoB,KAAKR,EAAMI,GAAaA,wDArDC,iCAyBlC,SACHb,EACAM,GAEA,OAAOF,EAAMJ,EAAG,EAAGM,GAAa,EAAIT,KAAKU,IAAIP,GAAKA,aAG/C,SAAmBS,EAAaH,GACnC,OAAOF,EAAMP,KAAKW,MAAMC,GAAMA,EAAKH,oDAqChC,SACHY,GAWA,IAVAZ,IAAAA,yDAAoBV,EACpBuB,yDAAyB,IAIrBC,EAAI,CAAC,EAAG,GACRC,EAAI,CAAC,EAAG,GACRC,EAAIzB,KAAKkB,MAAMG,GACfK,EAAML,EAAUI,EAEbD,EAAE,IAAMF,GAAgB,CAC3B,GAAIf,EAAMgB,EAAE,GAAKC,EAAE,GAAIH,EAASZ,GACrB,MAAA,CAACc,EAAE,GAAIC,EAAE,IAEpBD,EAAI,CAACE,EAAIF,EAAE,GAAKA,EAAE,GAAIA,EAAE,IACxBC,EAAI,CAACC,EAAID,EAAE,GAAKA,EAAE,GAAIA,EAAE,IAExBE,EAAM,EAAIA,GADVD,EAAIzB,KAAKkB,MAAM,EAAIQ,IAMvB,MAAO,CAACL,EAAS,MC7FrB,SAASM,EAASC,GACd,OAAOA,EAAMC,QAAO,CAACC,EAAMC,IAAQD,EAAOC,GAAK,GAGnD,SAASC,EAAaJ,GAClB,OAAOA,EAAMC,QAAO,CAACC,EAAMC,IAAQD,EAAOC,GAAK,GAG5C,SAAS7B,EAAM+B,EAAwBC,GAC1C,QAAK9B,EAAE+B,QAAQF,WAGGG,IAAdF,GAA2BD,EAAII,SAAWH,IAGvCD,EAAIK,MAAMC,IAId,SAASC,EAAUC,GACfC,OAAAA,EAAMD,EAAG,EAAIJ,EAAOI,IAIxB,SAASJ,EAAOI,GACZzC,OAAAA,KAAK2C,KAAKC,EAAIH,EAAGA,IAGrB,SAASG,EACZnB,EACAoB,GAKOlB,OAAAA,EAFQvB,EAAE0C,IAAIrB,EAAGoB,GACEE,IAAIf,IAQ3B,SAASgB,IAIZ,IAAMC,EAAS7C,EAAE0C,kBACjB,OAAOG,EAAOF,IAAIpB,GAGf,SAASuB,EACZC,EACAC,GAGOhD,OAAAA,EAAE0C,IAAIK,EAAIC,GAAIL,KAAKM,GAAQA,EAAI,GAAKA,EAAI,KAG5C,SAASC,EAAOb,GACnB,OAAOA,EAAEM,KAAK5C,IACFA,IAKT,SAASuC,EACZS,EACAI,GAEA,OAAOJ,EAAGJ,KAAK5C,GACJA,EAAIoD,IAIZ,SAAShD,EACZ4C,EACAC,EACA3C,GAOA,OAAOL,EAAE0C,IAAIK,EAAIC,GAAId,OAAOkB,GACxBjB,EAAciB,EAAK,GAAIA,EAAK,GAAI/C,KAIjC,SAASgD,EACZN,EACAC,EACA3C,GAMI8B,SAAAA,EAAcF,EAAOc,GAAK,EAAG1C,KAC7B8B,EAAcF,EAAOe,GAAK,EAAG3C,KAQ1BF,EAHP4C,EAAKX,EAAUW,GACfC,EAAKZ,EAAUY,GAEM3C,GAGlB,SAASiD,EACZP,EACAC,EACA3C,GAEA,OACIgD,EAAcN,EAAIC,EAAI3C,IACtBgD,EAAcN,EAAIG,EAAOF,GAAK3C,GAK/B,SAASkD,EACZlB,GAEA,IAAMmB,EAASvB,EAAOI,GAClBoB,EAAQ7D,KAAK8D,MAAMrB,EAAE,GAAIA,EAAE,IAO/B,OAJIoB,EAAQ,IACRA,GAAS,EAAI7D,KAAK+D,IAGf,CAACH,EAAQC,GAIb,SAASG,EACZvB,GAEA,IAAMwB,EAAQN,EAAiBlB,GAC/B,MAAO,CAACwB,EAAM,GAAgB,IAAXA,EAAM,GAAYjE,KAAK+D,IASvC,SAASG,EACZN,GACAC,IAAAA,yDAAiB,EAEjB,MAAO,CAACD,EAAS5D,KAAKmE,IAAIN,GAAQD,EAAS5D,KAAKoE,IAAIP,IASjD,SAASQ,EACZT,GACAC,IAAAA,yDAAiB,EAEVK,OAAAA,EAAiBN,EAASC,EAAQ7D,KAAK+D,GAAM,KAIjD,SAASO,EACZ7B,EACAoB,GAEA,IAAMI,EAAQN,EAAiBlB,GACzB8B,EAAQN,EAAM,GAAKJ,EAClBK,OAAAA,EAAiBD,EAAM,GAAIM,GAG/B,SAASC,EACZ/B,EACAoB,GAEA,IAAMI,EAAQD,EAAiBvB,GACzB8B,EAAQN,EAAM,GAAKJ,EAClBQ,OAAAA,EAAiBJ,EAAM,GAAIM,GAI/B,SAASE,EACZtB,EACAC,GAEOpD,OAAAA,KAAK0E,KAAK9B,EAAIO,EAAIC,IAAOf,EAAOc,GAAMd,EAAOe,KAWjD,SAASuB,EACZxB,EACAC,GAGA,OAAOV,EAAMU,EADER,EAAIO,EAAIC,GAAMR,EAAIQ,EAAIA,IAKlC,SAASzC,EACZsB,EACApB,GAEOoB,OAAAA,EAAIc,KAAI,CAAC6B,EAAMC,IAGlBtC,EAAcqC,EAAM/D,EAAUgE,IAAMhE,KAKrC,SAASE,EACZkB,EACAjB,GAEOiB,OAAAA,EAAIc,KAAI,CAAC6B,EAAMC,IAGlBtC,EAAgBqC,EAAM5D,EAAU6D,IAAM7D,KAIvC,SAASC,EACZgB,EACAjB,GAEOiB,OAAAA,EAAIc,KAAI,CAAC6B,EAAMC,IAGlBtC,EAAgBqC,EAAM5D,EAAU6D,IAAM7D,KAIvC,SAASG,EACZc,EACAjB,GAEOiB,OAAAA,EAAIc,KAAI,CAAC6B,EAAMC,IAGlBtC,EAAeqC,EAAM5D,EAAU6D,IAAM7D,uQA1DtC,SACHmC,EACAC,GAEQqB,OAAmB,IAAnBA,EAAStB,EAAIC,GAAapD,KAAK+D,wDCvKpC,SAASe,EAAeC,EAAcC,GACzC,IAAMC,EAAKC,EAAiBF,EAAK,GAAIA,EAAK,IACpCG,EAAKD,EAAiBH,EAAOC,EAAK,IAGxC,OAAOE,EADYA,EADCA,EAAmBC,EAAIF,GACME,IAK9C,SAASC,EACZL,EACAC,GAEA,IAAMC,EAAKC,EAAiBF,EAAK,GAAIA,EAAK,IACpCG,EAAKD,EAAiBH,EAAOC,EAAK,IAElCK,EAAcH,EAAiBA,EADjBA,EAAmBC,EAAIF,GACqB,GAAIE,GAC7DD,OAAAA,EAAYF,EAAK,GAAIK,GA6BzB,IAAMnF,EAAKgF,EAGLI,EAAYJ,EACZK,EAAaL,EACbM,EAAiBN,EACjB3E,EAAQ2E,EAGRvB,EAAmBuB,EACnBlB,EAAmBkB,EACnBhB,EAAmBgB,EACnBb,EAAmBa,EAGnBvE,EAAQuE,EACRnE,EAAUmE,EACVjE,EAAUiE,EACV/D,EAAS+D,4CA5Ff,SAAmBH,EAAclB,EAAe4B,GAC/CA,YAAWrD,IAAXqD,EACOP,EAAkBH,EAAOlB,GAEzBqB,EACHO,EACAP,EAAkBA,EAAiBH,EAAOU,GAAS5B,eAKxD,SAAmBkB,EAAclB,EAAe4B,GAC/CA,YAAWrD,IAAXqD,EACOP,EAAkBH,EAAOlB,GAEzBqB,EACHO,EACAP,EAAkBA,EAAiBH,EAAOU,GAAS5B,qBAMxD,SAAyB6B,EAAeC,GAC3C,OAAOT,EAAeA,EAAiBQ,EAAQC,gDAiC5C,SACHD,EACAC,EACAC,GAEA,GAAIF,EAAOrD,SAAWsD,EAAOtD,OACzB,OAAOqD,EAAOrD,OAASsD,EAAOtD,OAElC,IAAK,IAAIwC,EAAI,EAAGA,EAAIa,EAAOrD,OAAQwC,IAC/B,IAAKtC,EAAcmD,EAAOb,GAAIc,EAAOd,GAAIe,GAC9BF,OAAAA,EAAOb,GAAKc,EAAOd,GAGlC,OAAO,iOCxEJ,SAAyBG,EAAYD,GACxC,OAAOc,EAAsBd,EAAOC,iBAGjC,SACHA,EACAD,GAEA,OAAOc,EAAuBd,EAAOC,aAGlC,SAAkBA,GACrB,MAAO,EAAEA,EAAK,GAAG,GAAKA,EAAK,GAAG,IAAM,GAAIA,EAAK,GAAG,GAAKA,EAAK,GAAG,IAAM,UAGhE,SAAec,EAAaC,EAAatF,GAI5C,IAAM0C,EAAK+B,EAAiBY,EAAM,GAAIA,EAAM,IAExC,QAACZ,EAAkB/B,EADZ+B,EAAiBa,EAAM,GAAIA,EAAM,IACbtF,OAI3BoF,EAAaC,EAAM,GAAIC,EAAM,KAM1Bb,EAAkB/B,EADE+B,EAAiBa,EAAM,GAAID,EAAM,IACXrF,iDC7B9C,SAAeuF,EAAWC,EAAWxF,GAExC,IAAM0C,EAAK+B,EAAiBc,EAAK,GAAIA,EAAK,IACpC5C,EAAK8B,EAAiBe,EAAK,GAAIA,EAAK,IAEpCC,EAAaL,EAAaG,EAAK,GAAIC,EAAK,IACxCxC,EAAgByB,EAAsB/B,EAAIC,EAAI3C,GAE7CyF,OAAAA,GAAczC"}
+{"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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"}