svelteplot 0.4.6-pr-213.3 → 0.4.6

package/dist/regression/polynomial.d.ts

@@ -1,21 +0,0 @@
-/**
- * Adapted from https://github.com/HarryStevens/d3-regression
- */
-import type { PredictFunction, Accessor, DataPoint, Domain } from './types';
-export type PolynomialOutput = [DataPoint, DataPoint] & {
-    coefficients: number[];
-    predict: PredictFunction;
-    rSquared: number;
-};
-export interface PolynomialRegression<T> {
-    (data: T[]): PolynomialOutput;
-    domain(): Domain;
-    domain(domain?: Domain): this;
-    x(): Accessor<T>;
-    x(x: Accessor<T>): this;
-    y(): Accessor<T>;
-    y(y: Accessor<T>): this;
-    order(): number;
-    order(order: number): this;
-}
-export default function polynomial<T = DataPoint>(): PolynomialRegression<T>;

package/dist/regression/polynomial.js

@@ -1,160 +0,0 @@
-/**
- * Adapted from https://github.com/HarryStevens/d3-regression
- */
-// Adapted from regression-js by Tom Alexander
-// Source: https://github.com/Tom-Alexander/regression-js/blob/master/src/regression.js#L246
-// License: https://github.com/Tom-Alexander/regression-js/blob/master/LICENSE
-// ...with ideas from vega-statistics by Jeffrey Heer
-// Source: https://github.com/vega/vega/blob/f21cb8792b4e0cbe2b1a3fd44b0f5db370dbaadb/packages/vega-statistics/src/regression/poly.js
-// License: https://github.com/vega/vega/blob/f058b099decad9db78301405dd0d2e9d8ba3d51a/LICENSE
-import { determination } from './utils/determination';
-import { interpose } from './utils/interpose';
-import { points, visitPoints } from './utils/points';
-import linear from './linear';
-import quad from './quadratic';
-export default function polynomial() {
-    let x = (d) => d[0], y = (d) => d[1], order = 3, domain;
-    const polynomialRegression = function polynomialRegression(data) {
-        // Shortcut for lower-order polynomials:
-        if (order === 1) {
-            const o = linear().x(x).y(y).domain(domain)(data);
-            const result = [o[0], o[1]];
-            result.coefficients = [o.b, o.a];
-            result.predict = o.predict;
-            result.rSquared = o.rSquared;
-            return result;
-        }
-        if (order === 2) {
-            const o = quad().x(x).y(y).domain(domain)(data);
-            const result = [o[0], o[1]];
-            result.coefficients = [o.c, o.b, o.a];
-            result.predict = o.predict;
-            result.rSquared = o.rSquared;
-            return result;
-        }
-        const [xv, yv, ux, uy] = points(data, x, y);
-        const n = xv.length;
-        const k = order + 1;
-        const lhs = [];
-        const rhs = [];
-        let Y = 0, n0 = 0, xmin = domain ? +domain[0] : Infinity, xmax = domain ? +domain[1] : -Infinity;
-        visitPoints(data, x, y, (dx, dy) => {
-            n0++;
-            Y += (dy - Y) / n0;
-            if (!domain) {
-                if (dx < xmin)
-                    xmin = dx;
-                if (dx > xmax)
-                    xmax = dx;
-            }
-        });
-        // Build normal equations
-        for (let i = 0; i < k; i++) {
-            // LHS
-            let v = 0;
-            for (let l = 0; l < n; l++) {
-                v += Math.pow(xv[l], i) * yv[l];
-            }
-            lhs.push(v);
-            // RHS
-            const c = new Float64Array(k);
-            for (let j = 0; j < k; j++) {
-                let v2 = 0;
-                for (let l = 0; l < n; l++) {
-                    v2 += Math.pow(xv[l], i + j);
-                }
-                c[j] = v2;
-            }
-            rhs.push(c);
-        }
-        rhs.push(new Float64Array(lhs));
-        const coef = gaussianElimination(rhs);
-        const fn = (xx) => {
-            let shifted = xx - ux;
-            let val = uy + coef[0];
-            for (let i = 1; i < k; i++) {
-                val += coef[i] * Math.pow(shifted, i);
-            }
-            return val;
-        };
-        const out = interpose(xmin, xmax, fn);
-        out.coefficients = uncenter(k, coef, -ux, uy);
-        out.predict = fn;
-        out.rSquared = determination(data, x, y, Y, fn);
-        return out;
-    };
-    polynomialRegression.domain = function (arr) {
-        if (!arguments.length)
-            return domain;
-        domain = arr;
-        return polynomialRegression;
-    };
-    polynomialRegression.x = function (fn) {
-        if (!arguments.length)
-            return x;
-        x = fn;
-        return polynomialRegression;
-    };
-    polynomialRegression.y = function (fn) {
-        if (!arguments.length)
-            return y;
-        y = fn;
-        return polynomialRegression;
-    };
-    polynomialRegression.order = function (n) {
-        if (!arguments.length)
-            return order;
-        order = n;
-        return polynomialRegression;
-    };
-    return polynomialRegression;
-}
-function uncenter(k, a, x, y) {
-    const z = new Array(k).fill(0);
-    for (let i = k - 1; i >= 0; --i) {
-        let v = a[i];
-        z[i] += v;
-        let c = 1;
-        for (let j = 1; j <= i; ++j) {
-            c *= (i + 1 - j) / j; // binomial coefficient
-            z[i - j] += v * Math.pow(x, j) * c;
-        }
-    }
-    // bias term
-    z[0] += y;
-    return z;
-}
-// Solve A * x = b using Gaussian elimination
-function gaussianElimination(matrix) {
-    const n = matrix.length - 1;
-    const coef = new Array(n);
-    for (let i = 0; i < n; i++) {
-        let r = i;
-        // find pivot row
-        for (let j = i + 1; j < n; j++) {
-            if (Math.abs(matrix[i][j]) > Math.abs(matrix[i][r])) {
-                r = j;
-            }
-        }
-        // swap columns
-        for (let k = i; k < n + 1; k++) {
-            const t = matrix[k][i];
-            matrix[k][i] = matrix[k][r];
-            matrix[k][r] = t;
-        }
-        // reduce
-        for (let j = i + 1; j < n; j++) {
-            for (let k = n; k >= i; k--) {
-                matrix[k][j] -= (matrix[k][i] * matrix[i][j]) / matrix[i][i];
-            }
-        }
-    }
-    for (let j = n - 1; j >= 0; j--) {
-        let t = 0;
-        for (let k = j + 1; k < n; k++) {
-            t += matrix[k][j] * coef[k];
-        }
-        coef[j] = (matrix[n][j] - t) / matrix[j][j];
-    }
-    return coef;
-}

