svelteplot 0.4.6 → 0.4.7

package/dist/helpers/scales.d.ts

@@ -28,7 +28,7 @@ export declare function createScale<T extends ScaleOptions>(name: ScaleName, sca
  * Infer a scale type based on the scale name, the data values mapped to it and
  * the mark types that are bound to the scale
  */
-export declare function inferScaleType(name: ScaleName, dataValues: RawValue[], markTypes: Set<MarkType>): ScaleType;
+export declare function inferScaleType(name: ScaleName, dataValues: RawValue[], markTypes: Set<MarkType>, scaleOptions?: Partial<ScaleOptions>): ScaleType;
 /**
  * Mark channels can explicitly or implicitly be exempt from being
  * mapped to a scale, so everywhere where values are being mapped to

package/dist/helpers/scales.js

@@ -1,5 +1,5 @@
 import { extent, ascending } from 'd3-array';
-import { isColorOrNull, isDateOrNull, isNumberOrNull, isNumberOrNullOrNaN, isStringOrNull } from './typeChecks.js';
+import { isColorOrNull, isDate, isDateOrNull, isNumberOrNull, isNumberOrNullOrNaN, isStringOrNull } from './typeChecks.js';
 import { CHANNEL_SCALE, VALID_SCALE_TYPES } from '../constants.js';
 import { isSymbolOrNull } from './typeChecks.js';
 import { resolveProp, toChannelOption } from './resolve.js';
@@ -146,7 +146,7 @@ export function createScale(name, scaleOptions, marks, plotOptions, plotWidth, p
     // construct domain from data values
     const valueArr = [...dataValues.values(), ...(scaleOptions.domain || [])].filter((d) => d != null);
     const type = scaleOptions.type === 'auto'
-        ? inferScaleType(name, valueArr, markTypes)
+        ? inferScaleType(name, valueArr, markTypes, scaleOptions)
         : scaleOptions.type;
     if (VALID_SCALE_TYPES[name] && !VALID_SCALE_TYPES[name].has(type)) {
         throw new Error(`Invalid scale type ${type} for scale
@@ -217,11 +217,15 @@ function domainFromInterval(domain, interval, name) {
     const out = interval_.range(lo, interval_.offset(hi));
     return name === 'y' ? out.toReversed() : out;
 }
+const markTypesWithBandDefault = {
+    x: new Set(['barY', 'cell', 'tickY']),
+    y: new Set(['barX', 'cell', 'tickX'])
+};
 /**
  * Infer a scale type based on the scale name, the data values mapped to it and
  * the mark types that are bound to the scale
  */
-export function inferScaleType(name, dataValues, markTypes) {
+export function inferScaleType(name, dataValues, markTypes, scaleOptions = {}) {
     if (name === 'color') {
         if (!dataValues.length)
             return 'ordinal';
@@ -235,15 +239,22 @@ export function inferScaleType(name, dataValues, markTypes) {
     }
     if (name === 'symbol')
         return 'ordinal';
-    // for positional scales, try to pick a scale that's required by the mark types
     if (name === 'x' || name === 'y') {
-        if (name === 'y' &&
-            (markTypes.has('barX') || markTypes.has('tickX') || markTypes.has('cell')))
-            return 'band';
-        if (name === 'x' &&
-            (markTypes.has('barY') || markTypes.has('tickY') || markTypes.has('cell')))
-            return 'band';
+        // if for a positional scale we may infer the scale type from the scale options
+        if (scaleOptions.nice || scaleOptions.zero)
+            return 'linear';
+        if (scaleOptions.domain && scaleOptions.domain.length === 2) {
+            if (scaleOptions.domain.every(Number.isFinite))
+                return 'linear';
+            if (scaleOptions.domain.every(isDate))
+                return 'time';
+        }
     }
+    // for positional scales, try to pick a scale that's required by the mark types
+    if (name === 'y' && Array.from(markTypes).some((d) => markTypesWithBandDefault.y.has(d)))
+        return 'band';
+    if (name === 'x' && Array.from(markTypes).some((d) => markTypesWithBandDefault.x.has(d)))
+        return 'band';
     if (!dataValues.length)
         return 'linear';
     if (dataValues.length === 1)

package/dist/marks/helpers/Regression.svelte

@@ -43,7 +43,7 @@
         regressionLog,
         regressionPow,
         regressionLoess
-    } from '@gka/d3-regression';
+    } from '../../regression/index.js';
     import { resolveChannel } from '../../helpers/resolve.js';
     import { confidenceInterval } from '../../helpers/math.js';
     import callWithProps from '../../helpers/callWithProps.js';

package/dist/regression/exponential.d.ts

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

package/dist/regression/exponential.js

@@ -0,0 +1,56 @@
+/**
+ * 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 exponential() {
+    let y = (d) => d[1], x = (d) => d[0], domain;
+    const exponentialRegression = function (data) {
+        let n = 0, Y = 0, YL = 0, XY = 0, XYL = 0, X2Y = 0, xmin = domain ? +domain[0] : Infinity, xmax = domain ? +domain[1] : -Infinity;
+        visitPoints(data, x, y, (dx, dy) => {
+            const ly = Math.log(dy), xy = dx * dy;
+            ++n;
+            Y += (dy - Y) / n;
+            XY += (xy - XY) / n;
+            X2Y += (dx * xy - X2Y) / n;
+            YL += (dy * ly - YL) / n;
+            XYL += (xy * ly - XYL) / n;
+            if (!domain) {
+                if (dx < xmin)
+                    xmin = dx;
+                if (dx > xmax)
+                    xmax = dx;
+            }
+        });
+        let [a, b] = ols(XY / Y, YL / Y, XYL / Y, X2Y / Y);
+        a = Math.exp(a);
+        const fn = (xx) => a * Math.exp(b * xx);
+        const out = interpose(xmin, xmax, fn);
+        out.a = a;
+        out.b = b;
+        out.predict = fn;
+        out.rSquared = determination(data, x, y, Y, fn);
+        return out;
+    };
+    exponentialRegression.domain = function (arr) {
+        if (!arguments.length)
+            return domain;
+        domain = arr;
+        return exponentialRegression;
+    };
+    exponentialRegression.x = function (fn) {
+        if (!arguments.length)
+            return x;
+        x = fn;
+        return exponentialRegression;
+    };
+    exponentialRegression.y = function (fn) {
+        if (!arguments.length)
+            return y;
+        y = fn;
+        return exponentialRegression;
+    };
+    return exponentialRegression;
+}

package/dist/regression/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Adapted from https://github.com/HarryStevens/d3-regression
+ */
+export { default as regressionLinear } from './linear.js';
+export { default as regressionPoly } from './polynomial.js';
+export { default as regressionExp } from './exponential.js';
+export { default as regressionLog } from './logarithmic.js';
+export { default as regressionPow } from './power.js';
+export { default as regressionQuad } from './quadratic.js';
+export { default as regressionLoess } from './loess.js';

package/dist/regression/index.js

@@ -0,0 +1,10 @@
+/**
+ * Adapted from https://github.com/HarryStevens/d3-regression
+ */
+export { default as regressionLinear } from './linear.js';
+export { default as regressionPoly } from './polynomial.js';
+export { default as regressionExp } from './exponential.js';
+export { default as regressionLog } from './logarithmic.js';
+export { default as regressionPow } from './power.js';
+export { default as regressionQuad } from './quadratic.js';
+export { default as regressionLoess } from './loess.js';

package/dist/regression/linear.d.ts

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

package/dist/regression/linear.js

@@ -0,0 +1,59 @@
+/**
+ * Adapted from https://github.com/HarryStevens/d3-regression
+ */
+import { determination } from './utils/determination.js';
+import { ols } from './utils/ols.js';
+import { visitPoints } from './utils/points.js';
+export default function linear() {
+    let x = (d) => d[0], y = (d) => d[1], domain;
+    const linearRegression = function (data) {
+        let n = 0, X = 0, // sum of x
+        Y = 0, // sum of y
+        XY = 0, // sum of x*y
+        X2 = 0, // sum of x*x
+        xmin = domain ? +domain[0] : Infinity, xmax = domain ? +domain[1] : -Infinity;
+        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;
+            if (!domain) {
+                if (dx < xmin)
+                    xmin = dx;
+                if (dx > xmax)
+                    xmax = dx;
+            }
+        });
+        const [intercept, slope] = ols(X, Y, XY, X2);
+        const fn = (xx) => slope * xx + intercept;
+        const out = [
+            [xmin, fn(xmin)],
+            [xmax, fn(xmax)]
+        ];
+        out.a = slope;
+        out.b = intercept;
+        out.predict = fn;
+        out.rSquared = determination(data, x, y, Y, fn);
+        return out;
+    };
+    linearRegression.domain = function (arr) {
+        if (!arguments.length)
+            return domain;
+        domain = arr;
+        return linearRegression;
+    };
+    linearRegression.x = function (fn) {
+        if (!arguments.length)
+            return x;
+        x = fn;
+        return linearRegression;
+    };
+    linearRegression.y = function (fn) {
+        if (!arguments.length)
+            return y;
+        y = fn;
+        return linearRegression;
+    };
+    return linearRegression;
+}

