@sophistry/charts 0.0.0-stage → 0.0.1

package/dist/math/chord.d.ts

@@ -0,0 +1,104 @@
+/**
+ * Chord diagram layout over a square flow matrix: `matrix[i][j]` is the
+ * flow from group `i` to `j`. Each group is an arc as long as its outflow;
+ * a chord joins sub-arc `i → j` to `j → i`, each end as wide as its flow.
+ * Angles are radians from +x, y up, starting at 12 o'clock clockwise.
+ */
+import type { Point } from "@sophistry/core/geometry";
+import type { PolarSweepOptions } from "./shared/polar";
+/** @category Math */
+export interface ChordOptions extends PolarSweepOptions {
+    /** Gap between neighbouring groups, in radians. @default 0.04 */
+    padAngle?: number;
+    /** Order each group's sub-arcs by descending flow instead of by column. @default false */
+    sortSubgroups?: boolean;
+    /**
+     * Every non-zero `matrix[i][j]` becomes its own chord, equally wide at both
+     * ends, and a group's arc holds outflow then inflow (so receive-only groups
+     * get an arc). Off, one chord per pair with arcs sized by outflow.
+     * @default false
+     */
+    directed?: boolean;
+}
+/**
+ * One group's arc.
+ *
+ * @category Math & helpers
+ */
+export interface ChordGroup {
+    /** Row (and column) of the matrix. */
+    index: number;
+    /** Radians from +x, where the arc begins. */
+    startAngle: number;
+    /** Radians from +x, where it ends: `endAngle - startAngle` is the signed sweep. */
+    endAngle: number;
+    /** The row's total: everything leaving the group (plus, when `directed`, everything arriving). */
+    value: number;
+}
+/**
+ * One end of a chord: a sub-arc of a group.
+ *
+ * @category Math & helpers
+ */
+export interface ChordEnd {
+    /** The group the end sits on. */
+    index: number;
+    /** The group at the chord's other end. */
+    subindex: number;
+    startAngle: number;
+    endAngle: number;
+    /** The flow this end stands for: `matrix[index][subindex]` (a directed chord's target end: `matrix[subindex][index]`). */
+    value: number;
+}
+/**
+ * A chord between two groups (or a group and itself).
+ *
+ * @category Math & helpers
+ */
+export interface ChordLink {
+    /** The end with the larger flow. */
+    source: ChordEnd;
+    /** The other end. */
+    target: ChordEnd;
+}
+/** @category Math */
+export interface ChordLayout {
+    /** One arc per matrix row, in index order. */
+    groups: ChordGroup[];
+    /** One chord per pair of groups with any flow between them, by source row then column. */
+    chords: ChordLink[];
+}
+/**
+ * Lays a square flow matrix out as a chord diagram's groups and chords.
+ *
+ * @param matrix - `matrix[i][j]` is the flow from `i` to `j`; negative and non-finite entries count as 0, ragged rows are padded with 0.
+ * @returns The groups and chords; no chords and zero-length groups when there is no flow.
+ * @category Math & helpers
+ */
+export declare function chordLayout(matrix: readonly (readonly number[])[], options?: ChordOptions): ChordLayout;
+/** @category Math */
+export interface ChordRibbonOptions {
+    /** Centre. Defaults to the origin. */
+    center?: Point;
+    /** Points per radian along each end's arc. @default 24 */
+    arcDensity?: number;
+    /** Points along each curve through the middle. @default 24 */
+    curveSamples?: number;
+    /**
+     * Draw the target end as an arrowhead: the ribbon stops this far short of
+     * the circle and narrows to a point on it. For directed chords; in
+     * `radius`'s units.
+     * @default 0
+     */
+    headRadius?: number;
+}
+/**
+ * A chord's ribbon as one open ring: along the source arc, a quadratic
+ * curve through the centre to the target, along its arc (or an arrowhead
+ * with `headRadius`), and back.
+ *
+ * @param radius - Radius the ends sit on.
+ * @category Math & helpers
+ */
+export declare function chordRibbon(chord: ChordLink, radius: number, options?: ChordRibbonOptions): Point[];
+//# sourceMappingURL=chord.d.ts.map

