@zukhruf/statistics 0.0.0-stage → 0.8.3

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ezzabuzaid
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/NOTICE

@@ -0,0 +1,10 @@
+@zukhruf/statistics
+Copyright 2026 ezzabuzaid
+
+This package ports the semantics of the methods lower, higher, linear and
+inverted_cdf of numpy.quantile in NumPy 2.5.4, including the _lerp of its
+linear method, Copyright (c) NumPy Developers, BSD 3-Clause License,
+https://github.com/numpy/numpy. The package does not include NumPy's code.
+The names of the percentile bootstrap follow SciPy (scipy.stats.bootstrap)
+and arch (arch.bootstrap.IIDBootstrap); the package includes no code of
+either.

package/README.md

@@ -1,3 +1,54 @@
-# Temporary Holding Version
+# @zukhruf/statistics
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+The percentile bootstrap and the quantile methods of NumPy in JavaScript, to the last bit. Use it when a TypeScript eval must give the same interval as a Python program, such as the summary of a benchmark or the comparison of two models.
+
+The package is public on npm. Until 2026-11-07 it was private and reached through a workspace path (ADR 0001); it became public with `@zukhruf/evals`, which depends on it (backlog #3888).
+
+## Use it
+
+```ts
+import { Random } from 'python-random';
+
+import { IidBootstrap, Linear, PercentileInterval } from '@zukhruf/statistics';
+
+const random = new Random(42);
+const bootstrap = new IidBootstrap({
+  nResamples: 1000,
+  randomIndex: (n) => random.randrange(n),
+});
+const interval = bootstrap.interval(
+  scores,
+  (resample) =>
+    resample.reduce((sum, score) => sum + score, 0) / resample.length,
+  new PercentileInterval({ low: 0.025, high: 0.975, method: new Linear() }),
+);
+interval.low; // the 2.5% quantile of the 1000 means, as numpy.percentile
+interval.isAbove(0); // true when the whole interval lies above 0
+
+new Linear().of([1, 2, 3, 4], 0.5); // 2.5, as numpy.quantile(a, 0.5)
+```
+
+| Export                     | NumPy, SciPy or arch                                                               | What it does                                                                                                                                                                                                                                                                                       |
+| -------------------------- | ---------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `QuantileMethod`           | the `method` of `numpy.quantile`                                                   | A rule that gives the value at the quantile `q` of sorted values: `of(sorted, q)`. `q` is from 0 to 1. A `q` out of that range, or no values, throws a `RangeError`.                                                                                                                               |
+| `Lower`                    | `method='lower'`                                                                   | The value at the index `floor((n − 1)q)`.                                                                                                                                                                                                                                                          |
+| `Higher`                   | `method='higher'`                                                                  | The value at the index `ceil((n − 1)q)`.                                                                                                                                                                                                                                                           |
+| `Linear`                   | `method='linear'`, the default of NumPy                                            | The line between the two values around the index `(n − 1)q`, computed as NumPy's `_lerp` computes it, so the bits are NumPy's. d3-array's `quantileSorted` gives other bits for 1 value of 10.                                                                                                     |
+| `InvertedCdf`              | `method='inverted_cdf'`                                                            | The nearest rank: the value at the index `ceil(nq) − 1`, and the first value when `q` is 0.                                                                                                                                                                                                        |
+| `ConfidenceInterval`       | the `ConfidenceInterval` of `scipy.stats.bootstrap`                                | `low` and `high`. `isAbove(value)` is true when `low > value`, and `isBelow(value)` is true when `high < value`: the whole interval lies on one side of the value.                                                                                                                                 |
+| `ConfidenceIntervalMethod` | the `method` of `scipy.stats.bootstrap`                                            | A rule that gives the confidence interval of a bootstrap distribution: `of(distribution)`. `PercentileInterval` is one. A caller with a rule of its own writes another.                                                                                                                            |
+| `PercentileInterval`       | `method='percentile'` of `scipy.stats.bootstrap`                                   | The `low` and the `high` quantile of a bootstrap distribution, both read with one quantile method, as `numpy.percentile` reads them. It sorts a copy, so the distribution does not change.                                                                                                         |
+| `IidBootstrap`             | `arch.bootstrap.IIDBootstrap`; `n_resamples` and `bootstrap_distribution` of SciPy | Draws `nResamples` resamples of the data, with replacement. `distribution(data, statistic)` gives the statistic of each resample. `interval(data, statistic, method)` gives the interval that a `ConfidenceIntervalMethod` reads from that distribution. Data with no items throws a `RangeError`. |
+
+The random generator is an input. `randomIndex(n)` gives an index from 0 to n − 1. Each item of a resample takes one call, in order, resample by resample, as a Python loop over the same generator does. So `(n) => random.randrange(n)` of python-random draws as CPython's `random.Random`, and a port of NumPy's `default_rng` draws as `integers(0, n, n)` when it draws one index for each call. An index out of range throws a `RangeError`.
+
+These parts stay with each caller, because each caller has its own rule:
+
+- the random generators: python-random is on npm, and the NumPy generators are in `@zukhruf/random`. Each caller gives `randomIndex`;
+- a stratified bootstrap (relevance-filtering) and a block bootstrap (`@zukhruf/event-detection`): they draw their own resamples and give their distribution to `PercentileInterval`;
+- an interval with a rule of its own at each end, such as the `lower` method at the low end and the `higher` method at the high end of the Structured Output Benchmark: its caller writes it as a `ConfidenceIntervalMethod`;
+- a p-value and a verdict, such as "better" when the interval of a difference lies above 0: each caller builds its rule from `isAbove` and `isBelow`.
+
+## Documentation
+
+- [ADR 0001: one home for the percentile bootstrap that six places copied, reached through a workspace path](docs/adr/0001-one-home-for-the-percentile-bootstrap-that-six-places-copied.md)

package/dist/bootstrap/iid-bootstrap.d.ts

@@ -0,0 +1,12 @@
+import type { ConfidenceIntervalMethod } from '../interval/confidence-interval-method.ts';
+import type { ConfidenceInterval } from '../interval/confidence-interval.ts';
+export declare class IidBootstrap {
+    #private;
+    constructor({ nResamples, randomIndex, }: {
+        readonly nResamples: number;
+        readonly randomIndex: (n: number) => number;
+    });
+    distribution<T>(data: readonly T[], statistic: (resample: readonly T[]) => number): number[];
+    interval<T>(data: readonly T[], statistic: (resample: readonly T[]) => number, method: ConfidenceIntervalMethod): ConfidenceInterval;
+}
+//# sourceMappingURL=iid-bootstrap.d.ts.map

package/dist/bootstrap/iid-bootstrap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"iid-bootstrap.d.ts","sourceRoot":"","sources":["../../src/bootstrap/iid-bootstrap.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,2CAA2C,CAAC;AAC1F,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,oCAAoC,CAAC;AAM7E,qBAAa,YAAY;;gBAIX,EACV,UAAU,EACV,WAAW,GACZ,EAAE;QACD,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;QAC5B,QAAQ,CAAC,WAAW,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,CAAC;KAC7C;IAOD,YAAY,CAAC,CAAC,EACZ,IAAI,EAAE,SAAS,CAAC,EAAE,EAClB,SAAS,EAAE,CAAC,QAAQ,EAAE,SAAS,CAAC,EAAE,KAAK,MAAM,GAC5C,MAAM,EAAE;IAQX,QAAQ,CAAC,CAAC,EACR,IAAI,EAAE,SAAS,CAAC,EAAE,EAClB,SAAS,EAAE,CAAC,QAAQ,EAAE,SAAS,CAAC,EAAE,KAAK,MAAM,EAC7C,MAAM,EAAE,wBAAwB,GAC/B,kBAAkB;CAatB"}

package/dist/bootstrap/iid-bootstrap.js

@@ -0,0 +1,30 @@
+// The bootstrap of arch.bootstrap.IIDBootstrap: resamples of independent
+// items, drawn with replacement. The caller's generator gives each random
+// index, one call for each item, in order, resample by resample, as a Python
+// loop over the same generator draws them.
+export class IidBootstrap {
+    #nResamples;
+    #randomIndex;
+    constructor({ nResamples, randomIndex, }) {
+        this.#nResamples = nResamples;
+        this.#randomIndex = randomIndex;
+    }
+    // The bootstrap distribution of scipy.stats.bootstrap: the statistic of
+    // each resample, in the order of the resamples.
+    distribution(data, statistic) {
+        if (data.length === 0)
+            throw new RangeError('A bootstrap needs at least one item');
+        return Array.from({ length: this.#nResamples }, () => statistic(Array.from({ length: data.length }, () => this.#item(data))));
+    }
+    interval(data, statistic, method) {
+        return method.of(this.distribution(data, statistic));
+    }
+    #item(data) {
+        const index = this.#randomIndex(data.length);
+        const item = data[index];
+        if (item === undefined)
+            throw new RangeError(`A random index is from 0 to ${data.length - 1}, not ${index}`);
+        return item;
+    }
+}
+//# sourceMappingURL=iid-bootstrap.js.map

package/dist/bootstrap/iid-bootstrap.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"iid-bootstrap.js","sourceRoot":"","sources":["../../src/bootstrap/iid-bootstrap.ts"],"names":[],"mappings":"AAGA,yEAAyE;AACzE,0EAA0E;AAC1E,6EAA6E;AAC7E,2CAA2C;AAC3C,MAAM,OAAO,YAAY;IACd,WAAW,CAAS;IACpB,YAAY,CAAwB;IAE7C,YAAY,EACV,UAAU,EACV,WAAW,GAIZ;QACC,IAAI,CAAC,WAAW,GAAG,UAAU,CAAC;QAC9B,IAAI,CAAC,YAAY,GAAG,WAAW,CAAC;IAClC,CAAC;IAED,wEAAwE;IACxE,gDAAgD;IAChD,YAAY,CACV,IAAkB,EAClB,SAA6C;QAE7C,IAAI,IAAI,CAAC,MAAM,KAAK,CAAC;YACnB,MAAM,IAAI,UAAU,CAAC,qCAAqC,CAAC,CAAC;QAC9D,OAAO,KAAK,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,IAAI,CAAC,WAAW,EAAE,EAAE,GAAG,EAAE,CACnD,SAAS,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,IAAI,CAAC,MAAM,EAAE,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,CACvE,CAAC;IACJ,CAAC;IAED,QAAQ,CACN,IAAkB,EAClB,SAA6C,EAC7C,MAAgC;QAEhC,OAAO,MAAM,CAAC,EAAE,CAAC,IAAI,CAAC,YAAY,CAAC,IAAI,EAAE,SAAS,CAAC,CAAC,CAAC;IACvD,CAAC;IAED,KAAK,CAAI,IAAkB;QACzB,MAAM,KAAK,GAAG,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QAC7C,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC;QACzB,IAAI,IAAI,KAAK,SAAS;YACpB,MAAM,IAAI,UAAU,CAClB,+BAA+B,IAAI,CAAC,MAAM,GAAG,CAAC,SAAS,KAAK,EAAE,CAC/D,CAAC;QACJ,OAAO,IAAI,CAAC;IACd,CAAC;CACF"}

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+export { IidBootstrap } from './bootstrap/iid-bootstrap.ts';
+export { ConfidenceInterval } from './interval/confidence-interval.ts';
+export type { ConfidenceIntervalMethod } from './interval/confidence-interval-method.ts';
+export { PercentileInterval } from './interval/percentile-interval.ts';
+export { Higher } from './quantile/higher.ts';
+export { InvertedCdf } from './quantile/inverted-cdf.ts';
+export { Linear } from './quantile/linear.ts';
+export { Lower } from './quantile/lower.ts';
+export { QuantileMethod } from './quantile/quantile-method.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AAC5D,OAAO,EAAE,kBAAkB,EAAE,MAAM,mCAAmC,CAAC;AACvE,YAAY,EAAE,wBAAwB,EAAE,MAAM,0CAA0C,CAAC;AACzF,OAAO,EAAE,kBAAkB,EAAE,MAAM,mCAAmC,CAAC;AACvE,OAAO,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAC9C,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AACzD,OAAO,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAC9C,OAAO,EAAE,KAAK,EAAE,MAAM,qBAAqB,CAAC;AAC5C,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC"}

package/dist/index.js

@@ -0,0 +1,9 @@
+export { IidBootstrap } from "./bootstrap/iid-bootstrap.js";
+export { ConfidenceInterval } from "./interval/confidence-interval.js";
+export { PercentileInterval } from "./interval/percentile-interval.js";
+export { Higher } from "./quantile/higher.js";
+export { InvertedCdf } from "./quantile/inverted-cdf.js";
+export { Linear } from "./quantile/linear.js";
+export { Lower } from "./quantile/lower.js";
+export { QuantileMethod } from "./quantile/quantile-method.js";
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AAC5D,OAAO,EAAE,kBAAkB,EAAE,MAAM,mCAAmC,CAAC;AAEvE,OAAO,EAAE,kBAAkB,EAAE,MAAM,mCAAmC,CAAC;AACvE,OAAO,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAC9C,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AACzD,OAAO,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAC9C,OAAO,EAAE,KAAK,EAAE,MAAM,qBAAqB,CAAC;AAC5C,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC"}

package/dist/interval/confidence-interval-method.d.ts

@@ -0,0 +1,5 @@
+import type { ConfidenceInterval } from './confidence-interval.ts';
+export interface ConfidenceIntervalMethod {
+    of(distribution: readonly number[]): ConfidenceInterval;
+}
+//# sourceMappingURL=confidence-interval-method.d.ts.map

package/dist/interval/confidence-interval-method.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"confidence-interval-method.d.ts","sourceRoot":"","sources":["../../src/interval/confidence-interval-method.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAInE,MAAM,WAAW,wBAAwB;IACvC,EAAE,CAAC,YAAY,EAAE,SAAS,MAAM,EAAE,GAAG,kBAAkB,CAAC;CACzD"}

package/dist/interval/confidence-interval-method.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=confidence-interval-method.js.map

package/dist/interval/confidence-interval-method.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"confidence-interval-method.js","sourceRoot":"","sources":["../../src/interval/confidence-interval-method.ts"],"names":[],"mappings":""}

