qntjs-lib 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export * as math from './math/index.js';
+export * as ta from './ta/index.js';
+export * as arr from './arr/arr.js';
+export * as stats from './stats/index.js';

package/dist/math/basic.d.ts

@@ -0,0 +1,174 @@
+/**
+ * Element-wise addition.
+ * - If `b` is a number, returns `a + b` for each element.
+ * - If `b` is an array, returns element-wise sum up to the shorter length.
+ * @param a Left operand array
+ * @param b Right operand array or scalar
+ * @returns Float64Array of sums
+ */
+export declare function add(a: ArrayLike<number>, b: ArrayLike<number> | number): Float64Array;
+/**
+ * Element-wise subtraction.
+ * - If `b` is a number, returns `a - b` for each element.
+ * - If `b` is an array, returns element-wise difference up to the shorter length.
+ * @param a Left operand array
+ * @param b Right operand array or scalar
+ * @returns Float64Array of differences
+ */
+export declare function sub(a: ArrayLike<number>, b: ArrayLike<number> | number): Float64Array;
+/**
+ * Element-wise multiplication.
+ * - If `b` is a number, scales each element of `a` by `b`.
+ * - If `b` is an array, returns element-wise products up to the shorter length.
+ * @param a Left operand array
+ * @param b Right operand array or scalar
+ * @returns Float64Array of products
+ */
+export declare function mul(a: ArrayLike<number>, b: ArrayLike<number> | number): Float64Array;
+/**
+ * Element-wise division.
+ * - If `b` is a number, divides each element of `a` by `b`.
+ * - If `b` is an array, returns element-wise quotients up to the shorter length.
+ * @param a Numerator array
+ * @param b Denominator array or scalar
+ * @returns Float64Array of quotients
+ */
+export declare function div(a: ArrayLike<number>, b: ArrayLike<number> | number): Float64Array;
+/**
+ * Element-wise average: (a + b) / 2.
+ * Computes the average without allocating temporaries.
+ * @param a First array
+ * @param b Second array or scalar
+ * @returns Float64Array of averages
+ */
+export declare function avg(a: ArrayLike<number>, b: ArrayLike<number> | number): Float64Array;
+/**
+ * Scale an array by a scalar: `source * s`.
+ * @param source Input array
+ * @param s Scale factor
+ * @returns Float64Array scaled values
+ */
+export declare function scale(source: ArrayLike<number>, s: number): Float64Array;
+/**
+ * Clamp values to the inclusive range [lo, hi]. Preserves NaN entries.
+ * @param source Input array
+ * @param lo Lower bound
+ * @param hi Upper bound
+ * @returns Float64Array with values clamped or NaN preserved
+ */
+export declare function clamp(source: ArrayLike<number>, lo: number, hi: number): Float64Array;
+/**
+ * Element-wise absolute value.
+ * @param source Input array
+ * @returns Float64Array of absolute values
+ */
+export declare function abs(source: ArrayLike<number>): Float64Array;
+/**
+ * Element-wise sign (-1, 0, 1) for each entry.
+ * @param source Input array
+ * @returns Float64Array of sign values
+ */
+export declare function sign(source: ArrayLike<number>): Float64Array;
+/**
+ * Round values to nearest integer. Ties are rounded away from zero.
+ * @param source Input array
+ * @returns Float64Array of rounded integers
+ */
+export declare function round(source: ArrayLike<number>): Float64Array;
+/**
+ * Element-wise floor operation.
+ * @param source Input array
+ * @returns Float64Array of floored values
+ */
+export declare function floor(source: ArrayLike<number>): Float64Array;
+/**
+ * Element-wise ceil operation.
+ * @param source Input array
+ * @returns Float64Array of ceiled values
+ */
+export declare function ceil(source: ArrayLike<number>): Float64Array;
+/**
+ * First difference: output[i] = source[i] - source[i-1].
+ * The first element is NaN (no previous value).
+ * @param source Input array
+ * @returns Float64Array of differences (first element NaN)
+ */
+export declare function diff(source: ArrayLike<number>): Float64Array;
+/**
+ * Map a callback across `source` producing a new Float64Array.
+ * @param source Input array
+ * @param cb Mapping callback `(value, index, array) => number`
+ * @returns Float64Array of mapped values
+ */
+export declare function apply(source: ArrayLike<number>, cb: (v: number, i: number, arr: ArrayLike<number>) => number): Float64Array;
+/**
+ * Apply a callback to each element in `source` in-place.
+ * Modifies the provided array.
+ * @param source Mutable array to update
+ * @param cb Callback `(value, index) => newValue`
+ */
+export declare function applyInPlace(source: number[] | Float64Array, cb: (value: number, index: number) => number): void;
+/**
+ * Element-wise less-than comparison. Returns `Uint8Array` mask with 1 where true.
+ * @param a Left operand
+ * @param b Right operand or scalar
+ * @returns Uint8Array mask of comparisons
+ */
+export declare function lt(a: ArrayLike<number>, b: ArrayLike<number> | number): Uint8Array;
+/**
+ * Element-wise less-than-or-equal comparison (with epsilon tolerance).
+ * @param a Left operand
+ * @param b Right operand or scalar
+ * @returns Uint8Array mask of comparisons
+ */
+export declare function lte(a: ArrayLike<number>, b: ArrayLike<number> | number): Uint8Array;
+/**
+ * Element-wise greater-than comparison. Returns `Uint8Array` mask with 1 where true.
+ * @param a Left operand
+ * @param b Right operand or scalar
+ * @returns Uint8Array mask of comparisons
+ */
+export declare function gt(a: ArrayLike<number>, b: ArrayLike<number> | number): Uint8Array;
+/**
+ * Element-wise greater-than-or-equal comparison (with epsilon tolerance).
+ * @param a Left operand
+ * @param b Right operand or scalar
+ * @returns Uint8Array mask of comparisons
+ */
+export declare function gte(a: ArrayLike<number>, b: ArrayLike<number> | number): Uint8Array;
+/**
+ * Element-wise equality comparison using `Number.EPSILON` tolerance.
+ * @param a Left operand
+ * @param b Right operand or scalar
+ * @returns Uint8Array mask of equality tests
+ */
+export declare function eq(a: ArrayLike<number>, b: ArrayLike<number> | number): Uint8Array;
+/**
+ * Element-wise inequality comparison.
+ * @param a Left operand
+ * @param b Right operand or scalar
+ * @returns Uint8Array mask where elements are not equal
+ */
+export declare function neq(a: ArrayLike<number>, b: ArrayLike<number> | number): Uint8Array;
+/**
+ * Logical AND for boolean masks (Uint8Array) or with a scalar.
+ * Returns a Uint8Array of 1/0 values.
+ * @param a Left boolean mask
+ * @param b Right boolean mask or scalar
+ * @returns Uint8Array mask result
+ */
+export declare function and(a: Uint8Array, b: Uint8Array | number): Uint8Array;
+/**
+ * Logical OR for boolean masks (Uint8Array) or with a scalar.
+ * Returns a Uint8Array of 1/0 values.
+ * @param a Left boolean mask
+ * @param b Right boolean mask or scalar
+ * @returns Uint8Array mask result
+ */
+export declare function or(a: Uint8Array, b: Uint8Array | number): Uint8Array;
+/**
+ * Logical NOT for a boolean mask (Uint8Array).
+ * @param a Input boolean mask
+ * @returns Uint8Array mask with bits inverted
+ */
+export declare function not(a: Uint8Array): Uint8Array;

