lakutata 2.0.81 → 2.0.82

package/vendor/Package.17.mjs

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