package/dist/regression/power.d.ts

@@ -1,18 +0,0 @@
-import type { PredictFunction, DataPoint, Accessor, Domain } from './types.js';
-export type PowerOutput = [DataPoint, DataPoint] & {
-    a: number;
-    b: number;
-    predict: PredictFunction;
-    rSquared: number;
-};
-interface PowerRegression<T> {
-    (data: T[]): PowerOutput;
-    domain(): Domain;
-    domain(domain?: Domain): this;
-    x(): Accessor<T>;
-    x(x: Accessor<T>): this;
-    y(): Accessor<T>;
-    y(y: Accessor<T>): this;
-}
-export default function power<T = DataPoint>(): PowerRegression<T>;
-export {};

package/dist/regression/power.js

@@ -1,56 +0,0 @@
-/**
- * Adapted from https://github.com/HarryStevens/d3-regression
- */
-import { determination } from './utils/determination.js';
-import { interpose } from './utils/interpose.js';
-import { ols } from './utils/ols.js';
-import { visitPoints } from './utils/points.js';
-export default function power() {
-    let x = (d) => d[0], y = (d) => d[1], domain;
-    const powerRegression = function powerRegression(data) {
-        let n = 0, X = 0, Y = 0, XY = 0, X2 = 0, YS = 0, xmin = domain ? +domain[0] : Infinity, xmax = domain ? +domain[1] : -Infinity;
-        visitPoints(data, x, y, (dx, dy) => {
-            const lx = Math.log(dx), ly = Math.log(dy);
-            ++n;
-            X += (lx - X) / n;
-            Y += (ly - Y) / n;
-            XY += (lx * ly - XY) / n;
-            X2 += (lx * lx - X2) / n;
-            YS += (dy - YS) / n;
-            if (!domain) {
-                if (dx < xmin)
-                    xmin = dx;
-                if (dx > xmax)
-                    xmax = dx;
-            }
-        });
-        let [a, b] = ols(X, Y, XY, X2);
-        a = Math.exp(a);
-        const fn = (xx) => a * Math.pow(xx, b);
-        const out = interpose(xmin, xmax, fn);
-        out.a = a;
-        out.b = b;
-        out.predict = fn;
-        out.rSquared = determination(data, x, y, YS, fn);
-        return out;
-    };
-    powerRegression.domain = function (arr) {
-        if (!arguments.length)
-            return domain;
-        domain = arr;
-        return powerRegression;
-    };
-    powerRegression.x = function (fn) {
-        if (!arguments.length)
-            return x;
-        x = fn;
-        return powerRegression;
-    };
-    powerRegression.y = function (fn) {
-        if (!arguments.length)
-            return y;
-        y = fn;
-        return powerRegression;
-    };
-    return powerRegression;
-}