package/dist/math/chord.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chord.d.ts","sourceRoot":"","sources":["../../src/math/chord.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,0BAA0B,CAAC;AAEtD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAGxD,qBAAqB;AACrB,MAAM,WAAW,YAAa,SAAQ,iBAAiB;IACtD,iEAAiE;IACjE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,0FAA0F;IAC1F,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB;;;;;OAKG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;CACnB;AAED;;;;GAIG;AACH,MAAM,WAAW,UAAU;IAC1B,sCAAsC;IACtC,KAAK,EAAE,MAAM,CAAC;IACd,6CAA6C;IAC7C,UAAU,EAAE,MAAM,CAAC;IACnB,mFAAmF;IACnF,QAAQ,EAAE,MAAM,CAAC;IACjB,kGAAkG;IAClG,KAAK,EAAE,MAAM,CAAC;CACd;AAED;;;;GAIG;AACH,MAAM,WAAW,QAAQ;IACxB,iCAAiC;IACjC,KAAK,EAAE,MAAM,CAAC;IACd,0CAA0C;IAC1C,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,0HAA0H;IAC1H,KAAK,EAAE,MAAM,CAAC;CACd;AAED;;;;GAIG;AACH,MAAM,WAAW,SAAS;IACzB,oCAAoC;IACpC,MAAM,EAAE,QAAQ,CAAC;IACjB,qBAAqB;IACrB,MAAM,EAAE,QAAQ,CAAC;CACjB;AAED,qBAAqB;AACrB,MAAM,WAAW,WAAW;IAC3B,8CAA8C;IAC9C,MAAM,EAAE,UAAU,EAAE,CAAC;IACrB,0FAA0F;IAC1F,MAAM,EAAE,SAAS,EAAE,CAAC;CACpB;AAOD;;;;;;GAMG;AACH,wBAAgB,WAAW,CAC1B,MAAM,EAAE,SAAS,CAAC,SAAS,MAAM,EAAE,CAAC,EAAE,EACtC,OAAO,GAAE,YAAiB,GACxB,WAAW,CA+Eb;AAED,qBAAqB;AACrB,MAAM,WAAW,kBAAkB;IAClC,sCAAsC;IACtC,MAAM,CAAC,EAAE,KAAK,CAAC;IACf,0DAA0D;IAC1D,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,8DAA8D;IAC9D,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;;;;OAKG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;;;;;;GAOG;AACH,wBAAgB,WAAW,CAC1B,KAAK,EAAE,SAAS,EAChB,MAAM,EAAE,MAAM,EACd,OAAO,GAAE,kBAAuB,GAC9B,KAAK,EAAE,CAgDT"}

package/dist/math/cluster.d.ts

@@ -0,0 +1,89 @@
+/**
+ * Agglomerative hierarchical clustering: pairwise row distances, the merge
+ * tree single, complete or average linkage builds, and the leaf order a
+ * dendrogram follows. The tree feeds {@link hierarchyTreeLayout} with
+ * `distance: (n) => n.height`.
+ */
+/**
+ * How cluster distance is measured from member distances: `"single"` (the
+ * closest pair; chained clusters), `"complete"` (the farthest pair; compact
+ * clusters) or `"average"` (the mean over all pairs, UPGMA).
+ *
+ * @category Math & helpers
+ */
+export type ClusterLinkage = "single" | "complete" | "average";
+/**
+ * How far apart two rows are: `"euclidean"`, `"manhattan"` (sum of absolute
+ * differences) or `"correlation"` (`1 − r`: rows that rise and fall
+ * together are close whatever their level).
+ *
+ * @category Math & helpers
+ */
+export type ClusterMetric = "euclidean" | "manhattan" | "correlation";
+/**
+ * One node of a merge tree: a leaf (one input row) or the merge of two
+ * clusters.
+ *
+ * @category Math & helpers
+ */
+export interface ClusterNode {
+    /** The input row of a leaf; -1 for a merge. */
+    index: number;
+    /** The linkage distance at which the two children merged; 0 for a leaf. */
+    height: number;
+    /** How many rows the cluster holds. */
+    size: number;
+    /** A merge's two clusters, the one holding the lower row index first; absent on a leaf. */
+    children?: [ClusterNode, ClusterNode];
+}
+/** @category Math */
+export interface ClusterTree {
+    /** The merge tree, or `null` when there are no rows. */
+    root: ClusterNode | null;
+    /** The rows in dendrogram (left-to-right leaf) order: the order to draw them in. */
+    order: number[];
+}
+/** @category Math */
+export interface ClusterOptions {
+    /** See {@link ClusterLinkage}. @default "average" */
+    linkage?: ClusterLinkage;
+    /** See {@link ClusterMetric}. @default "euclidean" */
+    metric?: ClusterMetric;
+}
+/**
+ * The distance between every pair of rows. Non-finite entries are skipped
+ * pairwise and the sum scaled up to all columns, so a gap neither shrinks
+ * nor grows a distance; rows with no column in common get `NaN`.
+ *
+ * @param metric - Defaults to `"euclidean"`.
+ * @returns A symmetric `n × n` matrix with zeros on the diagonal.
+ * @category Math & helpers
+ */
+export declare function distanceMatrix(rows: readonly (readonly number[])[], metric?: ClusterMetric): number[][];
+/**
+ * Agglomerative clustering over a distance matrix: the two closest clusters
+ * merge until one is left. Ties merge the lowest row indices first, so it
+ * is deterministic; heights rise toward the root. A non-finite distance
+ * counts as the largest finite one. O(n³) in rows.
+ *
+ * @param linkage - Defaults to `"average"`.
+ * @returns The merge tree and the dendrogram's leaf order.
+ * @category Math & helpers
+ */
+export declare function linkageTree(distances: readonly (readonly number[])[], linkage?: ClusterLinkage): ClusterTree;
+/**
+ * Clusters rows by their values: {@link distanceMatrix} then
+ * {@link linkageTree}.
+ *
+ * @param rows - One vector per row (non-finite entries are gaps).
+ * @returns The merge tree and the rows' dendrogram order.
+ * @category Math & helpers
+ */
+export declare function clusterRows(rows: readonly (readonly number[])[], options?: ClusterOptions): ClusterTree;
+/**
+ * A merge tree's leaves, left to right: the input rows in dendrogram order.
+ *
+ * @category Math & helpers
+ */
+export declare function leafOrder(root: ClusterNode): number[];
+//# sourceMappingURL=cluster.d.ts.map