package/dist/interval/confidence-interval.d.ts

@@ -0,0 +1,8 @@
+export declare class ConfidenceInterval {
+    readonly low: number;
+    readonly high: number;
+    constructor(low: number, high: number);
+    isAbove(value: number): boolean;
+    isBelow(value: number): boolean;
+}
+//# sourceMappingURL=confidence-interval.d.ts.map

package/dist/interval/confidence-interval.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"confidence-interval.d.ts","sourceRoot":"","sources":["../../src/interval/confidence-interval.ts"],"names":[],"mappings":"AACA,qBAAa,kBAAkB;IAC7B,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;gBAEV,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM;IAMrC,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO;IAK/B,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO;CAGhC"}

package/dist/interval/confidence-interval.js

@@ -0,0 +1,18 @@
+// A low and a high value, such as two quantiles of a bootstrap distribution.
+export class ConfidenceInterval {
+    low;
+    high;
+    constructor(low, high) {
+        this.low = low;
+        this.high = high;
+    }
+    // The whole interval lies above the value.
+    isAbove(value) {
+        return this.low > value;
+    }
+    // The whole interval lies below the value.
+    isBelow(value) {
+        return this.high < value;
+    }
+}
+//# sourceMappingURL=confidence-interval.js.map

package/dist/interval/confidence-interval.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"confidence-interval.js","sourceRoot":"","sources":["../../src/interval/confidence-interval.ts"],"names":[],"mappings":"AAAA,6EAA6E;AAC7E,MAAM,OAAO,kBAAkB;IACpB,GAAG,CAAS;IACZ,IAAI,CAAS;IAEtB,YAAY,GAAW,EAAE,IAAY;QACnC,IAAI,CAAC,GAAG,GAAG,GAAG,CAAC;QACf,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;IACnB,CAAC;IAED,2CAA2C;IAC3C,OAAO,CAAC,KAAa;QACnB,OAAO,IAAI,CAAC,GAAG,GAAG,KAAK,CAAC;IAC1B,CAAC;IAED,2CAA2C;IAC3C,OAAO,CAAC,KAAa;QACnB,OAAO,IAAI,CAAC,IAAI,GAAG,KAAK,CAAC;IAC3B,CAAC;CACF"}