package/dist/regression/quadratic.d.ts

@@ -1,19 +0,0 @@
-import type { Accessor, DataPoint, PredictFunction, Domain } from './types.js';
-export type QuadraticOutput = [DataPoint, DataPoint] & {
-    a: number;
-    b: number;
-    c: number;
-    predict: PredictFunction;
-    rSquared: number;
-};
-interface QuadraticRegression<T> {
-    (data: T[]): QuadraticOutput;
-    domain(): Domain;
-    domain(domain?: Domain): this;
-    x(): Accessor<T>;
-    x(x: Accessor<T>): this;
-    y(): Accessor<T>;
-    y(y: Accessor<T>): this;
-}
-export default function quadratic<T = DataPoint>(): QuadraticRegression<T>;
-export {};

package/dist/regression/quadratic.js

@@ -1,70 +0,0 @@
-/**
- * Adapted from https://github.com/HarryStevens/d3-regression
- */
-import { determination } from './utils/determination.js';
-import { interpose } from './utils/interpose.js';
-import { points, visitPoints } from './utils/points.js';
-export default function quadratic() {
-    let x = (d) => d[0], y = (d) => d[1], domain;
-    const quadraticRegression = function quadraticRegression(data) {
-        const [xv, yv, ux, uy] = points(data, (dd) => x(dd), (dd) => y(dd));
-        const n = xv.length;
-        let X2 = 0, X3 = 0, X4 = 0, XY = 0, X2Y = 0, i, dx, dy, x2;
-        for (i = 0; i < n;) {
-            dx = xv[i];
-            dy = yv[i++];
-            x2 = dx * dx;
-            X2 += (x2 - X2) / i;
-            X3 += (x2 * dx - X3) / i;
-            X4 += (x2 * x2 - X4) / i;
-            XY += (dx * dy - XY) / i;
-            X2Y += (x2 * dy - X2Y) / i;
-        }
-        let Y = 0, n0 = 0, xmin = domain ? +domain[0] : Infinity, xmax = domain ? +domain[1] : -Infinity;
-        visitPoints(data, x, y, (dx2, dy2) => {
-            n0++;
-            Y += (dy2 - Y) / n0;
-            if (!domain) {
-                if (dx2 < xmin)
-                    xmin = dx2;
-                if (dx2 > xmax)
-                    xmax = dx2;
-            }
-        });
-        const X2X2 = X4 - X2 * X2;
-        const d = X2 * X2X2 - X3 * X3;
-        const a = (X2Y * X2 - XY * X3) / d;
-        const b = (XY * X2X2 - X2Y * X3) / d;
-        const c = -a * X2;
-        const fn = (xx) => {
-            const shifted = xx - ux;
-            return a * shifted * shifted + b * shifted + c + uy;
-        };
-        const out = interpose(xmin, xmax, fn);
-        out.a = a;
-        out.b = b - 2 * a * ux;
-        out.c = c - b * ux + a * ux * ux + uy;
-        out.predict = fn;
-        out.rSquared = determination(data, x, y, Y, fn);
-        return out;
-    };
-    quadraticRegression.domain = function (arr) {
-        if (!arguments.length)
-            return domain;
-        domain = arr;
-        return quadraticRegression;
-    };
-    quadraticRegression.x = function (fn) {
-        if (!arguments.length)
-            return x;
-        x = fn;
-        return quadraticRegression;
-    };
-    quadraticRegression.y = function (fn) {
-        if (!arguments.length)
-            return y;
-        y = fn;
-        return quadraticRegression;
-    };
-    return quadraticRegression;
-}