package/dist/math/cluster.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cluster.d.ts","sourceRoot":"","sources":["../../src/math/cluster.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;;;;;;GAMG;AACH,MAAM,MAAM,cAAc,GAAG,QAAQ,GAAG,UAAU,GAAG,SAAS,CAAC;AAE/D;;;;;;GAMG;AACH,MAAM,MAAM,aAAa,GAAG,WAAW,GAAG,WAAW,GAAG,aAAa,CAAC;AAEtE;;;;;GAKG;AACH,MAAM,WAAW,WAAW;IAC3B,+CAA+C;IAC/C,KAAK,EAAE,MAAM,CAAC;IACd,2EAA2E;IAC3E,MAAM,EAAE,MAAM,CAAC;IACf,uCAAuC;IACvC,IAAI,EAAE,MAAM,CAAC;IACb,2FAA2F;IAC3F,QAAQ,CAAC,EAAE,CAAC,WAAW,EAAE,WAAW,CAAC,CAAC;CACtC;AAED,qBAAqB;AACrB,MAAM,WAAW,WAAW;IAC3B,wDAAwD;IACxD,IAAI,EAAE,WAAW,GAAG,IAAI,CAAC;IACzB,oFAAoF;IACpF,KAAK,EAAE,MAAM,EAAE,CAAC;CAChB;AAED,qBAAqB;AACrB,MAAM,WAAW,cAAc;IAC9B,qDAAqD;IACrD,OAAO,CAAC,EAAE,cAAc,CAAC;IACzB,sDAAsD;IACtD,MAAM,CAAC,EAAE,aAAa,CAAC;CACvB;AAED;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAC7B,IAAI,EAAE,SAAS,CAAC,SAAS,MAAM,EAAE,CAAC,EAAE,EACpC,MAAM,GAAE,aAA2B,GACjC,MAAM,EAAE,EAAE,CAYZ;AA4CD;;;;;;;;;GASG;AACH,wBAAgB,WAAW,CAC1B,SAAS,EAAE,SAAS,CAAC,SAAS,MAAM,EAAE,CAAC,EAAE,EACzC,OAAO,GAAE,cAA0B,GACjC,WAAW,CAqEb;AAED;;;;;;;GAOG;AACH,wBAAgB,WAAW,CAC1B,IAAI,EAAE,SAAS,CAAC,SAAS,MAAM,EAAE,CAAC,EAAE,EACpC,OAAO,GAAE,cAAmB,GAC1B,WAAW,CAKb;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,WAAW,GAAG,MAAM,EAAE,CASrD"}

package/dist/math/contour.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Contour lines: iso-lines of a scalar field on a regular grid, by marching
+ * squares. `x` has length `ncols`, `y` length `nrows`, and `z[row][col]` is
+ * the sample at `(x[col], y[row])`.
+ */
+import type { Point } from "@sophistry/core/geometry";
+type Pt = Point;
+/** @category Math */
+export interface ContourLine {
+    level: number;
+    points: Point[];
+}
+/**
+ * `count` evenly spaced levels strictly between `min` and `max`.
+ *
+ * @internal
+ */
+export declare function evenLevels(min: number, max: number, count: number): number[];
+/**
+ * A contour segment: its two crossing points, and the identity of each — the
+ * grid or triangle edge it lies on, or the corner when the field is exactly at
+ * the level there — so the two cells sharing an edge meet at the same key.
+ *
+ * @internal
+ */
+export interface KeyedSegment {
+    keys: [number, number];
+    points: [Pt, Pt];
+}
+/**
+ * Stitches keyed segments into connected polylines, each running in its
+ * lowest-index segment's direction; a loop repeats its first point at the end.
+ *
+ * @internal
+ */
+export declare function stitch(segments: readonly KeyedSegment[]): Point[][];
+/**
+ * Iso-lines of `z` at `levels` by marching squares, one {@link ContourLine}
+ * per connected run. Cells touching a NaN corner are skipped; saddles are
+ * resolved by the cell's mean value.
+ *
+ * @param z - Samples as `z[row][col]`, at `(x[col], y[row])`.
+ * @param levels - Explicit levels, or a count strictly between the data's min and max.
+ * @returns Polylines tagged with their level; `[]` for a grid under 2 x 2 or `x`/`y` shorter than `z`.
+ * @category Math & helpers
+ */
+export declare function contourLines(x: readonly number[], y: readonly number[], z: readonly (readonly number[])[], levels: readonly number[] | number): ContourLine[];
+export {};
+//# sourceMappingURL=contour.d.ts.map