package/dist/regression/loess.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Adapted from https://github.com/HarryStevens/d3-regression
+ */
+import type { Accessor, DataPoint } from './types.js';
+export interface LoessRegression<T> {
+    (data: T[]): DataPoint[];
+    bandwidth(): number;
+    bandwidth(bw: number): this;
+    x(): Accessor<T>;
+    x(fn: Accessor<T>): this;
+    y(): Accessor<T>;
+    y(fn: Accessor<T>): this;
+}
+export default function loess<T = DataPoint>(): LoessRegression<T>;

package/dist/regression/loess.js

@@ -0,0 +1,122 @@
+/**
+ * Adapted from https://github.com/HarryStevens/d3-regression
+ */
+// Adapted from science.js by Jason Davies
+// License: https://github.com/jasondavies/science.js/blob/master/LICENSE
+// Source: https://github.com/jasondavies/science.js/blob/master/src/stats/loess.js
+// Adapted from vega-statistics by Jeffrey Heer
+// License: https://github.com/vega/vega/blob/f058b099decad9db78301405dd0d2e9d8ba3d51a/LICENSE
+// Source: https://github.com/vega/vega/blob/f21cb8792b4e0cbe2b1a3fd44b0f5db370dbaadb/packages/vega-statistics/src/regression/loess.js
+import { median } from './utils/median.js';
+import { ols } from './utils/ols.js';
+import { points } from './utils/points.js';
+const maxiters = 2, epsilon = 1e-12;
+export default function loess() {
+    let x = (d) => d[0], y = (d) => d[1], bandwidth = 0.3;
+    const loessRegression = function loessRegression(data) {
+        const [xv, yv, ux, uy] = points(data, (dd) => x(dd), (dd) => y(dd), true);
+        const n = xv.length;
+        const bw = Math.max(2, ~~(bandwidth * n)); // # of nearest neighbors
+        const yhat = new Float64Array(n);
+        const residuals = new Float64Array(n);
+        const robustWeights = new Float64Array(n).fill(1);
+        for (let iter = -1; ++iter <= maxiters;) {
+            const interval = [0, bw - 1];
+            for (let i = 0; i < n; ++i) {
+                const dx = xv[i];
+                const i0 = interval[0];
+                const i1 = interval[1];
+                const edge = dx - xv[i0] > xv[i1] - dx ? i0 : i1;
+                let W = 0, X = 0, Y = 0, XY = 0, X2 = 0;
+                const denom = 1 / Math.abs(xv[edge] - dx || 1);
+                for (let k = i0; k <= i1; ++k) {
+                    const xk = xv[k];
+                    const yk = yv[k];
+                    const w = tricube(Math.abs(dx - xk) * denom) * robustWeights[k];
+                    const xkw = xk * w;
+                    W += w;
+                    X += xkw;
+                    Y += yk * w;
+                    XY += yk * xkw;
+                    X2 += xk * xkw;
+                }
+                // Linear regression fit
+                const [a, b] = ols(X / W, Y / W, XY / W, X2 / W);
+                yhat[i] = a + b * dx;
+                residuals[i] = Math.abs(yv[i] - yhat[i]);
+                updateInterval(xv, i + 1, interval);
+            }
+            if (iter === maxiters) {
+                break;
+            }
+            const medianResidual = median(residuals);
+            if (Math.abs(medianResidual) < epsilon)
+                break;
+            for (let i = 0, arg, w; i < n; ++i) {
+                arg = residuals[i] / (6 * medianResidual);
+                // Default to epsilon (rather than zero) for large deviations
+                // Keeping weights tiny but non-zero prevents singularites
+                robustWeights[i] = arg >= 1 ? epsilon : (w = 1 - arg * arg) * w;
+            }
+        }
+        return output(xv, yhat, ux, uy);
+    };
+    loessRegression.bandwidth = function (bw) {
+        if (!arguments.length)
+            return bandwidth;
+        bandwidth = bw;
+        return loessRegression;
+    };
+    loessRegression.x = function (fn) {
+        if (!arguments.length)
+            return x;
+        x = fn;
+        return loessRegression;
+    };
+    loessRegression.y = function (fn) {
+        if (!arguments.length)
+            return y;
+        y = fn;
+        return loessRegression;
+    };
+    return loessRegression;
+}
+// Weighting kernel for local regression
+function tricube(x) {
+    return (x = 1 - x * x * x) * x * x;
+}
+// Advance sliding window interval of nearest neighbors
+function updateInterval(xv, i, interval) {
+    let val = xv[i], left = interval[0], right = interval[1] + 1;
+    if (right >= xv.length)
+        return;
+    // Step right if distance to new right edge is <= distance to old left edge
+    // Step when distance is equal to ensure movement over duplicate x values
+    while (i > left && xv[right] - val <= val - xv[left]) {
+        interval[0] = ++left;
+        interval[1] = right;
+        ++right;
+    }
+}
+// Generate smoothed output points
+// Average points with repeated x values
+function output(xv, yhat, ux, uy) {
+    const n = xv.length, out = [];
+    let i = 0, cnt = 0, prev = [], v;
+    for (; i < n; ++i) {
+        v = xv[i] + ux;
+        if (prev[0] === v) {
+            // Average output values via online update
+            prev[1] += (yhat[i] - prev[1]) / ++cnt;
+        }
+        else {
+            // Add new output point
+            cnt = 0;
+            prev[1] += uy;
+            prev = [v, yhat[i]];
+            out.push(prev);
+        }
+    }
+    prev[1] += uy;
+    return out;
+}