package/dist/regression/types.d.ts

@@ -1,4 +0,0 @@
-export type DataPoint = [number, number];
-export type Accessor<T> = (d: T, i?: number, data?: T[]) => number;
-export type PredictFunction = (x: number) => number;
-export type Domain = [number, number] | undefined;

package/dist/regression/types.js

@@ -1 +0,0 @@
-export {};

package/dist/regression/utils/determination.d.ts

@@ -1,6 +0,0 @@
-import type { Accessor, PredictFunction } from '../types';
-/**
- * Given a dataset, x- and y-accessors, the mean center of the y-values (uY),
- * and a prediction function, return the coefficient of determination, R^2.
- */
-export declare function determination<T>(data: T[], x: Accessor<T>, y: Accessor<T>, uY: number, predict: PredictFunction): number;

package/dist/regression/utils/determination.js

@@ -1,16 +0,0 @@
-import { visitPoints } from './points';
-/**
- * Given a dataset, x- and y-accessors, the mean center of the y-values (uY),
- * and a prediction function, return the coefficient of determination, R^2.
- */
-export function determination(data, x, y, uY, predict) {
-    let SSE = 0, // Sum of Squared Errors
-    SST = 0; // Total Sum of Squares
-    visitPoints(data, x, y, (dx, dy) => {
-        const sse = dy - predict(dx);
-        const sst = dy - uY;
-        SSE += sse * sse;
-        SST += sst * sst;
-    });
-    return 1 - SSE / SST;
-}

package/dist/regression/utils/geometry.d.ts

@@ -1,9 +0,0 @@
-import type { DataPoint } from '../types';
-/**
- * Returns the angle of a line in degrees.
- */
-export declare function angle(line: [DataPoint, DataPoint]): number;
-/**
- * Returns the midpoint of a line.
- */
-export declare function midpoint(line: [DataPoint, DataPoint]): DataPoint;

package/dist/regression/utils/geometry.js

@@ -1,12 +0,0 @@
-/**
- * Returns the angle of a line in degrees.
- */
-export function angle(line) {
-    return Math.atan2(line[1][1] - line[0][1], line[1][0] - line[0][0]) * (180 / Math.PI);
-}
-/**
- * Returns the midpoint of a line.
- */
-export function midpoint(line) {
-    return [(line[0][0] + line[1][0]) / 2, (line[0][1] + line[1][1]) / 2];
-}

package/dist/regression/utils/interpose.d.ts

@@ -1,6 +0,0 @@
-import type { PredictFunction, DataPoint } from '../types';
-/**
- * Given a start point (xmin), an end point (xmax),
- * and a prediction function, returns a smooth line.
- */
-export declare function interpose(xmin: number, xmax: number, predict: PredictFunction): [DataPoint, DataPoint];

package/dist/regression/utils/interpose.js

@@ -1,37 +0,0 @@
-import { angle, midpoint } from './geometry';
-/**
- * Given a start point (xmin), an end point (xmax),
- * and a prediction function, returns a smooth line.
- */
-export function interpose(xmin, xmax, predict) {
-    const l = (Math.log(xmax - xmin) * Math.LOG10E + 1) | 0;
-    const precision = Math.pow(10, -l / 2 - 1);
-    const maxIter = 1e4;
-    let points = [px(xmin), px(xmax)];
-    let iter = 0;
-    while (find(points) && iter < maxIter)
-        ;
-    return points;
-    function px(x) {
-        return [x, predict(x)];
-    }
-    function find(points) {
-        iter++;
-        const n = points.length;
-        let found = false;
-        for (let i = 0; i < n - 1; i++) {
-            const p0 = points[i];
-            const p1 = points[i + 1];
-            const m = midpoint([p0, p1]);
-            const mp = px(m[0]);
-            const a0 = angle([p0, m]);
-            const a1 = angle([p0, mp]);
-            const a = Math.abs(a0 - a1);
-            if (a > precision) {
-                points.splice(i + 1, 0, mp);
-                found = true;
-            }
-        }
-        return found;
-    }
-}

package/dist/regression/utils/median.d.ts

@@ -1,4 +0,0 @@
-/**
- * Returns the median value of an array of numbers.
- */
-export declare function median(arr: Float64Array): number;

package/dist/regression/utils/median.js