package/dist/math/contour.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contour.d.ts","sourceRoot":"","sources":["../../src/math/contour.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,0BAA0B,CAAC;AAItD,KAAK,EAAE,GAAG,KAAK,CAAC;AAEhB,qBAAqB;AACrB,MAAM,WAAW,WAAW;IAC3B,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,KAAK,EAAE,CAAC;CAChB;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CAK5E;AAqBD;;;;;;GAMG;AACH,MAAM,WAAW,YAAY;IAC5B,IAAI,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACvB,MAAM,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC;CACjB;AAOD;;;;;GAKG;AACH,wBAAgB,MAAM,CAAC,QAAQ,EAAE,SAAS,YAAY,EAAE,GAAG,KAAK,EAAE,EAAE,CAqBnE;AAED;;;;;;;;;GASG;AACH,wBAAgB,YAAY,CAC3B,CAAC,EAAE,SAAS,MAAM,EAAE,EACpB,CAAC,EAAE,SAAS,MAAM,EAAE,EACpB,CAAC,EAAE,SAAS,CAAC,SAAS,MAAM,EAAE,CAAC,EAAE,EACjC,MAAM,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,GAChC,WAAW,EAAE,CAkIf"}

package/dist/math/contourf.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Filled contours: bands between consecutive level thresholds over a grid
+ * (`x` length `ncols`, `y` length `nrows`, `z[row][col]` at `(x[col],
+ * y[row])`). Each grid cell is clipped on its own, giving many small
+ * polygons per band that meet edge to edge without gaps.
+ */
+import type { Point } from "@sophistry/core/geometry";
+/**
+ * A clip vertex: a point plus the field value at it.
+ *
+ * @internal
+ */
+export interface Vtx {
+    x: number;
+    y: number;
+    z: number;
+}
+/** @category Math */
+export interface ContourBand {
+    loLevel: number;
+    hiLevel: number;
+    /** Closed polygon rings, in data space, one per contributing grid cell. */
+    polygons: Point[][];
+}
+/**
+ * `count` evenly spaced band boundaries spanning `[min, max]` inclusively,
+ * so every sample falls in a band.
+ *
+ * @internal
+ */
+export declare function evenBoundaries(min: number, max: number, count: number): number[];
+/**
+ * Clips a convex polygon by a half-plane of `z` (`z >= threshold` with
+ * `keepAbove`, else `z <= threshold`); new vertices sit exactly on the
+ * threshold.
+ *
+ * @internal
+ */
+export declare function clipByThreshold(poly: Vtx[], threshold: number, keepAbove: boolean): Vtx[];
+/**
+ * Fills `z` into bands between consecutive `levels`: `N` levels make `N - 1`
+ * closed bands `loLevel <= z <= hiLevel`. Cells touching a NaN corner, and
+ * constant fields, contribute nothing.
+ *
+ * @param z - Samples as `z[row][col]`, at `(x[col], y[row])`.
+ * @param levels - Explicit boundaries, or a count spanning the data.
+ * @returns One {@link ContourBand} per pair of consecutive levels.
+ * @category Math & helpers
+ */
+export declare function contourBands(x: readonly number[], y: readonly number[], z: readonly (readonly number[])[], levels: readonly number[] | number): ContourBand[];
+//# sourceMappingURL=contourf.d.ts.map

package/dist/math/contourf.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contourf.d.ts","sourceRoot":"","sources":["../../src/math/contourf.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,0BAA0B,CAAC;AAGtD;;;;GAIG;AACH,MAAM,WAAW,GAAG;IACnB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACV;AAED,qBAAqB;AACrB,MAAM,WAAW,WAAW;IAC3B,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,2EAA2E;IAC3E,QAAQ,EAAE,KAAK,EAAE,EAAE,CAAC;CACpB;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAC7B,GAAG,EAAE,MAAM,EACX,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,MAAM,GACX,MAAM,EAAE,CAMV;AAUD;;;;;;GAMG;AACH,wBAAgB,eAAe,CAC9B,IAAI,EAAE,GAAG,EAAE,EACX,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,OAAO,GAChB,GAAG,EAAE,CAsBP;AAED;;;;;;;;;GASG;AACH,wBAAgB,YAAY,CAC3B,CAAC,EAAE,SAAS,MAAM,EAAE,EACpB,CAAC,EAAE,SAAS,MAAM,EAAE,EACpB,CAAC,EAAE,SAAS,CAAC,SAAS,MAAM,EAAE,CAAC,EAAE,EACjC,MAAM,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,GAChC,WAAW,EAAE,CAmDf"}

