lakutata 2.0.82 → 2.0.83

package/vendor/Package.17.cjs

@@ -1,563 +1,563 @@
 "use strict";
 
-function linearRegression(r) {
-    var e;
+function r(r) {
     var t;
+    var e;
     var n = r.length;
     if (n === 1) {
-        e = 0;
-        t = r[0][1];
+        t = 0;
+        e = r[0][1];
     } else {
         var a = 0;
-        var i = 0;
         var o = 0;
+        var i = 0;
         var u = 0;
-        var s;
-        var l;
         var f;
-        for (var v = 0; v < n; v++) {
-            s = r[v];
-            l = s[0];
-            f = s[1];
-            a += l;
-            i += f;
-            o += l * l;
-            u += l * f;
-        }
-        e = (n * u - a * i) / (n * o - a * a);
-        t = i / n - e * a / n;
+        var v;
+        var h;
+        for (var s = 0; s < n; s++) {
+            f = r[s];
+            v = f[0];
+            h = f[1];
+            a += v;
+            o += h;
+            i += v * v;
+            u += v * h;
+        }
+        t = (n * u - a * o) / (n * i - a * a);
+        e = o / n - t * a / n;
     }
     return {
-        m: e,
-        b: t
+        m: t,
+        b: e
     };
 }
 
-function linearRegressionLine(r) {
-    return function(e) {
-        return r.b + r.m * e;
+function t(r) {
+    return function(t) {
+        return r.b + r.m * t;
     };
 }
 
-function sum(r) {
+function e(r) {
     if (r.length === 0) {
         return 0;
     }
-    var e = r[0];
-    var t = 0;
+    var t = r[0];
+    var e = 0;
     var n;
-    if (typeof e !== "number") {
+    if (typeof t !== "number") {
         return Number.NaN;
     }
     for (var a = 1; a < r.length; a++) {
         if (typeof r[a] !== "number") {
             return Number.NaN;
         }
-        n = e + r[a];
-        if (Math.abs(e) >= Math.abs(r[a])) {
-            t += e - n + r[a];
+        n = t + r[a];
+        if (Math.abs(t) >= Math.abs(r[a])) {
+            e += t - n + r[a];
         } else {
-            t += r[a] - n + e;
+            e += r[a] - n + t;
         }
-        e = n;
+        t = n;
     }
-    return e + t;
+    return t + e;
 }
 
-function mean(r) {
+function n(r) {
     if (r.length === 0) {
         throw new Error("mean requires at least one data point");
     }
-    return sum(r) / r.length;
+    return e(r) / r.length;
 }
 
-function sumNthPowerDeviations(r, e) {
-    var t = mean(r);
-    var n = 0;
-    var a;
+function a(r, t) {
+    var e = n(r);
+    var a = 0;
+    var o;
     var i;
-    if (e === 2) {
+    if (t === 2) {
         for (i = 0; i < r.length; i++) {
-            a = r[i] - t;
-            n += a * a;
+            o = r[i] - e;
+            a += o * o;
         }
     } else {
         for (i = 0; i < r.length; i++) {
-            n += Math.pow(r[i] - t, e);
+            a += Math.pow(r[i] - e, t);
         }
     }
-    return n;
+    return a;
 }
 
-function variance(r) {
+function o(r) {
     if (r.length === 0) {
         throw new Error("variance requires at least one data point");
     }
-    return sumNthPowerDeviations(r, 2) / r.length;
+    return a(r, 2) / r.length;
 }
 
-function standardDeviation(r) {
+function i(r) {
     if (r.length === 1) {
         return 0;
     }
-    var e = variance(r);
-    return Math.sqrt(e);
+    var t = o(r);
+    return Math.sqrt(t);
 }
 
-function rSquared(r, e) {
+function u(r, t) {
     if (r.length < 2) {
         return 1;
     }
-    var t = 0;
+    var e = 0;
     for (var n = 0; n < r.length; n++) {
-        t += r[n][1];
+        e += r[n][1];
     }
-    var a = t / r.length;
-    var i = 0;
-    for (var o = 0; o < r.length; o++) {
-        i += Math.pow(a - r[o][1], 2);
+    var a = e / r.length;
+    var o = 0;
+    for (var i = 0; i < r.length; i++) {
+        o += Math.pow(a - r[i][1], 2);
     }
     var u = 0;
-    for (var s = 0; s < r.length; s++) {
-        u += Math.pow(r[s][1] - e(r[s][0]), 2);
+    for (var f = 0; f < r.length; f++) {
+        u += Math.pow(r[f][1] - t(r[f][0]), 2);
     }
-    return 1 - u / i;
+    return 1 - u / o;
 }
 
-function modeSorted(r) {
+function f(r) {
     if (r.length === 0) {
         throw new Error("mode requires at least one data point");
     }
     if (r.length === 1) {
         return r[0];
     }
-    var e = r[0];
-    var t = Number.NaN;
+    var t = r[0];
+    var e = Number.NaN;
     var n = 0;
     var a = 1;
-    for (var i = 1; i < r.length + 1; i++) {
-        if (r[i] !== e) {
+    for (var o = 1; o < r.length + 1; o++) {
+        if (r[o] !== t) {
             if (a > n) {
                 n = a;
-                t = e;
+                e = t;
             }
             a = 1;
-            e = r[i];
+            t = r[o];
         } else {
             a++;
         }
     }
-    return t;
+    return e;
 }
 
-function numericSort(r) {
-    return r.slice().sort((function(r, e) {
-        return r - e;
+function v(r) {
+    return r.slice().sort((function(r, t) {
+        return r - t;
     }));
 }
 
-function mode(r) {
-    return modeSorted(numericSort(r));
+function h(r) {
+    return f(v(r));
 }
 
-function modeFast(r) {
-    var e = new Map;
-    var t;
+function s(r) {
+    var t = new Map;
+    var e;
     var n = 0;
     for (var a = 0; a < r.length; a++) {
-        var i = e.get(r[a]);
-        if (i === undefined) {
-            i = 1;
+        var o = t.get(r[a]);
+        if (o === undefined) {
+            o = 1;
         } else {
-            i++;
+            o++;
         }
-        if (i > n) {
-            t = r[a];
-            n = i;
+        if (o > n) {
+            e = r[a];
+            n = o;
         }
-        e.set(r[a], i);
+        t.set(r[a], o);
     }
     if (n === 0) {
         throw new Error("mode requires at last one data point");
     }
-    return t;
+    return e;
 }
 
-function min(r) {
+function l(r) {
     if (r.length === 0) {
         throw new Error("min requires at least one data point");
     }
-    var e = r[0];
-    for (var t = 1; t < r.length; t++) {
-        if (r[t] < e) {
-            e = r[t];
+    var t = r[0];
+    for (var e = 1; e < r.length; e++) {
+        if (r[e] < t) {
+            t = r[e];
         }
     }
-    return e;
+    return t;
 }
 
-function max(r) {
+function c(r) {
     if (r.length === 0) {
         throw new Error("max requires at least one data point");
     }
-    var e = r[0];
-    for (var t = 1; t < r.length; t++) {
-        if (r[t] > e) {
-            e = r[t];
+    var t = r[0];
+    for (var e = 1; e < r.length; e++) {
+        if (r[e] > t) {
+            t = r[e];
         }
     }
-    return e;
+    return t;
 }
 
-function extent(r) {
+function p(r) {
     if (r.length === 0) {
         throw new Error("extent requires at least one data point");
     }
-    var e = r[0];
     var t = r[0];
+    var e = r[0];
     for (var n = 1; n < r.length; n++) {
-        if (r[n] > t) {
-            t = r[n];
-        }
-        if (r[n] < e) {
+        if (r[n] > e) {
             e = r[n];
         }
+        if (r[n] < t) {
+            t = r[n];
+        }
     }
-    return [ e, t ];
+    return [ t, e ];
 }
 
-function minSorted(r) {
+function g(r) {
     return r[0];
 }
 
-function maxSorted(r) {
+function w(r) {
     return r[r.length - 1];
 }
 
-function extentSorted(r) {
+function M(r) {
     return [ r[0], r[r.length - 1] ];
 }
 
-function sumSimple(r) {
-    var e = 0;
-    for (var t = 0; t < r.length; t++) {
-        if (typeof r[t] !== "number") {
+function m(r) {
+    var t = 0;
+    for (var e = 0; e < r.length; e++) {
+        if (typeof r[e] !== "number") {
             return Number.NaN;
         }
-        e += r[t];
+        t += r[e];
     }
-    return e;
+    return t;
 }
 
-function product(r) {
-    var e = 1;
-    for (var t = 0; t < r.length; t++) {
-        e *= r[t];
+function d(r) {
+    var t = 1;
+    for (var e = 0; e < r.length; e++) {
+        t *= r[e];
     }
-    return e;
+    return t;
 }
 
-function quantileSorted(r, e) {
-    var t = r.length * e;
+function b(r, t) {
+    var e = r.length * t;
     if (r.length === 0) {
         throw new Error("quantile requires at least one data point.");
-    } else if (e < 0 || e > 1) {
+    } else if (t < 0 || t > 1) {
         throw new Error("quantiles must be between 0 and 1");
-    } else if (e === 1) {
+    } else if (t === 1) {
         return r[r.length - 1];
-    } else if (e === 0) {
+    } else if (t === 0) {
         return r[0];
-    } else if (t % 1 !== 0) {
-        return r[Math.ceil(t) - 1];
+    } else if (e % 1 !== 0) {
+        return r[Math.ceil(e) - 1];
     } else if (r.length % 2 === 0) {
-        return (r[t - 1] + r[t]) / 2;
+        return (r[e - 1] + r[e]) / 2;
     } else {
-        return r[t];
+        return r[e];
     }
 }
 
-function quickselect(r, e, t, n) {
-    t = t || 0;
+function x(r, t, e, n) {
+    e = e || 0;
     n = n || r.length - 1;
-    while (n > t) {
-        if (n - t > 600) {
-            var a = n - t + 1;
-            var i = e - t + 1;
-            var o = Math.log(a);
-            var u = .5 * Math.exp(2 * o / 3);
-            var s = .5 * Math.sqrt(o * u * (a - u) / a);
-            if (i - a / 2 < 0) {
-                s *= -1;
+    while (n > e) {
+        if (n - e > 600) {
+            var a = n - e + 1;
+            var o = t - e + 1;
+            var i = Math.log(a);
+            var u = .5 * Math.exp(2 * i / 3);
+            var f = .5 * Math.sqrt(i * u * (a - u) / a);
+            if (o - a / 2 < 0) {
+                f *= -1;
             }
-            var l = Math.max(t, Math.floor(e - i * u / a + s));
-            var f = Math.min(n, Math.floor(e + (a - i) * u / a + s));
-            quickselect(r, e, l, f);
+            var v = Math.max(e, Math.floor(t - o * u / a + f));
+            var h = Math.min(n, Math.floor(t + (a - o) * u / a + f));
+            x(r, t, v, h);
         }
-        var v = r[e];
-        var h = t;
+        var s = r[t];
+        var l = e;
         var c = n;
-        swap(r, t, e);
-        if (r[n] > v) {
-            swap(r, t, n);
+        q(r, e, t);
+        if (r[n] > s) {
+            q(r, e, n);
         }
-        while (h < c) {
-            swap(r, h, c);
-            h++;
+        while (l < c) {
+            q(r, l, c);
+            l++;
             c--;
-            while (r[h] < v) {
-                h++;
+            while (r[l] < s) {
+                l++;
             }
-            while (r[c] > v) {
+            while (r[c] > s) {
                 c--;
             }
         }
-        if (r[t] === v) {
-            swap(r, t, c);
+        if (r[e] === s) {
+            q(r, e, c);
         } else {
             c++;
-            swap(r, c, n);
+            q(r, c, n);
         }
-        if (c <= e) {
-            t = c + 1;
+        if (c <= t) {
+            e = c + 1;
         }
-        if (e <= c) {
+        if (t <= c) {
             n = c - 1;
         }
     }
 }
 
-function swap(r, e, t) {
-    var n = r[e];
-    r[e] = r[t];
-    r[t] = n;
+function q(r, t, e) {
+    var n = r[t];
+    r[t] = r[e];
+    r[e] = n;
 }
 
-function quantile(r, e) {
-    var t = r.slice();
-    if (Array.isArray(e)) {
-        multiQuantileSelect(t, e);
+function E(r, t) {
+    var e = r.slice();
+    if (Array.isArray(t)) {
+        N(e, t);
         var n = [];
-        for (var a = 0; a < e.length; a++) {
-            n[a] = quantileSorted(t, e[a]);
+        for (var a = 0; a < t.length; a++) {
+            n[a] = b(e, t[a]);
         }
         return n;
     } else {
-        var i = quantileIndex(t.length, e);
-        quantileSelect(t, i, 0, t.length - 1);
-        return quantileSorted(t, e);
+        var o = k(e.length, t);
+        y(e, o, 0, e.length - 1);
+        return b(e, t);
     }
 }
 
-function quantileSelect(r, e, t, n) {
-    if (e % 1 === 0) {
-        quickselect(r, e, t, n);
+function y(r, t, e, n) {
+    if (t % 1 === 0) {
+        x(r, t, e, n);
     } else {
-        e = Math.floor(e);
-        quickselect(r, e, t, n);
-        quickselect(r, e + 1, e + 1, n);
+        t = Math.floor(t);
+        x(r, t, e, n);
+        x(r, t + 1, t + 1, n);
     }
 }
 
-function multiQuantileSelect(r, e) {
-    var t = [ 0 ];
-    for (var n = 0; n < e.length; n++) {
-        t.push(quantileIndex(r.length, e[n]));
+function N(r, t) {
+    var e = [ 0 ];
+    for (var n = 0; n < t.length; n++) {
+        e.push(k(r.length, t[n]));
     }
-    t.push(r.length - 1);
-    t.sort(compare);
-    var a = [ 0, t.length - 1 ];
+    e.push(r.length - 1);
+    e.sort(I);
+    var a = [ 0, e.length - 1 ];
     while (a.length) {
-        var i = Math.ceil(a.pop());
-        var o = Math.floor(a.pop());
-        if (i - o <= 1) {
+        var o = Math.ceil(a.pop());
+        var i = Math.floor(a.pop());
+        if (o - i <= 1) {
             continue;
         }
-        var u = Math.floor((o + i) / 2);
-        quantileSelect(r, t[u], Math.floor(t[o]), Math.ceil(t[i]));
-        a.push(o, u, u, i);
+        var u = Math.floor((i + o) / 2);
+        y(r, e[u], Math.floor(e[i]), Math.ceil(e[o]));
+        a.push(i, u, u, o);
     }
 }
 
-function compare(r, e) {
-    return r - e;
+function I(r, t) {
+    return r - t;
 }
 
-function quantileIndex(r, e) {
-    var t = r * e;
-    if (e === 1) {
+function k(r, t) {
+    var e = r * t;
+    if (t === 1) {
         return r - 1;
-    } else if (e === 0) {
+    } else if (t === 0) {
         return 0;
-    } else if (t % 1 !== 0) {
-        return Math.ceil(t) - 1;
+    } else if (e % 1 !== 0) {
+        return Math.ceil(e) - 1;
     } else if (r % 2 === 0) {
-        return t - .5;
+        return e - .5;
     } else {
-        return t;
+        return e;
     }
 }
 
-function quantileRankSorted(r, e) {
-    if (e < r[0]) {
+function A(r, t) {
+    if (t < r[0]) {
         return 0;
     }
-    if (e > r[r.length - 1]) {
+    if (t > r[r.length - 1]) {
         return 1;
     }
-    var t = lowerBound(r, e);
-    if (r[t] !== e) {
-        return t / r.length;
+    var e = P(r, t);
+    if (r[e] !== t) {
+        return e / r.length;
     }
-    t++;
-    var n = upperBound(r, e);
-    if (n === t) {
-        return t / r.length;
+    e++;
+    var n = S(r, t);
+    if (n === e) {
+        return e / r.length;
     }
-    var a = n - t + 1;
-    var i = a * (n + t) / 2;
-    var o = i / a;
-    return o / r.length;
+    var a = n - e + 1;
+    var o = a * (n + e) / 2;
+    var i = o / a;
+    return i / r.length;
 }
 
-function lowerBound(r, e) {
-    var t = 0;
+function P(r, t) {
+    var e = 0;
     var n = 0;
     var a = r.length;
     while (n < a) {
-        t = n + a >>> 1;
-        if (e <= r[t]) {
-            a = t;
+        e = n + a >>> 1;
+        if (t <= r[e]) {
+            a = e;
         } else {
-            n = -~t;
+            n = -~e;
         }
     }
     return n;
 }
 
-function upperBound(r, e) {
-    var t = 0;
+function S(r, t) {
+    var e = 0;
     var n = 0;
     var a = r.length;
     while (n < a) {
-        t = n + a >>> 1;
-        if (e >= r[t]) {
-            n = -~t;
+        e = n + a >>> 1;
+        if (t >= r[e]) {
+            n = -~e;
         } else {
-            a = t;
+            a = e;
         }
     }
     return n;
 }
 
-function quantileRank(r, e) {
-    var t = numericSort(r);
-    return quantileRankSorted(t, e);
+function C(r, t) {
+    var e = v(r);
+    return A(e, t);
 }
 
-function interquartileRange(r) {
-    var e = quantile(r, .75);
-    var t = quantile(r, .25);
-    if (typeof e === "number" && typeof t === "number") {
-        return e - t;
+function _(r) {
+    var t = E(r, .75);
+    var e = E(r, .25);
+    if (typeof t === "number" && typeof e === "number") {
+        return t - e;
     }
 }
 
-function median(r) {
-    return +quantile(r, .5);
+function T(r) {
+    return +E(r, .5);
 }
 
-function medianAbsoluteDeviation(r) {
-    var e = median(r);
-    var t = [];
+function V(r) {
+    var t = T(r);
+    var e = [];
     for (var n = 0; n < r.length; n++) {
-        t.push(Math.abs(r[n] - e));
+        e.push(Math.abs(r[n] - t));
     }
-    return median(t);
+    return T(e);
 }
 
-function chunk(r, e) {
-    var t = [];
-    if (e < 1) {
+function D(r, t) {
+    var e = [];
+    if (t < 1) {
         throw new Error("chunk size must be a positive number");
     }
-    if (Math.floor(e) !== e) {
+    if (Math.floor(t) !== t) {
         throw new Error("chunk size must be an integer");
     }
-    for (var n = 0; n < r.length; n += e) {
-        t.push(r.slice(n, n + e));
+    for (var n = 0; n < r.length; n += t) {
+        e.push(r.slice(n, n + t));
     }
-    return t;
+    return e;
 }
 
-function sampleWithReplacement(r, e, t) {
+function L(r, t, e) {
     if (r.length === 0) {
         return [];
     }
-    t = t || Math.random;
+    e = e || Math.random;
     var n = r.length;
     var a = [];
-    for (var i = 0; i < e; i++) {
-        var o = Math.floor(t() * n);
-        a.push(r[o]);
+    for (var o = 0; o < t; o++) {
+        var i = Math.floor(e() * n);
+        a.push(r[i]);
     }
     return a;
 }
 
-function shuffleInPlace(r, e) {
-    e = e || Math.random;
-    var t = r.length;
+function R(r, t) {
+    t = t || Math.random;
+    var e = r.length;
     var n;
     var a;
-    while (t > 0) {
-        a = Math.floor(e() * t--);
-        n = r[t];
-        r[t] = r[a];
+    while (e > 0) {
+        a = Math.floor(t() * e--);
+        n = r[e];
+        r[e] = r[a];
         r[a] = n;
     }
     return r;
 }
 
-function shuffle(r, e) {
-    var t = r.slice();
-    return shuffleInPlace(t, e);
+function U(r, t) {
+    var e = r.slice();
+    return R(e, t);
 }
 
-function sample(r, e, t) {
-    var n = shuffle(r, t);
-    return n.slice(0, e);
+function z(r, t, e) {
+    var n = U(r, e);
+    return n.slice(0, t);
 }
 
-function makeMatrix(r, e) {
-    var t = [];
+function F(r, t) {
+    var e = [];
     for (var n = 0; n < r; n++) {
         var a = [];
-        for (var i = 0; i < e; i++) {
+        for (var o = 0; o < t; o++) {
             a.push(0);
         }
-        t.push(a);
+        e.push(a);
     }
-    return t;
+    return e;
 }
 
-function uniqueCountSorted(r) {
-    var e = 0;
-    var t;
+function O(r) {
+    var t = 0;
+    var e;
     for (var n = 0; n < r.length; n++) {
-        if (n === 0 || r[n] !== t) {
-            t = r[n];
-            e++;
+        if (n === 0 || r[n] !== e) {
+            e = r[n];
+            t++;
         }
     }
-    return e;
+    return t;
 }
 
-function ssq(r, e, t, n) {
+function X(r, t, e, n) {
     var a;
     if (r > 0) {
-        var i = (t[e] - t[r - 1]) / (e - r + 1);
-        a = n[e] - n[r - 1] - (e - r + 1) * i * i;
+        var o = (e[t] - e[r - 1]) / (t - r + 1);
+        a = n[t] - n[r - 1] - (t - r + 1) * o * o;
     } else {
-        a = n[e] - t[e] * t[e] / (e + 1);
+        a = n[t] - e[t] * e[t] / (t + 1);
     }
     if (a < 0) {
         return 0;
@@ -565,573 +565,573 @@ function ssq(r, e, t, n) {
     return a;
 }
 
-function fillMatrixColumn(r, e, t, n, a, i, o) {
-    if (r > e) {
+function Y(r, t, e, n, a, o, i) {
+    if (r > t) {
         return;
     }
-    var u = Math.floor((r + e) / 2);
-    n[t][u] = n[t - 1][u - 1];
-    a[t][u] = u;
-    var s = t;
-    if (r > t) {
-        s = Math.max(s, a[t][r - 1] || 0);
+    var u = Math.floor((r + t) / 2);
+    n[e][u] = n[e - 1][u - 1];
+    a[e][u] = u;
+    var f = e;
+    if (r > e) {
+        f = Math.max(f, a[e][r - 1] || 0);
     }
-    s = Math.max(s, a[t - 1][u] || 0);
-    var l = u - 1;
-    if (e < n[0].length - 1) {
-        l = Math.min(l, a[t][e + 1] || 0);
+    f = Math.max(f, a[e - 1][u] || 0);
+    var v = u - 1;
+    if (t < n[0].length - 1) {
+        v = Math.min(v, a[e][t + 1] || 0);
     }
-    var f;
-    var v;
     var h;
+    var s;
+    var l;
     var c;
-    for (var p = l; p >= s; --p) {
-        f = ssq(p, u, i, o);
-        if (f + n[t - 1][s - 1] >= n[t][u]) {
+    for (var p = v; p >= f; --p) {
+        h = X(p, u, o, i);
+        if (h + n[e - 1][f - 1] >= n[e][u]) {
             break;
         }
-        v = ssq(s, u, i, o);
-        h = v + n[t - 1][s - 1];
-        if (h < n[t][u]) {
-            n[t][u] = h;
-            a[t][u] = s;
+        s = X(f, u, o, i);
+        l = s + n[e - 1][f - 1];
+        if (l < n[e][u]) {
+            n[e][u] = l;
+            a[e][u] = f;
         }
-        s++;
-        c = f + n[t - 1][p - 1];
-        if (c < n[t][u]) {
-            n[t][u] = c;
-            a[t][u] = p;
+        f++;
+        c = h + n[e - 1][p - 1];
+        if (c < n[e][u]) {
+            n[e][u] = c;
+            a[e][u] = p;
         }
     }
-    fillMatrixColumn(r, u - 1, t, n, a, i, o);
-    fillMatrixColumn(u + 1, e, t, n, a, i, o);
+    Y(r, u - 1, e, n, a, o, i);
+    Y(u + 1, t, e, n, a, o, i);
 }
 
-function fillMatrices(r, e, t) {
-    var n = e[0].length;
+function j(r, t, e) {
+    var n = t[0].length;
     var a = r[Math.floor(n / 2)];
-    var i = [];
     var o = [];
-    for (var u = 0, s = void 0; u < n; ++u) {
-        s = r[u] - a;
+    var i = [];
+    for (var u = 0, f = void 0; u < n; ++u) {
+        f = r[u] - a;
         if (u === 0) {
-            i.push(s);
-            o.push(s * s);
+            o.push(f);
+            i.push(f * f);
         } else {
-            i.push(i[u - 1] + s);
-            o.push(o[u - 1] + s * s);
+            o.push(o[u - 1] + f);
+            i.push(i[u - 1] + f * f);
         }
-        e[0][u] = ssq(0, u, i, o);
-        t[0][u] = 0;
+        t[0][u] = X(0, u, o, i);
+        e[0][u] = 0;
     }
-    var l;
-    for (var f = 1; f < e.length; ++f) {
-        if (f < e.length - 1) {
-            l = f;
+    var v;
+    for (var h = 1; h < t.length; ++h) {
+        if (h < t.length - 1) {
+            v = h;
         } else {
-            l = n - 1;
+            v = n - 1;
         }
-        fillMatrixColumn(l, n - 1, f, e, t, i, o);
+        Y(v, n - 1, h, t, e, o, i);
     }
 }
 
-function ckmeans(r, e) {
-    if (e > r.length) {
+function K(r, t) {
+    if (t > r.length) {
         throw new Error("cannot generate more classes than there are data values");
     }
-    var t = numericSort(r);
-    var n = uniqueCountSorted(t);
+    var e = v(r);
+    var n = O(e);
     if (n === 1) {
-        return [ t ];
+        return [ e ];
     }
-    var a = makeMatrix(e, t.length);
-    var i = makeMatrix(e, t.length);
-    fillMatrices(t, a, i);
-    var o = [];
-    var u = i[0].length - 1;
-    for (var s = i.length - 1; s >= 0; s--) {
-        var l = i[s][u];
-        o[s] = t.slice(l, u + 1);
-        if (s > 0) {
-            u = l - 1;
+    var a = F(t, e.length);
+    var o = F(t, e.length);
+    j(e, a, o);
+    var i = [];
+    var u = o[0].length - 1;
+    for (var f = o.length - 1; f >= 0; f--) {
+        var h = o[f][u];
+        i[f] = e.slice(h, u + 1);
+        if (f > 0) {
+            u = h - 1;
         }
     }
-    return o;
+    return i;
 }
 
-function jenksBreaks(r, e, t) {
+function W(r, t, e) {
     var n = r.length;
     var a = [];
-    var i = t;
-    a[t] = r[r.length - 1];
-    while (i > 0) {
-        a[i - 1] = r[e[n][i] - 1];
-        n = e[n][i] - 1;
-        i--;
+    var o = e;
+    a[e] = r[r.length - 1];
+    while (o > 0) {
+        a[o - 1] = r[t[n][o] - 1];
+        n = t[n][o] - 1;
+        o--;
     }
     return a;
 }
 
-function jenksMatrices(r, e) {
-    var t = [];
+function B(r, t) {
+    var e = [];
     var n = [];
     var a;
-    var i;
-    var o = 0;
+    var o;
+    var i = 0;
     for (a = 0; a < r.length + 1; a++) {
         var u = [];
-        var s = [];
-        for (i = 0; i < e + 1; i++) {
+        var f = [];
+        for (o = 0; o < t + 1; o++) {
             u.push(0);
-            s.push(0);
+            f.push(0);
         }
-        t.push(u);
-        n.push(s);
+        e.push(u);
+        n.push(f);
     }
-    for (a = 1; a < e + 1; a++) {
-        t[1][a] = 1;
+    for (a = 1; a < t + 1; a++) {
+        e[1][a] = 1;
         n[1][a] = 0;
-        for (i = 2; i < r.length + 1; i++) {
-            n[i][a] = Number.POSITIVE_INFINITY;
+        for (o = 2; o < r.length + 1; o++) {
+            n[o][a] = Number.POSITIVE_INFINITY;
         }
     }
-    for (var l = 2; l < r.length + 1; l++) {
-        var f = 0;
-        var v = 0;
+    for (var v = 2; v < r.length + 1; v++) {
         var h = 0;
+        var s = 0;
+        var l = 0;
         var c = 0;
-        for (var p = 1; p < l + 1; p++) {
-            var m = l - p + 1;
-            var g = r[m - 1];
-            h++;
-            f += g;
-            v += g * g;
-            o = v - f * f / h;
-            c = m - 1;
+        for (var p = 1; p < v + 1; p++) {
+            var g = v - p + 1;
+            var w = r[g - 1];
+            l++;
+            h += w;
+            s += w * w;
+            i = s - h * h / l;
+            c = g - 1;
             if (c !== 0) {
-                for (i = 2; i < e + 1; i++) {
-                    if (n[l][i] >= o + n[c][i - 1]) {
-                        t[l][i] = m;
-                        n[l][i] = o + n[c][i - 1];
+                for (o = 2; o < t + 1; o++) {
+                    if (n[v][o] >= i + n[c][o - 1]) {
+                        e[v][o] = g;
+                        n[v][o] = i + n[c][o - 1];
                     }
                 }
             }
         }
-        t[l][1] = 1;
-        n[l][1] = o;
+        e[v][1] = 1;
+        n[v][1] = i;
     }
     return {
-        lowerClassLimits: t,
+        lowerClassLimits: e,
         varianceCombinations: n
     };
 }
 
-function jenks(r, e) {
-    if (e > r.length) {
+function G(r, t) {
+    if (t > r.length) {
         return null;
     }
-    r = r.slice().sort((function(r, e) {
-        return r - e;
+    r = r.slice().sort((function(r, t) {
+        return r - t;
     }));
-    var t = jenksMatrices(r, e);
-    var n = t.lowerClassLimits;
-    return jenksBreaks(r, n, e);
+    var e = B(r, t);
+    var n = e.lowerClassLimits;
+    return W(r, n, t);
 }
 
-function equalIntervalBreaks(r, e) {
+function H(r, t) {
     if (r.length < 2) {
         return r;
     }
-    var t = min(r);
-    var n = max(r);
-    var a = [ t ];
-    var i = (n - t) / e;
-    for (var o = 1; o < e; o++) {
-        a.push(a[0] + i * o);
+    var e = l(r);
+    var n = c(r);
+    var a = [ e ];
+    var o = (n - e) / t;
+    for (var i = 1; i < t; i++) {
+        a.push(a[0] + o * i);
     }
     a.push(n);
     return a;
 }
 
-function sampleCovariance(r, e) {
-    if (r.length !== e.length) {
+function J(r, t) {
+    if (r.length !== t.length) {
         throw new Error("sampleCovariance requires samples with equal lengths");
     }
     if (r.length < 2) {
         throw new Error("sampleCovariance requires at least two data points in each sample");
     }
-    var t = mean(r);
-    var n = mean(e);
-    var a = 0;
+    var e = n(r);
+    var a = n(t);
+    var o = 0;
     for (var i = 0; i < r.length; i++) {
-        a += (r[i] - t) * (e[i] - n);
+        o += (r[i] - e) * (t[i] - a);
     }
-    var o = r.length - 1;
-    return a / o;
+    var u = r.length - 1;
+    return o / u;
 }
 
-function sampleVariance(r) {
+function Q(r) {
     if (r.length < 2) {
         throw new Error("sampleVariance requires at least two data points");
     }
-    var e = sumNthPowerDeviations(r, 2);
-    var t = r.length - 1;
-    return e / t;
+    var t = a(r, 2);
+    var e = r.length - 1;
+    return t / e;
 }
 
-function sampleStandardDeviation(r) {
-    var e = sampleVariance(r);
-    return Math.sqrt(e);
+function Z(r) {
+    var t = Q(r);
+    return Math.sqrt(t);
 }
 
-function sampleCorrelation(r, e) {
-    var t = sampleCovariance(r, e);
-    var n = sampleStandardDeviation(r);
-    var a = sampleStandardDeviation(e);
-    return t / n / a;
+function $(r, t) {
+    var e = J(r, t);
+    var n = Z(r);
+    var a = Z(t);
+    return e / n / a;
 }
 
-function sampleRankCorrelation(r, e) {
-    var t = r.map((function(r, e) {
-        return [ r, e ];
-    })).sort((function(r, e) {
-        return r[0] - e[0];
+function rr(r, t) {
+    var e = r.map((function(r, t) {
+        return [ r, t ];
+    })).sort((function(r, t) {
+        return r[0] - t[0];
     })).map((function(r) {
         return r[1];
     }));
-    var n = e.map((function(r, e) {
-        return [ r, e ];
-    })).sort((function(r, e) {
-        return r[0] - e[0];
+    var n = t.map((function(r, t) {
+        return [ r, t ];
+    })).sort((function(r, t) {
+        return r[0] - t[0];
     })).map((function(r) {
         return r[1];
     }));
-    var a = Array(t.length);
-    var i = Array(t.length);
-    for (var o = 0; o < t.length; o++) {
-        a[t[o]] = o;
-        i[n[o]] = o;
+    var a = Array(e.length);
+    var o = Array(e.length);
+    for (var i = 0; i < e.length; i++) {
+        a[e[i]] = i;
+        o[n[i]] = i;
     }
-    return sampleCorrelation(a, i);
+    return $(a, o);
 }
 
-function sampleSkewness(r) {
+function tr(r) {
     if (r.length < 3) {
         throw new Error("sampleSkewness requires at least three data points");
     }
-    var e = mean(r);
-    var t;
-    var n = 0;
+    var t = n(r);
+    var e;
     var a = 0;
+    var o = 0;
     for (var i = 0; i < r.length; i++) {
-        t = r[i] - e;
-        n += t * t;
-        a += t * t * t;
+        e = r[i] - t;
+        a += e * e;
+        o += e * e * e;
     }
-    var o = r.length - 1;
-    var u = Math.sqrt(n / o);
-    var s = r.length;
-    var l = Math.pow(u, 3);
-    return s * a / ((s - 1) * (s - 2) * l);
+    var u = r.length - 1;
+    var f = Math.sqrt(a / u);
+    var v = r.length;
+    var h = Math.pow(f, 3);
+    return v * o / ((v - 1) * (v - 2) * h);
 }
 
-function sampleKurtosis(r) {
-    var e = r.length;
-    if (e < 4) {
+function er(r) {
+    var t = r.length;
+    if (t < 4) {
         throw new Error("sampleKurtosis requires at least four data points");
     }
-    var t = mean(r);
-    var n;
-    var a = 0;
+    var e = n(r);
+    var a;
+    var o = 0;
     var i = 0;
-    for (var o = 0; o < e; o++) {
-        n = r[o] - t;
-        a += n * n;
-        i += n * n * n * n;
+    for (var u = 0; u < t; u++) {
+        a = r[u] - e;
+        o += a * a;
+        i += a * a * a * a;
     }
-    return (e - 1) / ((e - 2) * (e - 3)) * (e * (e + 1) * i / (a * a) - 3 * (e - 1));
+    return (t - 1) / ((t - 2) * (t - 3)) * (t * (t + 1) * i / (o * o) - 3 * (t - 1));
 }
 
-function permutationsHeap(r) {
-    var e = new Array(r.length);
-    var t = [ r.slice() ];
+function nr(r) {
+    var t = new Array(r.length);
+    var e = [ r.slice() ];
     for (var n = 0; n < r.length; n++) {
-        e[n] = 0;
+        t[n] = 0;
     }
     for (var a = 0; a < r.length; ) {
-        if (e[a] < a) {
-            var i = 0;
+        if (t[a] < a) {
+            var o = 0;
             if (a % 2 !== 0) {
-                i = e[a];
+                o = t[a];
             }
-            var o = r[i];
-            r[i] = r[a];
-            r[a] = o;
-            t.push(r.slice());
-            e[a]++;
+            var i = r[o];
+            r[o] = r[a];
+            r[a] = i;
+            e.push(r.slice());
+            t[a]++;
             a = 0;
         } else {
-            e[a] = 0;
+            t[a] = 0;
             a++;
         }
     }
-    return t;
+    return e;
 }
 
-function combinations(r, e) {
-    var t;
+function ar(r, t) {
+    var e;
     var n;
     var a = [];
-    var i;
     var o;
-    for (t = 0; t < r.length; t++) {
-        if (e === 1) {
-            a.push([ r[t] ]);
+    var i;
+    for (e = 0; e < r.length; e++) {
+        if (t === 1) {
+            a.push([ r[e] ]);
         } else {
-            i = combinations(r.slice(t + 1, r.length), e - 1);
-            for (n = 0; n < i.length; n++) {
-                o = i[n];
-                o.unshift(r[t]);
-                a.push(o);
+            o = ar(r.slice(e + 1, r.length), t - 1);
+            for (n = 0; n < o.length; n++) {
+                i = o[n];
+                i.unshift(r[e]);
+                a.push(i);
             }
         }
     }
     return a;
 }
 
-function combinationsReplacement(r, e) {
-    var t = [];
+function or(r, t) {
+    var e = [];
     for (var n = 0; n < r.length; n++) {
-        if (e === 1) {
-            t.push([ r[n] ]);
+        if (t === 1) {
+            e.push([ r[n] ]);
         } else {
-            var a = combinationsReplacement(r.slice(n, r.length), e - 1);
-            for (var i = 0; i < a.length; i++) {
-                t.push([ r[n] ].concat(a[i]));
+            var a = or(r.slice(n, r.length), t - 1);
+            for (var o = 0; o < a.length; o++) {
+                e.push([ r[n] ].concat(a[o]));
             }
         }
     }
-    return t;
+    return e;
 }
 
-function addToMean(r, e, t) {
-    return r + (t - r) / (e + 1);
+function ir(r, t, e) {
+    return r + (e - r) / (t + 1);
 }
 
-function combineMeans(r, e, t, n) {
-    return (r * e + t * n) / (e + n);
+function ur(r, t, e, n) {
+    return (r * t + e * n) / (t + n);
 }
 
-function combineVariances(r, e, t, n, a, i) {
-    var o = combineMeans(e, t, a, i);
-    return (t * (r + Math.pow(e - o, 2)) + i * (n + Math.pow(a - o, 2))) / (t + i);
+function fr(r, t, e, n, a, o) {
+    var i = ur(t, e, a, o);
+    return (e * (r + Math.pow(t - i, 2)) + o * (n + Math.pow(a - i, 2))) / (e + o);
 }
 
-function geometricMean(r) {
+function vr(r) {
     if (r.length === 0) {
         throw new Error("geometricMean requires at least one data point");
     }
-    var e = 1;
-    for (var t = 0; t < r.length; t++) {
-        if (r[t] < 0) {
+    var t = 1;
+    for (var e = 0; e < r.length; e++) {
+        if (r[e] < 0) {
             throw new Error("geometricMean requires only non-negative numbers as input");
         }
-        e *= r[t];
+        t *= r[e];
     }
-    return Math.pow(e, 1 / r.length);
+    return Math.pow(t, 1 / r.length);
 }
 
-function logAverage(r) {
+function hr(r) {
     if (r.length === 0) {
         throw new Error("logAverage requires at least one data point");
     }
-    var e = 0;
-    for (var t = 0; t < r.length; t++) {
-        if (r[t] < 0) {
+    var t = 0;
+    for (var e = 0; e < r.length; e++) {
+        if (r[e] < 0) {
             throw new Error("logAverage requires only non-negative numbers as input");
         }
-        e += Math.log(r[t]);
+        t += Math.log(r[e]);
     }
-    return Math.exp(e / r.length);
+    return Math.exp(t / r.length);
 }
 
-function harmonicMean(r) {
+function sr(r) {
     if (r.length === 0) {
         throw new Error("harmonicMean requires at least one data point");
     }
-    var e = 0;
-    for (var t = 0; t < r.length; t++) {
-        if (r[t] <= 0) {
+    var t = 0;
+    for (var e = 0; e < r.length; e++) {
+        if (r[e] <= 0) {
             throw new Error("harmonicMean requires only positive numbers as input");
         }
-        e += 1 / r[t];
+        t += 1 / r[e];
     }
-    return r.length / e;
+    return r.length / t;
 }
 
-function meanSimple(r) {
+function lr(r) {
     if (r.length === 0) {
         throw new Error("meanSimple requires at least one data point");
     }
-    return sumSimple(r) / r.length;
+    return m(r) / r.length;
 }
 
-function medianSorted(r) {
-    return quantileSorted(r, .5);
+function cr(r) {
+    return b(r, .5);
 }
 
-function subtractFromMean(r, e, t) {
-    return (r * e - t) / (e - 1);
+function pr(r, t, e) {
+    return (r * t - e) / (t - 1);
 }
 
-function rootMeanSquare(r) {
+function gr(r) {
     if (r.length === 0) {
         throw new Error("rootMeanSquare requires at least one data point");
     }
-    var e = 0;
-    for (var t = 0; t < r.length; t++) {
-        e += Math.pow(r[t], 2);
+    var t = 0;
+    for (var e = 0; e < r.length; e++) {
+        t += Math.pow(r[e], 2);
     }
-    return Math.sqrt(e / r.length);
+    return Math.sqrt(t / r.length);
 }
 
-function coefficientOfVariation(r) {
-    return sampleStandardDeviation(r) / mean(r);
+function wr(r) {
+    return Z(r) / n(r);
 }
 
-function tTest(r, e) {
-    var t = mean(r);
-    var n = standardDeviation(r);
-    var a = Math.sqrt(r.length);
-    return (t - e) / (n / a);
+function Mr(r, t) {
+    var e = n(r);
+    var a = i(r);
+    var o = Math.sqrt(r.length);
+    return (e - t) / (a / o);
 }
 
-function tTestTwoSample(r, e, t) {
-    var n = r.length;
-    var a = e.length;
-    if (!n || !a) {
+function mr(r, t, e) {
+    var a = r.length;
+    var o = t.length;
+    if (!a || !o) {
         return null;
     }
-    if (!t) {
-        t = 0;
+    if (!e) {
+        e = 0;
     }
-    var i = mean(r);
-    var o = mean(e);
-    var u = sampleVariance(r);
-    var s = sampleVariance(e);
-    if (typeof i === "number" && typeof o === "number" && typeof u === "number" && typeof s === "number") {
-        var l = ((n - 1) * u + (a - 1) * s) / (n + a - 2);
-        return (i - o - t) / Math.sqrt(l * (1 / n + 1 / a));
+    var i = n(r);
+    var u = n(t);
+    var f = Q(r);
+    var v = Q(t);
+    if (typeof i === "number" && typeof u === "number" && typeof f === "number" && typeof v === "number") {
+        var h = ((a - 1) * f + (o - 1) * v) / (a + o - 2);
+        return (i - u - e) / Math.sqrt(h * (1 / a + 1 / o));
     }
 }
 
-function wilcoxonRankSum(r, e) {
-    if (!r.length || !e.length) {
+function dr(r, t) {
+    if (!r.length || !t.length) {
         throw new Error("Neither sample can be empty");
     }
-    var t = r.map((function(r) {
+    var e = r.map((function(r) {
         return {
             label: "x",
             value: r
         };
-    })).concat(e.map((function(r) {
+    })).concat(t.map((function(r) {
         return {
             label: "y",
             value: r
         };
-    }))).sort((function(r, e) {
-        return r.value - e.value;
+    }))).sort((function(r, t) {
+        return r.value - t.value;
     }));
-    for (var n = 0; n < t.length; n++) {
-        t[n].rank = n;
-    }
-    var a = [ t[0].rank ];
-    for (var i = 1; i < t.length; i++) {
-        if (t[i].value === t[i - 1].value) {
-            a.push(t[i].rank);
-            if (i === t.length - 1) {
-                replaceRanksInPlace(t, a);
+    for (var n = 0; n < e.length; n++) {
+        e[n].rank = n;
+    }
+    var a = [ e[0].rank ];
+    for (var o = 1; o < e.length; o++) {
+        if (e[o].value === e[o - 1].value) {
+            a.push(e[o].rank);
+            if (o === e.length - 1) {
+                i(e, a);
             }
         } else if (a.length > 1) {
-            replaceRanksInPlace(t, a);
+            i(e, a);
         } else {
-            a = [ t[i].rank ];
+            a = [ e[o].rank ];
         }
     }
-    function replaceRanksInPlace(r, e) {
-        var t = (e[0] + e[e.length - 1]) / 2;
-        for (var n = 0; n < e.length; n++) {
-            r[e[n]].rank = t;
+    function i(r, t) {
+        var e = (t[0] + t[t.length - 1]) / 2;
+        for (var n = 0; n < t.length; n++) {
+            r[t[n]].rank = e;
         }
     }
-    var o = 0;
-    for (var u = 0; u < t.length; u++) {
-        var s = t[u];
-        if (s.label === "x") {
-            o += s.rank + 1;
+    var u = 0;
+    for (var f = 0; f < e.length; f++) {
+        var v = e[f];
+        if (v.label === "x") {
+            u += v.rank + 1;
         }
     }
-    return o;
+    return u;
 }
 
-var r = function BayesianClassifier() {
+var br = function r() {
     this.totalCount = 0;
     this.data = {};
 };
 
-r.prototype.train = function train(r, e) {
+br.prototype.train = function r(t, e) {
     if (!this.data[e]) {
         this.data[e] = {};
     }
-    for (var t in r) {
-        var n = r[t];
-        if (this.data[e][t] === undefined) {
-            this.data[e][t] = {};
+    for (var n in t) {
+        var a = t[n];
+        if (this.data[e][n] === undefined) {
+            this.data[e][n] = {};
         }
-        if (this.data[e][t][n] === undefined) {
-            this.data[e][t][n] = 0;
+        if (this.data[e][n][a] === undefined) {
+            this.data[e][n][a] = 0;
         }
-        this.data[e][t][n]++;
+        this.data[e][n][a]++;
     }
     this.totalCount++;
 };
 
-r.prototype.score = function score(r) {
+br.prototype.score = function r(t) {
     var e = {};
-    var t;
-    for (var n in r) {
-        var a = r[n];
-        for (t in this.data) {
-            e[t] = {};
-            if (this.data[t][n]) {
-                e[t][n + "_" + a] = (this.data[t][n][a] || 0) / this.totalCount;
+    var n;
+    for (var a in t) {
+        var o = t[a];
+        for (n in this.data) {
+            e[n] = {};
+            if (this.data[n][a]) {
+                e[n][a + "_" + o] = (this.data[n][a][o] || 0) / this.totalCount;
             } else {
-                e[t][n + "_" + a] = 0;
+                e[n][a + "_" + o] = 0;
             }
         }
     }
     var i = {};
-    for (t in e) {
-        i[t] = 0;
-        for (var o in e[t]) {
-            i[t] += e[t][o];
+    for (n in e) {
+        i[n] = 0;
+        for (var u in e[n]) {
+            i[n] += e[n][u];
         }
     }
     return i;
 };
 
-var e = function PerceptronModel() {
+var xr = function r() {
     this.weights = [];
     this.bias = 0;
 };
 
-e.prototype.predict = function predict(r) {
-    if (r.length !== this.weights.length) {
+xr.prototype.predict = function r(t) {
+    if (t.length !== this.weights.length) {
         return null;
     }
     var e = 0;
-    for (var t = 0; t < this.weights.length; t++) {
-        e += this.weights[t] * r[t];
+    for (var n = 0; n < this.weights.length; n++) {
+        e += this.weights[n] * t[n];
     }
     e += this.bias;
     if (e > 0) {
@@ -1141,121 +1141,121 @@ e.prototype.predict = function predict(r) {
     }
 };
 
-e.prototype.train = function train(r, e) {
+xr.prototype.train = function r(t, e) {
     if (e !== 0 && e !== 1) {
         return null;
     }
-    if (r.length !== this.weights.length) {
-        this.weights = r;
+    if (t.length !== this.weights.length) {
+        this.weights = t;
         this.bias = 1;
     }
-    var t = this.predict(r);
-    if (typeof t === "number" && t !== e) {
-        var n = e - t;
-        for (var a = 0; a < this.weights.length; a++) {
-            this.weights[a] += n * r[a];
+    var n = this.predict(t);
+    if (typeof n === "number" && n !== e) {
+        var a = e - n;
+        for (var o = 0; o < this.weights.length; o++) {
+            this.weights[o] += a * t[o];
         }
-        this.bias += n;
+        this.bias += a;
     }
     return this;
 };
 
-var t = 1e-4;
+var qr = 1e-4;
 
-function factorial(r) {
+function Er(r) {
     if (r < 0) {
         throw new Error("factorial requires a non-negative value");
     }
     if (Math.floor(r) !== r) {
         throw new Error("factorial requires an integer input");
     }
-    var e = 1;
-    for (var t = 2; t <= r; t++) {
-        e *= t;
+    var t = 1;
+    for (var e = 2; e <= r; e++) {
+        t *= e;
     }
-    return e;
+    return t;
 }
 
-function gamma(r) {
+function yr(r) {
     if (Number.isInteger(r)) {
         if (r <= 0) {
             return Number.NaN;
         } else {
-            return factorial(r - 1);
+            return Er(r - 1);
         }
     }
     r--;
     if (r < 0) {
-        return Math.PI / (Math.sin(Math.PI * -r) * gamma(-r));
+        return Math.PI / (Math.sin(Math.PI * -r) * yr(-r));
     } else {
-        var e = Math.pow(r / Math.E, r) * Math.sqrt(2 * Math.PI * (r + 1 / 6));
-        var t = r + 1 / 4;
-        var n = 1 + 1 / 144 / Math.pow(t, 2) - 1 / 12960 / Math.pow(t, 3) - 257 / 207360 / Math.pow(t, 4) - 52 / 2612736 / Math.pow(t, 5) + 5741173 / 9405849600 / Math.pow(t, 6) + 37529 / 18811699200 / Math.pow(t, 7);
-        return e * n;
+        var t = Math.pow(r / Math.E, r) * Math.sqrt(2 * Math.PI * (r + 1 / 6));
+        var e = r + 1 / 4;
+        var n = 1 + 1 / 144 / Math.pow(e, 2) - 1 / 12960 / Math.pow(e, 3) - 257 / 207360 / Math.pow(e, 4) - 52 / 2612736 / Math.pow(e, 5) + 5741173 / 9405849600 / Math.pow(e, 6) + 37529 / 18811699200 / Math.pow(e, 7);
+        return t * n;
     }
 }
 
-var n = [ .9999999999999971, 57.15623566586292, -59.59796035547549, 14.136097974741746, -.4919138160976202, 3399464998481189e-20, 4652362892704858e-20, -9837447530487956e-20, .0001580887032249125, -.00021026444172410488, .00021743961811521265, -.0001643181065367639, 8441822398385275e-20, -26190838401581408e-21, 36899182659531625e-22 ];
+var Nr = [ .9999999999999971, 57.15623566586292, -59.59796035547549, 14.136097974741746, -.4919138160976202, 3399464998481189e-20, 4652362892704858e-20, -9837447530487956e-20, .0001580887032249125, -.00021026444172410488, .00021743961811521265, -.0001643181065367639, 8441822398385275e-20, -26190838401581408e-21, 36899182659531625e-22 ];
 
-var a = 607 / 128;
+var Ir = 607 / 128;
 
-var i = Math.log(Math.sqrt(2 * Math.PI));
+var kr = Math.log(Math.sqrt(2 * Math.PI));
 
-function gammaln(r) {
+function Ar(r) {
     if (r <= 0) {
         return Number.POSITIVE_INFINITY;
     }
     r--;
-    var e = n[0];
-    for (var t = 1; t < 15; t++) {
-        e += n[t] / (r + t);
+    var t = Nr[0];
+    for (var e = 1; e < 15; e++) {
+        t += Nr[e] / (r + e);
     }
-    var o = a + .5 + r;
-    return i + Math.log(e) - o + (r + .5) * Math.log(o);
+    var n = Ir + .5 + r;
+    return kr + Math.log(t) - n + (r + .5) * Math.log(n);
 }
 
-function bernoulliDistribution(r) {
+function Pr(r) {
     if (r < 0 || r > 1) {
         throw new Error("bernoulliDistribution requires probability to be between 0 and 1 inclusive");
     }
     return [ 1 - r, r ];
 }
 
-function binomialDistribution(r, e) {
-    if (e < 0 || e > 1 || r <= 0 || r % 1 !== 0) {
+function Sr(r, t) {
+    if (t < 0 || t > 1 || r <= 0 || r % 1 !== 0) {
         return undefined;
     }
+    var e = 0;
     var n = 0;
-    var a = 0;
-    var i = [];
+    var a = [];
     var o = 1;
     do {
-        i[n] = o * Math.pow(e, n) * Math.pow(1 - e, r - n);
-        a += i[n];
-        n++;
-        o = o * (r - n + 1) / n;
-    } while (a < 1 - t);
-    return i;
+        a[e] = o * Math.pow(t, e) * Math.pow(1 - t, r - e);
+        n += a[e];
+        e++;
+        o = o * (r - e + 1) / e;
+    } while (n < 1 - qr);
+    return a;
 }
 
-function poissonDistribution(r) {
+function Cr(r) {
     if (r <= 0) {
         return undefined;
     }
+    var t = 0;
     var e = 0;
-    var n = 0;
-    var a = [];
-    var i = 1;
+    var n = [];
+    var a = 1;
     do {
-        a[e] = Math.exp(-r) * Math.pow(r, e) / i;
-        n += a[e];
-        e++;
-        i *= e;
-    } while (n < 1 - t);
-    return a;
+        n[t] = Math.exp(-r) * Math.pow(r, t) / a;
+        e += n[t];
+        t++;
+        a *= t;
+    } while (e < 1 - qr);
+    return n;
 }
 
-var o = {
+var _r = {
     1: {
         .995: 0,
         .99: 0,
@@ -1739,215 +1739,215 @@ var o = {
     }
 };
 
-function chiSquaredGoodnessOfFit(r, e, t) {
-    var n = mean(r);
-    var a = 0;
+function Tr(r, t, e) {
+    var a = n(r);
+    var o = 0;
     var i = 1;
-    var u = e(n);
-    var s = [];
-    var l = [];
-    for (var f = 0; f < r.length; f++) {
-        if (s[r[f]] === undefined) {
-            s[r[f]] = 0;
+    var u = t(a);
+    var f = [];
+    var v = [];
+    for (var h = 0; h < r.length; h++) {
+        if (f[r[h]] === undefined) {
+            f[r[h]] = 0;
         }
-        s[r[f]]++;
+        f[r[h]]++;
     }
-    for (var v = 0; v < s.length; v++) {
-        if (s[v] === undefined) {
-            s[v] = 0;
+    for (var s = 0; s < f.length; s++) {
+        if (f[s] === undefined) {
+            f[s] = 0;
         }
     }
-    for (var h in u) {
-        if (h in s) {
-            l[+h] = u[h] * r.length;
+    for (var l in u) {
+        if (l in f) {
+            v[+l] = u[l] * r.length;
         }
     }
-    for (var c = l.length - 1; c >= 0; c--) {
-        if (l[c] < 3) {
-            l[c - 1] += l[c];
-            l.pop();
-            s[c - 1] += s[c];
-            s.pop();
+    for (var c = v.length - 1; c >= 0; c--) {
+        if (v[c] < 3) {
+            v[c - 1] += v[c];
+            v.pop();
+            f[c - 1] += f[c];
+            f.pop();
         }
     }
-    for (var p = 0; p < s.length; p++) {
-        a += Math.pow(s[p] - l[p], 2) / l[p];
+    for (var p = 0; p < f.length; p++) {
+        o += Math.pow(f[p] - v[p], 2) / v[p];
     }
-    var m = s.length - i - 1;
-    return o[m][t] < a;
+    var g = f.length - i - 1;
+    return _r[g][e] < o;
 }
 
-var u = Math.sqrt(2 * Math.PI);
+var Vr = Math.sqrt(2 * Math.PI);
 
-var s = {
+var Dr = {
     gaussian: function(r) {
-        return Math.exp(-.5 * r * r) / u;
+        return Math.exp(-.5 * r * r) / Vr;
     }
 };
 
-var l = {
+var Lr = {
     nrd: function(r) {
-        var e = sampleStandardDeviation(r);
-        var t = interquartileRange(r);
-        if (typeof t === "number") {
-            e = Math.min(e, t / 1.34);
+        var t = Z(r);
+        var e = _(r);
+        if (typeof e === "number") {
+            t = Math.min(t, e / 1.34);
         }
-        return 1.06 * e * Math.pow(r.length, -.2);
+        return 1.06 * t * Math.pow(r.length, -.2);
     }
 };
 
-function kernelDensityEstimation(r, e, t) {
+function Rr(r, t, e) {
     var n;
-    if (e === undefined) {
-        n = s.gaussian;
-    } else if (typeof e === "string") {
-        if (!s[e]) {
-            throw new Error('Unknown kernel "' + e + '"');
+    if (t === undefined) {
+        n = Dr.gaussian;
+    } else if (typeof t === "string") {
+        if (!Dr[t]) {
+            throw new Error('Unknown kernel "' + t + '"');
         }
-        n = s[e];
+        n = Dr[t];
     } else {
-        n = e;
+        n = t;
     }
     var a;
-    if (typeof t === "undefined") {
-        a = l.nrd(r);
-    } else if (typeof t === "string") {
-        if (!l[t]) {
-            throw new Error('Unknown bandwidth method "' + t + '"');
+    if (typeof e === "undefined") {
+        a = Lr.nrd(r);
+    } else if (typeof e === "string") {
+        if (!Lr[e]) {
+            throw new Error('Unknown bandwidth method "' + e + '"');
         }
-        a = l[t](r);
+        a = Lr[e](r);
     } else {
-        a = t;
+        a = e;
     }
-    return function(e) {
-        var t = 0;
-        var i = 0;
-        for (t = 0; t < r.length; t++) {
-            i += n((e - r[t]) / a);
+    return function(t) {
+        var e = 0;
+        var o = 0;
+        for (e = 0; e < r.length; e++) {
+            o += n((t - r[e]) / a);
         }
-        return i / a / r.length;
+        return o / a / r.length;
     };
 }
 
-function zScore(r, e, t) {
-    return (r - e) / t;
+function Ur(r, t, e) {
+    return (r - t) / e;
 }
 
-var f = Math.sqrt(2 * Math.PI);
+var zr = Math.sqrt(2 * Math.PI);
 
-function cumulativeDistribution(r) {
-    var e = r;
+function Fr(r) {
     var t = r;
+    var e = r;
     for (var n = 1; n < 15; n++) {
-        t *= r * r / (2 * n + 1);
-        e += t;
+        e *= r * r / (2 * n + 1);
+        t += e;
     }
-    return Math.round((.5 + e / f * Math.exp(-r * r / 2)) * 1e4) / 1e4;
+    return Math.round((.5 + t / zr * Math.exp(-r * r / 2)) * 1e4) / 1e4;
 }
 
-var v = [];
+var Or = [];
 
-for (var h = 0; h <= 3.09; h += .01) {
-    v.push(cumulativeDistribution(h));
+for (var Xr = 0; Xr <= 3.09; Xr += .01) {
+    Or.push(Fr(Xr));
 }
 
-function cumulativeStdNormalProbability(r) {
-    var e = Math.abs(r);
-    var t = Math.min(Math.round(e * 100), v.length - 1);
+function Yr(r) {
+    var t = Math.abs(r);
+    var e = Math.min(Math.round(t * 100), Or.length - 1);
     if (r >= 0) {
-        return v[t];
+        return Or[e];
     } else {
-        return Math.round((1 - v[t]) * 1e4) / 1e4;
+        return Math.round((1 - Or[e]) * 1e4) / 1e4;
     }
 }
 
-function cumulativeStdLogisticProbability(r) {
+function jr(r) {
     return 1 / (Math.exp(-r) + 1);
 }
 
-function errorFunction(r) {
-    var e = 1 / (1 + .5 * Math.abs(r));
-    var t = e * Math.exp(-r * r + ((((((((.17087277 * e - .82215223) * e + 1.48851587) * e - 1.13520398) * e + .27886807) * e - .18628806) * e + .09678418) * e + .37409196) * e + 1.00002368) * e - 1.26551223);
+function Kr(r) {
+    var t = 1 / (1 + .5 * Math.abs(r));
+    var e = t * Math.exp(-r * r + ((((((((.17087277 * t - .82215223) * t + 1.48851587) * t - 1.13520398) * t + .27886807) * t - .18628806) * t + .09678418) * t + .37409196) * t + 1.00002368) * t - 1.26551223);
     if (r >= 0) {
-        return 1 - t;
+        return 1 - e;
     } else {
-        return t - 1;
+        return e - 1;
     }
 }
 
-function inverseErrorFunction(r) {
-    var e = 8 * (Math.PI - 3) / (3 * Math.PI * (4 - Math.PI));
-    var t = Math.sqrt(Math.sqrt(Math.pow(2 / (Math.PI * e) + Math.log(1 - r * r) / 2, 2) - Math.log(1 - r * r) / e) - (2 / (Math.PI * e) + Math.log(1 - r * r) / 2));
+function Wr(r) {
+    var t = 8 * (Math.PI - 3) / (3 * Math.PI * (4 - Math.PI));
+    var e = Math.sqrt(Math.sqrt(Math.pow(2 / (Math.PI * t) + Math.log(1 - r * r) / 2, 2) - Math.log(1 - r * r) / t) - (2 / (Math.PI * t) + Math.log(1 - r * r) / 2));
     if (r >= 0) {
-        return t;
+        return e;
     } else {
-        return -t;
+        return -e;
     }
 }
 
-function probit(r) {
+function Br(r) {
     if (r === 0) {
-        r = t;
+        r = qr;
     } else if (r >= 1) {
-        r = 1 - t;
+        r = 1 - qr;
     }
-    return Math.sqrt(2) * inverseErrorFunction(2 * r - 1);
+    return Math.sqrt(2) * Wr(2 * r - 1);
 }
 
-function logit(r) {
+function Gr(r) {
     if (r <= 0 || r >= 1) {
         throw new Error("p must be strictly between zero and one");
     }
     return Math.log(r / (1 - r));
 }
 
-function permutationTest(r, e, t, n, a) {
-    if (n === undefined) {
-        n = 1e4;
+function Hr(r, t, e, a, o) {
+    if (a === undefined) {
+        a = 1e4;
     }
-    if (t === undefined) {
-        t = "two_side";
+    if (e === undefined) {
+        e = "two_side";
     }
-    if (t !== "two_side" && t !== "greater" && t !== "less") {
+    if (e !== "two_side" && e !== "greater" && e !== "less") {
         throw new Error("`alternative` must be either 'two_side', 'greater', or 'less'.");
     }
-    var i = mean(r);
-    var o = mean(e);
-    var u = i - o;
-    var s = new Array(n);
-    var l = r.concat(e);
-    var f = Math.floor(l.length / 2);
-    for (var v = 0; v < n; v++) {
-        shuffleInPlace(l, a);
-        var h = l.slice(0, f);
-        var c = l.slice(f, l.length);
-        var p = mean(h) - mean(c);
-        s[v] = p;
-    }
-    var m = 0;
-    if (t === "two_side") {
-        for (var g = 0; g <= n; g++) {
-            if (Math.abs(s[g]) >= Math.abs(u)) {
-                m += 1;
+    var i = n(r);
+    var u = n(t);
+    var f = i - u;
+    var v = new Array(a);
+    var h = r.concat(t);
+    var s = Math.floor(h.length / 2);
+    for (var l = 0; l < a; l++) {
+        R(h, o);
+        var c = h.slice(0, s);
+        var p = h.slice(s, h.length);
+        var g = n(c) - n(p);
+        v[l] = g;
+    }
+    var w = 0;
+    if (e === "two_side") {
+        for (var M = 0; M <= a; M++) {
+            if (Math.abs(v[M]) >= Math.abs(f)) {
+                w += 1;
             }
         }
-    } else if (t === "greater") {
-        for (var d = 0; d <= n; d++) {
-            if (s[d] >= u) {
-                m += 1;
+    } else if (e === "greater") {
+        for (var m = 0; m <= a; m++) {
+            if (v[m] >= f) {
+                w += 1;
             }
         }
     } else {
-        for (var w = 0; w <= n; w++) {
-            if (s[w] <= u) {
-                m += 1;
+        for (var d = 0; d <= a; d++) {
+            if (v[d] <= f) {
+                w += 1;
             }
         }
     }
-    return m / n;
+    return w / a;
 }
 
-function sign(r) {
+function Jr(r) {
     if (typeof r === "number") {
         if (r < 0) {
             return -1;
@@ -1961,59 +1961,59 @@ function sign(r) {
     }
 }
 
-function bisect(r, e, t, n, a) {
+function Qr(r, t, e, n, a) {
     if (typeof r !== "function") {
         throw new TypeError("func must be a function");
     }
-    for (var i = 0; i < n; i++) {
-        var o = (e + t) / 2;
-        if (r(o) === 0 || Math.abs((t - e) / 2) < a) {
-            return o;
+    for (var o = 0; o < n; o++) {
+        var i = (t + e) / 2;
+        if (r(i) === 0 || Math.abs((e - t) / 2) < a) {
+            return i;
         }
-        if (sign(r(o)) === sign(r(e))) {
-            e = o;
+        if (Jr(r(i)) === Jr(r(t))) {
+            t = i;
         } else {
-            t = o;
+            e = i;
         }
     }
     throw new Error("maximum number of iterations exceeded");
 }
 
-function euclideanDistance(r, e) {
-    var t = 0;
+function Zr(r, t) {
+    var e = 0;
     for (var n = 0; n < r.length; n++) {
-        var a = r[n] - e[n];
-        t += a * a;
+        var a = r[n] - t[n];
+        e += a * a;
     }
-    return Math.sqrt(t);
+    return Math.sqrt(e);
 }
 
-function kMeansCluster(r, e, t) {
-    if (t === void 0) t = Math.random;
+function $r(r, t, e) {
+    if (e === void 0) e = Math.random;
     var n = null;
-    var a = sample(r, e, t);
-    var i = null;
-    var o = Number.MAX_VALUE;
-    while (o !== 0) {
-        i = labelPoints(r, a);
+    var a = z(r, t, e);
+    var o = null;
+    var i = Number.MAX_VALUE;
+    while (i !== 0) {
+        o = rt(r, a);
         n = a;
-        a = calculateCentroids(r, i, e);
-        o = calculateChange(a, n);
+        a = tt(r, o, t);
+        i = et(a, n);
     }
     return {
-        labels: i,
+        labels: o,
         centroids: a
     };
 }
 
-function labelPoints(r, e) {
+function rt(r, t) {
     return r.map((function(r) {
-        var t = Number.MAX_VALUE;
+        var e = Number.MAX_VALUE;
         var n = -1;
-        for (var a = 0; a < e.length; a++) {
-            var i = euclideanDistance(r, e[a]);
-            if (i < t) {
-                t = i;
+        for (var a = 0; a < t.length; a++) {
+            var o = Zr(r, t[a]);
+            if (o < e) {
+                e = o;
                 n = a;
             }
         }
@@ -2021,229 +2021,229 @@ function labelPoints(r, e) {
     }));
 }
 
-function calculateCentroids(r, e, t) {
+function tt(r, t, e) {
     var n = r[0].length;
-    var a = makeMatrix(t, n);
-    var i = Array(t).fill(0);
-    var o = r.length;
-    for (var u = 0; u < o; u++) {
-        var s = r[u];
-        var l = e[u];
-        var f = a[l];
-        for (var v = 0; v < n; v++) {
-            f[v] += s[v];
-        }
-        i[l] += 1;
-    }
-    for (var h = 0; h < t; h++) {
-        if (i[h] === 0) {
-            throw new Error("Centroid " + h + " has no friends");
-        }
-        var c = a[h];
+    var a = F(e, n);
+    var o = Array(e).fill(0);
+    var i = r.length;
+    for (var u = 0; u < i; u++) {
+        var f = r[u];
+        var v = t[u];
+        var h = a[v];
+        for (var s = 0; s < n; s++) {
+            h[s] += f[s];
+        }
+        o[v] += 1;
+    }
+    for (var l = 0; l < e; l++) {
+        if (o[l] === 0) {
+            throw new Error("Centroid " + l + " has no friends");
+        }
+        var c = a[l];
         for (var p = 0; p < n; p++) {
-            c[p] /= i[h];
+            c[p] /= o[l];
         }
     }
     return a;
 }
 
-function calculateChange(r, e) {
-    var t = 0;
+function et(r, t) {
+    var e = 0;
     for (var n = 0; n < r.length; n++) {
-        t += euclideanDistance(r[n], e[n]);
+        e += Zr(r[n], t[n]);
     }
-    return t;
+    return e;
 }
 
-function silhouette(r, e) {
-    if (r.length !== e.length) {
+function nt(r, t) {
+    if (r.length !== t.length) {
         throw new Error("must have exactly as many labels as points");
     }
-    var t = createGroups(e);
-    var n = calculateAllDistances(r);
+    var e = at(t);
+    var n = ot(r);
     var a = [];
-    for (var i = 0; i < r.length; i++) {
-        var o = 0;
-        if (t[e[i]].length > 1) {
-            var u = meanDistanceFromPointToGroup(i, t[e[i]], n);
-            var s = meanDistanceToNearestGroup(i, e, t, n);
-            o = (s - u) / Math.max(u, s);
+    for (var o = 0; o < r.length; o++) {
+        var i = 0;
+        if (e[t[o]].length > 1) {
+            var u = ut(o, e[t[o]], n);
+            var f = it(o, t, e, n);
+            i = (f - u) / Math.max(u, f);
         }
-        a.push(o);
+        a.push(i);
     }
     return a;
 }
 
-function createGroups(r) {
-    var e = 1 + max(r);
-    var t = Array(e);
+function at(r) {
+    var t = 1 + c(r);
+    var e = Array(t);
     for (var n = 0; n < r.length; n++) {
         var a = r[n];
-        if (t[a] === undefined) {
-            t[a] = [];
+        if (e[a] === undefined) {
+            e[a] = [];
         }
-        t[a].push(n);
+        e[a].push(n);
     }
-    return t;
+    return e;
 }
 
-function calculateAllDistances(r) {
-    var e = r.length;
-    var t = makeMatrix(e, e);
-    for (var n = 0; n < e; n++) {
+function ot(r) {
+    var t = r.length;
+    var e = F(t, t);
+    for (var n = 0; n < t; n++) {
         for (var a = 0; a < n; a++) {
-            t[n][a] = euclideanDistance(r[n], r[a]);
-            t[a][n] = t[n][a];
+            e[n][a] = Zr(r[n], r[a]);
+            e[a][n] = e[n][a];
         }
     }
-    return t;
+    return e;
 }
 
-function meanDistanceToNearestGroup(r, e, t, n) {
-    var a = e[r];
-    var i = Number.MAX_VALUE;
-    for (var o = 0; o < t.length; o++) {
-        if (o !== a) {
-            var u = meanDistanceFromPointToGroup(r, t[o], n);
-            if (u < i) {
-                i = u;
+function it(r, t, e, n) {
+    var a = t[r];
+    var o = Number.MAX_VALUE;
+    for (var i = 0; i < e.length; i++) {
+        if (i !== a) {
+            var u = ut(r, e[i], n);
+            if (u < o) {
+                o = u;
             }
         }
     }
-    return i;
+    return o;
 }
 
-function meanDistanceFromPointToGroup(r, e, t) {
+function ut(r, t, e) {
     var n = 0;
-    for (var a = 0; a < e.length; a++) {
-        n += t[r][e[a]];
+    for (var a = 0; a < t.length; a++) {
+        n += e[r][t[a]];
     }
-    return n / e.length;
+    return n / t.length;
 }
 
-function silhouetteMetric(r, e) {
-    var t = silhouette(r, e);
-    return max(t);
+function ft(r, t) {
+    var e = nt(r, t);
+    return c(e);
 }
 
-function relativeError(r, e) {
-    if (r === 0 && e === 0) {
+function vt(r, t) {
+    if (r === 0 && t === 0) {
         return 0;
     }
-    return Math.abs((r - e) / e);
+    return Math.abs((r - t) / t);
 }
 
-function approxEqual(r, e, n) {
-    if (n === void 0) n = t;
-    return relativeError(r, e) <= n;
+function ht(r, t, e) {
+    if (e === void 0) e = qr;
+    return vt(r, t) <= e;
 }
 
-exports.addToMean = addToMean;
+exports.addToMean = ir;
 
-exports.approxEqual = approxEqual;
+exports.approxEqual = ht;
 
-exports.bernoulliDistribution = bernoulliDistribution;
+exports.bernoulliDistribution = Pr;
 
-exports.binomialDistribution = binomialDistribution;
+exports.binomialDistribution = Sr;
 
-exports.bisect = bisect;
+exports.bisect = Qr;
 
-exports.chunk = chunk;
+exports.chunk = D;
 
-exports.coefficientOfVariation = coefficientOfVariation;
+exports.coefficientOfVariation = wr;
 
-exports.combinations = combinations;
+exports.combinations = ar;
 
-exports.combinationsReplacement = combinationsReplacement;
+exports.combinationsReplacement = or;
 
-exports.combineMeans = combineMeans;
+exports.combineMeans = ur;
 
-exports.combineVariances = combineVariances;
+exports.combineVariances = fr;
 
-exports.cumulativeStdLogisticProbability = cumulativeStdLogisticProbability;
+exports.cumulativeStdLogisticProbability = jr;
 
-exports.epsilon = t;
+exports.epsilon = qr;
 
-exports.extent = extent;
+exports.extent = p;
 
-exports.factorial = factorial;
+exports.factorial = Er;
 
-exports.gamma = gamma;
+exports.gamma = yr;
 
-exports.gammaln = gammaln;
+exports.gammaln = Ar;
 
-exports.geometricMean = geometricMean;
+exports.geometricMean = vr;
 
-exports.harmonicMean = harmonicMean;
+exports.harmonicMean = sr;
 
-exports.interquartileRange = interquartileRange;
+exports.interquartileRange = _;
 
-exports.jenks = jenks;
+exports.jenks = G;
 
-exports.linearRegression = linearRegression;
+exports.linearRegression = r;
 
-exports.linearRegressionLine = linearRegressionLine;
+exports.linearRegressionLine = t;
 
-exports.logAverage = logAverage;
+exports.logAverage = hr;
 
-exports.logit = logit;
+exports.logit = Gr;
 
-exports.max = max;
+exports.max = c;
 
-exports.mean = mean;
+exports.mean = n;
 
-exports.median = median;
+exports.median = T;
 
-exports.medianAbsoluteDeviation = medianAbsoluteDeviation;
+exports.medianAbsoluteDeviation = V;
 
-exports.min = min;
+exports.min = l;
 
-exports.mode = mode;
+exports.mode = h;
 
-exports.poissonDistribution = poissonDistribution;
+exports.poissonDistribution = Cr;
 
-exports.probit = probit;
+exports.probit = Br;
 
-exports.product = product;
+exports.product = d;
 
-exports.quantile = quantile;
+exports.quantile = E;
 
-exports.quantileRank = quantileRank;
+exports.quantileRank = C;
 
-exports.quickselect = quickselect;
+exports.quickselect = x;
 
-exports.rSquared = rSquared;
+exports.rSquared = u;
 
-exports.rootMeanSquare = rootMeanSquare;
+exports.rootMeanSquare = gr;
 
-exports.sample = sample;
+exports.sample = z;
 
-exports.sampleCorrelation = sampleCorrelation;
+exports.sampleCorrelation = $;
 
-exports.sampleCovariance = sampleCovariance;
+exports.sampleCovariance = J;
 
-exports.sampleSkewness = sampleSkewness;
+exports.sampleSkewness = tr;
 
-exports.sampleStandardDeviation = sampleStandardDeviation;
+exports.sampleStandardDeviation = Z;
 
-exports.sampleVariance = sampleVariance;
+exports.sampleVariance = Q;
 
-exports.sampleWithReplacement = sampleWithReplacement;
+exports.sampleWithReplacement = L;
 
-exports.shuffle = shuffle;
+exports.shuffle = U;
 
-exports.standardDeviation = standardDeviation;
+exports.standardDeviation = i;
 
-exports.subtractFromMean = subtractFromMean;
+exports.subtractFromMean = pr;
 
-exports.sum = sum;
+exports.sum = e;
 
-exports.sumNthPowerDeviations = sumNthPowerDeviations;
+exports.sumNthPowerDeviations = a;
 
-exports.tTest = tTest;
+exports.tTest = Mr;
 
-exports.tTestTwoSample = tTestTwoSample;
+exports.tTestTwoSample = mr;
 
-exports.variance = variance;
+exports.variance = o;
 
-exports.zScore = zScore;
+exports.zScore = Ur;