@@ -1,8 +0,0 @@
-/**
- * Returns the median value of an array of numbers.
- */
-export function median(arr) {
-    arr.sort((a, b) => a - b);
-    var i = arr.length / 2;
-    return i % 1 === 0 ? (arr[i - 1] + arr[i]) / 2 : arr[Math.floor(i)];
-}

package/dist/regression/utils/ols.d.ts

@@ -1,6 +0,0 @@
-/**
- * Ordinary Least Squares from vega-statistics by Jeffrey Heer
- * License: https://github.com/vega/vega/blob/f058b099decad9db78301405dd0d2e9d8ba3d51a/LICENSE
- * Source: https://github.com/vega/vega/blob/f058b099decad9db78301405dd0d2e9d8ba3d51a/packages/vega-statistics/src/regression/ols.js
- */
-export declare function ols(uX: number, uY: number, uXY: number, uX2: number): [number, number];

package/dist/regression/utils/ols.js

@@ -1,9 +0,0 @@
-/**
- * Ordinary Least Squares from vega-statistics by Jeffrey Heer
- * License: https://github.com/vega/vega/blob/f058b099decad9db78301405dd0d2e9d8ba3d51a/LICENSE
- * Source: https://github.com/vega/vega/blob/f058b099decad9db78301405dd0d2e9d8ba3d51a/packages/vega-statistics/src/regression/ols.js
- */
-export function ols(uX, uY, uXY, uX2) {
-    const delta = uX2 - uX * uX, slope = Math.abs(delta) < 1e-24 ? 0 : (uXY - uX * uY) / delta, intercept = uY - slope * uX;
-    return [intercept, slope];
-}

package/dist/regression/utils/points.d.ts

@@ -1,11 +0,0 @@
-import type { Accessor } from '../types';
-/**
- * Adapted from vega-statistics by Jeffrey Heer
- * License: https://github.com/vega/vega/blob/f058b099decad9db78301405dd0d2e9d8ba3d51a/LICENSE
- * Source: https://github.com/vega/vega/blob/f058b099decad9db78301405dd0d2e9d8ba3d51a/packages/vega-statistics/src/regression/points.js
- */
-export declare function points<T>(data: T[], x: Accessor<T>, y: Accessor<T>, sort?: boolean): [Float64Array, Float64Array, number, number];
-/**
- * Iterates over valid data points, invoking a callback for each.
- */
-export declare function visitPoints<T>(data: T[], x: Accessor<T>, y: Accessor<T>, cb: (dx: number, dy: number, index: number) => void): void;

package/dist/regression/utils/points.js

@@ -1,45 +0,0 @@
-/**
- * Adapted from vega-statistics by Jeffrey Heer
- * License: https://github.com/vega/vega/blob/f058b099decad9db78301405dd0d2e9d8ba3d51a/LICENSE
- * Source: https://github.com/vega/vega/blob/f058b099decad9db78301405dd0d2e9d8ba3d51a/packages/vega-statistics/src/regression/points.js
- */
-export function points(data, x, y, sort) {
-    data = data.filter((d, i) => {
-        let u = x(d, i), v = y(d, i);
-        return u != null && isFinite(u) && v != null && isFinite(v);
-    });
-    if (sort) {
-        data.sort((a, b) => x(a) - x(b));
-    }
-    const n = data.length, X = new Float64Array(n), Y = new Float64Array(n);
-    // extract values, calculate means
-    let ux = 0, uy = 0, xv, yv, d;
-    for (let i = 0; i < n;) {
-        d = data[i];
-        X[i] = xv = +x(d, i, data);
-        Y[i] = yv = +y(d, i, data);
-        ++i;
-        ux += (xv - ux) / i;
-        uy += (yv - uy) / i;
-    }
-    // mean center the data
-    for (let i = 0; i < n; ++i) {
-        X[i] -= ux;
-        Y[i] -= uy;
-    }
-    return [X, Y, ux, uy];
-}
-/**
- * Iterates over valid data points, invoking a callback for each.
- */
-export function visitPoints(data, x, y, cb) {
-    let iterations = 0;
-    for (let i = 0; i < data.length; i++) {
-        const d = data[i];
-        const dx = +x(d, i, data);
-        const dy = +y(d, i, data);
-        if (dx != null && isFinite(dx) && dy != null && isFinite(dy)) {
-            cb(dx, dy, iterations++);
-        }
-    }
-}