package/dist/math/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Barrel exports for math helpers. Re-exports individual functions from
+ * the `src/math` submodules for convenient imports.
+ */
+import { diff, add, sub, mul, div, avg, scale, clamp, abs, sign, round, floor, ceil, eq, neq, and, or, not, gt, gte, lt, lte } from './basic.js';
+import { prod, cumprod, rollprod } from './prod.js';
+import { sum, rollsum, cumsum } from './sum.js';
+import { min, rollmin, max, rollmax, argmin, argmax, cummax, cummin, rollminmax, rollargmin, rollargmax } from './minmax.js';
+import { randuniform, randnormal } from './random.js';
+import { dot, norm, ols, olsMulti } from './linalg.js';
+export { add, sub, avg, mul, div, scale, abs, sign, round, floor, ceil, eq, neq, gt, gte, lt, lte, and, or, not, clamp, sum, prod, min, max, argmin, argmax, cumsum, cumprod, cummax, cummin, rollsum, rollmin, rollmax, rollminmax, rollprod, rollargmin, rollargmax, diff, randuniform, randnormal, dot, norm, ols, olsMulti };

package/dist/math/linalg.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Dot product of two vectors: sum_i x[i] * y[i].
+ * Operates up to the shorter length of the inputs.
+ * @param x First vector
+ * @param y Second vector
+ * @returns Scalar dot product
+ */
+export declare function dot(x: ArrayLike<number>, y: ArrayLike<number>): number;
+/**
+ * Vector p-norm. Supports common p values (1, 2, Infinity) with a fast dense path.
+ * When `skipna` is true the implementation ignores NaNs and returns NaN if no valid entries exist.
+ * @param x Input vector
+ * @param p Norm order (default 2)
+ * @param skipna Whether to ignore NaNs (default true)
+ * @returns Norm value or NaN
+ */
+export declare function norm(x: ArrayLike<number>, p?: number, skipna?: boolean): number;
+/**
+ * Ordinary least squares for a simple linear model y = intercept + slope * x.
+ * Ignores paired NaN entries and returns NaN coefficients if no valid pairs or singular design.
+ * @param x Predictor values
+ * @param y Response values
+ * @returns Object with `intercept` and `slope` or NaNs on failure
+ */
+export declare function ols(x: ArrayLike<number>, y: ArrayLike<number>): {
+    intercept: number;
+    slope: number;
+};
+/**
+ * Multiple linear regression using normal equations (adds intercept column internally).
+ * Returns coefficient vector or null if the normal matrix is singular or inputs are empty.
+ * @param X Design matrix (rows = observations, cols = features)
+ * @param y Response vector
+ * @returns Coefficient array [intercept, beta1, beta2, ...] or null
+ */
+export declare function olsMulti(X: number[][], y: number[]): number[] | null;

