@danielsimonjr/mathts-functions 0.32.0 → 0.34.0

package/dist/signal/spectral-peaks.d.ts

@@ -0,0 +1,115 @@
+/** Options for {@link findPeaks}. */
+export interface FindPeaksOptions {
+    /** Minimum peak value to keep. */
+    height?: number;
+    /** Minimum index separation between kept peaks (greedily keeps the taller peak). */
+    distance?: number;
+    /** Minimum topographic prominence to keep (see {@link peakWidths} for the definition). */
+    prominence?: number;
+}
+/**
+ * Find strict local-maxima peak indices in `x` (`x[i-1] < x[i] > x[i+1]`), then
+ * optionally filter by minimum `height`, minimum index `distance` (greedily keeping
+ * the taller peak of any too-close pair), and/or minimum topographic `prominence` —
+ * `scipy.signal.find_peaks`.
+ *
+ * @param x - Input signal
+ * @param opts - `{ height?, distance?, prominence? }`
+ * @returns Ascending indices of the surviving peaks
+ */
+export declare function findPeaks(x: readonly number[], opts?: FindPeaksOptions): number[];
+/**
+ * Width (in samples) of each peak at `relHeight` down from the peak toward its
+ * topographic base (see {@link peakProminence}), with linearly-interpolated crossing
+ * points — `scipy.signal.peak_widths`.
+ *
+ * @param x - Input signal
+ * @param peaks - Peak indices (e.g. from {@link findPeaks})
+ * @param relHeight - Fraction of the prominence to descend (default 0.5, i.e. FWHM-style)
+ * @returns Width per peak, same order as `peaks`
+ */
+export declare function peakWidths(x: readonly number[], peaks: readonly number[], relHeight?: number): number[];
+/** Options shared by {@link csd} and {@link coherence}. */
+export interface CsdOptions {
+    /** Segment length (default `min(256, x.length, y.length)`). */
+    nperseg?: number;
+    /** Samples of overlap between segments (default `floor(nperseg/2)`). */
+    noverlap?: number;
+    /** Window applied to each segment (default `'hann'`) — see {@link windowFunction}. */
+    window?: string;
+    /** Sample rate in Hz, used to scale frequencies and power (default 1). */
+    fs?: number;
+}
+/**
+ * Cross-spectral density of `x` and `y` via Welch's overlapped-segment-averaging
+ * method (segment, window, FFT, average `X·conj(Y)`) — `scipy.signal.csd`.
+ *
+ * @param x - First signal
+ * @param y - Second signal
+ * @param opts - `{ nperseg?, noverlap?, window?, fs? }`
+ * @returns `{ frequencies, power }` — `power` is the magnitude of the averaged
+ *   cross spectrum at each frequency bin
+ */
+export declare function csd(x: readonly number[], y: readonly number[], opts?: CsdOptions): {
+    frequencies: number[];
+    power: number[];
+};
+/**
+ * Magnitude-squared coherence between `x` and `y`: `|Pxy|² / (Pxx·Pyy)`, per Welch
+ * frequency bin — `scipy.signal.coherence`. Values lie in `[0, 1]`.
+ *
+ * @param x - First signal
+ * @param y - Second signal
+ * @param opts - `{ nperseg?, noverlap?, window?, fs? }`
+ * @returns `{ frequencies, coherence }`
+ */
+export declare function coherence(x: readonly number[], y: readonly number[], opts?: CsdOptions): {
+    frequencies: number[];
+    coherence: number[];
+};
+/** Options for {@link stft} / {@link istft} — must match between the two calls. */
+export interface StftOptions {
+    /** Frame length (default 256). */
+    nperseg?: number;
+    /** Samples of overlap between frames (default `floor(nperseg/2)`). */
+    noverlap?: number;
+    /** Window applied to each frame (default `'hann'`) — see {@link windowFunction}. */
+    window?: string;
+}
+/** `stft`'s output: one row per frame, one column per (non-redundant-truncated) frequency bin. */
+export interface StftResult {
+    re: number[][];
+    im: number[][];
+}
+/**
+ * Short-time Fourier transform: windowed, overlapping frames, each FFT'd independently
+ * — `scipy.signal.stft` (magnitude/phase convention; frames are not scaled).
+ *
+ * @param x - Input signal
+ * @param opts - `{ nperseg?, noverlap?, window? }`
+ * @returns `{ re, im }`, each `number[frame][bin]`
+ */
+export declare function stft(x: readonly number[], opts?: StftOptions): StftResult;
+/**
+ * Inverse short-time Fourier transform via overlap-add: each frame is inverse-FFT'd
+ * back to `nperseg` samples, re-windowed, and accumulated; the accumulation is
+ * normalized by the running sum of squared window values (the standard
+ * constant-overlap-add / COLA normalization), so reconstruction is exact in the
+ * interior wherever the window's overlap sum is nonzero — `scipy.signal.istft`.
+ *
+ * @param S - `{ re, im }` as returned by {@link stft}
+ * @param opts - `{ nperseg?, noverlap?, window? }` — must match the `stft` call
+ * @returns Reconstructed signal
+ */
+export declare function istft(S: StftResult, opts?: StftOptions): number[];
+/**
+ * Downsample `x` by an integer factor `q`: apply a Butterworth anti-alias lowpass
+ * (order 4, cutoff `min(0.8/q, 0.99)` of Nyquist) with zero-phase `filtfilt`, then
+ * take every `q`-th sample — `scipy.signal.decimate` (IIR mode).
+ *
+ * @param x - Input signal
+ * @param q - Downsampling factor (positive integer)
+ * @returns Downsampled signal, length `ceil(x.length / q)`
+ */
+export declare function decimate(x: readonly number[], q: number): number[];
+//# sourceMappingURL=spectral-peaks.d.ts.map

