@danielsimonjr/mathts-functions 0.2.3 → 0.2.5

package/dist/typed/graph.d.ts

@@ -0,0 +1,339 @@
+/**
+ * Graph Theory Functions
+ *
+ * Provides fundamental graph algorithms operating on adjacency matrices:
+ * - adjacencyMatrix: create adjacency matrix from edge list
+ * - shortestPath: Dijkstra's algorithm for shortest path
+ * - minimumSpanningTree: Prim's algorithm for MST
+ * - connectedComponents: BFS-based component detection
+ * - stronglyConnectedComponents: Tarjan's algorithm for directed graphs
+ * - topologicalSort: Kahn's algorithm for DAGs
+ * - isConnected: check if graph is connected
+ * - graphDistance: shortest path length between two nodes
+ * - pageRank: PageRank centrality with optional random-restart fan-out (Slice 5.13)
+ * - betweennessCentrality: Brandes betweenness centrality with optional restarts
+ * - eigenvectorCentrality: power-iteration eigenvector centrality with optional restarts
+ *
+ * Input format: adjacency matrix as number[][] where adj[i][j] > 0
+ * means an edge from i to j with that weight.
+ *
+ * Worker-dispatch strategy (Slice 5.13) — centrality random-restart fan-out:
+ * - When `restarts >= CENTRALITY_WORKER_THRESHOLD` (4), the N independent
+ *   restart computations are fanned out via `Promise.all`.  Each restart uses a
+ *   different random-initialisation seed derived from the caller-supplied
+ *   `restartSeed` via SplitMix64-style hashing:
+ *     `seed_k = (baseSeed ^ (k * 0x9E3779B97F4A7C15)) >>> 0`
+ * - Graph serialisation: the adjacency matrix is plain `number[][]` and is
+ *   passed directly.  Option B (main-thread fan-out) is used because registering
+ *   a new worker handler would require modifying packages/workerpool/src/worker.ts
+ *   which is outside this slice's scope.
+ *
+ * @packageDocumentation
+ */
+/**
+ * Create an adjacency matrix from an edge list.
+ *
+ * @param edges - Array of [from, to] or [from, to, weight] tuples
+ * @param n - Number of nodes in the graph
+ * @param directed - Whether the graph is directed (default false)
+ * @returns n x n adjacency matrix
+ *
+ * @example
+ * adjacencyMatrix([[0, 1], [1, 2]], 3)
+ * // => [[0, 1, 0], [1, 0, 1], [0, 1, 0]] (undirected)
+ */
+export declare function adjacencyMatrix(edges: number[][], n: number, directed?: boolean): number[][];
+/**
+ * Find the shortest path between two nodes using Dijkstra's algorithm.
+ *
+ * Returns the sequence of node indices from start to end.
+ * Returns an empty array if no path exists.
+ *
+ * Time complexity: O(V^2) with simple linear scan.
+ *
+ * @param adj - Adjacency matrix (weights must be non-negative)
+ * @param start - Source node index
+ * @param end - Destination node index
+ * @returns Array of node indices forming the shortest path
+ *
+ * @example
+ * const adj = [[0,1,0],[1,0,1],[0,1,0]];
+ * shortestPath(adj, 0, 2) // => [0, 1, 2]
+ */
+export declare function shortestPath(adj: number[][], start: number, end: number): number[];
+/**
+ * Find the minimum spanning tree using Prim's algorithm.
+ *
+ * Returns edges of the MST as [from, to, weight] tuples.
+ * The graph must be connected for a valid MST.
+ *
+ * Time complexity: O(V^2)
+ *
+ * @param adj - Adjacency matrix (undirected, symmetric)
+ * @returns Array of MST edges as [from, to, weight]
+ *
+ * @example
+ * const adj = [[0,2,0],[2,0,1],[0,1,0]];
+ * minimumSpanningTree(adj) // => [[0, 1, 2], [1, 2, 1]]
+ */
+export declare function minimumSpanningTree(adj: number[][]): number[][];
+/**
+ * Find all connected components in an undirected graph.
+ *
+ * Returns an array of component arrays, where each component is an
+ * array of node indices belonging to that component.
+ *
+ * @param adj - Adjacency matrix (undirected)
+ * @returns Array of connected components
+ *
+ * @example
+ * const adj = [[0,1,0],[1,0,0],[0,0,0]];
+ * connectedComponents(adj) // => [[0, 1], [2]]
+ */
+export declare function connectedComponents(adj: number[][]): number[][];
+/**
+ * Find strongly connected components in a directed graph using Tarjan's algorithm.
+ *
+ * Returns an array of SCC arrays, each containing node indices.
+ *
+ * @param adj - Adjacency matrix (directed)
+ * @returns Array of strongly connected components
+ *
+ * @example
+ * const adj = [[0,1,0],[0,0,1],[1,0,0]];
+ * stronglyConnectedComponents(adj) // => [[2, 1, 0]]
+ */
+export declare function stronglyConnectedComponents(adj: number[][]): number[][];
+/**
+ * Topological sort of a directed acyclic graph using Kahn's algorithm.
+ *
+ * Returns an array of node indices in topological order.
+ * Throws if the graph contains a cycle.
+ *
+ * @param adj - Adjacency matrix (directed, acyclic)
+ * @returns Topologically sorted node indices
+ *
+ * @example
+ * const adj = [[0,1,0],[0,0,1],[0,0,0]];
+ * topologicalSort(adj) // => [0, 1, 2]
+ */
+export declare function topologicalSort(adj: number[][]): number[];
+/**
+ * Check if an undirected graph is connected.
+ *
+ * A graph is connected if there is a path between every pair of vertices.
+ *
+ * @param adj - Adjacency matrix (undirected)
+ * @returns true if the graph is connected
+ *
+ * @example
+ * isConnected([[0,1],[1,0]]) // => true
+ * isConnected([[0,0],[0,0]]) // => false
+ */
+export declare function isConnected(adj: number[][]): boolean;
+/**
+ * Compute the shortest path length (distance) between two nodes.
+ *
+ * Uses Dijkstra's algorithm internally.
+ * Returns Infinity if no path exists.
+ *
+ * @param adj - Adjacency matrix
+ * @param start - Source node index
+ * @param end - Destination node index
+ * @returns Shortest path distance (sum of edge weights)
+ *
+ * @example
+ * const adj = [[0,3,0],[3,0,2],[0,2,0]];
+ * graphDistance(adj, 0, 2) // => 5
+ */
+export declare function graphDistance(adj: number[][], start: number, end: number): number;
+/**
+ * Minimum restart count before fanning out via Promise.all rather than running
+ * sequentially.  Below this threshold restarts run one after another on the
+ * current microtask, avoiding Promise scheduling overhead for the common
+ * single-restart case.
+ */
+export declare const CENTRALITY_WORKER_THRESHOLD = 4;
+/**
+ * Shared options for centrality functions that support random-restart
+ * fan-out (Slice 5.13).
+ */
+export interface CentralityRestartOptions {
+    /**
+     * Number of independent restarts to run (default 1 — no fan-out).
+     * When `restarts >= CENTRALITY_WORKER_THRESHOLD` (4) the restarts are
+     * dispatched as a `Promise.all` fan-out.
+     */
+    restarts?: number;
+    /**
+     * Base seed for reproducible restart initialisation.  Each restart k
+     * receives a derived seed:
+     *   `seed_k = ((baseSeed ^ (k * 0x9E3779B97F4A7C15)) >>> 0)`
+     * Default: 0 (non-reproducible — uses `Math.random()`).
+     */
+    restartSeed?: number;
+    /**
+     * How to aggregate multi-restart results.
+     * - `'mean'` (default): return the element-wise average rank vector.
+     * - `'all'`: return all N rank vectors plus their mean and std.
+     */
+    aggregation?: 'mean' | 'all';
+}
+/** Options for pageRank. */
+export interface PageRankOptions {
+    /**
+     * Damping factor d (probability of following an edge rather than teleporting).
+     * Brin & Page recommend 0.85.  Default: 0.85.
+     */
+    dampingFactor?: number;
+    /**
+     * Maximum number of power-iteration steps.  Default: 100.
+     */
+    maxIter?: number;
+    /**
+     * Convergence tolerance.  Iteration stops when the L1 norm of the rank
+     * delta is below this value.  Default: 1e-6.
+     */
+    tol?: number;
+}
+/** Result when `restarts` is omitted or 1. */
+export interface PageRankResult {
+    /** Normalised rank vector (sums to 1). */
+    ranks: Float64Array;
+}
+/** Result when `restarts > 1` and `aggregation === 'all'`. */
+export interface PageRankRestartResult {
+    /** Element-wise average of all restart rank vectors. */
+    ranks: Float64Array;
+    /** All N rank vectors, one per restart (only when `aggregation='all'`). */
+    ranksPerRestart?: Float64Array[];
+    /** Per-element mean and std across restarts (only when `aggregation='all'`). */
+    restartStats?: {
+        mean: Float64Array;
+        std: Float64Array;
+    };
+}
+/**
+ * Compute PageRank centrality for each node in a directed graph.
+ *
+ * **Single-restart path** (`restarts` omitted or 1): runs one power-iteration
+ * sequence from a uniform initialisation and returns `{ ranks }` synchronously
+ * (wrapped in a resolved Promise for a uniform async API).
+ *
+ * **Multi-restart path** (`restarts >= CENTRALITY_WORKER_THRESHOLD` = 4):
+ * fans out N independent restarts via `Promise.all`, each initialised from a
+ * different seed derived by SplitMix64-style hashing of `restartSeed × k`.
+ * Results are averaged element-wise (or returned individually when
+ * `aggregation: 'all'`).
+ *
+ * **Option B note:** all restarts execute on the main thread because adding a
+ * new `centralityRestartChunk` worker handler would require modifying
+ * `packages/workerpool/src/worker.ts`, which is outside this slice's scope.
+ * The Promise.all fan-out still keeps the event loop responsive for consumers
+ * that `await` the result.
+ *
+ * @param adj  - Directed adjacency matrix
+ * @param opts - PageRank + restart options
+ *
+ * @example
+ * const adj = [[0,1,0],[0,0,1],[1,0,0]];
+ * const { ranks } = await pageRank(adj);
+ * // ranks ≈ [0.333, 0.333, 0.333] (symmetric ring)
+ *
+ * @example
+ * // 8 restarts, averaged
+ * const result = await pageRank(adj, { restarts: 8, restartSeed: 42 });
+ */
+export declare function pageRank(adj: number[][], opts?: PageRankOptions & CentralityRestartOptions): Promise<PageRankResult | PageRankRestartResult>;
+/** Options for betweennessCentrality. */
+export interface BetweennessOptions {
+    /**
+     * Whether the graph is directed.  Default: false (undirected).
+     */
+    directed?: boolean;
+    /**
+     * Normalise by the maximum possible betweenness: (n-1)(n-2)/2 for
+     * undirected, (n-1)(n-2) for directed.  Default: true.
+     */
+    normalise?: boolean;
+}
+/** Result returned by betweennessCentrality. */
+export interface BetweennessResult {
+    /** Betweenness centrality score for each node (length = n). */
+    centrality: Float64Array;
+}
+/** Result when `restarts > 1` and `aggregation === 'all'`. */
+export interface BetweennessRestartResult {
+    centrality: Float64Array;
+    centralityPerRestart?: Float64Array[];
+    restartStats?: {
+        mean: Float64Array;
+        std: Float64Array;
+    };
+}
+/**
+ * Compute betweenness centrality for each node.
+ *
+ * Uses Brandes' BFS-based algorithm (exact for a single restart).  When
+ * `restarts > 1` each restart samples n source nodes (with replacement) using
+ * a distinct seed; the per-restart scores are averaged.
+ *
+ * Worker-dispatch strategy: Option B — all restarts run on the main thread
+ * via `Promise.all`.
+ *
+ * @param adj  - Adjacency matrix
+ * @param opts - Betweenness + restart options
+ *
+ * @example
+ * const adj = [[0,1,1],[1,0,1],[1,1,0]];
+ * const { centrality } = await betweennessCentrality(adj);
+ */
+export declare function betweennessCentrality(adj: number[][], opts?: BetweennessOptions & CentralityRestartOptions): Promise<BetweennessResult | BetweennessRestartResult>;
+/** Options for eigenvectorCentrality. */
+export interface EigenvectorOptions {
+    /**
+     * Maximum number of power-iteration steps.  Default: 100.
+     */
+    maxIter?: number;
+    /**
+     * Convergence tolerance (L∞ norm of delta).  Default: 1e-6.
+     */
+    tol?: number;
+}
+/** Result from eigenvectorCentrality. */
+export interface EigenvectorResult {
+    /** Eigenvector centrality scores (length = n). */
+    centrality: Float64Array;
+}
+/** Result when `restarts > 1` and `aggregation === 'all'`. */
+export interface EigenvectorRestartResult {
+    centrality: Float64Array;
+    centralityPerRestart?: Float64Array[];
+    restartStats?: {
+        mean: Float64Array;
+        std: Float64Array;
+    };
+}
+/**
+ * Compute eigenvector centrality using power iteration.
+ *
+ * Each node's score is proportional to the sum of its neighbours' scores,
+ * converging to the principal eigenvector of the adjacency matrix.
+ *
+ * When `restarts > 1`, each restart is initialised from a distinct random
+ * vector seeded reproducibly.  The per-restart eigenvectors are sign-aligned
+ * and then averaged to produce a stable estimate.
+ *
+ * Worker-dispatch strategy: Option B — all restarts run on the main thread
+ * via `Promise.all`.
+ *
+ * @param adj  - Adjacency matrix (undirected, non-negative weights)
+ * @param opts - Eigenvector + restart options
+ *
+ * @example
+ * const adj = [[0,1,1],[1,0,1],[1,1,0]];
+ * const { centrality } = await eigenvectorCentrality(adj);
+ * // all ≈ [0.577, 0.577, 0.577] (symmetric k3)
+ */
+export declare function eigenvectorCentrality(adj: number[][], opts?: EigenvectorOptions & CentralityRestartOptions): Promise<EigenvectorResult | EigenvectorRestartResult>;
+//# sourceMappingURL=graph.d.ts.map

