lakutata 2.0.82 → 2.0.83

package/vendor/Package.17.mjs

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