package/dist/math/minmax.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Rolling minimum over a window. NaN-aware: windows containing only NaNs produce NaN.
+ * @param source Input values
+ * @param period Window length (must be > 0)
+ * @returns Float64Array of rolling minima (NaN for positions before the window fills)
+ */
+export declare function rollmin(source: ArrayLike<number>, period: number): Float64Array;
+/**
+ * Rolling maximum over a window. NaN-aware: windows containing only NaNs produce NaN.
+ * @param source Input values
+ * @param period Window length (must be > 0)
+ * @returns Float64Array of rolling maxima (NaN for positions before the window fills)
+ */
+export declare function rollmax(source: ArrayLike<number>, period: number): Float64Array;
+/**
+ * Compute rolling minima and maxima pairwise over two input series.
+ * Optional callback `cb(minVal, maxVal, i)` is invoked for each computed window.
+ * @param minSource Input for minima
+ * @param maxSource Input for maxima
+ * @param period Window length (must be > 0)
+ * @param cb Optional callback invoked per window
+ * @returns Object with `min` and `max` Float64Array results
+ */
+export declare function rollminmax(minSource: ArrayLike<number>, maxSource: ArrayLike<number>, period: number, cb?: (minVal: number, maxVal: number, i: number) => void): {
+    min: Float64Array;
+    max: Float64Array;
+};
+/**
+ * Minimum of an array, ignoring NaNs. Returns NaN if no valid entries.
+ * @param source Input array
+ * @returns Minimum value or NaN
+ */
+export declare function min(source: ArrayLike<number>): number;
+/**
+ * Maximum of an array, ignoring NaNs. Returns NaN if no valid entries.
+ * @param source Input array
+ * @returns Maximum value or NaN
+ */
+export declare function max(source: ArrayLike<number>): number;
+/**
+ * Index of the first minimum value (ignores NaNs). Returns -1 if none found.
+ * @param source Input array
+ * @returns Index of minimum or -1
+ */
+export declare function argmin(source: ArrayLike<number>): number;
+/**
+ * Index of the first maximum value (ignores NaNs). Returns -1 if none found.
+ * @param source Input array
+ * @returns Index of maximum or -1
+ */
+export declare function argmax(source: ArrayLike<number>): number;
+/**
+ * Cumulative maximum: at each index the maximum over all prior valid elements.
+ * NaNs are preserved in the output at positions where input is NaN.
+ * @param source Input array
+ * @returns Float64Array of cumulative maxima
+ */
+export declare function cummax(source: ArrayLike<number>): Float64Array;
+/**
+ * Cumulative minimum: at each index the minimum over all prior valid elements.
+ * NaNs are preserved in the output at positions where input is NaN.
+ * @param source Input array
+ * @returns Float64Array of cumulative minima
+ */
+export declare function cummin(source: ArrayLike<number>): Float64Array;
+/**
+ * Rolling argmin: returns the index (into `source`) of the minimum value in each window.
+ * Positions before the window fills are NaN.
+ * @param source Input array
+ * @param period Window length
+ * @returns Float64Array of argmin indices (NaN when not available)
+ */
+export declare function rollargmin(source: ArrayLike<number>, period: number): Float64Array;
+/**
+ * Rolling argmax: returns the index (into `source`) of the maximum value in each window.
+ * Positions before the window fills are NaN.
+ * @param source Input array
+ * @param period Window length
+ * @returns Float64Array of argmax indices (NaN when not available)
+ */
+export declare function rollargmax(source: ArrayLike<number>, period: number): Float64Array;