package/dist/signal/spectral-peaks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spectral-peaks.d.ts","sourceRoot":"","sources":["../../src/signal/spectral-peaks.ts"],"names":[],"mappings":"AAoBA,qCAAqC;AACrC,MAAM,WAAW,gBAAgB;IAC/B,kCAAkC;IAClC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,oFAAoF;IACpF,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,0FAA0F;IAC1F,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AA2DD;;;;;;;;;GASG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,SAAS,MAAM,EAAE,EAAE,IAAI,CAAC,EAAE,gBAAgB,GAAG,MAAM,EAAE,CAmBjF;AAyBD;;;;;;;;;GASG;AACH,wBAAgB,UAAU,CACxB,CAAC,EAAE,SAAS,MAAM,EAAE,EACpB,KAAK,EAAE,SAAS,MAAM,EAAE,EACxB,SAAS,SAAM,GACd,MAAM,EAAE,CAQV;AAMD,2DAA2D;AAC3D,MAAM,WAAW,UAAU;IACzB,+DAA+D;IAC/D,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,wEAAwE;IACxE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,sFAAsF;IACtF,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,0EAA0E;IAC1E,EAAE,CAAC,EAAE,MAAM,CAAC;CACb;AAgED;;;;;;;;;GASG;AACH,wBAAgB,GAAG,CACjB,CAAC,EAAE,SAAS,MAAM,EAAE,EACpB,CAAC,EAAE,SAAS,MAAM,EAAE,EACpB,IAAI,CAAC,EAAE,UAAU,GAChB;IAAE,WAAW,EAAE,MAAM,EAAE,CAAC;IAAC,KAAK,EAAE,MAAM,EAAE,CAAA;CAAE,CAI5C;AAED;;;;;;;;GAQG;AACH,wBAAgB,SAAS,CACvB,CAAC,EAAE,SAAS,MAAM,EAAE,EACpB,CAAC,EAAE,SAAS,MAAM,EAAE,EACpB,IAAI,CAAC,EAAE,UAAU,GAChB;IAAE,WAAW,EAAE,MAAM,EAAE,CAAC;IAAC,SAAS,EAAE,MAAM,EAAE,CAAA;CAAE,CAahD;AAMD,mFAAmF;AACnF,MAAM,WAAW,WAAW;IAC1B,kCAAkC;IAClC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,sEAAsE;IACtE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,oFAAoF;IACpF,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,kGAAkG;AAClG,MAAM,WAAW,UAAU;IACzB,EAAE,EAAE,MAAM,EAAE,EAAE,CAAC;IACf,EAAE,EAAE,MAAM,EAAE,EAAE,CAAC;CAChB;AAED;;;;;;;GAOG;AACH,wBAAgB,IAAI,CAAC,CAAC,EAAE,SAAS,MAAM,EAAE,EAAE,IAAI,CAAC,EAAE,WAAW,GAAG,UAAU,CAoBzE;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,UAAU,EAAE,IAAI,CAAC,EAAE,WAAW,GAAG,MAAM,EAAE,CA6BjE;AAMD;;;;;;;;GAQG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,SAAS,MAAM,EAAE,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAclE"}