package/dist/typed/graph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graph.d.ts","sourceRoot":"","sources":["../../src/typed/graph.ts"],"names":[],"mappings":"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"}

package/dist/typed/hypothesis.d.ts

@@ -0,0 +1,274 @@
+/**
+ * Statistical Hypothesis Tests
+ *
+ * Provides common statistical tests returning test statistics and p-values:
+ * - studentTTest: one-sample and two-sample t-test
+ * - chiSquareTest: chi-square goodness of fit
+ * - anova: one-way ANOVA
+ * - kolmogorovSmirnovTest: Kolmogorov-Smirnov test
+ * - mannWhitneyTest: Mann-Whitney U test
+ * - shapiroWilkTest: Shapiro-Wilk normality test
+ * - principalComponentAnalysis: PCA dimensionality reduction
+ *
+ * Worker-dispatch policy (Slice 3.10):
+ * - chiSquareTest (1D): element-wise reduction via applyKernel2 + sum above threshold.
+ * - kolmogorovSmirnovTest: sort on main thread; post-sort CDF-compare loop via
+ *   applyKernel (serialised normal-CDF) above threshold when no custom CDF is given.
+ * - mannWhitneyTest: sort on main thread; rank-sum via parallel dot above threshold.
+ * - shapiroWilkTest: sort on main thread; W-numerator dot-product via parallel dot
+ *   above threshold.
+ *
+ * Bootstrap fan-out (Slice 5.11):
+ * - All four two-sample / goodness-of-fit tests accept `{ bootstrap: N }`.
+ * - When set, N permuted resamples are drawn from the combined data pool and the
+ *   statistic is recomputed for each.  The N tasks are fanned out via
+ *   `Promise.all` so the JS event-loop can interleave them (embarrassingly
+ *   parallel at the microtask level; each individual run uses the existing
+ *   Slice-3.10 worker dispatch if the resample is large enough).
+ * - `bootstrapSeed` enables fully deterministic resampling via Mulberry32 PRNG.
+ *
+ * @packageDocumentation
+ */
+/** 64-bit float */
+type f64 = number;
+export interface TTestResult {
+    statistic: f64;
+    pValue: f64;
+    degreesOfFreedom: f64;
+}
+export interface ChiSquareResult {
+    statistic: f64;
+    pValue: f64;
+    degreesOfFreedom: f64;
+}
+export interface AnovaResult {
+    fStatistic: f64;
+    pValue: f64;
+    dfBetween: f64;
+    dfWithin: f64;
+}
+export interface KSTestResult {
+    statistic: f64;
+    pValue: f64;
+}
+export interface MannWhitneyResult {
+    uStatistic: f64;
+    pValue: f64;
+}
+export interface ShapiroWilkResult {
+    statistic: f64;
+    pValue: f64;
+}
+export interface PCAResult {
+    components: f64[][];
+    explained: f64[];
+    scores: f64[][];
+}
+/**
+ * Options for bootstrap resampling.  When `bootstrap` is set, the test is run
+ * on `bootstrap` independent permutations of the combined sample data, and the
+ * results are aggregated into a `*BootstrapResult` object.
+ *
+ * @example
+ * const r = await kolmogorovSmirnovTest(s1, s2, { bootstrap: 200, bootstrapSeed: 42 });
+ * // r.pValueEmpirical  — fraction of permuted statistics ≥ base statistic
+ */
+export interface BootstrapOptions {
+    /**
+     * Number of permutation-resampled test runs to execute.
+     * `0` or `undefined` = fall back to the ordinary (non-bootstrap) result.
+     */
+    bootstrap?: number;
+    /**
+     * Integer seed for the Mulberry32 PRNG so that permutations are
+     * deterministic across runs.  When omitted Math.random() is used.
+     */
+    bootstrapSeed?: number;
+}
+export interface KSBootstrapResult {
+    /** D statistic from the original (un-permuted) samples. */
+    statistic: f64;
+    /** Fraction of permuted statistics ≥ original statistic (two-tailed). */
+    pValueEmpirical: f64;
+    /** Raw permuted D statistics. */
+    bootstrapStatistics: Float64Array;
+    bootstrapMean: f64;
+    bootstrapStd: f64;
+}
+export interface MWBootstrapResult {
+    /** U statistic from the original (un-permuted) samples. */
+    uStatistic: f64;
+    /** Fraction of permuted U statistics ≥ original U statistic. */
+    pValueEmpirical: f64;
+    /** Raw permuted U statistics. */
+    bootstrapStatistics: Float64Array;
+    bootstrapMean: f64;
+    bootstrapStd: f64;
+}
+export interface SWBootstrapResult {
+    /** W statistic from the original (un-permuted) samples. */
+    statistic: f64;
+    /**
+     * Fraction of permuted W statistics ≤ original W statistic.
+     * (Small W indicates non-normality, so we count ≤.)
+     */
+    pValueEmpirical: f64;
+    /** Raw permuted W statistics. */
+    bootstrapStatistics: Float64Array;
+    bootstrapMean: f64;
+    bootstrapStd: f64;
+}
+export interface ChiSquareBootstrapResult {
+    /** chi² statistic from the original (un-permuted) samples. */
+    statistic: f64;
+    /** Fraction of permuted statistics ≥ original statistic. */
+    pValueEmpirical: f64;
+    /** Raw permuted chi² statistics. */
+    bootstrapStatistics: Float64Array;
+    bootstrapMean: f64;
+    bootstrapStd: f64;
+}
+/**
+ * Student's t-test.
+ *
+ * One-sample: test if sample mean differs from 0 (or provide second argument as null).
+ * Two-sample: Welch's t-test (unequal variances) comparing two independent samples.
+ *
+ * @param sample1 - First sample
+ * @param sample2 - Second sample (omit for one-sample test)
+ * @returns Test result with statistic, pValue, degreesOfFreedom
+ *
+ * @example
+ * studentTTest([1, 2, 3, 4, 5]) // one-sample test
+ * studentTTest([1, 2, 3], [4, 5, 6]) // two-sample test
+ */
+export declare function studentTTest(sample1: f64[], sample2?: f64[]): TTestResult;
+/**
+ * Chi-square goodness-of-fit test (1D) or independence test (2D contingency table).
+ *
+ * 1D form: tests whether observed frequencies match expected frequencies.
+ *   chi2 = sum((O_i - E_i)^2 / E_i), df = length - 1.
+ *
+ * 2D form: when called with a single 2D `observed` array (rows x cols),
+ *   tests independence of two categorical variables. Expected cell counts
+ *   are auto-computed from row totals * col totals / grand total.
+ *   chi2 = sum_{i,j} ((O_ij - E_ij)^2 / E_ij), df = (rows-1) * (cols-1).
+ *
+ * Worker dispatch (Slice 3.10): For the 1D form with ≥ 4096 categories the
+ * element-wise reduction `(o-e)²/e` is computed via `applyKernel2` + `sum`
+ * on the worker pool. The 2D form stays on the main thread (reduction over a
+ * 2D grid — marshal cost dominates).
+ *
+ * Bootstrap (Slice 5.11): When `opts.bootstrap > 0`, the observed counts are
+ * resampled with replacement from a multinomial distribution (preserving the
+ * total count), the statistic is re-computed for each resample, and the
+ * empirical p-value is the fraction of resampled statistics ≥ the base.
+ *
+ * @param observed - 1D observed counts, OR 2D contingency table (rows x cols)
+ * @param expected - 1D expected counts (required for 1D form; omit for 2D)
+ * @param opts     - Optional bootstrap settings
+ * @returns Chi-square test result (or bootstrap result when `opts.bootstrap > 0`)
+ *
+ * @example
+ * chiSquareTest([10, 20, 30], [20, 20, 20])     // 1D goodness-of-fit
+ * chiSquareTest([[10, 20], [30, 40]])           // 2D independence test
+ * chiSquareTest([10, 20, 30], [20, 20, 20], { bootstrap: 500 }) // bootstrap
+ */
+export declare function chiSquareTest(observed: f64[] | f64[][], expected?: f64[], opts?: BootstrapOptions): Promise<ChiSquareResult | ChiSquareBootstrapResult>;
+/**
+ * One-way ANOVA (Analysis of Variance).
+ *
+ * Tests whether the means of multiple groups are equal.
+ *
+ * @param groups - Array of sample arrays (at least 2 groups)
+ * @returns ANOVA result with F-statistic and p-value
+ *
+ * @example
+ * anova([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
+ */
+export declare function anova(groups: f64[][]): AnovaResult;
+/**
+ * Kolmogorov-Smirnov test for goodness of fit.
+ *
+ * One-sample test against the standard normal distribution (default),
+ * or provide a custom CDF function.
+ *
+ * Worker dispatch (Slice 3.10): When no custom CDF is supplied and
+ * `sample.length >= 4096`, the sort stays on the main thread but the
+ * per-element normal-CDF evaluation is dispatched via `applyKernel`.
+ * Max-reduction of |D+| and |D-| is done on the main thread from the
+ * returned CDF values (O(n) but cheap vs. O(n log n) sort).
+ * When a custom CDF closure is given, the parallel path is skipped
+ * (closures cannot be serialised into worker threads).
+ *
+ * Bootstrap (Slice 5.11): When `opts.bootstrap > 0`, the sample is resampled
+ * with replacement (parametric bootstrap from the empirical distribution),
+ * and the D statistic is recomputed against the same CDF for each resample.
+ * Empirical p-value = fraction of bootstrap D values ≥ base D.
+ *
+ * @param sample - Array of observations
+ * @param cdfFn  - CDF function to test against (default: standard normal)
+ * @param opts   - Optional bootstrap settings
+ * @returns K-S test result
+ *
+ * @example
+ * kolmogorovSmirnovTest([0.1, 0.5, 0.9], (x) => x) // test against uniform(0,1)
+ * kolmogorovSmirnovTest(data, undefined, { bootstrap: 200, bootstrapSeed: 1 })
+ */
+export declare function kolmogorovSmirnovTest(sample: f64[], cdfFn?: (x: f64) => f64, opts?: BootstrapOptions): Promise<KSTestResult | KSBootstrapResult>;
+/**
+ * Mann-Whitney U test (Wilcoxon rank-sum test).
+ *
+ * Non-parametric test for whether two independent samples are drawn
+ * from the same distribution.
+ *
+ * Worker dispatch (Slice 3.10): When the combined sample has ≥ 4096 elements,
+ * the sort stays on the main thread but the rank-sum for group 1 is computed
+ * via a parallel dot-product `dot(ranks, groupIndicator)` on the pool.
+ *
+ * @param sample1 - First sample
+ * @param sample2 - Second sample
+ * @param opts    - Optional bootstrap settings
+ * @returns Mann-Whitney test result
+ *
+ * @example
+ * mannWhitneyTest([1, 2, 3], [4, 5, 6])
+ * mannWhitneyTest(s1, s2, { bootstrap: 200, bootstrapSeed: 7 })
+ */
+export declare function mannWhitneyTest(sample1: f64[], sample2: f64[], opts?: BootstrapOptions): Promise<MannWhitneyResult | MWBootstrapResult>;
+/**
+ * Shapiro-Wilk test for normality.
+ *
+ * Tests the null hypothesis that the data is normally distributed.
+ * Implementation uses the simplified algorithm for sample sizes up to 5000.
+ *
+ * Worker dispatch (Slice 3.10): When `sample.length >= 4096`, the sort stays
+ * on the main thread but the W-statistic numerator dot-product
+ * `dot(coefficients, sorted_values)` is computed via the pool.
+ *
+ * @param sample - Array of observations (3 to 5000 elements)
+ * @param opts   - Optional bootstrap settings
+ * @returns Shapiro-Wilk test result
+ *
+ * @example
+ * shapiroWilkTest([1, 2, 3, 4, 5])
+ * shapiroWilkTest(data, { bootstrap: 100, bootstrapSeed: 42 })
+ */
+export declare function shapiroWilkTest(sample: f64[], opts?: BootstrapOptions): Promise<ShapiroWilkResult | SWBootstrapResult>;
+/**
+ * Principal Component Analysis (PCA).
+ *
+ * Reduces dimensionality of data by finding the directions of maximum variance.
+ *
+ * @param data - 2D array where each row is an observation, each column a variable
+ * @param k - Number of principal components to keep (default: all)
+ * @returns PCA result with components, explained variance ratios, and scores
+ *
+ * @example
+ * const result = principalComponentAnalysis([[1, 2], [3, 4], [5, 6]], 1);
+ * result.components  // [[0.707, 0.707]]
+ * result.explained   // [1.0]
+ */
+export declare function principalComponentAnalysis(data: f64[][], k?: number): PCAResult;
+export {};
+//# sourceMappingURL=hypothesis.d.ts.map

package/dist/typed/hypothesis.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hypothesis.d.ts","sourceRoot":"","sources":["../../src/typed/hypothesis.ts"],"names":[],"mappings":"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"}