package/dist/math/prod.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Product of array elements, ignoring NaNs. Returns NaN if no valid entries.
+ * @param source Input array
+ * @returns Product of values or NaN
+ */
+export declare function prod(source: ArrayLike<number>): number;
+/**
+ * Cumulative product (NaN-preserving). At each index the product of all prior valid elements.
+ * @param source Input array
+ * @returns Float64Array of cumulative products (NaN where input was NaN)
+ */
+export declare function cumprod(source: ArrayLike<number>): Float64Array;
+/**
+ * Rolling product over a window. NaN-aware: windows with no valid entries produce NaN.
+ * Zeros are handled efficiently by tracking counts.
+ * @param source Input array
+ * @param period Window length (must be > 0)
+ * @returns Float64Array of rolling products (NaN for positions before window fills)
+ */
+export declare function rollprod(source: ArrayLike<number>, period: number): Float64Array;

package/dist/math/random.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Generate `n` uniform random values in [lo, hi).
+ * Uses `Math.random()`; tests should stub `Math.random` for determinism.
+ * @param n Number of samples to generate
+ * @param options Optional `{ lo, hi }` bounds (defaults to 0..1)
+ * @returns Float64Array of length `n`
+ */
+export declare function randuniform(n: number, options?: {
+    lo?: number;
+    hi?: number;
+}): Float64Array;
+/**
+ * Generate `n` standard normal samples using the Box-Muller transform.
+ * Uses `Math.random()`; tests should stub `Math.random` for determinism.
+ * @param n Number of samples to generate
+ * @param options Optional `{ mean, sd }` to shift/scale samples
+ * @returns Float64Array of length `n`
+ */
+export declare function randnormal(n: number, options?: {
+    mean?: number;
+    sd?: number;
+}): Float64Array;

package/dist/math/sum.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Sum of array elements with optional NaN-skipping.
+ * When `skipna` is true (default) NaNs are ignored; returns NaN if no valid samples.
+ * Uses a fast dense path when global optimization allows it.
+ * @param source Input array
+ * @param skipna Whether to ignore NaNs (default: true)
+ * @returns Sum or NaN
+ */
+export declare function sum(source: ArrayLike<number>, skipna?: boolean): number;
+/**
+ * Cumulative sum preserving NaNs: NaN entries do not increase the running sum
+ * but are represented as the running total up to that point.
+ * @param source Input array
+ * @returns Float64Array of cumulative sums
+ */
+export declare function cumsum(source: ArrayLike<number>): Float64Array;
+/**
+ * Rolling sum over a window with optional NaN-skipping.
+ * If `skipna` is true, windows with no valid values produce NaN.
+ * Supports a fast dense path when inputs contain no NaNs.
+ * @param source Input array
+ * @param period Window length (must be > 0)
+ * @param skipna Whether to ignore NaNs (default: true)
+ * @returns Float64Array of rolling sums (NaN for positions before window fills)
+ */
+export declare function rollsum(source: ArrayLike<number>, period: number, skipna?: boolean): Float64Array;