package/dist/signal/wavelets.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Phase 6 Task 4 — inverse DWT, multilevel wavedec/waverec (perfect
+ * reconstruction), and the continuous wavelet transform (CWT).
+ *
+ * `idwt`/`wavedec`/`waverec` must invert the existing `dwt` (`../typed/signal.ts`)
+ * exactly, so they match its Haar convention bit-for-bit: analysis filters
+ * scaled by `s = 1/sqrt(2)`, `approx[i] = s*(x[2i]+x[2i+1])`,
+ * `detail[i] = s*(x[2i]-x[2i+1])`. Haar's synthesis (reconstruction) filters
+ * are the time-reverse of its analysis filters — for a symmetric 2-tap filter
+ * that reversal is a no-op, so the closed-form inverse below is exact:
+ * `x[2i] = s*(approx[i]+detail[i])`, `x[2i+1] = s*(approx[i]-detail[i])`.
+ *
+ * @packageDocumentation
+ */
+/**
+ * Inverse single-level discrete wavelet transform. Upsamples `approx`/`detail`
+ * and combines them with the Haar synthesis filters, exactly inverting `dwt`.
+ *
+ * @param approx - Approximation (low-pass) coefficients
+ * @param detail - Detail (high-pass) coefficients, same length as `approx`
+ * @param wavelet - Wavelet name (currently only 'haar'/'db1', matching `dwt`)
+ * @returns Reconstructed signal, length `2 * approx.length`
+ */
+export declare function idwt(approx: number[], detail: number[], wavelet?: string): number[];
+/**
+ * Multilevel discrete wavelet decomposition: repeatedly applies `dwt` to the
+ * approximation coefficients.
+ *
+ * @param x - Input signal
+ * @param wavelet - Wavelet name (passed through to `dwt`)
+ * @param level - Number of decomposition levels (>= 1)
+ * @returns `[cA_level, cD_level, cD_{level-1}, ..., cD_1]` (pywt order)
+ */
+export declare function wavedec(x: number[], wavelet?: string, level?: number): number[][];
+/**
+ * Inverse of `wavedec`: repeatedly applies `idwt` from the coarsest level
+ * (`coeffs[0]` = cA_level) up to the finest detail (`coeffs[coeffs.length-1]`
+ * = cD_1), reconstructing the original signal.
+ *
+ * @param coeffs - Coefficient arrays as returned by `wavedec`
+ * @param wavelet - Wavelet name (passed through to `idwt`)
+ * @returns Reconstructed signal
+ */
+export declare function waverec(coeffs: number[][], wavelet?: string): number[];
+/**
+ * Continuous wavelet transform: convolves `x` with a discretized, normalized
+ * wavelet at each requested scale.
+ *
+ * @param x - Input signal
+ * @param scales - Wavelet scales to evaluate (each > 0)
+ * @param wavelet - 'ricker' (Mexican-hat, default) or 'morlet'
+ * @returns `scales.length` x `x.length` matrix, row `i` = CWT at `scales[i]`
+ */
+export declare function cwt(x: number[], scales: number[], wavelet?: string): number[][];
+//# sourceMappingURL=wavelets.d.ts.map