package/dist/interval/percentile-interval.d.ts

@@ -0,0 +1,13 @@
+import type { QuantileMethod } from '../quantile/quantile-method.ts';
+import type { ConfidenceIntervalMethod } from './confidence-interval-method.ts';
+import { ConfidenceInterval } from './confidence-interval.ts';
+export declare class PercentileInterval implements ConfidenceIntervalMethod {
+    #private;
+    constructor({ low, high, method, }: {
+        readonly low: number;
+        readonly high: number;
+        readonly method: QuantileMethod;
+    });
+    of(distribution: readonly number[]): ConfidenceInterval;
+}
+//# sourceMappingURL=percentile-interval.d.ts.map

package/dist/interval/percentile-interval.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"percentile-interval.d.ts","sourceRoot":"","sources":["../../src/interval/percentile-interval.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAC;AACrE,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,iCAAiC,CAAC;AAChF,OAAO,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAM9D,qBAAa,kBAAmB,YAAW,wBAAwB;;gBAKrD,EACV,GAAG,EACH,IAAI,EACJ,MAAM,GACP,EAAE;QACD,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;QACrB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;QACtB,QAAQ,CAAC,MAAM,EAAE,cAAc,CAAC;KACjC;IAMD,EAAE,CAAC,YAAY,EAAE,SAAS,MAAM,EAAE,GAAG,kBAAkB;CAOxD"}