package/dist/regression/logarithmic.d.ts

@@ -0,0 +1,20 @@
+import type { PredictFunction, DataPoint, Accessor, Domain } from './types.js';
+type LogarithmicOutput = [DataPoint, DataPoint] & {
+    a: number;
+    b: number;
+    predict: PredictFunction;
+    rSquared: number;
+};
+export interface LogarithmicRegression<T> {
+    (data: T[]): LogarithmicOutput;
+    domain(): Domain;
+    domain(arr: Domain): this;
+    x(): Accessor<T>;
+    x(fn: Accessor<T>): this;
+    y(): Accessor<T>;
+    y(fn: Accessor<T>): this;
+    base(): number;
+    base(b: number): this;
+}
+export default function logarithmic<T = DataPoint>(): LogarithmicRegression<T>;
+export {};

package/dist/regression/logarithmic.js

@@ -0,0 +1,60 @@
+/**
+ * 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 logarithmic() {
+    let x = (d) => d[0], y = (d) => d[1], base = Math.E, domain;
+    const logarithmicRegression = function (data) {
+        let n = 0, X = 0, Y = 0, XY = 0, X2 = 0, xmin = domain ? +domain[0] : Infinity, xmax = domain ? +domain[1] : -Infinity, lb = Math.log(base);
+        visitPoints(data, x, y, (dx, dy) => {
+            const lx = Math.log(dx) / lb;
+            ++n;
+            X += (lx - X) / n;
+            Y += (dy - Y) / n;
+            XY += (lx * dy - XY) / n;
+            X2 += (lx * lx - X2) / n;
+            if (!domain) {
+                if (dx < xmin)
+                    xmin = dx;
+                if (dx > xmax)
+                    xmax = dx;
+            }
+        });
+        const [intercept, slope] = ols(X, Y, XY, X2);
+        const fn = (xx) => (slope * Math.log(xx)) / lb + intercept;
+        const out = interpose(xmin, xmax, fn);
+        out.a = slope;
+        out.b = intercept;
+        out.predict = fn;
+        out.rSquared = determination(data, x, y, Y, fn);
+        return out;
+    };
+    logarithmicRegression.domain = function (arr) {
+        if (!arguments.length)
+            return domain;
+        domain = arr;
+        return logarithmicRegression;
+    };
+    logarithmicRegression.x = function (fn) {
+        if (!arguments.length)
+            return x;
+        x = fn;
+        return logarithmicRegression;
+    };
+    logarithmicRegression.y = function (fn) {
+        if (!arguments.length)
+            return y;
+        y = fn;
+        return logarithmicRegression;
+    };
+    logarithmicRegression.base = function (b) {
+        if (!arguments.length)
+            return base;
+        base = b;
+        return logarithmicRegression;
+    };
+    return logarithmicRegression;
+}

package/dist/regression/polynomial.d.ts

@@ -0,0 +1,21 @@
+/**
+ * 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

@@ -0,0 +1,160 @@
+/**
+ * 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

@@ -0,0 +1,18 @@
+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

@@ -0,0 +1,56 @@
+/**
+ * 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

@@ -0,0 +1,19 @@
+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

@@ -0,0 +1,70 @@
+/**
+ * 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

@@ -0,0 +1,4 @@
+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

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

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

@@ -0,0 +1,6 @@
+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

@@ -0,0 +1,16 @@
+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

@@ -0,0 +1,9 @@
+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

@@ -0,0 +1,12 @@
+/**
+ * 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

@@ -0,0 +1,6 @@
+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

@@ -0,0 +1,37 @@
+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

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

package/dist/regression/utils/median.js

@@ -0,0 +1,8 @@
+/**
+ * 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

@@ -0,0 +1,6 @@
+/**
+ * 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

@@ -0,0 +1,9 @@
+/**
+ * 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

@@ -0,0 +1,11 @@
+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

@@ -0,0 +1,45 @@
+/**
+ * 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++);
+        }
+    }
+}

package/dist/types/scale.d.ts

@@ -24,7 +24,13 @@ export type ScaleOptions = {
     label?: string | false;
     interval?: string | number;
     clamp: boolean;
+    /**
+     * Extend the domain to nice round numbers (applicable to quantitative scales only)
+     */
     nice: boolean;
+    /**
+     * Include zero in the scale domain (applicable to quantitative scales only)
+     */
     zero: boolean;
     round: boolean;
     percent: boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "svelteplot",
-  "version": "0.4.6",
+  "version": "0.4.7",
   "license": "ISC",
   "author": {
     "name": "Gregor Aisch",
@@ -104,7 +104,6 @@
     "d3-path": "^3.1.0",
     "d3-quadtree": "^3.0.1",
     "d3-random": "^3.0.1",
-    "@gka/d3-regression": "^1.3.10-pr48",
     "d3-scale": "^4.0.2",
     "d3-scale-chromatic": "^3.1.0",
     "d3-shape": "^3.2.0",