package/dist/math/dodge.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Dodging overlapping marks apart: in data space, sub-bands within a
+ * category's band (`dodgeSpan`, grouped bars); in screen space, circles
+ * pushed off an axis until they clear each other (`beeswarmOffsets`).
+ */
+/**
+ * Sub-band `slot` of `count` within one band, as fractions `[from, to]` of
+ * the band, with `padding` of each sub-band left empty.
+ *
+ * @param padding - Fraction of each sub-band left empty, 0..1. Defaults to 0.1.
+ * @category Math & helpers
+ */
+export declare function dodgeSpan(slot: number, count: number, padding?: number): [number, number];
+/** @category Math */
+export interface BeeswarmOptions {
+    /**
+     * Which side of the axis circles may move to: `"both"` (centred on the
+     * axis), `"positive"` or `"negative"` (standing on a baseline).
+     * @default "both"
+     */
+    side?: "both" | "positive" | "negative";
+    /** Extra room left between neighbouring circles, in the same units as the radii. @default 0 */
+    gap?: number;
+}
+/**
+ * Beeswarm offsets: each circle keeps its position along the axis and moves
+ * across it just far enough to clear those placed before it (in ascending
+ * order). Deterministic, so it scrubs. Positions and radii share units
+ * (scene units).
+ *
+ * @param positions - Each circle's centre along the axis; non-finite ones get `NaN`.
+ * @param radii - One radius for every circle, or one per circle.
+ * @returns One offset across the axis per circle.
+ * @category Math & helpers
+ */
+export declare function beeswarmOffsets(positions: readonly number[], radii: number | readonly number[], options?: BeeswarmOptions): number[];
+//# sourceMappingURL=dodge.d.ts.map

package/dist/math/dodge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dodge.d.ts","sourceRoot":"","sources":["../../src/math/dodge.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH;;;;;;GAMG;AACH,wBAAgB,SAAS,CACxB,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,EACb,OAAO,SAAM,GACX,CAAC,MAAM,EAAE,MAAM,CAAC,CAIlB;AAED,qBAAqB;AACrB,MAAM,WAAW,eAAe;IAC/B;;;;OAIG;IACH,IAAI,CAAC,EAAE,MAAM,GAAG,UAAU,GAAG,UAAU,CAAC;IACxC,+FAA+F;IAC/F,GAAG,CAAC,EAAE,MAAM,CAAC;CACb;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,eAAe,CAC9B,SAAS,EAAE,SAAS,MAAM,EAAE,EAC5B,KAAK,EAAE,MAAM,GAAG,SAAS,MAAM,EAAE,EACjC,OAAO,GAAE,eAAoB,GAC3B,MAAM,EAAE,CA6DV"}

package/dist/math/ecdf.d.ts

@@ -0,0 +1,42 @@
+/** Empirical CDF: a step function rising from 0 to 1 by `1/n` at each observed value. */
+/**
+ * Step data shaped for `stairsPolyline`/`<Stairs>`: `edges.length === values.length + 1`.
+ *
+ * @category Math & helpers
+ */
+export interface EcdfSteps {
+    edges: number[];
+    values: number[];
+}
+/** @category Math */
+export interface EcdfOptions {
+    /**
+     * Padding left of the smallest value and right of the largest, in data units. Defaults to 5% of
+     * the data's span (0.5 when the span is 0).
+     */
+    pad?: number;
+}
+/**
+ * `EcdfOptions.pad`'s fraction-of-span default.
+ *
+ * @category Math & helpers
+ */
+export declare const DEFAULT_ECDF_PAD_FRACTION = 0.05;
+/**
+ * `EcdfOptions.pad`'s fallback when the data's span is 0 (every value identical).
+ *
+ * @category Math & helpers
+ */
+export declare const DEFAULT_ECDF_PAD_FALLBACK = 0.5;
+/**
+ * The step function of the empirical CDF of `values`, over the sorted unique
+ * finite values `u_1 < … < u_k`: `edges = [u_1 - pad, u_1, …, u_k, u_k + pad]`
+ * and `values = [0, F(u_1), …, F(u_k)]`, so the curve is 0 before `u_1`,
+ * jumps at each value, and ends at 1.
+ *
+ * @param values - The sample; non-finite entries are dropped.
+ * @returns `edges` and `values` for {@link stairsPolyline}; both empty when no finite value remains.
+ * @category Math & helpers
+ */
+export declare function ecdfSteps(values: readonly number[], options?: EcdfOptions): EcdfSteps;
+//# sourceMappingURL=ecdf.d.ts.map

package/dist/math/ecdf.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ecdf.d.ts","sourceRoot":"","sources":["../../src/math/ecdf.ts"],"names":[],"mappings":"AACA,yFAAyF;AAEzF;;;;GAIG;AACH,MAAM,WAAW,SAAS;IACzB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,MAAM,EAAE,MAAM,EAAE,CAAC;CACjB;AAED,qBAAqB;AACrB,MAAM,WAAW,WAAW;IAC3B;;;OAGG;IACH,GAAG,CAAC,EAAE,MAAM,CAAC;CACb;AAED;;;;GAIG;AACH,eAAO,MAAM,yBAAyB,OAAO,CAAC;AAC9C;;;;GAIG;AACH,eAAO,MAAM,yBAAyB,MAAM,CAAC;AAE7C;;;;;;;;;GASG;AACH,wBAAgB,SAAS,CACxB,MAAM,EAAE,SAAS,MAAM,EAAE,EACzB,OAAO,GAAE,WAAgB,GACvB,SAAS,CAoCX"}

