@visactor/vutils 1.0.9 → 1.0.10

package/dist/index.js

@@ -1716,54 +1716,946 @@
 	    return [min, max];
 	};
 
+	function invNorm(p) {
+	    if (p <= 0 || p >= 1) {
+	        return 0;
+	    }
+	    const a1 = -39.6968302866538;
+	    const a2 = 220.946098424521;
+	    const a3 = -275.928510446969;
+	    const a4 = 138.357751867269;
+	    const a5 = -30.6647980661472;
+	    const a6 = 2.50662827745924;
+	    const b1 = -54.4760987982241;
+	    const b2 = 161.585836858041;
+	    const b3 = -155.698979859887;
+	    const b4 = 66.8013118877197;
+	    const b5 = -13.2806815528857;
+	    const c1 = -0.00778489400243029;
+	    const c2 = -0.322396458041136;
+	    const c3 = -2.40075827716184;
+	    const c4 = -2.54973253934373;
+	    const c5 = 4.37466414146497;
+	    const c6 = 2.93816398269878;
+	    const d1 = 0.00778469570904146;
+	    const d2 = 0.32246712907004;
+	    const d3 = 2.445134137143;
+	    const d4 = 3.75440866190742;
+	    const pLow = 0.02425;
+	    const pHigh = 1 - pLow;
+	    let q;
+	    let r;
+	    if (p < pLow) {
+	        q = Math.sqrt(-2 * Math.log(p));
+	        return (((((c1 * q + c2) * q + c3) * q + c4) * q + c5) * q + c6) / ((((d1 * q + d2) * q + d3) * q + d4) * q + 1);
+	    }
+	    if (p <= pHigh) {
+	        q = p - 0.5;
+	        r = q * q;
+	        return (((((((a1 * r + a2) * r + a3) * r + a4) * r + a5) * r + a6) * q) /
+	            (((((b1 * r + b2) * r + b3) * r + b4) * r + b5) * r + 1));
+	    }
+	    q = Math.sqrt(-2 * Math.log(1 - p));
+	    return -((((((c1 * q + c2) * q + c3) * q + c4) * q + c5) * q + c6) / ((((d1 * q + d2) * q + d3) * q + d4) * q + 1));
+	}
+	function computeLinearCIComponents(data, x, y, predict) {
+	    let min = Infinity;
+	    let max = -Infinity;
+	    let n = 0;
+	    let sumX = 0;
+	    for (let i = 0; i < data.length; i++) {
+	        const d = data[i];
+	        let dx = x(d);
+	        let dy = y(d);
+	        if (!isNil(dx) && (dx = +dx) >= dx && !isNil(dy) && (dy = +dy) >= dy) {
+	            if (dx < min) {
+	                min = dx;
+	            }
+	            if (dx > max) {
+	                max = dx;
+	            }
+	            n++;
+	            sumX += dx;
+	        }
+	    }
+	    if (n === 0) {
+	        return { min, max, n, X: 0, SSE: 0, Sxx: 0 };
+	    }
+	    const X = sumX / n;
+	    let SSE = 0;
+	    let Sxx = 0;
+	    for (let i = 0; i < data.length; i++) {
+	        const d = data[i];
+	        let dx = x(d);
+	        let dy = y(d);
+	        if (!isNil(dx) && (dx = +dx) >= dx && !isNil(dy) && (dy = +dy) >= dy) {
+	            const r = dy - predict(dx);
+	            SSE += r * r;
+	            const dxc = dx - X;
+	            Sxx += dxc * dxc;
+	        }
+	    }
+	    return { min, max, n, X, SSE, Sxx };
+	}
+	function stdErrorsAt(px, comps) {
+	    const { n, X, Sxx, SSE } = comps;
+	    const s2 = n > 2 ? SSE / (n - 2) : 0;
+	    const seMean = Sxx > 0 ? Math.sqrt(s2 * (1 / n + ((px - X) * (px - X)) / Sxx)) : Math.sqrt(s2 / n);
+	    const sePred = Math.sqrt(s2 * (1 + 1 / n + (Sxx > 0 ? ((px - X) * (px - X)) / Sxx : 0)));
+	    return { seMean, sePred };
+	}
+
 	function ordinaryLeastSquares(uX, uY, uXY, uX2) {
-	    const delta = uX2 - uX * uX;
-	    const slope = Math.abs(delta) < 1e-24 ? 0 : (uXY - uX * uY) / delta;
-	    const intercept = uY - slope * uX;
-	    return [intercept, slope];
+	    const denom = uX2 - uX * uX;
+	    if (Math.abs(denom) < Number.EPSILON) {
+	        return { a: uY, b: 0 };
+	    }
+	    const b = (uXY - uX * uY) / denom;
+	    const a = uY - b * uX;
+	    return { a, b };
 	}
 	function visitPoints(data, x, y, callback) {
-	    let i = -1;
-	    let u;
-	    let v;
-	    data.forEach(d => {
-	        u = x(d);
-	        v = y(d);
-	        if (!isNil(u) && (u = +u) >= u && !isNil(v) && (v = +v) >= v) {
-	            callback(u, v, ++i);
+	    for (let i = 0; i < data.length; i++) {
+	        const d = data[i];
+	        let xi = x(d);
+	        let yi = y(d);
+	        if (!isNil(xi) && (xi = +xi) >= xi && !isNil(yi) && (yi = +yi) >= yi) {
+	            callback(xi, yi, i);
 	        }
-	    });
+	    }
 	}
 	function rSquared(data, x, y, uY, predict) {
-	    let SSE = 0;
-	    let SST = 0;
+	    let ssr = 0;
+	    let sst = 0;
+	    for (let i = 0; i < data.length; i++) {
+	        const d = data[i];
+	        let yi = y(d);
+	        if (!isNil(yi) && (yi = +yi) >= yi) {
+	            const p = predict(x(d));
+	            const r = yi - p;
+	            ssr += r * r;
+	            const t = yi - uY;
+	            sst += t * t;
+	        }
+	    }
+	    return sst === 0 ? 0 : 1 - ssr / sst;
+	}
+	function regressionLinear(data, x = d => d.x, y = d => d.y) {
+	    let n = 0;
+	    let meanX = 0;
+	    let meanY = 0;
+	    let meanXY = 0;
+	    let meanX2 = 0;
+	    visitPoints(data, x, y, (xi, yi) => {
+	        n++;
+	        meanX += (xi - meanX) / n;
+	        meanY += (yi - meanY) / n;
+	        meanXY += (xi * yi - meanXY) / n;
+	        meanX2 += (xi * xi - meanX2) / n;
+	    });
+	    const { a, b } = ordinaryLeastSquares(meanX, meanY, meanXY, meanX2);
+	    const predict = (xx) => a + b * xx;
+	    const comps = computeLinearCIComponents(data, x, y, predict);
+	    function evaluateGrid(N) {
+	        const out = [];
+	        if (comps.n === 0 || N <= 0) {
+	            return out;
+	        }
+	        if (comps.min === comps.max) {
+	            for (let i = 0; i < N; i++) {
+	                out.push({ x: comps.min, y: predict(comps.min) });
+	            }
+	            return out;
+	        }
+	        const step = (comps.max - comps.min) / (N - 1);
+	        for (let i = 0; i < N; i++) {
+	            const px = i === N - 1 ? comps.max : comps.min + step * i;
+	            out.push({ x: px, y: predict(px) });
+	        }
+	        return out;
+	    }
+	    function confidenceInterval(N = 50, alpha = 0.05) {
+	        const out = [];
+	        if (comps.n === 0 || N <= 0) {
+	            return out;
+	        }
+	        const z = invNorm(1 - alpha / 2);
+	        if (comps.min === comps.max) {
+	            const m = predict(comps.min);
+	            const errs = stdErrorsAt(comps.min, comps);
+	            for (let i = 0; i < N; i++) {
+	                out.push({
+	                    x: comps.min,
+	                    mean: m,
+	                    lower: m - z * errs.seMean,
+	                    upper: m + z * errs.seMean,
+	                    predLower: m - z * errs.sePred,
+	                    predUpper: m + z * errs.sePred
+	                });
+	            }
+	            return out;
+	        }
+	        const step = (comps.max - comps.min) / (N - 1);
+	        for (let i = 0; i < N; i++) {
+	            const px = i === N - 1 ? comps.max : comps.min + step * i;
+	            const m = predict(px);
+	            const errs = stdErrorsAt(px, comps);
+	            out.push({
+	                x: px,
+	                mean: m,
+	                lower: m - z * errs.seMean,
+	                upper: m + z * errs.seMean,
+	                predLower: m - z * errs.sePred,
+	                predUpper: m + z * errs.sePred
+	            });
+	        }
+	        return out;
+	    }
+	    return {
+	        coef: { a, b },
+	        predict,
+	        rSquared: rSquared(data, x, y, meanY, predict),
+	        evaluateGrid,
+	        confidenceInterval
+	    };
+	}
+
+	function regressionLogistic(data, x = d => d.x, y = d => d.y, options) {
+	    var _a, _b;
+	    const maxIter = (_a = options === null || options === void 0 ? void 0 : options.maxIteration) !== null && _a !== void 0 ? _a : 25;
+	    const tol = (_b = options === null || options === void 0 ? void 0 : options.tol) !== null && _b !== void 0 ? _b : 1e-6;
+	    const xs = [];
+	    const ys = [];
+	    visitPoints(data, x, y, (dx, dy) => {
+	        xs.push(dx);
+	        ys.push(dy ? 1 : 0);
+	    });
+	    const n = xs.length;
+	    if (n === 0) {
+	        return {
+	            coef: [0, 0],
+	            predict: (_x) => 0,
+	            evaluateGrid: (N) => [],
+	            confidenceInterval: (N = 50) => []
+	        };
+	    }
+	    let intercept = 0;
+	    let beta = 0;
+	    for (let iter = 0; iter < maxIter; iter++) {
+	        const p = new Array(n);
+	        let converged = true;
+	        for (let i = 0; i < n; i++) {
+	            const z = intercept + beta * xs[i];
+	            const pi = 1 / (1 + Math.exp(-z));
+	            p[i] = pi;
+	        }
+	        let g0 = 0;
+	        let g1 = 0;
+	        let h00 = 0;
+	        let h01 = 0;
+	        let h11 = 0;
+	        for (let i = 0; i < n; i++) {
+	            const wi = p[i] * (1 - p[i]);
+	            const diff = ys[i] - p[i];
+	            g0 += diff;
+	            g1 += diff * xs[i];
+	            h00 += wi;
+	            h01 += wi * xs[i];
+	            h11 += wi * xs[i] * xs[i];
+	        }
+	        const det = h00 * h11 - h01 * h01;
+	        if (Math.abs(det) < 1e-12) {
+	            break;
+	        }
+	        const delta0 = (h11 * g0 - h01 * g1) / det;
+	        const delta1 = (-h01 * g0 + h00 * g1) / det;
+	        intercept += delta0;
+	        beta += delta1;
+	        if (Math.abs(delta0) > tol || Math.abs(delta1) > tol) {
+	            converged = false;
+	        }
+	        if (converged) {
+	            break;
+	        }
+	    }
+	    const predict = (xx) => {
+	        const z = intercept + beta * xx;
+	        return 1 / (1 + Math.exp(-z));
+	    };
+	    function evaluateGrid(N) {
+	        const out = [];
+	        if (N <= 0) {
+	            return out;
+	        }
+	        let min = Infinity;
+	        let max = -Infinity;
+	        visitPoints(data, x, y, dx => {
+	            if (dx < min) {
+	                min = dx;
+	            }
+	            if (dx > max) {
+	                max = dx;
+	            }
+	        });
+	        if (min === Infinity || max === -Infinity) {
+	            return out;
+	        }
+	        if (min === max) {
+	            const v = predict(min);
+	            for (let i = 0; i < N; i++) {
+	                out.push({ x: min, y: v });
+	            }
+	            return out;
+	        }
+	        const step = (max - min) / (N - 1);
+	        for (let i = 0; i < N; i++) {
+	            const px = i === N - 1 ? max : min + step * i;
+	            out.push({ x: px, y: predict(px) });
+	        }
+	        return out;
+	    }
+	    function confidenceInterval(N = 50, alpha = 0.05) {
+	        const out = [];
+	        if (N <= 0) {
+	            return out;
+	        }
+	        const comps = computeLinearCIComponents(data, x, y, predict);
+	        if (comps.n === 0) {
+	            return out;
+	        }
+	        const z = Math.abs(invNorm(1 - alpha / 2));
+	        if (comps.min === comps.max) {
+	            const v = predict(comps.min);
+	            const errs = stdErrorsAt(comps.min, comps);
+	            for (let i = 0; i < N; i++) {
+	                out.push({
+	                    x: comps.min,
+	                    mean: v,
+	                    lower: v - z * errs.seMean,
+	                    upper: v + z * errs.seMean,
+	                    predLower: v - z * errs.sePred,
+	                    predUpper: v + z * errs.sePred
+	                });
+	            }
+	            return out;
+	        }
+	        const step = (comps.max - comps.min) / (N - 1);
+	        for (let i = 0; i < N; i++) {
+	            const px = i === N - 1 ? comps.max : comps.min + step * i;
+	            const yh = predict(px);
+	            const errs = stdErrorsAt(px, comps);
+	            out.push({
+	                x: px,
+	                mean: yh,
+	                lower: yh - z * errs.seMean,
+	                upper: yh + z * errs.seMean,
+	                predLower: yh - z * errs.sePred,
+	                predUpper: yh + z * errs.sePred
+	            });
+	        }
+	        return out;
+	    }
+	    return {
+	        coef: [intercept, beta],
+	        predict,
+	        evaluateGrid,
+	        confidenceInterval
+	    };
+	}
+
+	function tricube(u) {
+	    const uu = Math.abs(u);
+	    if (uu >= 1) {
+	        return 0;
+	    }
+	    const t = 1 - uu * uu * uu;
+	    return t * t * t;
+	}
+	function regressionLowess(data, x = d => d.x, y = d => d.y, options = {}) {
+	    const span = options.span || 0.3;
+	    const degree = options.degree === 0 ? 0 : 1;
+	    const iterations = options.iterations == null ? 2 : options.iterations;
+	    const ptsX = [];
+	    const ptsY = [];
 	    visitPoints(data, x, y, (dx, dy) => {
-	        const sse = dy - predict(dx);
-	        const sst = dy - uY;
-	        SSE += sse * sse;
-	        SST += sst * sst;
+	        ptsX.push(dx);
+	        ptsY.push(dy);
 	    });
-	    return 1 - SSE / SST;
+	    const n = ptsX.length;
+	    function predictSingle(x0, robustWeights) {
+	        if (n === 0) {
+	            return 0;
+	        }
+	        const dists = [];
+	        for (let i = 0; i < n; i++) {
+	            dists.push({ idx: i, dist: Math.abs(ptsX[i] - x0) });
+	        }
+	        dists.sort((a, b) => a.dist - b.dist);
+	        const m = Math.max(2, Math.min(n, Math.floor(span * n)));
+	        const maxDist = dists[m - 1].dist || 0;
+	        const w = new Array(m);
+	        let sumw = 0;
+	        for (let i = 0; i < m; i++) {
+	            const idx = dists[i].idx;
+	            const u = maxDist === 0 ? 0 : dists[i].dist / maxDist;
+	            let wi = tricube(u);
+	            if (robustWeights && robustWeights[idx] != null) {
+	                wi *= robustWeights[idx];
+	            }
+	            w[i] = wi;
+	            sumw += wi;
+	        }
+	        if (sumw === 0) {
+	            return ptsY[dists[0].idx];
+	        }
+	        if (degree === 0) {
+	            let s = 0;
+	            for (let i = 0; i < m; i++) {
+	                s += w[i] * ptsY[dists[i].idx];
+	            }
+	            return s / sumw;
+	        }
+	        let sw = 0;
+	        let sx = 0;
+	        let sy = 0;
+	        let sxx = 0;
+	        let sxy = 0;
+	        for (let i = 0; i < m; i++) {
+	            const idx = dists[i].idx;
+	            const xi = ptsX[idx];
+	            const yi = ptsY[idx];
+	            const wi = w[i];
+	            sw += wi;
+	            sx += wi * xi;
+	            sy += wi * yi;
+	            sxx += wi * xi * xi;
+	            sxy += wi * xi * yi;
+	        }
+	        const meanX = sx / sw;
+	        const meanY = sy / sw;
+	        const denom = sxx - sx * meanX;
+	        const slope = Math.abs(denom) < 1e-12 ? 0 : (sxy - sx * meanY) / denom;
+	        const intercept = meanY - slope * meanX;
+	        return intercept + slope * x0;
+	    }
+	    function predict(x0) {
+	        if (Array.isArray(x0)) {
+	            const out = [];
+	            for (let i = 0; i < x0.length; i++) {
+	                out.push(predictSingle(x0[i]));
+	            }
+	            return out;
+	        }
+	        return predictSingle(x0);
+	    }
+	    function evaluateGrid(N) {
+	        const out = [];
+	        if (N <= 0) {
+	            return out;
+	        }
+	        if (n === 0) {
+	            return out;
+	        }
+	        let min = Infinity;
+	        let max = -Infinity;
+	        for (let i = 0; i < n; i++) {
+	            if (ptsX[i] < min) {
+	                min = ptsX[i];
+	            }
+	            if (ptsX[i] > max) {
+	                max = ptsX[i];
+	            }
+	        }
+	        if (min === max) {
+	            const v = predictSingle(min);
+	            for (let i = 0; i < N; i++) {
+	                out.push({ x: min, y: v });
+	            }
+	            return out;
+	        }
+	        const step = (max - min) / (N - 1);
+	        let robustWeights;
+	        for (let iter = 0; iter < iterations; iter++) {
+	            const fits = [];
+	            for (let i = 0; i < n; i++) {
+	                fits.push(predictSingle(ptsX[i], robustWeights));
+	            }
+	            const res = [];
+	            for (let i = 0; i < n; i++) {
+	                res.push(Math.abs(ptsY[i] - fits[i]));
+	            }
+	            const sortedRes = res.slice().sort((a, b) => a - b);
+	            const med = sortedRes[Math.floor(n / 2)] || 0;
+	            robustWeights = new Array(n);
+	            for (let i = 0; i < n; i++) {
+	                const u = med === 0 ? 0 : res[i] / (6 * med);
+	                const w = Math.abs(u) >= 1 ? 0 : (1 - u * u) * (1 - u * u);
+	                robustWeights[i] = w;
+	            }
+	        }
+	        for (let i = 0; i < N; i++) {
+	            const px = i === N - 1 ? max : min + step * i;
+	            out.push({ x: px, y: predictSingle(px, robustWeights) });
+	        }
+	        return out;
+	    }
+	    function confidenceInterval(N = 50, alpha = 0.05) {
+	        const out = [];
+	        if (N <= 0) {
+	            return out;
+	        }
+	        if (n === 0) {
+	            return out;
+	        }
+	        let min = Infinity;
+	        let max = -Infinity;
+	        for (let i = 0; i < n; i++) {
+	            if (ptsX[i] < min) {
+	                min = ptsX[i];
+	            }
+	            if (ptsX[i] > max) {
+	                max = ptsX[i];
+	            }
+	        }
+	        if (min === Infinity || max === -Infinity) {
+	            return out;
+	        }
+	        const comps = computeLinearCIComponents(data, x, y, (xx) => predictSingle(xx));
+	        if (comps.n === 0) {
+	            return out;
+	        }
+	        const z = Math.abs(invNorm(1 - alpha / 2));
+	        if (comps.min === comps.max) {
+	            const v = predictSingle(comps.min);
+	            const errs = stdErrorsAt(comps.min, comps);
+	            for (let i = 0; i < N; i++) {
+	                out.push({
+	                    x: comps.min,
+	                    mean: v,
+	                    lower: v - z * errs.seMean,
+	                    upper: v + z * errs.seMean,
+	                    predLower: v - z * errs.sePred,
+	                    predUpper: v + z * errs.sePred
+	                });
+	            }
+	            return out;
+	        }
+	        const step = (max - min) / (N - 1);
+	        for (let i = 0; i < N; i++) {
+	            const px = i === N - 1 ? max : min + step * i;
+	            const yh = predictSingle(px);
+	            const errs = stdErrorsAt(px, comps);
+	            out.push({
+	                x: px,
+	                mean: yh,
+	                lower: yh - z * errs.seMean,
+	                upper: yh + z * errs.seMean,
+	                predLower: yh - z * errs.sePred,
+	                predUpper: yh + z * errs.sePred
+	            });
+	        }
+	        return out;
+	    }
+	    return {
+	        predict,
+	        evaluate: predict,
+	        evaluateGrid,
+	        confidenceInterval
+	    };
 	}
-	function regressionLinear(data, x = datum => datum.x, y = datum => datum.y) {
-	    let X = 0;
-	    let Y = 0;
-	    let XY = 0;
-	    let X2 = 0;
-	    let n = 0;
+
+	function solveLinearSystem(A, b) {
+	    const n = b.length;
+	    const M = new Array(n);
+	    for (let i = 0; i < n; i++) {
+	        M[i] = A[i].slice();
+	        M[i].push(b[i]);
+	    }
+	    for (let k = 0; k < n; k++) {
+	        let maxRow = k;
+	        let maxVal = Math.abs(M[k][k]);
+	        for (let i = k + 1; i < n; i++) {
+	            const v = Math.abs(M[i][k]);
+	            if (v > maxVal) {
+	                maxVal = v;
+	                maxRow = i;
+	            }
+	        }
+	        if (maxRow !== k) {
+	            const tmp = M[k];
+	            M[k] = M[maxRow];
+	            M[maxRow] = tmp;
+	        }
+	        if (Math.abs(M[k][k]) < 1e-12) {
+	            const res = new Array(n).fill(0);
+	            return res;
+	        }
+	        for (let j = k + 1; j <= n; j++) {
+	            M[k][j] = M[k][j] / M[k][k];
+	        }
+	        M[k][k] = 1;
+	        for (let i = 0; i < n; i++) {
+	            if (i === k) {
+	                continue;
+	            }
+	            const factor = M[i][k];
+	            if (factor === 0) {
+	                continue;
+	            }
+	            for (let j = k + 1; j <= n; j++) {
+	                M[i][j] -= factor * M[k][j];
+	            }
+	            M[i][k] = 0;
+	        }
+	    }
+	    const x = new Array(n);
+	    for (let i = 0; i < n; i++) {
+	        x[i] = M[i][n];
+	    }
+	    return x;
+	}
+	function regressionPolynomial(data, x = d => d.x, y = d => d.y, options = {}) {
+	    var _a;
+	    let degree = (_a = options.degree) !== null && _a !== void 0 ? _a : 0;
+	    if (degree < 0) {
+	        degree = 0;
+	    }
+	    const m = degree + 1;
+	    const sums = new Array(2 * degree + 1).fill(0);
 	    visitPoints(data, x, y, (dx, dy) => {
-	        ++n;
-	        X += (dx - X) / n;
-	        Y += (dy - Y) / n;
-	        XY += (dx * dy - XY) / n;
-	        X2 += (dx * dx - X2) / n;
+	        let xp = 1;
+	        for (let k = 0; k < sums.length; k++) {
+	            sums[k] += xp;
+	            xp *= dx;
+	        }
 	    });
-	    const coef = ordinaryLeastSquares(X, Y, XY, X2);
-	    const predict = (x) => coef[0] + coef[1] * x;
+	    const A = new Array(m);
+	    for (let i = 0; i < m; i++) {
+	        A[i] = new Array(m).fill(0);
+	        for (let j = 0; j < m; j++) {
+	            A[i][j] = sums[i + j];
+	        }
+	    }
+	    const B = new Array(m).fill(0);
+	    visitPoints(data, x, y, (dx, dy) => {
+	        let xp = 1;
+	        for (let k = 0; k < m; k++) {
+	            B[k] += dy * xp;
+	            xp *= dx;
+	        }
+	    });
+	    const coef = solveLinearSystem(A, B);
+	    const predict = (xx) => {
+	        let xp = 1;
+	        let v = 0;
+	        for (let k = 0; k < coef.length; k++) {
+	            v += coef[k] * xp;
+	            xp *= xx;
+	        }
+	        return v;
+	    };
+	    return {
+	        degree,
+	        coef,
+	        predict,
+	        rSquared: rSquared(data, x, y, (() => {
+	            let sum = 0;
+	            let cnt = 0;
+	            visitPoints(data, x, y, (_dx, dy) => {
+	                sum += dy;
+	                cnt++;
+	            });
+	            return cnt === 0 ? 0 : sum / cnt;
+	        })(), predict),
+	        evaluateGrid(N) {
+	            const out = [];
+	            if (N <= 0) {
+	                return out;
+	            }
+	            let min = Infinity;
+	            let max = -Infinity;
+	            visitPoints(data, x, y, dx => {
+	                if (!isNil(dx)) {
+	                    if (dx < min) {
+	                        min = dx;
+	                    }
+	                    if (dx > max) {
+	                        max = dx;
+	                    }
+	                }
+	            });
+	            if (min === Infinity || max === -Infinity) {
+	                return out;
+	            }
+	            if (min === max) {
+	                const v = predict(min);
+	                for (let i = 0; i < N; i++) {
+	                    out.push({ x: min, y: v });
+	                }
+	                return out;
+	            }
+	            const step = (max - min) / (N - 1);
+	            for (let i = 0; i < N; i++) {
+	                const px = i === N - 1 ? max : min + step * i;
+	                out.push({ x: px, y: predict(px) });
+	            }
+	            return out;
+	        },
+	        confidenceInterval(N = 50, alpha = 0.05) {
+	            const out = [];
+	            if (N <= 0) {
+	                return out;
+	            }
+	            const comps = computeLinearCIComponents(data, x, y, predict);
+	            if (comps.n === 0) {
+	                return out;
+	            }
+	            const z = Math.abs(invNorm(1 - alpha / 2));
+	            if (comps.min === comps.max) {
+	                const v = predict(comps.min);
+	                const errs = stdErrorsAt(comps.min, comps);
+	                for (let i = 0; i < N; i++) {
+	                    out.push({
+	                        x: comps.min,
+	                        mean: v,
+	                        lower: v - z * errs.seMean,
+	                        upper: v + z * errs.seMean,
+	                        predLower: v - z * errs.sePred,
+	                        predUpper: v + z * errs.sePred
+	                    });
+	                }
+	                return out;
+	            }
+	            const step = (comps.max - comps.min) / (N - 1);
+	            for (let i = 0; i < N; i++) {
+	                const px = i === N - 1 ? comps.max : comps.min + step * i;
+	                const yh = predict(px);
+	                const errs = stdErrorsAt(px, comps);
+	                out.push({
+	                    x: px,
+	                    mean: yh,
+	                    lower: yh - z * errs.seMean,
+	                    upper: yh + z * errs.seMean,
+	                    predLower: yh - z * errs.sePred,
+	                    predUpper: yh + z * errs.sePred
+	                });
+	            }
+	            return out;
+	        }
+	    };
+	}
+
+	const gaussian = (u) => {
+	    const invSqrt2Pi = 1 / Math.sqrt(2 * Math.PI);
+	    return invSqrt2Pi * Math.exp(-0.5 * u * u);
+	};
+	const epanechnikov = (u) => {
+	    const absu = Math.abs(u);
+	    return absu <= 1 ? 0.75 * (1 - u * u) : 0;
+	};
+	function scott(n, std, dim = 1) {
+	    if (n <= 0 || std === 0) {
+	        return 0;
+	    }
+	    return std * Math.pow(n, -1 / (dim + 4));
+	}
+	function silverman(n, std, dim = 1) {
+	    if (n <= 0 || std === 0) {
+	        return 0;
+	    }
+	    const factor = Math.pow(4 / (dim + 2), 1 / (dim + 4));
+	    return factor * std * Math.pow(n, -1 / (dim + 4));
+	}
+	function std(values) {
+	    const n = values.length;
+	    if (n === 0) {
+	        return 0;
+	    }
+	    let mean = 0;
+	    for (let i = 0; i < n; i++) {
+	        mean += values[i];
+	    }
+	    mean /= n;
+	    let s = 0;
+	    for (let i = 0; i < n; i++) {
+	        const d = values[i] - mean;
+	        s += d * d;
+	    }
+	    return Math.sqrt(s / n);
+	}
+	function kde(data, options = {}) {
+	    const n = data.length;
+	    const kernel = options.kernel || gaussian;
+	    let h = options.bandwidth;
+	    if (!h || h <= 0) {
+	        const sd = std(data) || 0;
+	        const method = options.bandwidthMethod || 'scott';
+	        if (method === 'silverman') {
+	            h = silverman(n, sd, 1);
+	        }
+	        else {
+	            h = scott(n, sd, 1);
+	        }
+	    }
+	    if (!h || h <= 0) {
+	        const zerosEval = (x) => {
+	            if (Array.isArray(x)) {
+	                const out = [];
+	                for (let i = 0; i < x.length; i++) {
+	                    out.push(0);
+	                }
+	                return out;
+	            }
+	            return 0;
+	        };
+	        const zerosGrid = (N) => {
+	            const out = [];
+	            if (N <= 0) {
+	                return out;
+	            }
+	            let min = Infinity;
+	            let max = -Infinity;
+	            for (let j = 0; j < n; j++) {
+	                const v = data[j];
+	                if (v < min) {
+	                    min = v;
+	                }
+	                if (v > max) {
+	                    max = v;
+	                }
+	            }
+	            if (min === Infinity || max === -Infinity) {
+	                for (let i = 0; i < N; i++) {
+	                    out.push({ x: 0, y: 0 });
+	                }
+	                return out;
+	            }
+	            for (let i = 0; i < N; i++) {
+	                out.push({ x: min, y: 0 });
+	            }
+	            return out;
+	        };
+	        return {
+	            bandwidth: 0,
+	            kernel,
+	            evaluate: zerosEval,
+	            evaluateGrid: zerosGrid
+	        };
+	    }
+	    const invNh = 1 / (n * h);
+	    function evalPoint(x) {
+	        let sum = 0;
+	        for (let j = 0; j < n; j++) {
+	            sum += kernel((x - data[j]) / h);
+	        }
+	        return sum * invNh;
+	    }
+	    function evaluate(x) {
+	        if (Array.isArray(x)) {
+	            const out = [];
+	            for (let i = 0; i < x.length; i++) {
+	                out.push(evalPoint(x[i]));
+	            }
+	            return out;
+	        }
+	        return evalPoint(x);
+	    }
+	    return {
+	        bandwidth: h,
+	        kernel,
+	        evaluate: evaluate,
+	        evaluateGrid(N) {
+	            const out = [];
+	            if (N <= 0) {
+	                return out;
+	            }
+	            let min = Infinity;
+	            let max = -Infinity;
+	            for (let i = 0; i < n; i++) {
+	                const v = data[i];
+	                if (v < min) {
+	                    min = v;
+	                }
+	                if (v > max) {
+	                    max = v;
+	                }
+	            }
+	            if (min === Infinity || max === -Infinity) {
+	                return out;
+	            }
+	            if (min === max) {
+	                for (let i = 0; i < N; i++) {
+	                    out.push({ x: min, y: evalPoint(min) });
+	                }
+	                return out;
+	            }
+	            const step = (max - min) / (N - 1);
+	            for (let i = 0; i < N; i++) {
+	                const x = i === N - 1 ? max : min + step * i;
+	                out.push({ x, y: evalPoint(x) });
+	            }
+	            return out;
+	        }
+	    };
+	}
+
+	function ecdf(data) {
+	    const n = data.length;
+	    const sorted = data.slice().sort((a, b) => a - b);
+	    function evaluateSingle(x) {
+	        if (n === 0) {
+	            return 0;
+	        }
+	        let lo = 0;
+	        let hi = n;
+	        while (lo < hi) {
+	            const mid = (lo + hi) >>> 1;
+	            if (sorted[mid] <= x) {
+	                lo = mid + 1;
+	            }
+	            else {
+	                hi = mid;
+	            }
+	        }
+	        return lo / n;
+	    }
+	    function evaluate(x) {
+	        if (Array.isArray(x)) {
+	            const out = [];
+	            for (let i = 0; i < x.length; i++) {
+	                out.push(evaluateSingle(x[i]));
+	            }
+	            return out;
+	        }
+	        return evaluateSingle(x);
+	    }
+	    function evaluateGrid(N) {
+	        const out = [];
+	        if (N <= 0) {
+	            return out;
+	        }
+	        if (n === 0) {
+	            return out;
+	        }
+	        const min = sorted[0];
+	        const max = sorted[n - 1];
+	        if (min === max) {
+	            for (let i = 0; i < N; i++) {
+	                out.push({ x: min, y: 1 });
+	            }
+	            return out;
+	        }
+	        const step = (max - min) / (N - 1);
+	        for (let i = 0; i < N; i++) {
+	            const x = i === N - 1 ? max : min + step * i;
+	            out.push({ x, y: evaluateSingle(x) });
+	        }
+	        return out;
+	    }
 	    return {
-	        coef: coef,
-	        predict: predict,
-	        rSquared: rSquared(data, x, y, Y, predict)
+	        evaluate: evaluate,
+	        evaluateGrid,
+	        n
 	    };
 	}
 
@@ -6384,6 +7276,8 @@
 	exports.deviation = deviation;
 	exports.dotProduct = dotProduct;
 	exports.eastAsianCharacterInfo = eastAsianCharacterInfo;
+	exports.ecdf = ecdf;
+	exports.epanechnikov = epanechnikov;
 	exports.epsilon = epsilon;
 	exports.exponent = exponent;
 	exports.extent = extent;
@@ -6400,6 +7294,7 @@
 	exports.fullYearSetterName = fullYearSetterName;
 	exports.fuzzyEqualNumber = fuzzyEqualNumber;
 	exports.fuzzyEqualVec = fuzzyEqualVec;
+	exports.gaussian = gaussian;
 	exports.gemv = gemv;
 	exports.generateCeil = generateCeil;
 	exports.generateCount = generateCount;
@@ -6474,6 +7369,7 @@
 	exports.isValid = isValid;
 	exports.isValidNumber = isValidNumber;
 	exports.isValidUrl = isValidUrl;
+	exports.kde = kde;
 	exports.keys = keys;
 	exports.last = last;
 	exports.lengthFromPointToLine = lengthFromPointToLine;
@@ -6539,10 +7435,14 @@
 	exports.range = range;
 	exports.rectInsideAnotherRect = rectInsideAnotherRect;
 	exports.regressionLinear = regressionLinear;
+	exports.regressionLogistic = regressionLogistic;
+	exports.regressionLowess = regressionLowess;
+	exports.regressionPolynomial = regressionPolynomial;
 	exports.rgbToHex = rgbToHex;
 	exports.rgbToHsl = rgbToHsl;
 	exports.rotatePoint = rotatePoint;
 	exports.scale = scale;
+	exports.scott = scott;
 	exports.secondCount = secondCount;
 	exports.secondField = secondField;
 	exports.secondFloor = secondFloor;
@@ -6551,6 +7451,7 @@
 	exports.secondsSetterName = secondsSetterName;
 	exports.seedRandom = seedRandom;
 	exports.shuffleArray = shuffleArray;
+	exports.silverman = silverman;
 	exports.simpleField = simpleField;
 	exports.sin = sin;
 	exports.span = span;