package/dist/stats/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Stats barrel: re-export statistical helpers for convenient imports.
+ */
+import { variance, covar, stdev, rollvar, rollstdev, rollcovar } from './var.js';
+import { zscore, norminmax, corr, rollcorr, winsorize } from './transforms.js';
+import { rollmean, mean, hmean, gmean, mad } from './mean.js';
+import { median, rollmedian, quantile, percentiles, rollquantile } from './quantile.js';
+import { skew, kurtosis, rollskew, rollkurtosis } from './skew.js';
+import { bootstrap, sample, shuffle } from './sampling.js';
+export { mean, hmean, gmean, mad, skew, kurtosis, median, quantile, percentiles, variance as var, covar, stdev, corr, rollcorr, rollmean, rollvar, rollcovar, rollstdev, rollmedian, rollquantile, rollskew, rollkurtosis, zscore, norminmax, winsorize, sample, shuffle, bootstrap };

package/dist/stats/mean.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Compute the (possibly weighted) mean of `source`.
+ * By default NaNs are skipped (`skipna=true`). When `weights` are provided they
+ * must match `source` length and the function computes the weighted mean.
+ * A dense fast-path is used when the global optimization allows it.
+ * @param source Input array
+ * @param options Optional `{ weights?, skipna? }`
+ * @returns Mean value or NaN when undefined
+ */
+export declare function mean(source: ArrayLike<number>, options?: {
+    weights?: ArrayLike<number>;
+    skipna?: boolean;
+}): number;
+/**
+ * Rolling mean (moving average) over a sliding window of length `period`.
+ * When `skipna` is true, NaNs inside windows are ignored; windows with no
+ * valid values produce NaN. A fast dense path is used when no NaNs.
+ * @param source Input array
+ * @param period Window length (>0)
+ * @param skipna Whether to ignore NaNs (default: true)
+ * @returns Float64Array of rolling means
+ */
+export declare function rollmean(source: ArrayLike<number>, period: number, skipna?: boolean): Float64Array;
+/**
+ * Harmonic mean (optionally weighted). Values must be positive; NaNs are
+ * ignored when `skipna` is true. Returns NaN when no valid values.
+ * @param source Input array
+ * @param options Optional `{ weights?, skipna? }`
+ * @returns Harmonic mean or NaN
+ */
+export declare function hmean(source: ArrayLike<number>, options?: {
+    weights?: ArrayLike<number>;
+    skipna?: boolean;
+}): number;
+/**
+ * Geometric mean (optionally weighted). Values must be positive; NaNs are
+ * ignored when `skipna` is true. Returns NaN when no valid values.
+ * @param source Input array
+ * @param options Optional `{ weights?, skipna? }`
+ * @returns Geometric mean or NaN
+ */
+export declare function gmean(source: ArrayLike<number>, options?: {
+    weights?: ArrayLike<number>;
+    skipna?: boolean;
+}): number;
+/**
+ * Mean absolute deviation from the mean. When `skipna` is true NaNs are
+ * ignored. Returns NaN when the input contains no valid values.
+ * @param source Input array
+ * @param options Optional `{ skipna? }`
+ * @returns Mean absolute deviation or NaN
+ */
+export declare function mad(source: ArrayLike<number>, skipna?: boolean): number;

package/dist/stats/quantile.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Median of `source` (ignores NaNs). Implemented via `quantile(source, 0.5)`.
+ * @param source Input array
+ * @returns Median value or NaN
+ */
+export declare function median(source: ArrayLike<number>): number;
+/**
+ * Compute the rolling median over a sliding window.
+ * Ignores NaNs and validates `period`.
+ * Returns a Float64Array with NaN entries for positions before the window fills.
+ * @param source Input array
+ * @param period Window length
+ * @returns Float64Array of rolling medians
+ */
+export declare function rollmedian(source: ArrayLike<number>, period: number): Float64Array;
+/**
+ * Compute the quantile `q` of `source`, ignoring NaNs. Implements a
+ * selection-based algorithm using quickselect for expected linear time.
+ * @param source Input array
+ * @param q Quantile in [0,1]
+ * @returns Quantile value or NaN
+ */
+export declare function quantile(source: ArrayLike<number>, q: number): number;
+/**
+ * Compute multiple percentiles (quantiles) for `source`. When `qs.length`
+ * is small, selection is used for each quantile; otherwise the data are
+ * sorted once for efficiency.
+ * @param source Input array
+ * @param qs Array of quantiles in [0,1]
+ * @returns Array of quantile values
+ */
+export declare function percentiles(source: ArrayLike<number>, qs: number[]): number[];
+/**
+ * Compute the rolling quantile over a sliding window.
+ * Ignores NaNs and validates `period` and `q`.
+ * Returns a Float64Array with NaN entries for positions before the window fills.
+ * @param source Input array
+ * @param period Window length
+ * @param q Quantile in [0,1]
+ * @returns Float64Array of rolling quantiles
+ */
+export declare function rollquantile(source: ArrayLike<number>, period: number, q: number): Float64Array;