package/dist/interval/percentile-interval.js

@@ -0,0 +1,20 @@
+import { ConfidenceInterval } from "./confidence-interval.js";
+// The percentile method of scipy.stats.bootstrap: the low and the high
+// quantile of a bootstrap distribution, both read with one quantile method,
+// as numpy.percentile reads them. It sorts a copy, so the distribution stays
+// as it is.
+export class PercentileInterval {
+    #low;
+    #high;
+    #method;
+    constructor({ low, high, method, }) {
+        this.#low = low;
+        this.#high = high;
+        this.#method = method;
+    }
+    of(distribution) {
+        const sorted = distribution.toSorted((a, b) => a - b);
+        return new ConfidenceInterval(this.#method.of(sorted, this.#low), this.#method.of(sorted, this.#high));
+    }
+}
+//# sourceMappingURL=percentile-interval.js.map

package/dist/interval/percentile-interval.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"percentile-interval.js","sourceRoot":"","sources":["../../src/interval/percentile-interval.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAE9D,uEAAuE;AACvE,4EAA4E;AAC5E,6EAA6E;AAC7E,YAAY;AACZ,MAAM,OAAO,kBAAkB;IACpB,IAAI,CAAS;IACb,KAAK,CAAS;IACd,OAAO,CAAiB;IAEjC,YAAY,EACV,GAAG,EACH,IAAI,EACJ,MAAM,GAKP;QACC,IAAI,CAAC,IAAI,GAAG,GAAG,CAAC;QAChB,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC;QAClB,IAAI,CAAC,OAAO,GAAG,MAAM,CAAC;IACxB,CAAC;IAED,EAAE,CAAC,YAA+B;QAChC,MAAM,MAAM,GAAG,YAAY,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;QACtD,OAAO,IAAI,kBAAkB,CAC3B,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC,MAAM,EAAE,IAAI,CAAC,IAAI,CAAC,EAClC,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC,MAAM,EAAE,IAAI,CAAC,KAAK,CAAC,CACpC,CAAC;IACJ,CAAC;CACF"}

package/dist/quantile/higher.d.ts

@@ -0,0 +1,5 @@
+import { QuantileMethod } from './quantile-method.ts';
+export declare class Higher extends QuantileMethod {
+    protected valueAt(sorted: readonly number[], q: number): number;
+}
+//# sourceMappingURL=higher.d.ts.map

package/dist/quantile/higher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"higher.d.ts","sourceRoot":"","sources":["../../src/quantile/higher.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAGtD,qBAAa,MAAO,SAAQ,cAAc;IACxC,SAAS,CAAC,OAAO,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM;CAGhE"}

package/dist/quantile/higher.js

@@ -0,0 +1,8 @@
+import { QuantileMethod } from "./quantile-method.js";
+// numpy.quantile(method='higher'): the value at ceil((n - 1)q).
+export class Higher extends QuantileMethod {
+    valueAt(sorted, q) {
+        return QuantileMethod.value(sorted, Math.ceil((sorted.length - 1) * q));
+    }
+}
+//# sourceMappingURL=higher.js.map

package/dist/quantile/higher.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"higher.js","sourceRoot":"","sources":["../../src/quantile/higher.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAEtD,gEAAgE;AAChE,MAAM,OAAO,MAAO,SAAQ,cAAc;IAC9B,OAAO,CAAC,MAAyB,EAAE,CAAS;QACpD,OAAO,cAAc,CAAC,KAAK,CAAC,MAAM,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;IAC1E,CAAC;CACF"}

package/dist/quantile/inverted-cdf.d.ts

@@ -0,0 +1,5 @@
+import { QuantileMethod } from './quantile-method.ts';
+export declare class InvertedCdf extends QuantileMethod {
+    protected valueAt(sorted: readonly number[], q: number): number;
+}
+//# sourceMappingURL=inverted-cdf.d.ts.map

package/dist/quantile/inverted-cdf.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inverted-cdf.d.ts","sourceRoot":"","sources":["../../src/quantile/inverted-cdf.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAKtD,qBAAa,WAAY,SAAQ,cAAc;IAC7C,SAAS,CAAC,OAAO,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM;CAMhE"}

package/dist/quantile/inverted-cdf.js

@@ -0,0 +1,13 @@
+import { QuantileMethod } from "./quantile-method.js";
+// numpy.quantile(method='inverted_cdf'), the nearest rank: NumPy reads the
+// index nq - 1, keeps it when it is whole and else takes the next one, and
+// reads the first value below 0.
+export class InvertedCdf extends QuantileMethod {
+    valueAt(sorted, q) {
+        const index = sorted.length * q - 1;
+        const previous = Math.floor(index);
+        const picked = index - previous === 0 ? previous : previous + 1;
+        return QuantileMethod.value(sorted, Math.max(picked, 0));
+    }
+}
+//# sourceMappingURL=inverted-cdf.js.map

package/dist/quantile/inverted-cdf.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"inverted-cdf.js","sourceRoot":"","sources":["../../src/quantile/inverted-cdf.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAEtD,2EAA2E;AAC3E,2EAA2E;AAC3E,iCAAiC;AACjC,MAAM,OAAO,WAAY,SAAQ,cAAc;IACnC,OAAO,CAAC,MAAyB,EAAE,CAAS;QACpD,MAAM,KAAK,GAAG,MAAM,CAAC,MAAM,GAAG,CAAC,GAAG,CAAC,CAAC;QACpC,MAAM,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;QACnC,MAAM,MAAM,GAAG,KAAK,GAAG,QAAQ,KAAK,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,QAAQ,GAAG,CAAC,CAAC;QAChE,OAAO,cAAc,CAAC,KAAK,CAAC,MAAM,EAAE,IAAI,CAAC,GAAG,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,CAAC;IAC3D,CAAC;CACF"}

package/dist/quantile/linear.d.ts

@@ -0,0 +1,5 @@
+import { QuantileMethod } from './quantile-method.ts';
+export declare class Linear extends QuantileMethod {
+    protected valueAt(sorted: readonly number[], q: number): number;
+}
+//# sourceMappingURL=linear.d.ts.map

package/dist/quantile/linear.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"linear.d.ts","sourceRoot":"","sources":["../../src/quantile/linear.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAMtD,qBAAa,MAAO,SAAQ,cAAc;IACxC,SAAS,CAAC,OAAO,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM;CAYhE"}

package/dist/quantile/linear.js

@@ -0,0 +1,17 @@
+import { QuantileMethod } from "./quantile-method.js";
+// numpy.quantile(method='linear'), the default of NumPy: the line between the
+// values around the index (n - 1)q, as NumPy's _lerp computes it. From the
+// middle on, _lerp goes back from the upper value, so a fraction of 0.5 or
+// more gives other bits than a + (b - a)t.
+export class Linear extends QuantileMethod {
+    valueAt(sorted, q) {
+        const position = (sorted.length - 1) * q;
+        const below = Math.floor(position);
+        const a = QuantileMethod.value(sorted, below);
+        const b = QuantileMethod.value(sorted, Math.min(below + 1, sorted.length - 1));
+        const t = position - below;
+        const difference = b - a;
+        return t >= 0.5 ? b - difference * (1 - t) : a + difference * t;
+    }
+}
+//# sourceMappingURL=linear.js.map

package/dist/quantile/linear.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"linear.js","sourceRoot":"","sources":["../../src/quantile/linear.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAEtD,8EAA8E;AAC9E,2EAA2E;AAC3E,2EAA2E;AAC3E,2CAA2C;AAC3C,MAAM,OAAO,MAAO,SAAQ,cAAc;IAC9B,OAAO,CAAC,MAAyB,EAAE,CAAS;QACpD,MAAM,QAAQ,GAAG,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC;QACzC,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC;QACnC,MAAM,CAAC,GAAG,cAAc,CAAC,KAAK,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;QAC9C,MAAM,CAAC,GAAG,cAAc,CAAC,KAAK,CAC5B,MAAM,EACN,IAAI,CAAC,GAAG,CAAC,KAAK,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC,CACvC,CAAC;QACF,MAAM,CAAC,GAAG,QAAQ,GAAG,KAAK,CAAC;QAC3B,MAAM,UAAU,GAAG,CAAC,GAAG,CAAC,CAAC;QACzB,OAAO,CAAC,IAAI,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,UAAU,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,UAAU,GAAG,CAAC,CAAC;IAClE,CAAC;CACF"}

package/dist/quantile/lower.d.ts

@@ -0,0 +1,5 @@
+import { QuantileMethod } from './quantile-method.ts';
+export declare class Lower extends QuantileMethod {
+    protected valueAt(sorted: readonly number[], q: number): number;
+}
+//# sourceMappingURL=lower.d.ts.map

package/dist/quantile/lower.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lower.d.ts","sourceRoot":"","sources":["../../src/quantile/lower.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAGtD,qBAAa,KAAM,SAAQ,cAAc;IACvC,SAAS,CAAC,OAAO,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM;CAGhE"}

package/dist/quantile/lower.js

@@ -0,0 +1,8 @@
+import { QuantileMethod } from "./quantile-method.js";
+// numpy.quantile(method='lower'): the value at floor((n - 1)q).
+export class Lower extends QuantileMethod {
+    valueAt(sorted, q) {
+        return QuantileMethod.value(sorted, Math.floor((sorted.length - 1) * q));
+    }
+}
+//# sourceMappingURL=lower.js.map

package/dist/quantile/lower.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lower.js","sourceRoot":"","sources":["../../src/quantile/lower.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAEtD,gEAAgE;AAChE,MAAM,OAAO,KAAM,SAAQ,cAAc;IAC7B,OAAO,CAAC,MAAyB,EAAE,CAAS;QACpD,OAAO,cAAc,CAAC,KAAK,CAAC,MAAM,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;IAC3E,CAAC;CACF"}

package/dist/quantile/quantile-method.d.ts

@@ -0,0 +1,6 @@
+export declare abstract class QuantileMethod {
+    of(sorted: readonly number[], q: number): number;
+    protected abstract valueAt(sorted: readonly number[], q: number): number;
+    protected static value(sorted: readonly number[], index: number): number;
+}
+//# sourceMappingURL=quantile-method.d.ts.map

package/dist/quantile/quantile-method.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"quantile-method.d.ts","sourceRoot":"","sources":["../../src/quantile/quantile-method.ts"],"names":[],"mappings":"AAGA,8BAAsB,cAAc;IAClC,EAAE,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM;IAQhD,SAAS,CAAC,QAAQ,CAAC,OAAO,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM;IAGxE,SAAS,CAAC,MAAM,CAAC,KAAK,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM;CAMzE"}

