@cooljapan/scirs2 0.3.4

package/scirs2_wasm.d.ts

@@ -0,0 +1,1155 @@
+/* tslint:disable */
+/* eslint-disable */
+
+/**
+ * Performance timing utilities for benchmarking WASM operations
+ */
+export class PerformanceTimer {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Get elapsed time in milliseconds
+     */
+    elapsed(): number;
+    /**
+     * Log the elapsed time to console
+     */
+    log_elapsed(): void;
+    /**
+     * Create a new performance timer with a label
+     */
+    constructor(label: string);
+}
+
+/**
+ * A wrapper around ndarray for JavaScript interop
+ */
+export class WasmArray {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Create an array with evenly spaced values (like numpy.arange)
+     */
+    static arange(start: number, end: number, step: number): WasmArray;
+    /**
+     * Clone the array
+     */
+    clone(): WasmArray;
+    /**
+     * Create an array with a specific shape from flat data
+     */
+    static from_shape(shape: any, data: any): WasmArray;
+    /**
+     * Create an array filled with a constant value
+     */
+    static full(shape: any, value: number): WasmArray;
+    /**
+     * Get a value at the specified index (flat indexing)
+     */
+    get(index: number): number;
+    /**
+     * Check if the array is empty
+     */
+    is_empty(): boolean;
+    /**
+     * Get the total number of elements
+     */
+    len(): number;
+    /**
+     * Create an evenly spaced array (like numpy.linspace)
+     */
+    static linspace(start: number, end: number, num: number): WasmArray;
+    /**
+     * Get the number of dimensions
+     */
+    ndim(): number;
+    /**
+     * Create a 1D array from a JavaScript array or typed array
+     */
+    constructor(data: any);
+    /**
+     * Create an array of ones with the given shape
+     */
+    static ones(shape: any): WasmArray;
+    /**
+     * Reshape the array
+     */
+    reshape(new_shape: any): WasmArray;
+    /**
+     * Set a value at the specified index (flat indexing)
+     */
+    set(index: number, value: number): void;
+    /**
+     * Get the shape of the array
+     */
+    shape(): Array<any>;
+    /**
+     * Convert to a flat JavaScript Float64Array
+     */
+    to_array(): Float64Array;
+    /**
+     * Convert to a JavaScript array (nested for multi-dimensional arrays)
+     */
+    to_nested_array(): any;
+    /**
+     * Transpose the array (2D only for now)
+     */
+    transpose(): WasmArray;
+    /**
+     * Create an array of zeros with the given shape
+     */
+    static zeros(shape: any): WasmArray;
+}
+
+/**
+ * Add two arrays element-wise
+ */
+export function add(a: WasmArray, b: WasmArray): WasmArray;
+
+/**
+ * Perform Akima interpolation.
+ *
+ * Akima interpolation is a piecewise cubic method that is designed to be
+ * robust against outliers. Unlike standard cubic splines, Akima interpolation
+ * uses a local scheme for computing derivatives, making it less prone to
+ * oscillations near outliers or abrupt changes in the data.
+ *
+ * # Arguments
+ *
+ * * `x` - Known x-coordinates (must be sorted in strictly ascending order, at least 5 points)
+ * * `y` - Known y-coordinates (same length as x)
+ * * `x_new` - x-coordinates at which to evaluate the interpolation
+ *
+ * # Returns
+ *
+ * A `Vec<f64>` containing the interpolated values at each point in `x_new`.
+ *
+ * # Errors
+ *
+ * Returns an error if:
+ * - Input arrays are empty or have mismatched lengths
+ * - Fewer than 5 data points are provided (Akima requires at least 5)
+ * - x values are not sorted in strictly ascending order
+ * - Evaluation points are outside the data range
+ */
+export function akima(x: Float64Array, y: Float64Array, x_new: Float64Array): Float64Array;
+
+/**
+ * Find a root of a function using the bisection method.
+ *
+ * Given an interval [a, b] where the function changes sign, repeatedly halves
+ * the interval to converge on the root.
+ *
+ * # Arguments
+ * * `a` - Lower bracket endpoint
+ * * `b` - Upper bracket endpoint
+ * * `fa` - Function value at a: f(a)
+ * * `fb` - Function value at b: f(b)
+ * * `tol` - Convergence tolerance on the interval width
+ * * `max_iter` - Maximum number of iterations
+ *
+ * # Returns
+ * Estimated root location as f64
+ */
+export function bisect_root(a: number, b: number, fa: number, fb: number, tol: number, max_iter: number): number;
+
+/**
+ * Iterative bisection step: given bracket [a, b] with opposite-sign function values,
+ * and the function value at the midpoint, returns the narrowed bracket.
+ *
+ * # Arguments
+ * * `a` - Lower bracket
+ * * `b` - Upper bracket
+ * * `fa` - f(a)
+ * * `fb` - f(b)
+ * * `f_mid` - f((a+b)/2)
+ *
+ * # Returns
+ * JsValue with:
+ * - `a`, `b`: new bracket bounds
+ * - `fa`, `fb`: function values at new bounds
+ * - `mid`: current midpoint
+ * - `converged`: whether |b - a| < given tol (caller can check)
+ */
+export function bisection_step(a: number, b: number, fa: number, fb: number, f_mid: number): any;
+
+/**
+ * Generate a Blackman window of length `n`.
+ *
+ * The Blackman window is a three-term cosine series window providing
+ * excellent sidelobe suppression at the cost of wider main lobe.
+ *
+ * # Arguments
+ *
+ * * `n` - Number of points in the window
+ *
+ * # Returns
+ *
+ * A `Vec<f64>` containing the window coefficients.
+ */
+export function blackman(n: number): Float64Array;
+
+/**
+ * Find a root of a function using Brent's method.
+ *
+ * Given an interval [a, b] where the function changes sign, finds x such that f(x) ~ 0.
+ * The caller provides the function values at the endpoints.
+ *
+ * # Arguments
+ * * `a` - Lower bracket endpoint
+ * * `b` - Upper bracket endpoint
+ * * `fa` - Function value at a: f(a)
+ * * `fb` - Function value at b: f(b)
+ * * `tol` - Convergence tolerance on the root position
+ * * `max_iter` - Maximum number of iterations
+ *
+ * # Returns
+ * Estimated root location as f64
+ */
+export function brent_root(a: number, b: number, fa: number, fb: number, tol: number, max_iter: number): number;
+
+/**
+ * Design a Butterworth digital filter.
+ *
+ * Returns a JSON object with `b` (numerator) and `a` (denominator) coefficients.
+ *
+ * # Arguments
+ *
+ * * `order` - Filter order (positive integer)
+ * * `cutoff` - Cutoff frequency, normalized 0..1 where 1 is Nyquist
+ * * `btype` - Filter type: "lowpass", "highpass", "bandpass", or "bandstop"
+ * * `fs` - Sampling frequency in Hz (cutoff will be normalized by fs/2)
+ *
+ * # Returns
+ *
+ * A JsValue containing a JSON object `{ b: number[], a: number[] }`.
+ */
+export function butter(order: number, cutoff: number, btype: string, fs: number): any;
+
+/**
+ * Get system capabilities and features available in this build
+ */
+export function capabilities(): any;
+
+/**
+ * Perform 1D convolution of two arrays.
+ *
+ * # Arguments
+ *
+ * * `a` - First input array
+ * * `b` - Second input array
+ * * `mode` - Output mode: "full", "same", or "valid"
+ *
+ * # Returns
+ *
+ * A `Vec<f64>` containing the convolution result.
+ */
+export function convolve(a: Float64Array, b: Float64Array, mode: string): Float64Array;
+
+/**
+ * Compute correlation coefficient between two arrays
+ */
+export function corrcoef(x: WasmArray, y: WasmArray): number;
+
+/**
+ * Perform 1D cross-correlation of two arrays.
+ *
+ * Cross-correlation is equivalent to convolution with the second array reversed.
+ *
+ * # Arguments
+ *
+ * * `a` - First input array
+ * * `b` - Second input array
+ * * `mode` - Output mode: "full", "same", or "valid"
+ *
+ * # Returns
+ *
+ * A `Vec<f64>` containing the correlation result.
+ */
+export function correlate(a: Float64Array, b: Float64Array, mode: string): Float64Array;
+
+/**
+ * Perform natural cubic spline interpolation.
+ *
+ * Constructs a natural cubic spline (zero second derivative at boundaries)
+ * through the given data points and evaluates it at the specified x coordinates.
+ * Provides C2 continuity (continuous second derivatives).
+ *
+ * # Arguments
+ *
+ * * `x` - Known x-coordinates (must be sorted in ascending order, at least 3 points)
+ * * `y` - Known y-coordinates (same length as x)
+ * * `x_new` - x-coordinates at which to evaluate the spline
+ *
+ * # Returns
+ *
+ * A `Vec<f64>` containing the interpolated values at each point in `x_new`.
+ *
+ * # Errors
+ *
+ * Returns an error if:
+ * - Input arrays are empty or have mismatched lengths
+ * - Fewer than 3 data points are provided
+ * - x values are not sorted in ascending order
+ * - Evaluation points are outside the data range
+ */
+export function cubic_spline(x: Float64Array, y: Float64Array, x_new: Float64Array): Float64Array;
+
+/**
+ * Compute cumulative product of an array
+ */
+export function cumprod(arr: WasmArray): WasmArray;
+
+/**
+ * Compute cumulative sum of an array
+ */
+export function cumsum(arr: WasmArray): WasmArray;
+
+/**
+ * Compute the cumulative integral of `y` over `x` using the trapezoidal
+ * rule.
+ *
+ * Returns a `Float64Array` of length `n - 1` where `n = y.len()`, with
+ * each element being the integral from `x[0]` to `x[i+1]`.
+ *
+ * # Errors
+ * Returns a `JsValue` error on mismatched lengths or fewer than 2 points.
+ */
+export function cumulative_trapezoid(y_js: any, x_js: any): Float64Array;
+
+/**
+ * Compute the determinant of a square matrix
+ */
+export function det(arr: WasmArray): number;
+
+/**
+ * Divide two arrays element-wise
+ */
+export function divide(a: WasmArray, b: WasmArray): WasmArray;
+
+/**
+ * Compute dot product (1D) or matrix multiplication (2D)
+ */
+export function dot(a: WasmArray, b: WasmArray): WasmArray;
+
+/**
+ * Compute the forward Fast Fourier Transform (FFT) of complex input data.
+ *
+ * # Arguments
+ *
+ * * `data` - Interleaved real/imaginary pairs: `[re_0, im_0, re_1, im_1, ...]`
+ *
+ * # Returns
+ *
+ * Interleaved real/imaginary pairs of the FFT result.
+ * The output length equals the input length (same number of interleaved pairs).
+ *
+ * # Errors
+ *
+ * Returns a `JsValue` error if:
+ * - The input length is not even (not valid interleaved complex data)
+ * - The input is empty
+ * - The FFT computation fails
+ *
+ * # Example (JavaScript)
+ *
+ * ```javascript
+ * // Signal: [1+0i, 2+0i, 3+0i, 4+0i] as interleaved
+ * const input = new Float64Array([1, 0, 2, 0, 3, 0, 4, 0]);
+ * const result = fft(input);
+ * // result contains interleaved [re, im, re, im, ...]
+ * ```
+ */
+export function fft(data: Float64Array): Float64Array;
+
+/**
+ * Compute the magnitude (absolute value) of complex interleaved data.
+ *
+ * For each complex value `(re, im)`, computes `sqrt(re^2 + im^2)`.
+ *
+ * # Arguments
+ *
+ * * `data` - Interleaved real/imaginary pairs: `[re_0, im_0, re_1, im_1, ...]`
+ *
+ * # Returns
+ *
+ * A vector of magnitudes, one per complex value. Length is `data.len() / 2`.
+ *
+ * # Errors
+ *
+ * Returns a `JsValue` error if the input length is not even.
+ *
+ * # Example (JavaScript)
+ *
+ * ```javascript
+ * // Complex values: [3+4i, 0+1i] => magnitudes: [5.0, 1.0]
+ * const data = new Float64Array([3, 4, 0, 1]);
+ * const mags = fft_magnitude(data);
+ * ```
+ */
+export function fft_magnitude(data: Float64Array): Float64Array;
+
+/**
+ * Compute the phase angle of complex interleaved data (in radians).
+ *
+ * For each complex value `(re, im)`, computes `atan2(im, re)`.
+ *
+ * # Arguments
+ *
+ * * `data` - Interleaved real/imaginary pairs: `[re_0, im_0, re_1, im_1, ...]`
+ *
+ * # Returns
+ *
+ * A vector of phase angles in radians `[-pi, pi]`, one per complex value.
+ * Length is `data.len() / 2`.
+ *
+ * # Errors
+ *
+ * Returns a `JsValue` error if the input length is not even.
+ *
+ * # Example (JavaScript)
+ *
+ * ```javascript
+ * // Complex value: [1+1i] => phase: pi/4 (~0.785)
+ * const data = new Float64Array([1, 1]);
+ * const phases = fft_phase(data);
+ * ```
+ */
+export function fft_phase(data: Float64Array): Float64Array;
+
+/**
+ * Compute the FFT sample frequencies.
+ *
+ * Returns the frequency bin centers in cycles per unit of the sample spacing,
+ * following the same convention as NumPy/SciPy.
+ *
+ * # Arguments
+ *
+ * * `n` - Number of samples in the signal (window length).
+ * * `d` - Sample spacing (inverse of the sampling rate). Must be positive.
+ *
+ * # Returns
+ *
+ * A vector of length `n` containing the sample frequencies.
+ * For even `n`: `[0, 1, ..., n/2-1, -n/2, ..., -1] / (d*n)`
+ * For odd `n`: `[0, 1, ..., (n-1)/2, -(n-1)/2, ..., -1] / (d*n)`
+ *
+ * # Errors
+ *
+ * Returns a `JsValue` error if:
+ * - `n` is 0
+ * - `d` is not positive
+ * - The computation fails
+ *
+ * # Example (JavaScript)
+ *
+ * ```javascript
+ * const freqs = fftfreq(8, 0.1);
+ * // freqs = [0.0, 1.25, 2.5, 3.75, -5.0, -3.75, -2.5, -1.25]
+ * ```
+ */
+export function fftfreq(n: number, d: number): Float64Array;
+
+/**
+ * Shift the zero-frequency component to the center of the spectrum.
+ *
+ * Rearranges the FFT output so that the zero-frequency component is at
+ * the center, with negative frequencies on the left and positive on the right.
+ *
+ * # Arguments
+ *
+ * * `data` - FFT output as a flat f64 array (real-valued, e.g. from `power_spectrum`
+ *   or magnitude array).
+ *
+ * # Returns
+ *
+ * The shifted array with zero-frequency at the center.
+ *
+ * # Errors
+ *
+ * Returns a `JsValue` error if the input is empty.
+ *
+ * # Example (JavaScript)
+ *
+ * ```javascript
+ * const data = new Float64Array([0, 1, 2, 3, 4, -4, -3, -2, -1]);
+ * const shifted = fftshift(data);
+ * // shifted = [-4, -3, -2, -1, 0, 1, 2, 3, 4]
+ * ```
+ */
+export function fftshift(data: Float64Array): Float64Array;
+
+/**
+ * Design an FIR (Finite Impulse Response) lowpass filter using the window method.
+ *
+ * Designs a linear-phase FIR lowpass filter with the specified number of taps
+ * and cutoff frequency, using a Hamming window.
+ *
+ * # Arguments
+ *
+ * * `n` - Number of filter taps (must be >= 3)
+ * * `cutoff` - Cutoff frequency in Hz
+ * * `fs` - Sampling frequency in Hz
+ *
+ * # Returns
+ *
+ * A `Vec<f64>` containing the FIR filter coefficients.
+ */
+export function firwin(n: number, cutoff: number, fs: number): Float64Array;
+
+/**
+ * Step-wise golden section search: given bracket [a, b] and two interior
+ * function evaluations, returns the narrowed bracket and next evaluation points.
+ *
+ * # Arguments
+ * * `a` - Current lower bound
+ * * `b` - Current upper bound
+ * * `f_x1` - Function value at interior point x1
+ * * `f_x2` - Function value at interior point x2
+ * * `tol` - Convergence tolerance
+ *
+ * # Returns
+ * JsValue with:
+ * - `a`, `b`: new bracket bounds
+ * - `x1`, `x2`: new interior evaluation points
+ * - `converged`: whether |b - a| < tol
+ * - `x_min`: current best estimate of the minimizer
+ */
+export function golden_section_step(a: number, b: number, f_x1: number, f_x2: number, tol: number): any;
+
+/**
+ * Generate a Hamming window of length `n`.
+ *
+ * The Hamming window is a raised cosine window with non-zero endpoints,
+ * providing better sidelobe suppression than the Hann window.
+ *
+ * # Arguments
+ *
+ * * `n` - Number of points in the window
+ *
+ * # Returns
+ *
+ * A `Vec<f64>` containing the window coefficients.
+ */
+export function hamming(n: number): Float64Array;
+
+/**
+ * Generate a Hanning (Hann) window of length `n`.
+ *
+ * The Hann window is a raised cosine window with zero values at both endpoints,
+ * providing good frequency resolution and moderate sidelobe suppression.
+ *
+ * # Arguments
+ *
+ * * `n` - Number of points in the window
+ *
+ * # Returns
+ *
+ * A `Vec<f64>` containing the window coefficients.
+ */
+export function hanning(n: number): Float64Array;
+
+/**
+ * Check if WASM SIMD is supported in the current environment
+ */
+export function has_simd_support(): boolean;
+
+/**
+ * Compute the inverse Fast Fourier Transform (IFFT) of complex input data.
+ *
+ * # Arguments
+ *
+ * * `data` - Interleaved real/imaginary pairs: `[re_0, im_0, re_1, im_1, ...]`
+ *
+ * # Returns
+ *
+ * Interleaved real/imaginary pairs of the IFFT result.
+ * The output length equals the input length (same number of interleaved pairs).
+ *
+ * # Errors
+ *
+ * Returns a `JsValue` error if:
+ * - The input length is not even
+ * - The input is empty
+ * - The IFFT computation fails
+ *
+ * # Example (JavaScript)
+ *
+ * ```javascript
+ * const spectrum = new Float64Array([10, 0, -2, 2, -2, 0, -2, -2]);
+ * const signal = ifft(spectrum);
+ * ```
+ */
+export function ifft(data: Float64Array): Float64Array;
+
+/**
+ * Inverse of `fftshift`: shift zero-frequency component back to the beginning.
+ *
+ * This undoes the effect of `fftshift`.
+ *
+ * # Arguments
+ *
+ * * `data` - Shifted spectrum (with zero-frequency at center).
+ *
+ * # Returns
+ *
+ * The unshifted array with zero-frequency at the beginning.
+ *
+ * # Errors
+ *
+ * Returns a `JsValue` error if the input is empty.
+ *
+ * # Example (JavaScript)
+ *
+ * ```javascript
+ * const shifted = new Float64Array([-4, -3, -2, -1, 0, 1, 2, 3, 4]);
+ * const unshifted = ifftshift(shifted);
+ * // unshifted = [0, 1, 2, 3, 4, -4, -3, -2, -1]
+ * ```
+ */
+export function ifftshift(data: Float64Array): Float64Array;
+
+/**
+ * Initialize the WASM module with panic hooks and logging
+ */
+export function init(): void;
+
+/**
+ * Perform 1D interpolation with a specified method.
+ *
+ * Interpolates between the given (x, y) data points and evaluates the
+ * interpolation at the new x coordinates.
+ *
+ * # Arguments
+ *
+ * * `x` - Known x-coordinates (must be sorted in ascending order)
+ * * `y` - Known y-coordinates (same length as x)
+ * * `x_new` - x-coordinates at which to evaluate the interpolation
+ * * `kind` - Interpolation method: "linear", "nearest", or "quadratic" (uses cubic/Catmull-Rom)
+ *
+ * # Returns
+ *
+ * A `Vec<f64>` containing the interpolated values at each point in `x_new`.
+ *
+ * # Errors
+ *
+ * Returns an error if:
+ * - Input arrays are empty or have mismatched lengths
+ * - x values are not sorted in ascending order
+ * - An unknown interpolation kind is specified
+ * - Insufficient points for the requested method
+ */
+export function interp1d(x: Float64Array, y: Float64Array, x_new: Float64Array, kind: string): Float64Array;
+
+/**
+ * Compute matrix inverse
+ */
+export function inv(arr: WasmArray): WasmArray;
+
+/**
+ * Compute the inverse FFT for real-valued output (IRFFT).
+ *
+ * This is the inverse of `rfft`. It takes the positive-frequency half-spectrum
+ * and reconstructs the original real-valued signal.
+ *
+ * # Arguments
+ *
+ * * `data` - Interleaved real/imaginary pairs of the half-spectrum:
+ *   `[re_0, im_0, re_1, im_1, ...]`. The length must be even.
+ * * `n` - Length of the output real signal. If 0, it is computed as
+ *   `2 * (num_complex - 1)` where `num_complex` is the number of complex values.
+ *
+ * # Returns
+ *
+ * Real-valued output signal as `f64` array.
+ *
+ * # Errors
+ *
+ * Returns a `JsValue` error if:
+ * - The input length is not even
+ * - The input is empty
+ * - The IRFFT computation fails
+ *
+ * # Example (JavaScript)
+ *
+ * ```javascript
+ * const spectrum = rfft(new Float64Array([1, 2, 3, 4]));
+ * const signal = irfft(spectrum, 4);  // Recover original 4-element signal
+ * ```
+ */
+export function irfft(data: Float64Array, n: number): Float64Array;
+
+/**
+ * Perform Lagrange polynomial interpolation.
+ *
+ * Uses barycentric Lagrange interpolation, which is numerically more stable
+ * than the naive Lagrange formula. The order of the polynomial equals
+ * the number of data points minus one.
+ *
+ * # Arguments
+ *
+ * * `x` - Known x-coordinates (must have distinct values)
+ * * `y` - Known y-coordinates (same length as x)
+ * * `x_new` - x-coordinates at which to evaluate the polynomial
+ *
+ * # Returns
+ *
+ * A `Vec<f64>` containing the interpolated values at each point in `x_new`.
+ *
+ * # Errors
+ *
+ * Returns an error if:
+ * - Input arrays are empty or have mismatched lengths
+ * - Fewer than 2 data points are provided
+ * - x values contain duplicates
+ */
+export function lagrange(x: Float64Array, y: Float64Array, x_new: Float64Array): Float64Array;
+
+/**
+ * Apply a digital filter to a signal using direct form II transposed structure.
+ *
+ * Implements causal filtering with the inherent group delay of the filter.
+ * Both IIR and FIR filters are supported.
+ *
+ * # Arguments
+ *
+ * * `b` - Numerator (feedforward) coefficients
+ * * `a` - Denominator (feedback) coefficients. For FIR filters, use `[1.0]`.
+ * * `x` - Input signal
+ *
+ * # Returns
+ *
+ * A `Vec<f64>` containing the filtered signal (same length as input).
+ */
+export function lfilter(b: Float64Array, a: Float64Array, x: Float64Array): Float64Array;
+
+/**
+ * Perform simple linear regression: y = slope * x + intercept.
+ *
+ * # Arguments
+ * * `x` - Independent variable values
+ * * `y` - Dependent variable values
+ *
+ * # Returns
+ * JsValue containing:
+ * - `slope`: regression slope
+ * - `intercept`: regression intercept
+ * - `r_squared`: coefficient of determination (R^2)
+ * - `std_err_slope`: standard error of the slope
+ * - `std_err_intercept`: standard error of the intercept
+ * - `n`: number of data points
+ */
+export function linear_regression(x: Float64Array, y: Float64Array): any;
+
+/**
+ * Log a message to the browser console
+ */
+export function log(message: string): void;
+
+/**
+ * Find the maximum value
+ */
+export function max(arr: WasmArray): number;
+
+/**
+ * Compute the mean of all elements
+ */
+export function mean(arr: WasmArray): number;
+
+/**
+ * Compute the median of an array
+ */
+export function median(arr: WasmArray): number;
+
+/**
+ * Memory usage information for the WASM module
+ */
+export function memory_usage(): any;
+
+/**
+ * Find the minimum value
+ */
+export function min(arr: WasmArray): number;
+
+/**
+ * Minimize a scalar function over a bracketed interval using golden section search.
+ *
+ * This is a derivative-free 1D optimization method. Since WASM cannot pass
+ * function closures, this method works on a tabulated function: the caller provides
+ * sample points and their values, and the algorithm interpolates.
+ *
+ * # Arguments
+ * * `a` - Lower bound of the search interval
+ * * `b` - Upper bound of the search interval
+ * * `tol` - Convergence tolerance on the interval width
+ * * `max_iter` - Maximum number of iterations
+ *
+ * # Returns
+ * A JsValue containing:
+ * - `x`: estimated minimizer
+ * - `fun`: estimated function value at minimizer (NaN if unknown)
+ * - `a`: final bracket lower bound
+ * - `b`: final bracket upper bound
+ * - `nit`: number of iterations
+ * - `success`: whether tolerance was achieved
+ */
+export function minimize_golden(a: number, b: number, tol: number, max_iter: number): any;
+
+/**
+ * Minimize a function using the Nelder-Mead simplex algorithm.
+ *
+ * Since WASM cannot pass function closures from JS, this performs the Nelder-Mead
+ * optimization using pre-evaluated simplex vertices and their function values.
+ *
+ * # Arguments
+ * * `f_values` - Function values at the initial simplex vertices (n+1 values for n dimensions)
+ * * `x0` - Flat array of initial simplex vertex coordinates, row-major layout:
+ *   each vertex has `n` coordinates, so total length is `(n+1) * n`
+ * * `tol` - Convergence tolerance (standard deviation of simplex values)
+ * * `max_iter` - Maximum number of iterations
+ *
+ * # Returns
+ * A JsValue containing an object with fields:
+ * - `x`: best point found (as array)
+ * - `fun`: function value at best point
+ * - `nit`: number of iterations performed
+ * - `success`: whether convergence was achieved
+ * - `simplex`: final simplex vertices (flat array)
+ * - `simplex_values`: function values at final simplex vertices
+ *
+ * Note: With pre-evaluated data, this performs a single Nelder-Mead step cycle.
+ * For iterative optimization, call repeatedly from JS, re-evaluating the function
+ * at the new simplex points each iteration.
+ */
+export function minimize_nelder_mead(f_values: Float64Array, x0: Float64Array, tol: number, max_iter: number): any;
+
+/**
+ * Multiply two arrays element-wise
+ */
+export function multiply(a: WasmArray, b: WasmArray): WasmArray;
+
+/**
+ * Compute the Frobenius norm of a matrix
+ */
+export function norm_frobenius(arr: WasmArray): number;
+
+/**
+ * Solve the ODE  dy/dt = -y  (exponential decay) using the classic RK4
+ * method.
+ *
+ * Since JavaScript cannot pass function pointers to WASM, this solver uses
+ * a built-in right-hand side (exponential decay, dy_i/dt = -y_i for every
+ * component).
+ *
+ * * `y0_js`     -- initial state vector (1-D array).
+ * * `t_span_js` -- two-element array `[t_start, t_end]`.
+ * * `n_steps`   -- number of integration steps.
+ *
+ * Returns a serialised JSON object (via `JsValue`) with fields:
+ * * `t`  -- array of time values.
+ * * `y`  -- array of arrays, one per time point (each inner array has the
+ *   same length as `y0`).
+ *
+ * # Errors
+ * Returns a `JsValue` error when inputs are invalid.
+ */
+export function ode_solve(y0_js: any, t_span_js: any, n_steps: number): any;
+
+/**
+ * Perform PCHIP (Piecewise Cubic Hermite Interpolating Polynomial) interpolation.
+ *
+ * PCHIP produces a monotonicity-preserving interpolant: if the input data is
+ * monotonically increasing (or decreasing) in an interval, the interpolation
+ * will be too. The first derivatives are continuous, but the second derivatives
+ * may have jumps at the knot points.
+ *
+ * # Arguments
+ *
+ * * `x` - Known x-coordinates (must be sorted in ascending order, at least 2 points)
+ * * `y` - Known y-coordinates (same length as x)
+ * * `x_new` - x-coordinates at which to evaluate the interpolation
+ *
+ * # Returns
+ *
+ * A `Vec<f64>` containing the interpolated values at each point in `x_new`.
+ *
+ * # Errors
+ *
+ * Returns an error if:
+ * - Input arrays are empty or have mismatched lengths
+ * - Fewer than 2 data points are provided
+ * - x values are not sorted in ascending order
+ */
+export function pchip(x: Float64Array, y: Float64Array, x_new: Float64Array): Float64Array;
+
+/**
+ * Compute a percentile of an array
+ */
+export function percentile(arr: WasmArray, q: number): number;
+
+/**
+ * Evaluate a fitted polynomial at given points.
+ *
+ * # Arguments
+ * * `coeffs` - Polynomial coefficients in ascending power order [c_0, c_1, ..., c_d]
+ * * `x` - Points at which to evaluate the polynomial
+ *
+ * # Returns
+ * Evaluated values as `Vec<f64>`
+ */
+export function polynomial_eval(coeffs: Float64Array, x: Float64Array): Float64Array;
+
+/**
+ * Fit a polynomial of given degree to data points using least squares.
+ *
+ * Finds coefficients c_0, c_1, ..., c_d such that:
+ *   y ~ c_0 + c_1*x + c_2*x^2 + ... + c_d*x^d
+ *
+ * # Arguments
+ * * `x` - Independent variable values
+ * * `y` - Dependent variable values
+ * * `degree` - Degree of the polynomial to fit
+ *
+ * # Returns
+ * Coefficients as a `Vec<f64>` in ascending power order: `[c_0, c_1, ..., c_d]`
+ */
+export function polynomial_fit(x: Float64Array, y: Float64Array, degree: number): Float64Array;
+
+/**
+ * Compute the power spectrum (power spectral density) of a real-valued signal.
+ *
+ * Computes `|FFT(signal)|^2` for each frequency bin. The result represents
+ * the distribution of signal power across frequencies.
+ *
+ * # Arguments
+ *
+ * * `data` - Real-valued input signal as `f64` array.
+ *
+ * # Returns
+ *
+ * A vector of length `n/2 + 1` containing the power at each frequency bin
+ * (only positive frequencies, since the input is real-valued).
+ *
+ * # Errors
+ *
+ * Returns a `JsValue` error if:
+ * - The input is empty
+ * - The FFT computation fails
+ *
+ * # Example (JavaScript)
+ *
+ * ```javascript
+ * const signal = new Float64Array([1, 0, -1, 0, 1, 0, -1, 0]);
+ * const psd = power_spectrum(signal);
+ * // psd[2] should have the dominant peak (frequency = 2 cycles per 8 samples)
+ * ```
+ */
+export function power_spectrum(data: Float64Array): Float64Array;
+
+/**
+ * Generate random numbers from an exponential distribution
+ */
+export function random_exponential(shape: any, lambda: number): WasmArray;
+
+/**
+ * Generate random integers in the range [low, high)
+ */
+export function random_integers(shape: any, low: number, high: number): WasmArray;
+
+/**
+ * Generate random numbers from a normal (Gaussian) distribution
+ */
+export function random_normal(shape: any, mean: number, std_dev: number): WasmArray;
+
+/**
+ * Generate random numbers from a uniform distribution [0, 1)
+ */
+export function random_uniform(shape: any): WasmArray;
+
+/**
+ * Compute the matrix rank
+ */
+export function rank(arr: WasmArray, tolerance?: number | null): number;
+
+/**
+ * Compute the FFT of real-valued input data (RFFT).
+ *
+ * This is optimized for real-valued signals. The output contains only the
+ * positive-frequency half of the spectrum (plus the DC and Nyquist components),
+ * since the negative frequencies are redundant for real input.
+ *
+ * # Arguments
+ *
+ * * `data` - Real-valued input signal as `f64` array.
+ *
+ * # Returns
+ *
+ * Interleaved real/imaginary pairs of the half-spectrum.
+ * Output length is `2 * (n/2 + 1)` where `n` is the input length, because
+ * the result contains `n/2 + 1` complex values stored as interleaved pairs.
+ *
+ * # Errors
+ *
+ * Returns a `JsValue` error if:
+ * - The input is empty
+ * - The RFFT computation fails
+ *
+ * # Example (JavaScript)
+ *
+ * ```javascript
+ * const signal = new Float64Array([1.0, 2.0, 3.0, 4.0]);
+ * const spectrum = rfft(signal);
+ * // spectrum has (4/2 + 1) * 2 = 6 elements: 3 complex values as interleaved pairs
+ * ```
+ */
+export function rfft(data: Float64Array): Float64Array;
+
+/**
+ * Compute the FFT sample frequencies for real-valued FFT (RFFT).
+ *
+ * Returns the frequency bin centers for the positive-frequency half of the
+ * spectrum, which is the output of `rfft`.
+ *
+ * # Arguments
+ *
+ * * `n` - Number of samples in the original signal (window length).
+ * * `d` - Sample spacing (inverse of the sampling rate). Must be positive.
+ *
+ * # Returns
+ *
+ * A vector of length `n/2 + 1` containing the sample frequencies for
+ * the positive half of the spectrum.
+ *
+ * # Errors
+ *
+ * Returns a `JsValue` error if:
+ * - `n` is 0
+ * - `d` is not positive
+ * - The computation fails
+ *
+ * # Example (JavaScript)
+ *
+ * ```javascript
+ * const freqs = rfftfreq(8, 0.1);
+ * // freqs = [0.0, 1.25, 2.5, 3.75, 5.0]
+ * ```
+ */
+export function rfftfreq(n: number, d: number): Float64Array;
+
+/**
+ * Perform a single explicit Runge-Kutta 4th order (RK4) step.
+ *
+ * Because JavaScript cannot pass function pointers, the caller must supply
+ * the derivative values pre-computed at the current state.
+ *
+ * * `f_vals_js` -- derivative values dy/dt evaluated at (t, y), one per
+ *   component.
+ * * `t`         -- current time.
+ * * `y_js`      -- current state vector.
+ * * `h`         -- step size.
+ *
+ * The function approximates the next state assuming a *constant* derivative
+ * (i.e. Euler) combined with the classical RK4 weighting using the provided
+ * derivative.  For a full multi-stage RK4 the caller would need to evaluate
+ * the derivative at the intermediate stages; this helper is therefore best
+ * suited for demonstration / simple cases.
+ *
+ * Returns the new state vector `y_{n+1}` as a `Float64Array`.
+ *
+ * # Errors
+ * Returns a `JsValue` error when `f_vals` and `y` have different lengths.
+ */
+export function rk4_step(f_vals_js: any, _t: number, y_js: any, h: number): Float64Array;
+
+/**
+ * Compute the integral of tabulated data `y` with uniform spacing `dx`
+ * using Romberg integration (Richardson extrapolation of the trapezoidal
+ * rule).
+ *
+ * The number of data points must be of the form `2^k + 1` for some
+ * non-negative integer `k` (e.g. 2, 3, 5, 9, 17, 33, ...).  If the length
+ * does not satisfy this requirement an error is returned.
+ *
+ * # Arguments
+ * * `y_js` -- ordinate values (array of `f64`).
+ * * `dx`   -- uniform spacing between consecutive x-values.
+ *
+ * # Errors
+ * Returns a `JsValue` error when the input length is not `2^k + 1` or when
+ * fewer than 2 points are given.
+ */
+export function romberg(y_js: any, dx: number): number;
+
+/**
+ * Set the random seed for reproducibility
+ */
+export function set_random_seed(seed: bigint): string;
+
+/**
+ * Compute the definite integral of `y` over `x` using Simpson's rule.
+ *
+ * For segments where three consecutive points are available the classic
+ * Simpson 1/3 rule is used.  A final trapezoidal panel is added when the
+ * number of intervals is odd.
+ *
+ * # Errors
+ * Returns a `JsValue` error on mismatched lengths or fewer than 2 points.
+ */
+export function simpson(y_js: any, x_js: any): number;
+
+/**
+ * Solve a system of linear equations Ax = b
+ */
+export function solve(a: WasmArray, b: WasmArray): WasmArray;
+
+/**
+ * Compute the standard deviation of an array
+ */
+export function std(arr: WasmArray): number;
+
+/**
+ * Compute the standard deviation with specified degrees of freedom
+ */
+export function std_with_ddof(arr: WasmArray, ddof: number): number;
+
+/**
+ * Subtract two arrays element-wise
+ */
+export function subtract(a: WasmArray, b: WasmArray): WasmArray;
+
+/**
+ * Sum all elements in the array
+ */
+export function sum(arr: WasmArray): number;
+
+/**
+ * Compute the trace of a matrix (sum of diagonal elements)
+ */
+export function trace(arr: WasmArray): number;
+
+/**
+ * Compute the definite integral of `y` over `x` using the composite
+ * trapezoidal rule.
+ *
+ * Both `y_js` and `x_js` must be arrays of the same length (>= 2).
+ *
+ * # Errors
+ * Returns a `JsValue` error when the inputs have mismatched lengths or
+ * contain fewer than 2 points.
+ */
+export function trapezoid(y_js: any, x_js: any): number;
+
+/**
+ * Compute the variance of an array
+ */
+export function variance(arr: WasmArray): number;
+
+/**
+ * Compute the variance with specified degrees of freedom
+ */
+export function variance_with_ddof(arr: WasmArray, ddof: number): number;
+
+/**
+ * Get the version of SciRS2-WASM
+ */
+export function version(): string;