package/dist/stats/sampling.d.ts

@@ -0,0 +1,23 @@
+/**
+ * In-place Fisher–Yates shuffle of `arr`.
+ * Uses `Math.random()`; tests should stub `Math.random` for determinism.
+ * @param arr Array to shuffle (mutated)
+ * @returns The shuffled array (same reference)
+ */
+export declare function shuffle<T>(arr: T[]): T[];
+/**
+ * Draw `k` unique samples without replacement from `arr`.
+ * If `k` >= arr.length a shallow copy is returned. Uses `Math.random()`.
+ * @param arr Source array
+ * @param k Number of samples to draw
+ * @returns Array of sampled elements
+ */
+export declare function sample<T>(arr: T[], k: number): T[];
+/**
+ * Draw `k` bootstrap samples (with replacement) from `arr`.
+ * Uses `Math.random()`; tests should stub `Math.random` for determinism.
+ * @param arr Source array
+ * @param k Number of draws
+ * @returns Array of sampled elements (with replacement)
+ */
+export declare function bootstrap<T>(arr: T[], k: number): T[];

package/dist/stats/skew.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Fisher-Pearson sample skewness (ignores NaNs). Returns NaN when insufficient data.
+ * @param source Input array
+ * @returns Skewness or NaN
+ */
+export declare function skew(source: ArrayLike<number>): number;
+/**
+ * Excess kurtosis (kurtosis - 3) for `source` (ignores NaNs). Returns NaN when insufficient data.
+ * @param source Input array
+ * @returns Excess kurtosis or NaN
+ */
+export declare function kurtosis(source: ArrayLike<number>): number;
+/**
+ * Rolling skewness over a sliding window of length `period`.
+ * @param source Input array
+ * @param period Window length
+ * @returns Float64Array of rolling skewness values
+ */
+export declare function rollskew(source: ArrayLike<number>, period: number): Float64Array;
+/**
+ * Rolling excess kurtosis over a sliding window of length `period`.
+ * @param source Input array
+ * @param period Window length
+ * @returns Float64Array of rolling kurtosis values
+ */
+export declare function rollkurtosis(source: ArrayLike<number>, period: number): Float64Array;

package/dist/stats/transforms.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Compute z-scores for `source`: (x - mean) / std (ddof=1). NaNs preserved.
+ * @param source Input array
+ * @param options Optional `{ skipna? }` to ignore NaNs
+ * @returns Float64Array of z-scores
+ */
+export declare function zscore(source: ArrayLike<number>, skipna?: boolean): Float64Array;
+/**
+ * Normalize to [0,1] by min/max scaling. Preserves NaNs when `skipna` is true.
+ * @param source Input array
+ * @param options Optional `{ skipna? }`
+ * @returns Float64Array of normalized values
+ */
+export declare function norminmax(source: ArrayLike<number>, skipna?: boolean): Float64Array;
+/**
+ * Pearson correlation between `x` and `y`. When `skipna` is true only
+ * pairwise-valid entries are used; otherwise a dense fast-path is taken.
+ * @param x First input array
+ * @param y Second input array
+ * @param options Optional `{ skipna? }`
+ * @returns Correlation coefficient or NaN
+ */
+export declare function corr(x: ArrayLike<number>, y: ArrayLike<number>, skipna?: boolean): number;
+/**
+ * Rolling Pearson correlation computed from rolling covariance and stddev.
+ * Supports alignment modes via `options.outLength` ('min' or 'max').
+ * @param x First input array
+ * @param y Second input array
+ * @param period Window length
+ * @param options Optional `{ skipna?, outLength? }`
+ * @returns Float64Array of rolling correlations
+ */
+export declare function rollcorr(x: ArrayLike<number>, y: ArrayLike<number>, period: number, options?: {
+    skipna?: boolean;
+    outLength?: 'min' | 'max';
+}): Float64Array;
+/**
+ * Winsorize values to the given lower and upper quantile bounds.
+ * Preserves NaNs when `skipna` is true.
+ * @param source Input array
+ * @param options Optional `{ lower?, upper?, skipna? }` where bounds are in [0,1]
+ * @returns Float64Array of winsorized values
+ */
+export declare function winsorize(source: ArrayLike<number>, options?: {
+    lower?: number;
+    upper?: number;
+    skipna?: boolean;
+}): Float64Array;