package/dist/quantile/quantile-method.js

@@ -0,0 +1,20 @@
+// A rule that gives the value at the quantile q of sorted values: a method of
+// numpy.quantile, with NumPy's name. q is from 0 to 1, as NumPy requires. A
+// subclass gives only where its rule reads the values (Template Method).
+export class QuantileMethod {
+    of(sorted, q) {
+        if (!(q >= 0 && q <= 1))
+            throw new RangeError(`A quantile is from 0 to 1, not ${q}`);
+        if (sorted.length === 0)
+            throw new RangeError('A quantile needs at least one value');
+        return this.valueAt(sorted, q);
+    }
+    // The value at an index that the rule computed, which is always in range.
+    static value(sorted, index) {
+        const value = sorted[index];
+        if (value === undefined)
+            throw new RangeError(`No value at the index ${index}`);
+        return value;
+    }
+}
+//# sourceMappingURL=quantile-method.js.map

package/dist/quantile/quantile-method.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"quantile-method.js","sourceRoot":"","sources":["../../src/quantile/quantile-method.ts"],"names":[],"mappings":"AAAA,8EAA8E;AAC9E,4EAA4E;AAC5E,yEAAyE;AACzE,MAAM,OAAgB,cAAc;IAClC,EAAE,CAAC,MAAyB,EAAE,CAAS;QACrC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YACrB,MAAM,IAAI,UAAU,CAAC,kCAAkC,CAAC,EAAE,CAAC,CAAC;QAC9D,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC;YACrB,MAAM,IAAI,UAAU,CAAC,qCAAqC,CAAC,CAAC;QAC9D,OAAO,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC;IACjC,CAAC;IAID,0EAA0E;IAChE,MAAM,CAAC,KAAK,CAAC,MAAyB,EAAE,KAAa;QAC7D,MAAM,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC;QAC5B,IAAI,KAAK,KAAK,SAAS;YACrB,MAAM,IAAI,UAAU,CAAC,yBAAyB,KAAK,EAAE,CAAC,CAAC;QACzD,OAAO,KAAK,CAAC;IACf,CAAC;CACF"}

package/package.json

@@ -1,6 +1,42 @@
 {
   "name": "@zukhruf/statistics",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.8.3",
+  "description": "The percentile bootstrap and the quantile methods of NumPy in JavaScript, to the last bit: resamples of a dataset with a random generator that the caller gives, the percentile interval of their statistic, and NumPy's quantile methods.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/JanuaryLabs/zukhruf",
+    "directory": "packages/statistics"
+  },
+  "bugs": {
+    "url": "https://github.com/JanuaryLabs/zukhruf/issues"
+  },
+  "homepage": "https://github.com/JanuaryLabs/zukhruf/tree/main/packages/statistics#readme",
+  "keywords": [
+    "statistics",
+    "bootstrap",
+    "confidence-interval",
+    "quantile",
+    "numpy"
+  ],
+  "type": "module",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "@zukhruf/source": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "NOTICE",
+    "!dist/spec/**",
+    "!**/*.tsbuildinfo",
+    "!**/*.test.*"
+  ],
+  "publishConfig": {
+    "access": "public"
+  }
+}