package/dist/signal/wavelets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wavelets.d.ts","sourceRoot":"","sources":["../../src/signal/wavelets.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAKH;;;;;;;;GAQG;AACH,wBAAgB,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,EAAE,OAAO,GAAE,MAAe,GAAG,MAAM,EAAE,CAgB3F;AAED;;;;;;;;GAQG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,OAAO,GAAE,MAAe,EAAE,KAAK,GAAE,MAAU,GAAG,MAAM,EAAE,EAAE,CAc5F;AAED;;;;;;;;GAQG;AACH,wBAAgB,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,EAAE,OAAO,GAAE,MAAe,GAAG,MAAM,EAAE,CAU9E;AA2BD;;;;;;;;GAQG;AACH,wBAAgB,GAAG,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,EAAE,OAAO,GAAE,MAAiB,GAAG,MAAM,EAAE,EAAE,CAYzF"}

package/dist/signal-filter-extra.d.ts

@@ -1,4 +1,12 @@
+/**
+ * Digital filter design + application (Wave D / remaining). FIR window design
+ * (`firwin`), IIR Butterworth design (`butter`), the direct-form filter (`lfilter`),
+ * and zero-phase filtering (`filtfilt`). Matches `scipy.signal`. `butter` reuses the
+ * core `Complex` type for the analog-pole bilinear-transform pipeline.
+ */
+import { Complex } from '@danielsimonjr/mathts-core';
 type Vec = readonly number[] | Float64Array;
+export declare const sinc: (x: number) => number;
 /**
  * FIR lowpass filter coefficients by the windowed-sinc method (Hamming window,
  * normalized to unit DC gain) — `scipy.signal.firwin(numtaps, cutoff)` with the
@@ -22,12 +30,43 @@ export declare function lfilterZi(b: Vec, a: Vec): number[];
  * magnitude response is applied with no phase distortion.
  */
 export declare function filtfilt(b: Vec, a: Vec, x: Vec): number[];
+export declare const cAdd: (p: Complex, q: Complex) => Complex;
+export declare const cSub: (p: Complex, q: Complex) => Complex;
+export declare const cMul: (p: Complex, q: Complex) => Complex;
+export declare const cDiv: (p: Complex, q: Complex) => Complex;
+/** Scale a Complex by a real number (`Complex.mul` only accepts `Scalar`, not `number`). */
+export declare const cScale: (p: Complex, s: number) => Complex;
+/** Real polynomial coefficients (highest degree first) of ∏(x − rₖ). */
+export declare function polyFromRoots(roots: Complex[]): number[];
+/** Analog lowpass prototype: zeros, poles, gain (cutoff normalized to 1 rad/s). */
+export interface AnalogProto {
+    z: Complex[];
+    p: Complex[];
+    k: number;
+}
+export type FilterBtype = 'low' | 'high' | 'bandpass' | 'bandstop';
+/** zpk → transfer-function coefficients (scipy `zpk2tf`). */
+export declare function zpkToTf(z: Complex[], p: Complex[], k: number): {
+    b: number[];
+    a: number[];
+};
+/**
+ * Digital IIR filter design pipeline shared by butter/cheby1/cheby2/ellip:
+ * pre-warp `Wn` → frequency-transform the analog lowpass prototype (`proto`,
+ * cutoff normalized to 1 rad/s) to the requested `btype` → bilinear transform →
+ * zpk2tf. Matches `scipy.signal.iirfilter`'s internal pipeline (fs = 2 convention).
+ */
+export declare function analogToDigital(proto: AnalogProto, Wn: number | readonly number[], btype: FilterBtype): {
+    b: number[];
+    a: number[];
+};
 /**
  * Butterworth IIR filter design — returns `{ b, a }` transfer-function coefficients.
- * `N` is the order, `Wn` the cutoff normalized to Nyquist (0..1). Lowpass only
- * (`btype='low'`, the common case). Matches `scipy.signal.butter(N, Wn)`.
+ * `N` is the order, `Wn` the cutoff (scalar) or `[low, high]` band edges, normalized
+ * to Nyquist (0..1). `btype` defaults to `'low'` (matches the original 2-arg call
+ * unchanged). Matches `scipy.signal.butter(N, Wn, btype)`.
  */