package/dist/math/errorbar.d.ts

@@ -0,0 +1,28 @@
+/** `errorbar(x, y, yerr, xerr)` — a marker plus optional error bars for each finite `(x, y)` pair. */
+import type { Point } from "@sophistry/core/geometry";
+/**
+ * Symmetric errors as one magnitude per index, or asymmetric ones as a
+ * `[lower[], upper[]]` tuple.
+ *
+ * @category Math & helpers
+ */
+export type ErrorSpec = readonly number[] | readonly [readonly number[], readonly number[]];
+/** @category Math */
+export interface ErrorBarPoint {
+    /** Index into the input `xs`/`ys`, matching a point to its row after non-finite pairs are dropped. */
+    index: number;
+    point: Point;
+    /** `[point - lower, point + upper]` along y; omitted where `yerr` has no finite magnitude here. */
+    yBar?: [Point, Point];
+    /** `[point - lower, point + upper]` along x; omitted where `xerr` has no finite magnitude here. */
+    xBar?: [Point, Point];
+}
+/**
+ * One marker plus optional error bars per finite `(x, y)` pair.
+ *
+ * @param yerr - Vertical error magnitudes. See {@link ErrorSpec}.
+ * @param xerr - Horizontal error magnitudes. See {@link ErrorSpec}.
+ * @category Math & helpers
+ */
+export declare function errorBarPoints(xs: readonly number[], ys: readonly number[], yerr?: ErrorSpec, xerr?: ErrorSpec): ErrorBarPoint[];
+//# sourceMappingURL=errorbar.d.ts.map

package/dist/math/errorbar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errorbar.d.ts","sourceRoot":"","sources":["../../src/math/errorbar.ts"],"names":[],"mappings":"AAAA,sGAAsG;AAEtG,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,0BAA0B,CAAC;AAGtD;;;;;GAKG;AACH,MAAM,MAAM,SAAS,GAClB,SAAS,MAAM,EAAE,GACjB,SAAS,CAAC,SAAS,MAAM,EAAE,EAAE,SAAS,MAAM,EAAE,CAAC,CAAC;AAEnD,qBAAqB;AACrB,MAAM,WAAW,aAAa;IAC7B,sGAAsG;IACtG,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,KAAK,CAAC;IACb,mGAAmG;IACnG,IAAI,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;IACtB,mGAAmG;IACnG,IAAI,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;CACtB;AAmBD;;;;;;GAMG;AACH,wBAAgB,cAAc,CAC7B,EAAE,EAAE,SAAS,MAAM,EAAE,EACrB,EAAE,EAAE,SAAS,MAAM,EAAE,EACrB,IAAI,CAAC,EAAE,SAAS,EAChB,IAAI,CAAC,EAAE,SAAS,GACd,aAAa,EAAE,CA6BjB"}

package/dist/math/eventplot.d.ts

@@ -0,0 +1,27 @@
+/** Event plot: a raster of vertical tick marks, one row per sequence (e.g. spike trains). */
+import type { Point } from "@sophistry/core/geometry";
+/** @category Math */
+export interface EventRow {
+    /** Index into the original `rows` — which band this row's ticks belong to. */
+    row: number;
+    /** One `[from, to]` drop-line pair per finite event time in this row. */
+    ticks: [Point, Point][];
+}
+/** @category Math */
+export interface EventPlotOptions {
+    /** Data-space spacing between successive rows' y. @default 1 */
+    lineOffset?: number;
+    /** Data-space height of each tick, centred on its row's y. @default 0.8 */
+    lineLength?: number;
+}
+/**
+ * One vertical tick per finite event time, grouped by row: row `i` sits at
+ * `y = i * lineOffset`, each tick at `x = t`, `lineLength` tall. Empty rows
+ * are kept.
+ *
+ * @param rows - One array of event positions (x) per row.
+ * @returns One {@link EventRow} per input row, in order.
+ * @category Math & helpers
+ */
+export declare function eventPlotRows(rows: readonly (readonly number[])[], options?: EventPlotOptions): EventRow[];
+//# sourceMappingURL=eventplot.d.ts.map

