@danielsimonjr/mathts-functions 0.2.2 → 0.2.4

package/dist/typed/signal.d.ts

@@ -0,0 +1,427 @@
+/**
+ * Typed Signal Processing Functions (Parallel-First)
+ *
+ * AssemblyScript-friendly TypeScript implementations with typed-function
+ * integration and workerpool parallel execution.
+ *
+ * Includes FFT, IFFT, convolution, and correlation functions optimized
+ * for Float64Array.
+ *
+ * Parallelism note: the element-wise spectrum operations (magnitude, power)
+ * offload large Float64Array inputs to the worker pool. The radix-2 FFT
+ * butterfly itself runs on the calling thread — its stages have tight
+ * data dependencies that a chunked worker dispatch cannot exploit.
+ *
+ * @packageDocumentation
+ */
+import { applyWindowDispatch } from '../wasm/signal/wasm-bridge.js';
+/** 64-bit float (default for decimals) */
+type f64 = number;
+/** 32-bit signed integer */
+type i32 = number;
+/**
+ * Parallel FFT with typed-function dispatch
+ *
+ * Supports: number[], Float64Array, Complex[]
+ */
+export declare const parallelFFT: import("typed-function").TypedFunction;
+/**
+ * Parallel IFFT with typed-function dispatch.
+ *
+ * Async: large inverse transforms are parallelized across worker threads via
+ * the four-step (transpose) decomposition; small ones run on this thread.
+ */
+export declare const parallelIFFT: import("typed-function").TypedFunction;
+/**
+ * FFT magnitude spectrum
+ */
+export declare const parallelFFTMagnitude: import("typed-function").TypedFunction;
+/**
+ * FFT power spectrum (|X|^2)
+ */
+export declare const parallelFFTPower: import("typed-function").TypedFunction;
+/**
+ * Parallel 1D convolution using FFT method
+ *
+ * Uses convolution theorem: conv(x,h) = IFFT(FFT(x) * FFT(h))
+ */
+export declare const parallelConv: import("typed-function").TypedFunction;
+/**
+ * Parallel cross-correlation
+ */
+export declare const parallelXCorr: import("typed-function").TypedFunction;
+/**
+ * Parallel auto-correlation
+ */
+export declare const parallelAutoCorr: import("typed-function").TypedFunction;
+/**
+ * Cross-correlation of two real signals via sliding dot product.
+ * Returns array of length (a.length + b.length - 1).
+ *
+ * @param a - First signal
+ * @param b - Second signal
+ * @returns Cross-correlation array
+ */
+export declare function crossCorrelation(a: number[], b: number[]): number[];
+/**
+ * Auto-correlation of a signal (cross-correlation with itself).
+ *
+ * @param a - Input signal
+ * @returns Auto-correlation array
+ */
+export declare function autoCorrelation(a: number[]): number[];
+/**
+ * Compute the group delay of a digital filter defined by numerator and
+ * denominator polynomial coefficients.
+ *
+ * Group delay is the negative derivative of the phase response with
+ * respect to angular frequency.
+ *
+ * @param b - Numerator coefficients (FIR for IIR: b/a)
+ * @param a - Denominator coefficients (use [1] for FIR)
+ * @param w - Optional array of angular frequencies; defaults to 512 points in [0, pi]
+ * @returns Object with { w: number[], delay: number[] }
+ */
+export declare function groupDelay(b: number[], a: number[], w?: number[]): {
+    w: number[];
+    delay: number[];
+};
+/**
+ * Unwrap phase angles by adding +/-2*pi to remove discontinuities.
+ *
+ * @param phase - Array of phase values in radians
+ * @returns Unwrapped phase array
+ */
+export declare function unwrapPhase(phase: number[]): number[];
+/**
+ * Discrete Cosine Transform (Type II).
+ *
+ * @param x - Input signal
+ * @returns DCT coefficients
+ *
+ * @example
+ * dct([1, 2, 3, 4]) // DCT-II coefficients
+ */
+export declare function dct(x: number[]): number[];
+/**
+ * Inverse Discrete Cosine Transform (Type III).
+ *
+ * @param X - DCT coefficients
+ * @returns Reconstructed signal
+ */
+export declare function idct(X: number[]): number[];
+/**
+ * Discrete Sine Transform (Type II).
+ *
+ * @param x - Input signal
+ * @returns DST coefficients
+ */
+export declare function dst(x: number[]): number[];
+/**
+ * Inverse Discrete Sine Transform (Type III).
+ *
+ * @param X - DST coefficients
+ * @returns Reconstructed signal
+ */
+export declare function idst(X: number[]): number[];
+/**
+ * Discrete wavelet transform using Haar wavelet.
+ *
+ * @param x - Input signal (length must be power of 2)
+ * @param wavelet - Wavelet name (currently only 'haar')
+ * @returns { approx: number[], detail: number[] }
+ */
+export declare function dwt(x: number[], wavelet?: string): {
+    approx: number[];
+    detail: number[];
+};
+/**
+ * 2D FFT of a matrix (array of arrays).
+ *
+ * The transform is two batches of independent 1D FFTs — every row, then every
+ * column — so for large inputs each batch is dispatched to the worker pool via
+ * `computePool.fftBatch`. Below the parallel threshold (or when the pool is
+ * uninitialized) it falls back to the sequential per-row/per-column loop.
+ *
+ * @param x - 2D input (rows x cols), each value is real
+ * @returns { real: number[][], imag: number[][] }
+ */
+export declare function fft2d(x: number[][]): Promise<{
+    real: number[][];
+    imag: number[][];
+}>;
+/**
+ * Numerical continuous Fourier transform.
+ * F(omega) = integral f(t) * exp(-j*omega*t) dt
+ *
+ * @param f - Time-domain function
+ * @param t - Time sample points
+ * @param omega - Frequency to evaluate at
+ * @returns { re: number, im: number }
+ */
+export declare function fourier(f: (t: f64) => f64, t: number[], omega: f64): {
+    re: f64;
+    im: f64;
+};
+/**
+ * Numerical inverse Fourier transform.
+ * f(t) = (1/2pi) integral F(omega) * exp(j*omega*t) domega
+ *
+ * @param F - Frequency-domain function returning {re, im}
+ * @param omega - Frequency sample points
+ * @param t - Time point to evaluate at
+ * @returns Reconstructed value at t
+ */
+export declare function invFourier(F: (omega: f64) => {
+    re: f64;
+    im: f64;
+}, omega: number[], t: f64): f64;
+/**
+ * Hilbert transform of a real signal via FFT.
+ *
+ * @param x - Real input signal
+ * @returns Imaginary part of the analytic signal
+ */
+export declare function hilbertTransform(x: number[]): number[];
+/**
+ * Compute spectrogram using Short-Time Fourier Transform.
+ *
+ * Each windowed frame is FFT'd independently, so for large inputs the frames
+ * are dispatched as a batch to the worker pool via `computePool.fftBatch`.
+ * Below the parallel threshold (or when the pool is uninitialized) it falls
+ * back to the sequential per-frame loop.
+ *
+ * @param x - Input signal
+ * @param opts - { windowSize, hopSize, window }
+ * @returns { magnitude: number[][], frequencies: number[], times: number[] }
+ */
+export declare function spectrogram(x: number[], opts?: {
+    windowSize?: i32;
+    hopSize?: i32;
+    window?: string;
+}): Promise<{
+    magnitude: number[][];
+    frequencies: number[];
+    times: number[];
+}>;
+/**
+ * Estimate power spectral density using periodogram method.
+ *
+ * @param x - Input signal
+ * @param opts - { nfft, window }
+ * @returns { psd: number[], frequencies: number[] }
+ */
+export declare function periodogram(x: number[], opts?: {
+    nfft?: i32;
+    window?: string;
+}): {
+    psd: number[];
+    frequencies: number[];
+};
+/**
+ * Apply a lowpass FIR filter using windowed sinc.
+ *
+ * @param x - Input signal
+ * @param cutoff - Normalized cutoff frequency (0 to 0.5)
+ * @param order - Filter order (default 31)
+ * @returns Filtered signal
+ */
+export declare function lowpassFilter(x: number[], cutoff: f64, order?: i32): number[];
+/**
+ * Apply a highpass FIR filter using windowed sinc.
+ *
+ * @param x - Input signal
+ * @param cutoff - Normalized cutoff frequency (0 to 0.5)
+ * @param order - Filter order (default 31)
+ * @returns Filtered signal
+ */
+export declare function highpassFilter(x: number[], cutoff: f64, order?: i32): number[];
+/**
+ * Apply a bandpass FIR filter.
+ *
+ * @param x - Input signal
+ * @param low - Low cutoff frequency (normalized, 0 to 0.5)
+ * @param high - High cutoff frequency (normalized, 0 to 0.5)
+ * @param order - Filter order (default 31)
+ * @returns Filtered signal
+ */
+export declare function bandpassFilter(x: number[], low: f64, high: f64, order?: i32): number[];
+/**
+ * Resample a signal to a new sample rate using linear interpolation.
+ *
+ * @param x - Input signal
+ * @param newRate - Target sample rate
+ * @param oldRate - Original sample rate
+ * @returns Resampled signal
+ */
+export declare function resample(x: number[], newRate: f64, oldRate: f64): number[];
+/**
+ * Apply a median filter to a signal.
+ *
+ * @param x - Input signal
+ * @param n - Window size (default 3, must be odd)
+ * @returns Filtered signal
+ */
+export declare function medfilt(x: number[], n?: i32): number[];
+/**
+ * Generate a window function of given type and length.
+ *
+ * @param n - Window length
+ * @param type - Window type: 'hamming' | 'hann' | 'blackman' | 'rectangular' | 'bartlett'
+ * @returns Window coefficients
+ */
+export declare function windowFunction(n: i32, type: string): number[];
+/**
+ * Direct convolution of two signals (alias for sequential use).
+ *
+ * @param a - First signal
+ * @param b - Second signal
+ * @returns Convolution result (length a.length + b.length - 1)
+ */
+export declare function convolve(a: number[], b: number[]): number[];
+/**
+ * Cross-correlation of two signals (alias).
+ *
+ * @param a - First signal
+ * @param b - Second signal
+ * @returns Cross-correlation result
+ */
+export declare function correlate(a: number[], b: number[]): number[];
+/**
+ * Welch's overlapped-segment-averaging Power Spectral Density.
+ *
+ * For arrays >= WASM_SIGNAL_THRESHOLD samples (4096) dispatches to the
+ * WASM kernel (Rust → AS → JS fallback).
+ *
+ * @param signal - Input signal samples
+ * @param opts - { frameLength, overlap, window }
+ * @returns { psd: number[], frequencies: number[], frameLength: number }
+ */
+export declare function welchPSD(signal: number[] | Float64Array, opts?: {
+    frameLength?: i32;
+    overlap?: i32;
+    window?: string;
+}): {
+    psd: number[];
+    frequencies: number[];
+    frameLength: number;
+};
+/**
+ * Bartlett's non-overlapped segment-averaging Power Spectral Density.
+ *
+ * Special case of Welch with overlap=0 and rectangular window.
+ *
+ * @param signal - Input signal samples
+ * @param opts - { frameLength }
+ * @returns { psd: number[], frequencies: number[], frameLength: number }
+ */
+export declare function bartlettPSD(signal: number[] | Float64Array, opts?: {
+    frameLength?: i32;
+}): {
+    psd: number[];
+    frequencies: number[];
+    frameLength: number;
+};
+/**
+ * Multi-taper Power Spectral Density (Thomson's method, order K=5).
+ *
+ * Uses K discrete prolate spheroidal sequences (DPSS, approximated here
+ * as Slepian windows via cos-sum) to reduce spectral leakage. The final
+ * PSD is the mean of the K individual tapered periodograms.
+ *
+ * For large inputs, each tapered periodogram is computed via the WASM
+ * Welch kernel (frame = full signal, overlap = 0).
+ *
+ * @param signal - Input signal samples
+ * @param opts - { nfft, K } (K = number of tapers, default 5)
+ * @returns { psd: number[], frequencies: number[] }
+ */
+export declare function multiTaperPSD(signal: number[] | Float64Array, opts?: {
+    nfft?: i32;
+    K?: i32;
+}): {
+    psd: number[];
+    frequencies: number[];
+};
+/**
+ * Goertzel algorithm: compute the power |X[k]|² at a single frequency.
+ *
+ * Dispatches to the WASM kernel for arrays >= 4096 samples.
+ *
+ * @param signal - Input signal samples
+ * @param targetFreq - Target frequency in Hz
+ * @param sampleRate - Sample rate in Hz
+ * @returns |X[k]|² (unnormalized power at the target frequency)
+ */
+export declare function goertzel(signal: number[] | Float64Array, targetFreq: f64, sampleRate: f64): f64;
+/**
+ * Chirp-Z Transform (Bluestein algorithm).
+ *
+ * Computes M points of the z-transform along a chirp contour in the
+ * z-plane. The contour is defined by:
+ *   A = exp(2πi·phiStart)  — starting point
+ *   W = exp(2πi·phiStep)   — angular step
+ *
+ * Dispatches to the WASM kernel for max(n, m) >= 4096.
+ *
+ * @param signal - Input signal samples (real)
+ * @param m - Number of output points
+ * @param phiStart - Start angle in turns (e.g. 0 = DC, 0.5 = Nyquist)
+ * @param phiStep - Step angle in turns (negative for standard DFT)
+ * @returns { re: Float64Array, im: Float64Array } — M complex output values
+ */
+export declare function chirpZTransform(signal: number[] | Float64Array, m: i32, phiStart?: f64, phiStep?: f64): {
+    re: Float64Array;
+    im: Float64Array;
+};
+/**
+ * Primary export: typed signal processing functions
+ */
+export declare const typedSignal: {
+    fft: import("typed-function").TypedFunction;
+    ifft: import("typed-function").TypedFunction;
+    fftMagnitude: import("typed-function").TypedFunction;
+    fftPower: import("typed-function").TypedFunction;
+    conv: import("typed-function").TypedFunction;
+    xcorr: import("typed-function").TypedFunction;
+    autocorr: import("typed-function").TypedFunction;
+    crossCorrelation: typeof crossCorrelation;
+    autoCorrelation: typeof autoCorrelation;
+    groupDelay: typeof groupDelay;
+    unwrapPhase: typeof unwrapPhase;
+    dct: typeof dct;
+    idct: typeof idct;
+    dst: typeof dst;
+    idst: typeof idst;
+    dwt: typeof dwt;
+    fft2d: typeof fft2d;
+    fourier: typeof fourier;
+    invFourier: typeof invFourier;
+    hilbertTransform: typeof hilbertTransform;
+    spectrogram: typeof spectrogram;
+    periodogram: typeof periodogram;
+    lowpassFilter: typeof lowpassFilter;
+    highpassFilter: typeof highpassFilter;
+    bandpassFilter: typeof bandpassFilter;
+    resample: typeof resample;
+    medfilt: typeof medfilt;
+    windowFunction: typeof windowFunction;
+    convolve: typeof convolve;
+    correlate: typeof correlate;
+    welchPSD: typeof welchPSD;
+    bartlettPSD: typeof bartlettPSD;
+    multiTaperPSD: typeof multiTaperPSD;
+    goertzel: typeof goertzel;
+    chirpZTransform: typeof chirpZTransform;
+    applyWindow: typeof applyWindowDispatch;
+};
+/**
+ * Initialize signal processing pool
+ */
+export declare function initializeSignal(): Promise<void>;
+/**
+ * Terminate signal processing pool
+ */
+export declare function terminateSignal(): Promise<void>;
+export {};
+//# sourceMappingURL=signal.d.ts.map

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

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