@visactor/vutils 1.0.25 → 1.0.27

package/dist/index.js

@@ -2236,6 +2236,213 @@
 	    return [min, max];
 	};
 
+	function regressionPoints(data, x, y) {
+	    const points = [];
+	    data.forEach(d => {
+	        const a = x(d);
+	        const b = y(d);
+	        // 保留既有 accessor 对缺失观测的排除行为；无穷大不是可拟合观测。
+	        if (a != null && b != null && Number.isFinite(+a) && Number.isFinite(+b)) {
+	            points.push({ x: +a, y: +b });
+	        }
+	    });
+	    return points;
+	}
+	function normalizeRegression(value, center, scale) {
+	    const delta = value - center;
+	    return Number.isFinite(delta) ? delta / scale : value / scale - center / scale;
+	}
+	function regressionBasis(points) {
+	    let xMin = Infinity;
+	    let xMax = -Infinity;
+	    let yMin = Infinity;
+	    let yMax = -Infinity;
+	    for (const p of points) {
+	        xMin = Math.min(xMin, p.x);
+	        xMax = Math.max(xMax, p.x);
+	        yMin = Math.min(yMin, p.y);
+	        yMax = Math.max(yMax, p.y);
+	    }
+	    if (!points.length) {
+	        return { xCenter: 0, xScale: 1, yCenter: 0, yScale: 1 };
+	    }
+	    const xCenter = xMin / 2 + xMax / 2;
+	    const yCenter = yMin / 2 + yMax / 2;
+	    return {
+	        xCenter,
+	        yCenter,
+	        xScale: Math.max(Math.abs(xMin - xCenter), Math.abs(xMax - xCenter)) || 1,
+	        yScale: Math.max(Math.abs(yMin - yCenter), Math.abs(yMax - yCenter)) || 1
+	    };
+	}
+	/** 秩不足时对 QR 的小型 R 做单边 Jacobi SVD，获得明确的最小范数解。 */
+	function minimumNorm(r, rhs) {
+	    const p = rhs.length;
+	    const a = r.map(row => row.slice());
+	    const v = Array.from({ length: p }, (_, i) => Array.from({ length: p }, (_, j) => +(i === j)));
+	    for (let sweep = 0; sweep < 50; sweep++) {
+	        let changed = false;
+	        for (let j = 0; j < p - 1; j++) {
+	            for (let k = j + 1; k < p; k++) {
+	                let aa = 0;
+	                let bb = 0;
+	                let ab = 0;
+	                for (let i = 0; i < p; i++) {
+	                    aa += a[i][j] ** 2;
+	                    bb += a[i][k] ** 2;
+	                    ab += a[i][j] * a[i][k];
+	                }
+	                if (Math.abs(ab) <= Number.EPSILON * 8 * Math.sqrt(aa * bb)) {
+	                    continue;
+	                }
+	                changed = true;
+	                const tau = (bb - aa) / (2 * ab);
+	                const t = (tau >= 0 ? 1 : -1) / (Math.abs(tau) + Math.hypot(1, tau));
+	                const c = 1 / Math.hypot(1, t);
+	                const s = c * t;
+	                for (let i = 0; i < p; i++) {
+	                    const aj = a[i][j];
+	                    const ak = a[i][k];
+	                    const vj = v[i][j];
+	                    const vk = v[i][k];
+	                    a[i][j] = c * aj - s * ak;
+	                    a[i][k] = s * aj + c * ak;
+	                    v[i][j] = c * vj - s * vk;
+	                    v[i][k] = s * vj + c * vk;
+	                }
+	            }
+	        }
+	        if (!changed) {
+	            break;
+	        }
+	    }
+	    const norms = Array.from({ length: p }, (_, j) => Math.hypot(...a.map(row => row[j])));
+	    const tolerance = Math.max(...norms) * Number.EPSILON * p * 64;
+	    const coef = new Array(p).fill(0);
+	    let rank = 0;
+	    for (let j = 0; j < p; j++) {
+	        if (norms[j] <= tolerance) {
+	            continue;
+	        }
+	        rank++;
+	        let projection = 0;
+	        for (let i = 0; i < p; i++) {
+	            projection += a[i][j] * rhs[i];
+	        }
+	        projection /= norms[j] ** 2;
+	        for (let i = 0; i < p; i++) {
+	            coef[i] += v[i][j] * projection;
+	        }
+	    }
+	    return { coef, rank };
+	}
+	function fitRegression(points, degree, basis = regressionBasis(points)) {
+	    const p = degree + 1;
+	    if (degree === 1) {
+	        let mx = 0;
+	        let my = 0;
+	        let n = 0;
+	        for (const row of points) {
+	            n++;
+	            mx += (normalizeRegression(row.x, basis.xCenter, basis.xScale) - mx) / n;
+	            my += (normalizeRegression(row.y, basis.yCenter, basis.yScale) - my) / n;
+	        }
+	        let sxx = 0;
+	        let sxy = 0;
+	        for (const row of points) {
+	            const dx = normalizeRegression(row.x, basis.xCenter, basis.xScale) - mx;
+	            sxx += dx * dx;
+	            sxy += dx * (normalizeRegression(row.y, basis.yCenter, basis.yScale) - my);
+	        }
+	        const b = sxx === 0 ? 0 : sxy / sxx;
+	        const coef = sxx === 0 ? [my / (1 + mx * mx), (mx * my) / (1 + mx * mx)] : [my - b * mx, b];
+	        return { coef, rank: n === 0 ? 0 : sxx === 0 ? 1 : 2, basis };
+	    }
+	    const r = Array.from({ length: p }, () => new Array(p).fill(0));
+	    const rhs = new Array(p).fill(0);
+	    const row = new Array(p);
+	    for (const point of points) {
+	        const z = normalizeRegression(point.x, basis.xCenter, basis.xScale);
+	        row[0] = 1;
+	        for (let j = 1; j < p; j++) {
+	            row[j] = row[j - 1] * z;
+	        }
+	        let value = normalizeRegression(point.y, basis.yCenter, basis.yScale);
+	        // 增量 Givens QR 仅保留 p×p 的 R，bootstrap 不分配 N×p 矩阵。
+	        for (let j = 0; j < p; j++) {
+	            const norm = Math.hypot(r[j][j], row[j]);
+	            if (norm === 0) {
+	                continue;
+	            }
+	            const c = r[j][j] / norm;
+	            const s = row[j] / norm;
+	            r[j][j] = norm;
+	            for (let k = j + 1; k < p; k++) {
+	                const previous = r[j][k];
+	                r[j][k] = c * previous + s * row[k];
+	                row[k] = -s * previous + c * row[k];
+	            }
+	            const previous = rhs[j];
+	            rhs[j] = c * previous + s * value;
+	            value = -s * previous + c * value;
+	        }
+	    }
+	    const tolerance = Math.max(...r.map((row, i) => Math.abs(row[i]))) * Number.EPSILON * p * 64;
+	    if (r.some((row, i) => Math.abs(row[i]) <= tolerance)) {
+	        return Object.assign(Object.assign({}, minimumNorm(r, rhs)), { basis });
+	    }
+	    const coef = new Array(p);
+	    for (let i = p - 1; i >= 0; i--) {
+	        let value = rhs[i];
+	        for (let j = i + 1; j < p; j++) {
+	            value -= r[i][j] * coef[j];
+	        }
+	        coef[i] = value / r[i][i];
+	    }
+	    return { coef, rank: p, basis };
+	}
+	function regressionPrediction(model, x) {
+	    const z = normalizeRegression(x, model.basis.xCenter, model.basis.xScale);
+	    let value = 0;
+	    for (let j = model.coef.length - 1; j >= 0; j--) {
+	        value = value * z + model.coef[j];
+	    }
+	    return model.basis.yCenter + model.basis.yScale * value;
+	}
+	/** 保留公开的升幂 coef；预测始终使用稳定基底。 */
+	function regressionCoefficients(model) {
+	    let coef = [model.coef[model.coef.length - 1]];
+	    const a = -model.basis.xCenter / model.basis.xScale;
+	    const b = 1 / model.basis.xScale;
+	    for (let j = model.coef.length - 2; j >= 0; j--) {
+	        const next = new Array(coef.length + 1).fill(0);
+	        coef.forEach((c, i) => {
+	            next[i] += a * c;
+	            next[i + 1] += b * c;
+	        });
+	        next[0] += model.coef[j];
+	        coef = next;
+	    }
+	    coef = coef.map(c => c * model.basis.yScale);
+	    coef[0] += model.basis.yCenter;
+	    if (coef.some(c => !Number.isFinite(c))) {
+	        throw new RangeError('Regression coefficients are not finite');
+	    }
+	    return coef;
+	}
+	function regressionGrid(min, max, count, predict) {
+	    if (!Number.isInteger(count) || count <= 0 || !Number.isFinite(min) || !Number.isFinite(max)) {
+	        return [];
+	    }
+	    const width = max - min;
+	    const step = count === 1 ? 0 : width / (count - 1);
+	    return Array.from({ length: count }, (_, i) => {
+	        const t = count === 1 ? 0 : i / (count - 1);
+	        const x = i === 0 ? min : i === count - 1 ? max : Number.isFinite(width) ? min + i * step : (1 - t) * min + t * max;
+	        return { x, y: predict(x) };
+	    });
+	}
+
 	/** Compute a two-sided normal critical value without subtracting a small tail probability from one. */
 	function confidenceCriticalValue(alpha) {
 	    if (!Number.isFinite(alpha) || alpha < 0 || alpha > 1) {
@@ -2347,39 +2554,19 @@
 	function regressionLinear(data, x = d => d.x, y = d => d.y, options) {
 	    var _a;
 	    const alpha = (_a = options === null || options === void 0 ? void 0 : options.alpha) !== null && _a !== void 0 ? _a : 0.05;
-	    // accumulate online means (sufficient statistics)
-	    let n = 0;
-	    let meanX = 0;
+	    const points = regressionPoints(data, x, y);
+	    const model = fitRegression(points, 1);
+	    const coef = regressionCoefficients(model);
+	    const a = coef[0];
+	    const b = coef[1];
+	    const predict = (xx) => regressionPrediction(model, xx);
+	    const comps = computeLinearCIComponents(data, x, y, predict);
 	    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;
+	    points.forEach((p, i) => {
+	        meanY += (p.y - meanY) / (i + 1);
 	    });
-	    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;
+	        return regressionGrid(comps.min, comps.max, N, predict);
 	    }
 	    function confidenceInterval(N = 50) {
 	        const out = [];
@@ -2424,6 +2611,7 @@
 	    }
 	    return {
 	        coef: { a, b },
+	        rank: model.rank,
 	        predict,
 	        rSquared: rSquared(data, x, y, meanY, predict),
 	        evaluateGrid,
@@ -2589,222 +2777,226 @@
 	    };
 	}
 
-	function tricube(u) {
-	    const uu = Math.abs(u);
-	    if (uu >= 1) {
-	        return 0;
-	    }
-	    const t = 1 - uu * uu * uu;
-	    return t * t * t;
-	}
 	/**
-	 * Stratified sampling to reduce data size while preserving distribution
-	 */
-	function stratifiedSample(sortedData, maxSamples) {
-	    const n = sortedData.length;
-	    if (n <= maxSamples) {
-	        return sortedData;
-	    }
-	    const sampled = [];
-	    // More aggressive sampling - use exact step size
-	    const step = n / maxSamples;
-	    for (let i = 0; i < maxSamples; i++) {
-	        const idx = Math.min(Math.floor(i * step), n - 1);
-	        sampled.push(sortedData[idx]);
-	    }
-	    return sampled;
-	}
-	/**
-	 * Simple lowess implementation (univariate x)
-	 * options:
-	 * - span: fraction of points used in local regression (0,1]
-	 * - degree: 0 (constant) or 1 (linear)
-	 * - iterations: number of robustifying iterations
-	 * - alpha: confidence level for CI
-	 * - maxSamples: maximum number of points to use (default: 1000 for fast processing)
+	 * 局部线性 LOWESS。默认全量观测、span=2/3、三次稳健重加权。
+	 * delta 显式插值加速；maxSamples 仅保留显式选择的历史抽样用途。
+	 * predict 与 evaluateGrid 查询构建时固定的同一模型，不触发再拟合。
 	 */
 	function regressionLowess(data, x = d => d.x, y = d => d.y, options = {}) {
-	    var _a;
-	    const span = options.span || 0.3;
-	    const degree = options.degree === 0 ? 0 : 1;
-	    const alpha = (_a = options.alpha) !== null && _a !== void 0 ? _a : 0.05;
-	    const iterations = options.iterations == null ? 2 : options.iterations;
-	    const maxSamples = options.maxSamples || 1000;
-	    // Collect and sort data by x
-	    const rawPoints = [];
-	    visitPoints(data, x, y, (dx, dy, index) => {
-	        rawPoints.push({ x: dx, y: dy, index });
-	    });
-	    rawPoints.sort((a, b) => a.x - b.x);
-	    // Apply sampling if needed
-	    const sampledPoints = stratifiedSample(rawPoints, maxSamples);
-	    const n = sampledPoints.length;
-	    const ptsX = new Array(n);
-	    const ptsY = new Array(n);
-	    for (let i = 0; i < n; i++) {
-	        ptsX[i] = sampledPoints[i].x;
-	        ptsY[i] = sampledPoints[i].y;
-	    }
-	    /**
-	     * Optimized predictSingle using binary search on pre-sorted data
-	     */
-	    function predictSingle(x0, robustWeights) {
-	        if (n === 0) {
+	    var _a, _b, _c, _d, _e;
+	    const span = (_a = options.span) !== null && _a !== void 0 ? _a : 2 / 3;
+	    const degree = (_b = options.degree) !== null && _b !== void 0 ? _b : 1;
+	    const iterations = (_c = options.iterations) !== null && _c !== void 0 ? _c : 3;
+	    const delta = (_d = options.delta) !== null && _d !== void 0 ? _d : 0;
+	    const alpha = (_e = options.alpha) !== null && _e !== void 0 ? _e : 0.05;
+	    if (!(span > 0 && span <= 1) ||
+	        !Number.isInteger(iterations) ||
+	        iterations < 0 ||
+	        !Number.isFinite(delta) ||
+	        delta < 0 ||
+	        (degree !== 0 && degree !== 1) ||
+	        (options.maxSamples != null && (!Number.isInteger(options.maxSamples) || options.maxSamples < 2))) {
+	        throw new RangeError('Invalid LOWESS span, degree, iterations, delta or maxSamples');
+	    }
+	    let pts = regressionPoints(data, x, y).sort((a, b) => a.x - b.x || a.y - b.y);
+	    if (options.maxSamples != null && pts.length > options.maxSamples) {
+	        const full = pts;
+	        const count = options.maxSamples;
+	        pts = Array.from({ length: count }, (_, i) => full[Math.floor((i * (full.length - 1)) / (count - 1))]);
+	    }
+	    const n = pts.length;
+	    const ptsX = pts.map(p => p.x);
+	    const ptsY = pts.map(p => p.y);
+	    const basis = regressionBasis(pts);
+	    const normalizedX = ptsX.map(v => normalizeRegression(v, basis.xCenter, basis.xScale));
+	    const normalizedY = ptsY.map(v => normalizeRegression(v, basis.yCenter, basis.yScale));
+	    const count = Math.min(n, Math.max(2, Math.floor(span * n + 1e-10)));
+	    let robustWeights;
+	    function exact(x0) {
+	        if (!n) {
 	            return 0;
 	        }
-	        // Binary search to find insertion point
+	        const query = normalizeRegression(x0, basis.xCenter, basis.xScale);
+	        // 找到连续的最近邻窗口；相等距离选择较小的 x（ties 的 y 已排序）。
 	        let left = 0;
-	        let right = n;
+	        let right = n - count;
 	        while (left < right) {
-	            const mid = (left + right) >> 1;
-	            if (ptsX[mid] < x0) {
+	            const mid = (left + right) >>> 1;
+	            const lowerDistance = x0 - ptsX[mid];
+	            const upperDistance = ptsX[mid + count] - x0;
+	            if (Number.isFinite(lowerDistance) && Number.isFinite(upperDistance)
+	                ? lowerDistance > upperDistance
+	                : query - normalizedX[mid] > normalizedX[mid + count] - query) {
 	                left = mid + 1;
 	            }
 	            else {
 	                right = mid;
 	            }
 	        }
-	        const m = Math.min(n, Math.max(2, Math.floor(span * n)));
-	        // Expand by distance: equal numbers on either side need not be the nearest points.
-	        let lo = left - 1;
-	        let hi = left;
-	        for (let count = 0; count < m; count++) {
-	            if (lo >= 0 && (hi >= n || x0 - ptsX[lo] <= ptsX[hi] - x0)) {
-	                lo--;
+	        let start = left;
+	        let end = left + count;
+	        if (ptsX[start] === ptsX[end - 1]) {
+	            while (start > 0 && ptsX[start - 1] === ptsX[start]) {
+	                start--;
 	            }
-	            else {
-	                hi++;
-	            }
-	        }
-	        const actualStart = lo + 1;
-	        const end = hi;
-	        // Find max distance and compute weights in single pass
-	        let maxDist = 0;
-	        const windowSize = end - actualStart;
-	        const distances = new Array(windowSize);
-	        for (let i = actualStart; i < end; i++) {
-	            const dist = Math.abs(ptsX[i] - x0);
-	            distances[i - actualStart] = dist;
-	            if (dist > maxDist) {
-	                maxDist = dist;
-	            }
-	        }
-	        // Compute weights using pre-calculated distances
-	        let sumw = 0;
-	        const w = new Array(windowSize);
-	        for (let i = 0; i < windowSize; i++) {
-	            const u = maxDist === 0 ? 0 : distances[i] / maxDist;
-	            let wi = tricube(u);
-	            if (robustWeights && robustWeights[actualStart + i] != null) {
-	                wi *= robustWeights[actualStart + i];
-	            }
-	            w[i] = wi;
-	            sumw += wi;
-	        }
-	        if (sumw === 0) {
-	            // Fall back to the nearest y, preserving input order for equal distances.
-	            let nearestIdx = 0;
-	            let nearestDistance = Math.abs(ptsX[0] - x0);
-	            for (let i = 1; i < n; i++) {
-	                const distance = Math.abs(ptsX[i] - x0);
-	                if (distance < nearestDistance ||
-	                    (distance === nearestDistance && sampledPoints[i].index < sampledPoints[nearestIdx].index)) {
-	                    nearestIdx = i;
-	                    nearestDistance = distance;
-	                }
+	            while (end < n && ptsX[end] === ptsX[start]) {
+	                end++;
 	            }
-	            return ptsY[nearestIdx];
 	        }
-	        if (degree === 0) {
-	            let s = 0;
-	            for (let i = 0; i < w.length; i++) {
-	                s += w[i] * ptsY[actualStart + i];
-	            }
-	            return s / sumw;
+	        const rawRadius = Math.max(Math.abs(ptsX[start] - x0), Math.abs(ptsX[end - 1] - x0));
+	        const scaled = !Number.isFinite(rawRadius);
+	        const radius = scaled
+	            ? Math.max(Math.abs(normalizedX[start] - query), Math.abs(normalizedX[end - 1] - query))
+	            : rawRadius;
+	        // 局部响应坐标不能由远处、未参与该邻域的观测决定精度。
+	        let yMin = Infinity;
+	        let yMax = -Infinity;
+	        for (let i = start; i < end; i++) {
+	            yMin = Math.min(yMin, ptsY[i]);
+	            yMax = Math.max(yMax, ptsY[i]);
 	        }
-	        // weighted linear regression on local points
+	        const yCenter = yMin / 2 + yMax / 2;
+	        const yScale = Math.max(Math.abs(yMin - yCenter), Math.abs(yMax - yCenter)) || 1;
 	        let sw = 0;
 	        let sx = 0;
 	        let sy = 0;
 	        let sxx = 0;
 	        let sxy = 0;
-	        for (let i = actualStart; i < end; i++) {
-	            const idx = i - actualStart;
-	            const xi = ptsX[i];
-	            const yi = ptsY[i];
-	            const wi = w[idx];
-	            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;
+	        for (let i = start; i < end; i++) {
+	            const z = radius === 0 ? 0 : (scaled ? normalizedX[i] - query : ptsX[i] - x0) / radius;
+	            const u = Math.abs(z);
+	            const t = u >= 1 ? 0 : 1 - u * u * u;
+	            const w = t * t * t * (robustWeights ? robustWeights[i] : 1);
+	            sw += w;
+	            sx += w * z;
+	            const response = normalizeRegression(ptsY[i], yCenter, yScale);
+	            sy += w * response;
+	            sxx += w * z * z;
+	            sxy += w * z * response;
+	        }
+	        if (sw === 0) {
+	            // 核边界零权重时使用最近有效观测的加权常数；等距离取均值。
+	            let distance = Infinity;
+	            let weight = 0;
+	            let value = 0;
+	            for (let i = 0; i < n; i++) {
+	                const w = robustWeights ? robustWeights[i] : 1;
+	                if (w === 0) {
+	                    continue;
+	                }
+	                const d = Math.abs(scaled ? normalizedX[i] - query : ptsX[i] - x0);
+	                if (d < distance) {
+	                    distance = d;
+	                    weight = w;
+	                    value = ptsY[i];
+	                }
+	                else if (d === distance) {
+	                    value = value * (weight / (weight + w)) + ptsY[i] * (w / (weight + w));
+	                    weight += w;
+	                }
+	            }
+	            if (weight === 0) {
+	                throw new RangeError('LOWESS has no effective local observations');
+	            }
+	            return value;
+	        }
+	        const mx = sx / sw;
+	        const my = sy / sw;
+	        const variance = sxx / sw - mx * mx;
+	        const slope = degree === 0 || variance <= Number.EPSILON * 32 ? 0 : (sxy / sw - mx * my) / variance;
+	        return yCenter + yScale * (my - slope * mx);
+	    }
+	    // delta 不删除观测。只减少局部回归求值位置，全部残差参与重加权。
+	    const anchors = [];
+	    for (let i = 0; i < n;) {
+	        anchors.push(i);
+	        if (i === n - 1) {
+	            break;
+	        }
+	        let next = i + 1;
+	        if (delta > 0) {
+	            while (next + 1 < n && ptsX[next + 1] - ptsX[i] <= delta) {
+	                next++;
+	            }
+	        }
+	        // 重复 x 一起使用同一预测；端点不能丢失。
+	        while (next + 1 < n && ptsX[next + 1] === ptsX[next]) {
+	            next++;
+	        }
+	        i = next;
 	    }
-	    function predict(x0) {
-	        if (Array.isArray(x0)) {
-	            const len = x0.length;
-	            const out = new Array(len);
-	            for (let i = 0; i < len; i++) {
-	                out[i] = predictSingle(x0[i]);
+	    let fits = new Array(n);
+	    function fitObservations() {
+	        const out = new Array(n);
+	        for (let a = 0; a < anchors.length; a++) {
+	            const index = anchors[a];
+	            out[index] = exact(ptsX[index]);
+	            if (a === 0) {
+	                continue;
+	            }
+	            const previous = anchors[a - 1];
+	            const rawWidth = ptsX[index] - ptsX[previous];
+	            const width = Number.isFinite(rawWidth) ? rawWidth : normalizedX[index] - normalizedX[previous];
+	            for (let i = previous + 1; i < index; i++) {
+	                const t = width === 0
+	                    ? 0
+	                    : (Number.isFinite(rawWidth) ? ptsX[i] - ptsX[previous] : normalizedX[i] - normalizedX[previous]) / width;
+	                out[i] = out[previous] * (1 - t) + out[index] * t;
 	            }
-	            return out;
 	        }
-	        return predictSingle(x0);
+	        return out;
 	    }
-	    function evaluateGrid(N) {
-	        if (N <= 0) {
-	            return [];
+	    for (let iteration = 0; iteration <= iterations; iteration++) {
+	        fits = fitObservations();
+	        if (iteration === iterations) {
+	            break;
 	        }
-	        if (n === 0) {
-	            return [];
+	        const residuals = fits.map((v, i) => {
+	            const residual = ptsY[i] - v;
+	            return Number.isFinite(residual)
+	                ? Math.abs(residual / basis.yScale)
+	                : Math.abs(normalizedY[i] - normalizeRegression(v, basis.yCenter, basis.yScale));
+	        });
+	        const med = median(residuals.slice());
+	        const currentFits = fits;
+	        robustWeights = residuals.map((r, i) => {
+	            if (med === 0) {
+	                const tolerance = Number.EPSILON * 64 * (Math.max(Math.abs(ptsY[i]), Math.abs(currentFits[i])) / basis.yScale);
+	                return r <= tolerance ? 1 : 0;
+	            }
+	            const u = r / (6 * med);
+	            return u >= 1 ? 0 : (1 - u * u) ** 2;
+	        });
+	    }
+	    function predictSingle(x0) {
+	        if (delta === 0 || n < 2 || x0 < ptsX[0] || x0 > ptsX[n - 1]) {
+	            return exact(x0);
 	        }
-	        const out = new Array(N);
-	        const min = ptsX[0];
-	        const max = ptsX[n - 1];
-	        if (min === max) {
-	            const v = predictSingle(min);
-	            for (let i = 0; i < N; i++) {
-	                out[i] = { x: min, y: v };
+	        let lo = 0;
+	        let hi = n - 1;
+	        while (hi - lo > 1) {
+	            const mid = (lo + hi) >>> 1;
+	            if (ptsX[mid] <= x0) {
+	                lo = mid;
 	            }
-	            return out;
-	        }
-	        const step = (max - min) / (N - 1);
-	        // optionally add robust iterations
-	        let robustWeights;
-	        // Disable robustness iterations for large datasets to improve performance
-	        // Users can override by setting iterations explicitly
-	        const effectiveIterations = options.iterations != null ? iterations : n > 500 ? 0 : iterations;
-	        if (effectiveIterations > 0) {
-	            for (let iter = 0; iter < effectiveIterations; iter++) {
-	                // compute fits - pre-allocate arrays
-	                const fits = new Array(n);
-	                const res = new Array(n);
-	                for (let i = 0; i < n; i++) {
-	                    fits[i] = predictSingle(ptsX[i], robustWeights);
-	                    res[i] = Math.abs(ptsY[i] - fits[i]);
-	                }
-	                // median absolute deviation
-	                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;
-	                }
+	            else {
+	                hi = mid;
 	            }
 	        }
-	        for (let i = 0; i < N; i++) {
-	            const px = i === N - 1 ? max : min + step * i;
-	            out[i] = { x: px, y: predictSingle(px, robustWeights) };
+	        if (ptsX[hi] === ptsX[lo]) {
+	            return fits[lo];
 	        }
-	        return out;
+	        const width = ptsX[hi] - ptsX[lo];
+	        const t = Number.isFinite(width)
+	            ? (x0 - ptsX[lo]) / width
+	            : (normalizeRegression(x0, basis.xCenter, basis.xScale) - normalizedX[lo]) / (normalizedX[hi] - normalizedX[lo]);
+	        return fits[lo] * (1 - t) + fits[hi] * t;
+	    }
+	    function predict(x0) {
+	        return Array.isArray(x0) ? x0.map(predictSingle) : predictSingle(x0);
+	    }
+	    function evaluateGrid(N) {
+	        return regressionGrid(ptsX[0], ptsX[n - 1], N, predictSingle);
 	    }
 	    function confidenceInterval(N = 50) {
 	        const out = [];
@@ -2864,111 +3056,26 @@
 	        predict,
 	        evaluate: predict,
 	        evaluateGrid,
-	        confidenceInterval
+	        confidenceInterval,
+	        // 节点值按 x 排序，重复观测仍保持其统计权重。
+	        fitted: pts.map((p, i) => ({ x: p.x, y: fits[i] }))
 	    };
 	}
 
-	function solveLinearSystem(A, b) {
-	    // Gaussian elimination with partial pivoting
-	    const n = b.length;
-	    // clone
-	    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++) {
-	        // find pivot
-	        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;
-	        }
-	        // singular check
-	        if (Math.abs(M[k][k]) < 1e-12) {
-	            // return least squares fallback zeros
-	            const res = new Array(n).fill(0);
-	            return res;
-	        }
-	        // normalize row
-	        for (let j = k + 1; j <= n; j++) {
-	            M[k][j] = M[k][j] / M[k][k];
-	        }
-	        M[k][k] = 1;
-	        // eliminate
-	        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, _b;
-	    let degree = (_a = options.degree) !== null && _a !== void 0 ? _a : 0;
-	    if (degree < 0) {
-	        degree = 0;
+	    const degree = (_a = options.degree) !== null && _a !== void 0 ? _a : 0;
+	    if (!Number.isInteger(degree) || degree < 0) {
+	        throw new RangeError('Polynomial degree must be an nonnegative integer');
 	    }
 	    const alpha = (_b = options.alpha) !== null && _b !== void 0 ? _b : 0.05;
-	    const m = degree + 1;
-	    const sums = new Array(2 * degree + 1).fill(0);
-	    visitPoints(data, x, y, (dx, dy) => {
-	        let xp = 1;
-	        for (let k = 0; k < sums.length; k++) {
-	            sums[k] += xp;
-	            xp *= dx;
-	        }
-	    });
-	    // build normal matrix
-	    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;
-	    };
+	    const points = regressionPoints(data, x, y);
+	    const model = fitRegression(points, degree);
+	    const coef = regressionCoefficients(model);
+	    const predict = (xx) => regressionPrediction(model, xx);
 	    return {
 	        degree,
+	        rank: model.rank,
 	        coef,
 	        predict,
 	        rSquared: rSquared(data, x, y, (() => {
@@ -2982,39 +3089,13 @@
 	            return cnt === 0 ? 0 : sum / cnt;
 	        })(), predict),
 	        evaluateGrid(N) {
-	            const out = [];
-	            if (N <= 0) {
-	                return out;
-	            }
-	            // compute range
 	            let min = Infinity;
 	            let max = -Infinity;
-	            visitPoints(data, x, y, dx => {
-	                if (!isNil(dx)) {
-	                    if (dx < min) {
-	                        min = dx;
-	                    }
-	                    if (dx > max) {
-	                        max = dx;
-	                    }
-	                }
+	            points.forEach(p => {
+	                min = Math.min(min, p.x);
+	                max = Math.max(max, p.x);
 	            });
-	            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;
+	            return regressionGrid(min, max, N, predict);
 	        },
 	        confidenceInterval(N = 50) {
 	            const out = [];
@@ -3064,6 +3145,33 @@
 	    };
 	}
 
+	/** 有限数值的均值；空输入没有均值，不修改输入。 */
+	function mean(values) {
+	    if (!values.length) {
+	        return undefined;
+	    }
+	    let scale = 0;
+	    for (const value of values) {
+	        if (!Number.isFinite(value)) {
+	            throw new RangeError('mean requires finite numbers');
+	        }
+	        scale = Math.max(scale, Math.abs(value));
+	    }
+	    if (scale === 0) {
+	        return 0;
+	    }
+	    let sum = 0;
+	    let correction = 0;
+	    for (const value of values) {
+	        const next = value / scale;
+	        const total = sum + next;
+	        // Neumaier compensation retains small contributions even when larger values cancel.
+	        correction += Math.abs(sum) >= Math.abs(next) ? sum - total + next : next - total + sum;
+	        sum = total;
+	    }
+	    return ((sum + correction) / values.length) * scale;
+	}
+
 	/**
 	 * Kernel Density Estimation (KDE) utilities
 	 *
@@ -3103,33 +3211,59 @@
 	/**
 	 * Compute standard deviation for numeric array
 	 */
-	function std(values) {
+	function std(values, convention) {
 	    const n = values.length;
-	    if (n === 0) {
+	    if (n < 2) {
 	        return 0;
 	    }
-	    let mean = 0;
+	    const center = mean(values);
+	    const differences = [];
+	    let scale = 0;
+	    let sourceScale = 1;
 	    for (let i = 0; i < n; i++) {
-	        mean += values[i];
+	        const difference = values[i] - center;
+	        differences.push(difference);
+	        scale = Math.max(scale, Math.abs(difference));
+	    }
+	    // Finite values of opposite signs can overflow subtraction although population deviation is representable.
+	    if (scale === Infinity) {
+	        sourceScale = Math.abs(center);
+	        for (const value of values) {
+	            sourceScale = Math.max(sourceScale, Math.abs(value));
+	        }
+	        scale = 0;
+	        for (let i = 0; i < n; i++) {
+	            differences[i] = values[i] / sourceScale - center / sourceScale;
+	            scale = Math.max(scale, Math.abs(differences[i]));
+	        }
+	    }
+	    if (scale === 0) {
+	        return 0;
 	    }
-	    mean /= n;
-	    let s = 0;
 	    for (let i = 0; i < n; i++) {
-	        const d = values[i] - mean;
-	        s += d * d;
+	        differences[i] /= scale;
 	    }
-	    return Math.sqrt(s / n);
+	    const correction = convention === 'population' ? (n - 1) / n : 1;
+	    return Math.sqrt(variance(differences) * correction) * scale * sourceScale;
 	}
 	/**
 	 * Factory: create a KDE evaluator for given data and options.
 	 * Usage: const model = kde(data, options); model.evaluate(x) or model.evaluate([x1,x2])
 	 */
 	function kde(data, options = {}) {
+	    const deviation = options.standardDeviation === undefined ? 'population' : options.standardDeviation;
+	    const adjustment = options.bandwidthAdjust === undefined ? 1 : options.bandwidthAdjust;
+	    if (deviation !== 'sample' && deviation !== 'population') {
+	        throw new RangeError('standardDeviation must be sample or population');
+	    }
+	    if (!Number.isFinite(adjustment) || adjustment <= 0) {
+	        throw new RangeError('bandwidthAdjust must be finite and positive');
+	    }
 	    const n = data.length;
 	    const kernel = options.kernel || gaussian;
 	    let h = options.bandwidth;
 	    if (!h || h <= 0) {
-	        const sd = std(data) || 0;
+	        const sd = std(data, deviation) || 0;
 	        const method = options.bandwidthMethod || 'scott';
 	        if (method === 'silverman') {
 	            h = silverman(n, sd, 1);
@@ -3138,6 +3272,7 @@
 	            h = scott(n, sd, 1);
 	        }
 	    }
+	    h *= adjustment;
 	    // if still zero (constant data), evaluator returns zeros
 	    if (!h || h <= 0) {
 	        const zerosEval = (x) => {
@@ -3185,7 +3320,7 @@
 	            evaluateGrid: zerosGrid
 	        };
 	    }
-	    const invNh = 1 / (n * h);
+	    const invNh = 1 / n / h;
 	    function evalPoint(x) {
 	        let sum = 0;
 	        for (let j = 0; j < n; j++) {
@@ -3442,33 +3577,6 @@
 	    return method === 'kendall' ? kendall(x, y) : method === 'spearman' ? pearson(ranks(x), ranks(y)) : pearson(x, y);
 	}
 
-	/** 有限数值的均值；空输入没有均值，不修改输入。 */
-	function mean(values) {
-	    if (!values.length) {
-	        return undefined;
-	    }
-	    let scale = 0;
-	    for (const value of values) {
-	        if (!Number.isFinite(value)) {
-	            throw new RangeError('mean requires finite numbers');
-	        }
-	        scale = Math.max(scale, Math.abs(value));
-	    }
-	    if (scale === 0) {
-	        return 0;
-	    }
-	    let sum = 0;
-	    let correction = 0;
-	    for (const value of values) {
-	        const next = value / scale;
-	        const total = sum + next;
-	        // Neumaier compensation retains small contributions even when larger values cancel.
-	        correction += Math.abs(sum) >= Math.abs(next) ? sum - total + next : next - total + sum;
-	        sum = total;
-	    }
-	    return ((sum + correction) / values.length) * scale;
-	}
-
 	/** 有放回重采样；回调不得修改或持有复用的只读样本缓冲区。 */
 	function bootstrapEstimate(values, estimator, options) {
 	    if (!values.length ||
@@ -3496,6 +3604,55 @@
 	    return estimates;
 	}
 
+	/** 成对 percentile bootstrap；每次重采样仅拟合一次，固定原始坐标基底。 */
+	function regressionBootstrap(data, options) {
+	    var _a;
+	    const degree = options.method === 'linear' ? 1 : (_a = options.degree) !== null && _a !== void 0 ? _a : NaN;
+	    if ((options.method !== 'linear' && options.method !== 'polynomial') ||
+	        !Number.isInteger(degree) ||
+	        degree < 1 ||
+	        !data.length ||
+	        data.some(p => !Number.isFinite(p.x) || !Number.isFinite(p.y)) ||
+	        options.grid.some(x => !Number.isFinite(x)) ||
+	        !(options.level > 0 && options.level < 1) ||
+	        !Number.isInteger(options.resamples) ||
+	        options.resamples < 1 ||
+	        !Number.isInteger(options.seed) ||
+	        options.seed < 0 ||
+	        options.seed > 0xffffffff) {
+	        throw new RangeError('Invalid paired regression bootstrap inputs');
+	    }
+	    if (data.length <= degree + 1) {
+	        throw new RangeError('Regression bootstrap requires positive residual degrees of freedom');
+	    }
+	    const sorted = data.slice().sort((a, b) => a.x - b.x || a.y - b.y);
+	    const basis = regressionBasis(sorted);
+	    if (fitRegression(sorted, degree, basis).rank < degree + 1) {
+	        throw new RangeError('Original regression design is rank deficient');
+	    }
+	    const random = randomLCG(options.seed);
+	    const sample = new Array(sorted.length);
+	    const values = options.grid.map(() => new Array(options.resamples));
+	    for (let b = 0; b < options.resamples; b++) {
+	        for (let i = 0; i < sample.length; i++) {
+	            sample[i] = sorted[Math.floor(random() * sorted.length)];
+	        }
+	        const model = fitRegression(sample, degree, basis);
+	        for (let j = 0; j < options.grid.length; j++) {
+	            const value = regressionPrediction(model, options.grid[j]);
+	            if (!Number.isFinite(value)) {
+	                throw new RangeError('Regression bootstrap prediction is not finite');
+	            }
+	            values[j][b] = value;
+	        }
+	    }
+	    const tail = (1 - options.level) / 2;
+	    return options.grid.map((x, j) => {
+	        values[j].sort((a, b) => a - b);
+	        return { x, lower: quantileSorted(values[j], tail), upper: quantileSorted(values[j], 1 - tail) };
+	    });
+	}
+
 	class HashValue {
 	}
 	// 基于 array 和 object的 HashTable
@@ -8975,6 +9132,7 @@
 	exports.randomLCG = randomLCG;
 	exports.range = range;
 	exports.rectInsideAnotherRect = rectInsideAnotherRect;
+	exports.regressionBootstrap = regressionBootstrap;
 	exports.regressionLinear = regressionLinear;
 	exports.regressionLogistic = regressionLogistic;
 	exports.regressionLowess = regressionLowess;