package/dist/stats/var.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Variance: compute a single variance over the whole series, dropping NaNs.
+ * Uses `ddof` (delta degrees of freedom) like NumPy/pandas: denominator = N - ddof.
+ * Default pandas behavior is sample variance (ddof=1), so the default here is ddof=1.
+ */
+export declare function variance(source: ArrayLike<number>, options?: {
+    ddof?: number;
+    skipna?: boolean;
+}): number;
+/**
+ * Standard deviation: compute a single standard deviation over the whole series, dropping NaNs.
+ * Uses `ddof` (delta degrees of freedom) like NumPy/pandas: denominator = N - ddof.
+ * Default pandas behavior is sample standard deviation (ddof=1), so the default here is ddof=1.
+ */
+export declare function stdev(source: ArrayLike<number>, options?: {
+    ddof?: number;
+    skipna?: boolean;
+}): number;
+/**
+ * Pairwise covariance: cov(X,Y) = E[XY] - E[X]E[Y]
+ */
+export declare function covar(x: ArrayLike<number>, y: ArrayLike<number>, options?: {
+    ddof?: number;
+}): number;
+/**
+ * Rolling variance over a sliding window. Accepts `{ skipna?, ddof? }`.
+ * @param source Input array
+ * @param period Window length (>0)
+ * @param options Optional `{ skipna?, ddof? }`
+ * @returns Float64Array of rolling variances
+ */
+export declare function rollvar(source: ArrayLike<number>, period: number, options?: {
+    skipna?: boolean;
+    ddof?: number;
+}): Float64Array;
+export declare function rollcovar(x: ArrayLike<number>, y: ArrayLike<number>, period: number, options?: {
+    ddof?: number;
+}): Float64Array;
+export declare function rollstdev(source: ArrayLike<number>, period: number, options?: {
+    skipna?: boolean;
+    ddof?: number;
+}): Float64Array;

package/dist/ta/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Technical indicators barrel: re-export grouped TA modules for convenient imports.
+ * This file collects moving averages, momentum oscillators, trend and
+ * volatility indicators, as well as utility helpers.
+ */
+export { dema, ema, hma, kama, sma, wma, vwma, trima, t3, tema, rma, } from './moving-averages/index.js';
+export { ao, apo, aroon, change, cmo, kst, macd, mom, ppo, roc, rsi, stoch, stochrsi, ultosc, wpr } from './momentum-oscillators/index.js';
+export type { KstOptions, UltoscOptions } from './momentum-oscillators/index.js';
+export { supertrend, adx, adxr, dx, cci, di, dpo, ichimoku, psar } from './trend/index.js';
+export type { IchimokuOptions } from './trend/index.js';
+export { atr, tr, natr, bb, bbw, donchian, keltner } from './volatility/index.js';
+export { adosc, obv, pnvi, wad, ad, mfi } from './volume-money-flow/index.js';
+export { cross, crossover, crossunder, rising, falling } from './util.js';

package/dist/ta/momentum-oscillators/ao.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Awesome Oscillator (AO): difference between short and long simple moving averages
+ * of the median price ((high + low)/2). Supports NaN-aware and dense fast-paths.
+ * @param high High price series
+ * @param low Low price series
+ * @param shortPeriod Short SMA period (default 5)
+ * @param longPeriod Long SMA period (default 34)
+ * @param skipna When true, ignore NaNs inside windows; false forces dense path
+ * @returns Float64Array AO series (NaN where undefined)
+ */
+export declare function ao(high: ArrayLike<number>, low: ArrayLike<number>, shortPeriod?: number, longPeriod?: number, skipna?: boolean): Float64Array;