package/dist/math/eventplot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"eventplot.d.ts","sourceRoot":"","sources":["../../src/math/eventplot.ts"],"names":[],"mappings":"AAAA,6FAA6F;AAE7F,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,0BAA0B,CAAC;AAEtD,qBAAqB;AACrB,MAAM,WAAW,QAAQ;IACxB,8EAA8E;IAC9E,GAAG,EAAE,MAAM,CAAC;IACZ,yEAAyE;IACzE,KAAK,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC,EAAE,CAAC;CACxB;AAED,qBAAqB;AACrB,MAAM,WAAW,gBAAgB;IAChC,gEAAgE;IAChE,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,2EAA2E;IAC3E,UAAU,CAAC,EAAE,MAAM,CAAC;CACpB;AAKD;;;;;;;;GAQG;AACH,wBAAgB,aAAa,CAC5B,IAAI,EAAE,SAAS,CAAC,SAAS,MAAM,EAAE,CAAC,EAAE,EACpC,OAAO,GAAE,gBAAqB,GAC5B,QAAQ,EAAE,CAeZ"}

package/dist/math/facet.d.ts

@@ -0,0 +1,91 @@
+/**
+ * Small multiples: which panel goes where, how big each is, and how a
+ * grid of panels reveals. Pure functions behind `<Facet>`, `<PairPlot>` and
+ * `<JointPlot>`.
+ */
+import type { BandKey, Bounds, Point } from "@sophistry/core/geometry";
+/** One panel's place in a facet grid. */
+export interface FacetSlot {
+    /** Reading-order index (row-major). */
+    index: number;
+    /** Grid row, from the top. */
+    row: number;
+    /** Grid column, from the left. */
+    column: number;
+    /** The panel's `row` category, when faceting by rows. */
+    rowKey?: BandKey;
+    /** The panel's `column` category, when faceting by columns. */
+    columnKey?: BandKey;
+}
+/** The grid {@link facetSlots} lays out. */
+export interface FacetSlots {
+    slots: FacetSlot[];
+    rows: number;
+    columns: number;
+}
+/**
+ * Where each panel of a facet grid goes: with both key lists a full grid;
+ * with one, a single row (`columnKeys`) or column (`rowKeys`) wrapped after
+ * `wrap` panels; with neither, one panel.
+ *
+ * @param wrap - Panels per line when faceting by one variable.
+ */
+export declare function facetSlots(rowKeys: readonly BandKey[], columnKeys: readonly BandKey[], wrap?: number): FacetSlots;
+/** Whether no panel sits directly below (or above, `"top"`) a slot: it is on the grid's outer edge there. */
+export declare function outerEdge(slot: FacetSlot, slots: readonly FacetSlot[], side: "top" | "bottom" | "left" | "right"): boolean;
+/** Room around a grid or panel, per side, in scene units. */
+export interface SideRoom {
+    left: number;
+    right: number;
+    top: number;
+    bottom: number;
+}
+/** Options for {@link facetGrid}. */
+export interface FacetGridOptions {
+    rows: number;
+    columns: number;
+    /** The whole footprint's width, in scene units. */
+    width: number;
+    /** The whole footprint's height. */
+    height: number;
+    /** The footprint's centre. Defaults to the origin. */
+    center?: Point;
+    /** Space between neighbouring panels' plotting areas, across a column gap. */
+    gapX: number;
+    /** Space between neighbouring panels' plotting areas, across a row gap. */
+    gapY: number;
+    /** Room kept free around the grid of plots, inside the footprint. */
+    outer?: Partial<SideRoom>;
+    /** Relative column widths. Defaults to equal. */
+    widthRatios?: readonly number[];
+    /** Relative row heights, top to bottom. Defaults to equal. */
+    heightRatios?: readonly number[];
+}
+/** One cell of a {@link facetGrid}: the plotting area of a panel. */
+export interface FacetCell {
+    center: Point;
+    width: number;
+    height: number;
+}
+/** What {@link facetGrid} returns. */
+export interface FacetGrid {
+    /** `cells[row][column]`, rows from the top. */
+    cells: FacetCell[][];
+    /** The box around every plotting area (the grid without its outer room). */
+    plots: Bounds;
+}
+/**
+ * Lays out a grid of plotting areas inside a footprint: outer room first,
+ * then the gaps, the rest shared between columns and rows by ratio. Each
+ * plot keeps at least a tenth of a unit.
+ */
+export declare function facetGrid(options: FacetGridOptions): FacetGrid;
+/**
+ * A panel's reveal from the grid's: every panel's frame half at once, then
+ * the data half staggered across panels in reading order.
+ *
+ * @param stagger - Fraction of the data half spent staggering, 0..0.95.
+ * @param frameEnd - Where a panel's frame half ends. Defaults to 0.5.
+ */
+export declare function panelProgress(progress: number, index: number, count: number, stagger?: number, frameEnd?: number): number;
+//# sourceMappingURL=facet.d.ts.map