-export declare function butter(N: number, Wn: number): {
+export declare function butter(N: number, Wn: number | readonly number[], btype?: FilterBtype): {
     b: number[];
     a: number[];
 };

package/dist/signal-filter-extra.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"signal-filter-extra.d.ts","sourceRoot":"","sources":["../src/signal-filter-extra.ts"],"names":[],"mappings":"AAYA,KAAK,GAAG,GAAG,SAAS,MAAM,EAAE,GAAG,YAAY,CAAC;AAK5C;;;;GAIG;AACH,wBAAgB,MAAM,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAahE;AAkCD;;;GAGG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,GAAG,MAAM,EAAE,CAExD;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,GAAG,MAAM,EAAE,CAqBlD;AAED;;;;GAIG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,GAAG,MAAM,EAAE,CAqBzD;AAuBD;;;;GAIG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG;IAAE,CAAC,EAAE,MAAM,EAAE,CAAC;IAAC,CAAC,EAAE,MAAM,EAAE,CAAA;CAAE,CA4B1E"}
+{"version":3,"file":"signal-filter-extra.d.ts","sourceRoot":"","sources":["../src/signal-filter-extra.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,EAAE,OAAO,EAAE,MAAM,4BAA4B,CAAC;AAMrD,KAAK,GAAG,GAAG,SAAS,MAAM,EAAE,GAAG,YAAY,CAAC;AAG5C,eAAO,MAAM,IAAI,GAAI,GAAG,MAAM,KAAG,MAA+D,CAAC;AAEjG;;;;GAIG;AACH,wBAAgB,MAAM,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAahE;AAkCD;;;GAGG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,GAAG,MAAM,EAAE,CAExD;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,GAAG,MAAM,EAAE,CAuBlD;AAED;;;;GAIG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,GAAG,MAAM,EAAE,CA+BzD;AAMD,eAAO,MAAM,IAAI,GAAI,GAAG,OAAO,EAAE,GAAG,OAAO,KAAG,OAAmB,CAAC;AAClE,eAAO,MAAM,IAAI,GAAI,GAAG,OAAO,EAAE,GAAG,OAAO,KAAG,OAAmB,CAAC;AAClE,eAAO,MAAM,IAAI,GAAI,GAAG,OAAO,EAAE,GAAG,OAAO,KAAG,OAAwB,CAAC;AACvE,eAAO,MAAM,IAAI,GAAI,GAAG,OAAO,EAAE,GAAG,OAAO,KAAG,OAAsB,CAAC;AACrE,4FAA4F;AAC5F,eAAO,MAAM,MAAM,GAAI,GAAG,OAAO,EAAE,GAAG,MAAM,KAAG,OAAqC,CAAC;AAErF,wEAAwE;AACxE,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,MAAM,EAAE,CAWxD;AAED,mFAAmF;AACnF,MAAM,WAAW,WAAW;IAC1B,CAAC,EAAE,OAAO,EAAE,CAAC;IACb,CAAC,EAAE,OAAO,EAAE,CAAC;IACb,CAAC,EAAE,MAAM,CAAC;CACX;AAED,MAAM,MAAM,WAAW,GAAG,KAAK,GAAG,MAAM,GAAG,UAAU,GAAG,UAAU,CAAC;AAoFnE,6DAA6D;AAC7D,wBAAgB,OAAO,CAAC,CAAC,EAAE,OAAO,EAAE,EAAE,CAAC,EAAE,OAAO,EAAE,EAAE,CAAC,EAAE,MAAM,GAAG;IAAE,CAAC,EAAE,MAAM,EAAE,CAAC;IAAC,CAAC,EAAE,MAAM,EAAE,CAAA;CAAE,CAE3F;AAgBD;;;;;GAKG;AACH,wBAAgB,eAAe,CAC7B,KAAK,EAAE,WAAW,EAClB,EAAE,EAAE,MAAM,GAAG,SAAS,MAAM,EAAE,EAC9B,KAAK,EAAE,WAAW,GACjB;IAAE,CAAC,EAAE,MAAM,EAAE,CAAC;IAAC,CAAC,EAAE,MAAM,EAAE,CAAA;CAAE,CAgB9B;AAaD;;;;;GAKG;AACH,wBAAgB,MAAM,CACpB,CAAC,EAAE,MAAM,EACT,EAAE,EAAE,MAAM,GAAG,SAAS,MAAM,EAAE,EAC9B,KAAK,GAAE,WAAmB,GACzB;IAAE,CAAC,EAAE,MAAM,EAAE,CAAC;IAAC,CAAC,EAAE,MAAM,EAAE,CAAA;CAAE,CAG9B"}

package/dist/special/hypergeometric.d.ts

@@ -0,0 +1,91 @@
+/**
+ * Hypergeometric functions.
+ *
+ * Implements the generalized hypergeometric series pFq via the ascending
+ * Pochhammer-ratio method: each term is generated from the previous one by
+ * multiplying by the ratio of rising factorials,
+ *
+ *   term_{n+1} / term_n = ( prod_i (a_i + n) / prod_j (b_j + n) ) * z / (n + 1)
+ *
+ * accumulating until the term becomes negligible relative to the running sum
+ * (|term| < 1e-16 * |sum|) or a hard iteration cap is hit. This incremental
+ * form avoids recomputing factorials/Pochhammer symbols from scratch at each
+ * order and is numerically well-behaved for the convergent regimes documented
+ * per function below.
+ *
+ * @packageDocumentation
+ */
+/**
+ * Generalized hypergeometric function pFq(a; b; z), computed via the
+ * ascending Pochhammer-ratio series:
+ *
+ *   pFq(a_1..a_p; b_1..b_q; z) = sum_{n=0}^inf
+ *     ( prod_i (a_i)_n / prod_j (b_j)_n ) * z^n / n!
+ *
+ * This is the generic engine that hyp0f1/hyp1f1/hyp2f1 delegate to. No
+ * convergence-region check is performed here (that is the caller's
+ * responsibility, see hyp2f1's |z| < 1 guard) — the series is simply summed
+ * until it converges to machine precision or MAX_TERMS is reached.
+ *
+ * @param a - Upper (numerator) parameters
+ * @param b - Lower (denominator) parameters
+ * @param z - Argument
+ * @returns pFq(a; b; z)
+ */
+export declare function pFq(a: number[], b: number[], z: number): number;
+/**
+ * Confluent hypergeometric limit function 0F1(; b; z):
+ *
+ *   hyp0f1(b, z) = sum_{n=0}^inf z^n / ((b)_n n!)
+ *
+ * Entire in z (converges for all finite z, real or otherwise real-valued
+ * here); related to the Bessel functions.
+ *
+ * @param b - Parameter
+ * @param z - Argument
+ * @returns 0F1(; b; z)
+ *
+ * @example
+ * hyp0f1(2, 0.5) // ~1.2717234563
+ */
+export declare function hyp0f1(b: number, z: number): number;
+/**
+ * Kummer's confluent hypergeometric function 1F1(a; b; z) (Kummer's M):
+ *
+ *   hyp1f1(a, b, z) = sum_{n=0}^inf ( (a)_n / (b)_n ) * z^n / n!
+ *
+ * Entire in z. The direct ascending series targets moderate |z| — for large
+ * |z| the series requires many terms and loses accuracy to cancellation
+ * (particularly when a and b have opposite signs); an asymptotic expansion
+ * would be needed for large |z| but is not implemented here.
+ *
+ * @param a - Numerator parameter
+ * @param b - Denominator parameter
+ * @param z - Argument
+ * @returns 1F1(a; b; z)
+ *
+ * @example
+ * hyp1f1(1, 2, 0.5) // ~1.2974425414
+ */
+export declare function hyp1f1(a: number, b: number, z: number): number;
+/**
+ * Gauss's hypergeometric function 2F1(a, b; c; z):
+ *
+ *   hyp2f1(a, b, c, z) = sum_{n=0}^inf ( (a)_n (b)_n / (c)_n ) * z^n / n!
+ *
+ * The ascending series converges only for |z| < 1. Analytic continuation
+ * beyond the unit disk (e.g. via connection formulas or a transformation to
+ * 1-z) is not yet implemented.
+ *
+ * @param a - First numerator parameter
+ * @param b - Second numerator parameter
+ * @param c - Denominator parameter
+ * @param z - Argument, must satisfy |z| < 1
+ * @returns 2F1(a, b; c; z)
+ * @throws {Error} If |z| >= 1
+ *
+ * @example
+ * hyp2f1(1, 2, 3, 0.5) // ~1.5451774445
+ */
+export declare function hyp2f1(a: number, b: number, c: number, z: number): number;
+//# sourceMappingURL=hypergeometric.d.ts.map

package/dist/special/hypergeometric.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hypergeometric.d.ts","sourceRoot":"","sources":["../../src/special/hypergeometric.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAQH;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,GAAG,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAgB/D;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAEnD;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAE9D;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAKzE"}

package/dist/special/jacobi-elliptic.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Jacobi elliptic functions sn, cn, dn.
+ *
+ * Uses the parameter convention `m = k^2` (matching scipy's
+ * `scipy.special.ellipj(u, m)` and mpmath's `ellipfun(..., u, m)`), not the
+ * modulus-angle convention some texts use.
+ *
+ * Computed via the descending Landen transformation / arithmetic-geometric
+ * mean (AGM) method (Abramowitz & Stegun 16.4, the Bulirsch algorithm):
+ * build the AGM sequences
+ *
+ *   a_0 = 1, b_0 = sqrt(1 - m), c_0 = sqrt(m)
+ *   a_{i+1} = (a_i + b_i) / 2
+ *   b_{i+1} = sqrt(a_i * b_i)
+ *   c_{i+1} = (a_i - b_i) / 2
+ *
+ * until c_N is negligible, then descend the amplitude
+ *
+ *   phi_N = 2^N * a_N * u
+ *   phi_{i-1} = (phi_i + asin((c_i / a_i) * sin(phi_i))) / 2   for i = N..1
+ *
+ * so that sn(u,m) = sin(phi_0), cn(u,m) = cos(phi_0),
+ * dn(u,m) = sqrt(1 - m * sn^2(u,m)).
+ *
+ * @packageDocumentation
+ */
+/**
+ * Jacobi elliptic function sn(u, m), parameter convention m = k^2.
+ *
+ * @param u - Argument
+ * @param m - Parameter m = k^2, must be in [0, 1]
+ * @returns sn(u, m)
+ *
+ * @example
+ * jacobiSN(0.5, 0.3) // ~0.4742156227
+ */
+export declare function jacobiSN(u: number, m: number): number;
+/**
+ * Jacobi elliptic function cn(u, m), parameter convention m = k^2.
+ *
+ * @param u - Argument
+ * @param m - Parameter m = k^2, must be in [0, 1]
+ * @returns cn(u, m)
+ *
+ * @example
+ * jacobiCN(0.5, 0.3) // ~0.8804087364
+ */
+export declare function jacobiCN(u: number, m: number): number;
+/**
+ * Jacobi elliptic function dn(u, m), parameter convention m = k^2.
+ *
+ * @param u - Argument
+ * @param m - Parameter m = k^2, must be in [0, 1]
+ * @returns dn(u, m)
+ *
+ * @example
+ * jacobiDN(0.5, 0.3) // ~0.9656789647
+ */
+export declare function jacobiDN(u: number, m: number): number;
+//# sourceMappingURL=jacobi-elliptic.d.ts.map

package/dist/special/jacobi-elliptic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jacobi-elliptic.d.ts","sourceRoot":"","sources":["../../src/special/jacobi-elliptic.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAwDH;;;;;;;;;GASG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAErD;AAED;;;;;;;;;GASG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAErD;AAED;;;;;;;;;GASG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAErD"}

package/dist/special/polygamma-orthopoly.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Polygamma functions and classical orthogonal polynomials.
+ *
+ * `polygamma(n, x)` is the n-th derivative of the digamma function,
+ * ψ^(n)(x) = d^n/dx^n ψ(x). It is computed by shifting the argument up via
+ * the standard recurrence
+ *
+ *   ψ^(n)(x) = ψ^(n)(x + m) + (-1)^(n+1) n! * sum_{k=0}^{m-1} 1/(x+k)^(n+1)
+ *
+ * until x + m is large enough (>= SHIFT_THRESHOLD) for the asymptotic
+ * (Bernoulli) expansion (DLMF 5.15.8) to converge to machine precision:
+ *
+ *   psi^(n)(X) ~ (-1)^(n-1) * [ (n-1)!/X^n + n!/(2 X^(n+1))
+ *                 + sum_j B_{2j} * (2j+n-1)! / ((2j)! * X^(2j+n)) ]
+ *
+ * Since (-1)^(n+1) = (-1)^(n-1), both pieces share the same overall sign.
+ *
+ * `jacobiP` and `gegenbauerC` are evaluated with their standard stable
+ * three-term recurrences (DLMF 18.9.2 and 18.9.1 respectively), matching the
+ * pattern already used for `chebyshevT` / `hermiteH` / `laguerreL` /
+ * `legendreP`.
+ *
+ * @packageDocumentation
+ */
+/**
+ * Polygamma function ψ^(n)(x): the n-th derivative of the digamma function.
+ *
+ * `polygamma(0, x)` delegates to `digamma(x)`. For `n >= 1`, x is shifted up
+ * via the standard recurrence until it is large enough for the Bernoulli
+ * asymptotic expansion to converge.
+ *
+ * @param n - Derivative order (nonnegative integer)
+ * @param x - Argument (must not be a nonpositive integer, where ψ^(n) has poles)
+ * @returns ψ^(n)(x)
+ *
+ * @example
+ * polygamma(1, 2) // ~0.6449340668 (trigamma(2))
+ * polygamma(2, 1) // ~-2.4041138063
+ */
+export declare function polygamma(n: number, x: number): number;
+/**
+ * Trigamma function ψ'(x) = ψ^(1)(x): the first derivative of the digamma
+ * function. Equivalent to `polygamma(1, x)`.
+ *
+ * @param x - Argument
+ * @returns ψ'(x)
+ *
+ * @example
+ * trigamma(2) // ~0.6449340668 (= zeta(2) - 1 = pi^2/6 - 1)
+ */
+export declare function trigamma(x: number): number;
+/**
+ * Jacobi polynomial P_n^(alpha,beta)(x), evaluated via the standard
+ * three-term recurrence (DLMF 18.9.2).
+ *
+ * @param n - Degree (nonnegative integer)
+ * @param alpha - Parameter alpha (> -1)
+ * @param beta - Parameter beta (> -1)
+ * @param x - Evaluation point
+ * @returns P_n^(alpha,beta)(x)
+ *
+ * @example
+ * jacobiP(2, 1, 1, 0.5) // 0.1875
+ */
+export declare function jacobiP(n: number, alpha: number, beta: number, x: number): number;
+/**
+ * Gegenbauer (ultraspherical) polynomial C_n^(alpha)(x), evaluated via the
+ * standard three-term recurrence (DLMF 18.9.1).
+ *
+ * @param n - Degree (nonnegative integer)
+ * @param alpha - Parameter alpha (> -1/2, alpha != 0)
+ * @param x - Evaluation point
+ * @returns C_n^(alpha)(x)
+ *
+ * @example
+ * gegenbauerC(2, 1, 1) // 3 (C_2^(1)(x) = 4x^2 - 1)
+ */
+export declare function gegenbauerC(n: number, alpha: number, x: number): number;
+//# sourceMappingURL=polygamma-orthopoly.d.ts.map

package/dist/special/polygamma-orthopoly.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"polygamma-orthopoly.d.ts","sourceRoot":"","sources":["../../src/special/polygamma-orthopoly.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAiBH;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAkCtD;AAED;;;;;;;;;GASG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAE1C;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAqBjF;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAgBvE"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danielsimonjr/mathts-functions",
-  "version": "0.32.0",
+  "version": "0.34.0",
   "description": "Mathematical functions for MathTS - arithmetic, algebra, trigonometry, statistics, and more",
   "author": "Daniel Simon Jr.",
   "license": "MIT",