package/dist/math/facet.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"facet.d.ts","sourceRoot":"","sources":["../../src/math/facet.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,0BAA0B,CAAC;AAEvE,yCAAyC;AACzC,MAAM,WAAW,SAAS;IACzB,uCAAuC;IACvC,KAAK,EAAE,MAAM,CAAC;IACd,8BAA8B;IAC9B,GAAG,EAAE,MAAM,CAAC;IACZ,kCAAkC;IAClC,MAAM,EAAE,MAAM,CAAC;IACf,yDAAyD;IACzD,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,+DAA+D;IAC/D,SAAS,CAAC,EAAE,OAAO,CAAC;CACpB;AAED,4CAA4C;AAC5C,MAAM,WAAW,UAAU;IAC1B,KAAK,EAAE,SAAS,EAAE,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;GAMG;AACH,wBAAgB,UAAU,CACzB,OAAO,EAAE,SAAS,OAAO,EAAE,EAC3B,UAAU,EAAE,SAAS,OAAO,EAAE,EAC9B,IAAI,CAAC,EAAE,MAAM,GACX,UAAU,CA6CZ;AAED,6GAA6G;AAC7G,wBAAgB,SAAS,CACxB,IAAI,EAAE,SAAS,EACf,KAAK,EAAE,SAAS,SAAS,EAAE,EAC3B,IAAI,EAAE,KAAK,GAAG,QAAQ,GAAG,MAAM,GAAG,OAAO,GACvC,OAAO,CAMT;AAED,6DAA6D;AAC7D,MAAM,WAAW,QAAQ;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;CACf;AAED,qCAAqC;AACrC,MAAM,WAAW,gBAAgB;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,mDAAmD;IACnD,KAAK,EAAE,MAAM,CAAC;IACd,oCAAoC;IACpC,MAAM,EAAE,MAAM,CAAC;IACf,sDAAsD;IACtD,MAAM,CAAC,EAAE,KAAK,CAAC;IACf,8EAA8E;IAC9E,IAAI,EAAE,MAAM,CAAC;IACb,2EAA2E;IAC3E,IAAI,EAAE,MAAM,CAAC;IACb,qEAAqE;IACrE,KAAK,CAAC,EAAE,OAAO,CAAC,QAAQ,CAAC,CAAC;IAC1B,iDAAiD;IACjD,WAAW,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAChC,8DAA8D;IAC9D,YAAY,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CACjC;AAED,qEAAqE;AACrE,MAAM,WAAW,SAAS;IACzB,MAAM,EAAE,KAAK,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CACf;AAED,sCAAsC;AACtC,MAAM,WAAW,SAAS;IACzB,+CAA+C;IAC/C,KAAK,EAAE,SAAS,EAAE,EAAE,CAAC;IACrB,4EAA4E;IAC5E,KAAK,EAAE,MAAM,CAAC;CACd;AAgBD;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,OAAO,EAAE,gBAAgB,GAAG,SAAS,CA2C9D;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAC5B,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,MAAM,EACb,OAAO,SAAI,EACX,QAAQ,SAAM,GACZ,MAAM,CAQR"}

package/dist/math/fillBetween.d.ts

@@ -0,0 +1,29 @@
+/** The region between two series over shared `x` values: a confidence band or min/max envelope. */
+import type { CurveKind, CurvePath, Point } from "@sophistry/core/geometry";
+/**
+ * One ring per continuous run, returned closed (first point repeated), as
+ * the reveal walks it back to its start.
+ *
+ * @category Math & helpers
+ */
+export type FillBetweenRings = Point[][];
+/**
+ * One closed ring per continuous run of `(x, y1, y2)`, split wherever a value
+ * is non-finite, so a gap shades as two regions.
+ *
+ * @param y1 - One boundary, parallel to `xs`.
+ * @param y2 - The other boundary, parallel to `xs`.
+ * @returns Closed rings, one per run of at least 2 finite points.
+ * @category Math & helpers
+ */
+export declare function fillBetweenRings(xs: readonly number[], y1: readonly number[], y2: readonly number[]): FillBetweenRings;
+/**
+ * One of {@link fillBetweenRings}' rings (in any units) as a closed curve,
+ * each boundary curved on its own so a boundary shared by adjacent bands is
+ * the same curve in both. A ring of another shape is closed straight.
+ *
+ * @param ring - `n` upper points, `n` lower points reversed, the first repeated.
+ * @category Math & helpers
+ */
+export declare function fillBetweenCurve(ring: readonly Point[], curve: CurveKind): CurvePath;
+//# sourceMappingURL=fillBetween.d.ts.map

package/dist/math/fillBetween.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fillBetween.d.ts","sourceRoot":"","sources":["../../src/math/fillBetween.ts"],"names":[],"mappings":"AAAA,mGAAmG;AAEnG,OAAO,KAAK,EAAE,SAAS,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,0BAA0B,CAAC;AAI5E;;;;;GAKG;AACH,MAAM,MAAM,gBAAgB,GAAG,KAAK,EAAE,EAAE,CAAC;AAQzC;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAC/B,EAAE,EAAE,SAAS,MAAM,EAAE,EACrB,EAAE,EAAE,SAAS,MAAM,EAAE,EACrB,EAAE,EAAE,SAAS,MAAM,EAAE,GACnB,gBAAgB,CAuBlB;AAED;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAC/B,IAAI,EAAE,SAAS,KAAK,EAAE,EACtB,KAAK,EAAE,SAAS,GACd,SAAS,CAMX"}