deepbox 0.1.0

package/dist/index-BWGhrDlr.d.ts

@@ -0,0 +1,733 @@
+import { T as Tensor } from './Tensor-g8mUClel.js';
+import { A as Axis } from './tensor-B96jjJLQ.js';
+
+/**
+ * Pearson correlation coefficient.
+ *
+ * Measures linear correlation between two variables.
+ *
+ * @param x - First tensor
+ * @param y - Second tensor (must have same size as x)
+ * @returns Tuple of [correlation coefficient in [-1, 1], two-tailed p-value]
+ * @throws {InvalidParameterError} If tensors have different sizes, < 2 samples, or constant input
+ *
+ * @example
+ * ```ts
+ * const x = tensor([1, 2, 3, 4, 5]);
+ * const y = tensor([2, 4, 6, 8, 10]);
+ * const [r, p] = pearsonr(x, y);  // r = 1.0 (perfect linear)
+ * ```
+ *
+ * @remarks
+ * This function follows IEEE 754 semantics for special values:
+ * - NaN inputs propagate to NaN correlation
+ * - Infinity inputs result in NaN correlation
+ *
+ * @see {@link https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.pearsonr.html | SciPy stats.pearsonr}
+ */
+declare function pearsonr(x: Tensor, y: Tensor): [number, number];
+/**
+ * Computes Spearman's rank correlation coefficient.
+ *
+ * Non-parametric measure of monotonic relationship between two variables.
+ * Computed as Pearson correlation of rank values.
+ * - ρ = 1: Perfect monotonic increasing relationship
+ * - ρ = 0: No monotonic relationship
+ * - ρ = -1: Perfect monotonic decreasing relationship
+ *
+ * @param x - First tensor
+ * @param y - Second tensor (must have same size as x)
+ * @returns Tuple of [correlation coefficient, p-value]
+ * @throws {InvalidParameterError} If tensors have different sizes, < 2 samples, or constant input
+ *
+ * @example
+ * ```ts
+ * const x = tensor([1, 2, 3, 4, 5]);
+ * const y = tensor([2, 4, 6, 8, 10]);
+ * const [rho, p] = spearmanr(x, y);  // rho = 1.0 (perfect monotonic)
+ * ```
+ *
+ * @remarks
+ * Ties are assigned average ranks.
+ * NaN values are ranked according to JavaScript sort behavior.
+ * Infinity values are sorted naturally (±Infinity at extremes).
+ *
+ * @see {@link https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.spearmanr.html | SciPy stats.spearmanr}
+ */
+declare function spearmanr(x: Tensor, y: Tensor): [number, number];
+/**
+ * Computes Kendall's tau correlation coefficient.
+ *
+ * Non-parametric measure of ordinal association based on concordant/discordant pairs.
+ * More robust to outliers than Spearman, but computationally more expensive.
+ * - τ = 1: All pairs concordant (perfect agreement)
+ * - τ = 0: Equal concordant and discordant pairs
+ * - τ = -1: All pairs discordant (perfect disagreement)
+ *
+ * @param x - First tensor
+ * @param y - Second tensor (must have same size as x)
+ * @returns Tuple of [tau coefficient, p-value]
+ * @throws {InvalidParameterError} If tensors have different sizes or < 2 samples
+ *
+ * @example
+ * ```ts
+ * const x = tensor([1, 2, 3, 4, 5]);
+ * const y = tensor([1, 3, 2, 4, 5]);
+ * const [tau, p] = kendalltau(x, y);  // Mostly concordant
+ * ```
+ *
+ * @remarks
+ * This implementation uses the tau-b variant with tie correction.
+ * Ties are excluded from concordant/discordant counts and reduce the denominator.
+ * The p-value uses a normal approximation with tie-corrected variance.
+ *
+ * @complexity O(n²) - suitable for moderate sample sizes (n < 10,000)
+ *
+ * @see {@link https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.kendalltau.html | SciPy stats.kendalltau}
+ */
+declare function kendalltau(x: Tensor, y: Tensor): [number, number];
+/**
+ * Computes the Pearson correlation coefficient matrix.
+ *
+ * For two variables, returns 2x2 correlation matrix.
+ * For a 2D tensor, treats each column as a variable and computes pairwise correlations.
+ *
+ * @param x - Input tensor (1D or 2D)
+ * @param y - Optional second tensor (if provided, computes correlation between x and y)
+ * @returns Correlation matrix (symmetric with 1s on diagonal)
+ * @throws {InvalidParameterError} If < 2 observations or size mismatch
+ * @throws {ShapeError} If tensor is not 1D or 2D
+ *
+ * @example
+ * ```ts
+ * const x = tensor([1, 2, 3, 4, 5]);
+ * const y = tensor([2, 4, 5, 4, 5]);
+ * corrcoef(x, y);  // Returns [[1.0, 0.8], [0.8, 1.0]]
+ *
+ * const data = tensor([[1, 2], [3, 4], [5, 6]]);
+ * corrcoef(data);  // Returns 2x2 correlation matrix for 2 variables
+ * ```
+ *
+ * @see {@link https://numpy.org/doc/stable/reference/generated/numpy.corrcoef.html | NumPy corrcoef}
+ */
+declare function corrcoef(x: Tensor, y?: Tensor): Tensor;
+/**
+ * Computes the covariance matrix.
+ *
+ * Covariance measures how two variables change together.
+ * For two variables, returns 2x2 covariance matrix.
+ * For a 2D tensor, treats each column as a variable.
+ *
+ * @param x - Input tensor (1D or 2D)
+ * @param y - Optional second tensor (if provided, computes covariance between x and y)
+ * @param ddof - Delta degrees of freedom (0 = population, 1 = sample, default: 1)
+ * @returns Covariance matrix (symmetric)
+ * @throws {InvalidParameterError} If tensor is empty, ddof < 0, ddof >= sample size, or size mismatch
+ * @throws {ShapeError} If tensor is not 1D or 2D
+ *
+ * @example
+ * ```ts
+ * const x = tensor([1, 2, 3, 4, 5]);
+ * const y = tensor([2, 4, 5, 4, 5]);
+ * cov(x, y);  // Returns 2x2 covariance matrix
+ *
+ * const data = tensor([[1, 2], [3, 4], [5, 6]]);
+ * cov(data);  // Returns 2x2 covariance matrix for 2 variables
+ * ```
+ *
+ * @see {@link https://numpy.org/doc/stable/reference/generated/numpy.cov.html | NumPy cov}
+ */
+declare function cov(x: Tensor, y?: Tensor, ddof?: number): Tensor;
+
+/**
+ * Internal utilities for the stats package.
+ *
+ * This module contains internal helper functions used by the stats package.
+ * Functions are exported for use by other stats modules but are not part
+ * of the stable public API exported from `src/stats/index.ts`.
+ *
+ * Some functions (particularly CDFs and special functions like `normalCdf`,
+ * `studentTCdf`, `logGamma`, etc.) may be promoted to the public API in
+ * future versions if there is user demand.
+ *
+ * @internal
+ * @module stats/_internal
+ */
+
+/**
+ * Type representing axis specification for reduction operations.
+ * Can be a single axis number/alias or an array of axis numbers/aliases.
+ *
+ * @example
+ * ```ts
+ * const axis1: AxisLike = 0;        // Single axis
+ * const axis2: AxisLike = [0, 1];   // Multiple axes
+ * const axis3: AxisLike = "rows";   // Alias
+ * ```
+ */
+type AxisLike = Axis | readonly Axis[];
+
+/**
+ * Computes the arithmetic mean along specified axes.
+ *
+ * The mean is the sum of all values divided by the count.
+ * Supports axis-wise reduction with optional dimension preservation.
+ *
+ * @param t - Input tensor
+ * @param axis - Axis or axes along which to compute the mean (undefined = all axes)
+ * @param _keepdims - If true, reduced axes are retained with size 1 (default: false)
+ * @returns Tensor containing mean values
+ * @throws {InvalidParameterError} If tensor is empty or reduction over empty axis
+ * @throws {IndexError} If axis is out of bounds
+ *
+ * @example
+ * ```ts
+ * const t = tensor([[1, 2, 3], [4, 5, 6]]);
+ * mean(t);           // Returns tensor([3.5]) - mean of all elements
+ * mean(t, 0);        // Returns tensor([2.5, 3.5, 4.5]) - column means
+ * mean(t, 1);        // Returns tensor([2, 5]) - row means
+ * mean(t, 1, true);  // Returns tensor([[2], [5]]) - keepdims
+ * ```
+ *
+ * @remarks
+ * This function follows IEEE 754 semantics for special values:
+ * - NaN inputs propagate to NaN output
+ * - Infinity is handled according to standard arithmetic rules
+ * - Mixed Infinity values (Infinity + -Infinity) result in NaN
+ *
+ * @see {@link https://numpy.org/doc/stable/reference/generated/numpy.mean.html | NumPy mean}
+ */
+declare function mean(t: Tensor, axis?: AxisLike, _keepdims?: boolean): Tensor;
+/**
+ * Computes the median (50th percentile) along specified axes.
+ *
+ * The median is the middle value when data is sorted. For even-sized arrays,
+ * it's the average of the two middle values. More robust to outliers than mean.
+ *
+ * @param t - Input tensor
+ * @param axis - Axis or axes along which to compute the median (undefined = all axes)
+ * @param _keepdims - If true, reduced axes are retained with size 1 (default: false)
+ * @returns Tensor containing median values
+ * @throws {InvalidParameterError} If tensor is empty or reduction over empty axis
+ * @throws {IndexError} If axis is out of bounds
+ *
+ * @example
+ * ```ts
+ * const t = tensor([1, 2, 3, 4, 5]);
+ * median(t);  // Returns tensor([3])
+ *
+ * const t2 = tensor([1, 2, 3, 4]);
+ * median(t2); // Returns tensor([2.5]) - average of 2 and 3
+ * ```
+ *
+ * @remarks
+ * This function follows IEEE 754 semantics for special values:
+ * - NaN inputs result in NaN output (NaN sorts to end)
+ * - Infinity values are sorted naturally (±Infinity at extremes)
+ *
+ * @see {@link https://numpy.org/doc/stable/reference/generated/numpy.median.html | NumPy median}
+ */
+declare function median(t: Tensor, axis?: AxisLike, _keepdims?: boolean): Tensor;
+/**
+ * Computes the mode (most frequent value) along specified axis.
+ *
+ * The mode is the value that appears most frequently in the dataset.
+ * If multiple values have the same maximum frequency, returns the smallest value.
+ *
+ * @param t - Input tensor
+ * @param axis - Axis or axes along which to compute the mode (undefined = all axes)
+ * @returns Tensor containing mode values
+ * @throws {InvalidParameterError} If tensor is empty
+ * @throws {IndexError} If axis is out of bounds
+ *
+ * @example
+ * ```ts
+ * const t = tensor([1, 2, 2, 3, 3, 3]);
+ * mode(t);  // Returns tensor([3]) - most frequent value
+ *
+ * const t2 = tensor([[1, 2, 2], [3, 3, 4]]);
+ * mode(t2, 1);  // Returns tensor([2, 3]) - mode of each row
+ * ```
+ *
+ * @remarks
+ * NaN inputs propagate to NaN output.
+ *
+ * @see {@link https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.mode.html | SciPy stats.mode}
+ */
+declare function mode(t: Tensor, axis?: AxisLike): Tensor;
+/**
+ * Computes the standard deviation along specified axes.
+ *
+ * Standard deviation is the square root of variance, measuring spread of data.
+ * Uses Welford's algorithm for numerical stability via the variance function.
+ *
+ * @param t - Input tensor
+ * @param axis - Axis or axes along which to compute std (undefined = all axes)
+ * @param _keepdims - If true, reduced axes are retained with size 1 (default: false)
+ * @param ddof - Delta degrees of freedom (0 = population, 1 = sample, default: 0)
+ * @returns Tensor containing standard deviation values
+ * @throws {InvalidParameterError} If tensor is empty, ddof < 0, ddof >= sample size, or reduction over empty axis
+ * @throws {IndexError} If axis is out of bounds
+ * @throws {DTypeError} If tensor has string dtype
+ *
+ * @example
+ * ```ts
+ * const t = tensor([1, 2, 3, 4, 5]);
+ * std(t);        // Population std (ddof=0)
+ * std(t, 0, false, 1);  // Sample std (ddof=1)
+ * ```
+ *
+ * @remarks
+ * This function follows IEEE 754 semantics for special values:
+ * - NaN inputs propagate to NaN output
+ * - Infinity inputs result in NaN (infinite standard deviation)
+ *
+ * @see {@link https://numpy.org/doc/stable/reference/generated/numpy.std.html | NumPy std}
+ */
+declare function std(t: Tensor, axis?: AxisLike, _keepdims?: boolean, ddof?: number): Tensor;
+/**
+ * Computes the variance along specified axes.
+ *
+ * Variance measures the average squared deviation from the mean.
+ * Uses Welford's online algorithm for numerical stability.
+ *
+ * @param t - Input tensor
+ * @param axis - Axis or axes along which to compute variance (undefined = all axes)
+ * @param _keepdims - If true, reduced axes are retained with size 1 (default: false)
+ * @param ddof - Delta degrees of freedom (0 = population, 1 = sample, default: 0)
+ * @returns Tensor containing variance values
+ * @throws {InvalidParameterError} If tensor is empty, ddof < 0, ddof >= sample size, or reduction over empty axis
+ * @throws {IndexError} If axis is out of bounds
+ * @throws {DTypeError} If tensor has string dtype
+ *
+ * @example
+ * ```ts
+ * const t = tensor([1, 2, 3, 4, 5]);
+ * variance(t);              // Population variance: 2.0
+ * variance(t, 0, false, 1); // Sample variance: 2.5
+ * ```
+ *
+ * @remarks
+ * This function follows IEEE 754 semantics for special values:
+ * - NaN inputs propagate to NaN output
+ * - Infinity inputs result in NaN (infinite variance)
+ *
+ * @see {@link https://numpy.org/doc/stable/reference/generated/numpy.var.html | NumPy var}
+ */
+declare function variance(t: Tensor, axis?: AxisLike, _keepdims?: boolean, ddof?: number): Tensor;
+/**
+ * Computes the skewness (third standardized moment) along specified axis.
+ *
+ * Skewness measures the asymmetry of the probability distribution.
+ * - Negative skew: left tail is longer (mean < median)
+ * - Zero skew: symmetric distribution (normal distribution)
+ * - Positive skew: right tail is longer (mean > median)
+ *
+ * Uses Fisher's moment coefficient: E[(X - μ)³] / σ³
+ *
+ * @param t - Input tensor
+ * @param axis - Axis or axes along which to compute skewness (undefined = all axes)
+ * @param bias - If false, applies the unbiased Fisher-Pearson correction (default: true)
+ * @returns Tensor containing skewness values
+ *
+ * @example
+ * ```ts
+ * const t = tensor([1, 2, 3, 4, 5]);
+ * skewness(t);  // Returns ~0 (symmetric)
+ *
+ * const t2 = tensor([1, 2, 2, 3, 3, 3, 4, 4, 4, 4]);
+ * skewness(t2); // Positive skew (right-tailed)
+ * ```
+ *
+ * @remarks
+ * This function follows IEEE 754 semantics for special values:
+ * - NaN inputs propagate to NaN output
+ * - Returns NaN for constant input (zero variance)
+ * - Unbiased correction requires at least 3 samples; otherwise returns NaN
+ *
+ * @see {@link https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.skew.html | SciPy stats.skew}
+ */
+declare function skewness(t: Tensor, axis?: AxisLike, bias?: boolean): Tensor;
+/**
+ * Computes the kurtosis (fourth standardized moment) along specified axis.
+ *
+ * Kurtosis measures the "tailedness" of the probability distribution.
+ * - Negative excess kurtosis: lighter tails than normal (platykurtic)
+ * - Zero excess kurtosis: same tails as normal distribution (mesokurtic)
+ * - Positive excess kurtosis: heavier tails than normal (leptokurtic)
+ *
+ * Uses Fisher's definition: E[(X - μ)⁴] / σ⁴ - 3 (excess kurtosis)
+ *
+ * @param t - Input tensor
+ * @param axis - Axis or axes along which to compute kurtosis (undefined = all axes)
+ * @param fisher - If true, returns excess kurtosis (subtract 3, default: true)
+ * @param bias - If false, applies bias correction (requires at least 4 samples, default: true)
+ * @returns Tensor containing kurtosis values
+ *
+ * @example
+ * ```ts
+ * const t = tensor([1, 2, 3, 4, 5]);
+ * kurtosis(t, undefined, true);  // Excess kurtosis (Fisher)
+ * kurtosis(t, undefined, false); // Raw kurtosis (Pearson)
+ * ```
+ *
+ * @remarks
+ * This function follows IEEE 754 semantics for special values:
+ * - NaN inputs propagate to NaN output
+ * - Returns NaN for constant input (zero variance)
+ * - Unbiased correction requires at least 4 samples; otherwise returns NaN
+ *
+ * @see {@link https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.kurtosis.html | SciPy stats.kurtosis}
+ */
+declare function kurtosis(t: Tensor, axis?: AxisLike, fisher?: boolean, bias?: boolean): Tensor;
+/**
+ * Computes quantiles along specified axes.
+ *
+ * Quantiles are cut points dividing the range of a probability distribution.
+ * Uses linear interpolation between data points.
+ *
+ * @param t - Input tensor
+ * @param q - Quantile(s) to compute, in range [0, 1] (0.5 = median)
+ * @param axis - Axis or axes along which to compute quantiles (undefined = all axes)
+ * @returns Tensor containing quantile values
+ * @throws {InvalidParameterError} If q is not in [0, 1], tensor is empty, or reduction over empty axis
+ * @throws {IndexError} If axis is out of bounds
+ *
+ * @example
+ * ```ts
+ * const t = tensor([1, 2, 3, 4, 5]);
+ * quantile(t, 0.5);        // Returns tensor([3]) - median
+ * quantile(t, [0.25, 0.75]); // Returns tensor([2, 4]) - quartiles
+ * quantile(t, 0.95);       // Returns tensor([4.8]) - 95th percentile
+ * ```
+ *
+ * @see {@link https://numpy.org/doc/stable/reference/generated/numpy.quantile.html | NumPy quantile}
+ */
+declare function quantile(t: Tensor, q: number | number[], axis?: AxisLike): Tensor;
+/**
+ * Computes percentiles along specified axes.
+ *
+ * Percentiles are quantiles expressed as percentages (0-100 instead of 0-1).
+ * This is a convenience wrapper around quantile().
+ *
+ * @param t - Input tensor
+ * @param q - Percentile(s) to compute, in range [0, 100] (50 = median)
+ * @param axis - Axis or axes along which to compute percentiles (undefined = all axes)
+ * @returns Tensor containing percentile values
+ * @throws {InvalidParameterError} If q is not in [0, 100], tensor is empty, or reduction over empty axis
+ * @throws {IndexError} If axis is out of bounds
+ *
+ * @example
+ * ```ts
+ * const t = tensor([1, 2, 3, 4, 5]);
+ * percentile(t, 50);       // Returns tensor([3]) - median
+ * percentile(t, [25, 75]); // Returns tensor([2, 4]) - quartiles
+ * percentile(t, 95);       // Returns tensor([4.8]) - 95th percentile
+ * ```
+ *
+ * @see {@link https://numpy.org/doc/stable/reference/generated/numpy.percentile.html | NumPy percentile}
+ */
+declare function percentile(t: Tensor, q: number | number[], axis?: AxisLike): Tensor;
+/**
+ * Computes the n-th central moment about the mean.
+ *
+ * The n-th moment is defined as: E[(X - μ)ⁿ]
+ * - n=1: Always 0 (by definition of mean)
+ * - n=2: Variance
+ * - n=3: Related to skewness
+ * - n=4: Related to kurtosis
+ *
+ * @param t - Input tensor
+ * @param n - Order of the moment (must be non-negative integer)
+ * @param axis - Axis or axes along which to compute moment (undefined = all axes)
+ * @returns Tensor containing moment values
+ * @throws {InvalidParameterError} If n is not a non-negative integer
+ * @throws {IndexError} If axis is out of bounds
+ *
+ * @example
+ * ```ts
+ * const t = tensor([1, 2, 3, 4, 5]);
+ * moment(t, 1);  // Returns ~0 (first moment about mean)
+ * moment(t, 2);  // Returns variance
+ * moment(t, 3);  // Returns third moment (related to skewness)
+ * ```
+ *
+ * @see {@link https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.moment.html | SciPy stats.moment}
+ */
+declare function moment(t: Tensor, n: number, axis?: AxisLike): Tensor;
+/**
+ * Computes the geometric mean along specified axis.
+ *
+ * The geometric mean is the n-th root of the product of n values.
+ * Computed as: exp(mean(log(x))) for numerical stability.
+ * Useful for averaging ratios, growth rates, and multiplicative processes.
+ *
+ * @param t - Input tensor (all values must be > 0)
+ * @param axis - Axis or axes along which to compute geometric mean (undefined = all axes)
+ * @returns Tensor containing geometric mean values
+ * @throws {InvalidParameterError} If any value is <= 0
+ * @throws {IndexError} If axis is out of bounds
+ *
+ * @example
+ * ```ts
+ * const t = tensor([1, 2, 4, 8]);
+ * geometricMean(t);  // Returns ~2.83 (⁴√(1*2*4*8))
+ *
+ * // Growth rates: 10% and 20% growth
+ * const growth = tensor([1.1, 1.2]);
+ * geometricMean(growth);  // Returns ~1.149 (average growth rate)
+ * ```
+ *
+ * @see {@link https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.gmean.html | SciPy stats.gmean}
+ */
+declare function geometricMean(t: Tensor, axis?: AxisLike): Tensor;
+/**
+ * Computes the harmonic mean along specified axis.
+ *
+ * The harmonic mean is the reciprocal of the arithmetic mean of reciprocals.
+ * Computed as: n / sum(1/x)
+ * Useful for averaging rates and ratios (e.g., speeds, densities).
+ *
+ * @param t - Input tensor (all values must be > 0)
+ * @param axis - Axis or axes along which to compute harmonic mean (undefined = all axes)
+ * @returns Tensor containing harmonic mean values
+ * @throws {InvalidParameterError} If any value is <= 0
+ * @throws {IndexError} If axis is out of bounds
+ *
+ * @example
+ * ```ts
+ * const t = tensor([1, 2, 4]);
+ * harmonicMean(t);  // Returns ~1.71 (3 / (1/1 + 1/2 + 1/4))
+ *
+ * // Average speed: 60 mph for half distance, 40 mph for other half
+ * const speeds = tensor([60, 40]);
+ * harmonicMean(speeds);  // Returns 48 mph (correct average)
+ * ```
+ *
+ * @see {@link https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.hmean.html | SciPy stats.hmean}
+ */
+declare function harmonicMean(t: Tensor, axis?: AxisLike): Tensor;
+/**
+ * Computes the trimmed mean (mean after removing outliers from both tails).
+ *
+ * Removes a specified proportion of extreme values from both ends before computing mean.
+ * More robust to outliers than regular mean, less extreme than median.
+ *
+ * @param t - Input tensor
+ * @param proportiontocut - Fraction to cut from each tail, in range [0, 0.5)
+ * @param axis - Axis or axes along which to compute trimmed mean (undefined = all axes)
+ * @returns Tensor containing trimmed mean values
+ * @throws {InvalidParameterError} If proportiontocut is not in [0, 0.5), tensor is empty, or reduction over empty axis
+ * @throws {IndexError} If axis is out of bounds
+ *
+ * @example
+ * ```ts
+ * const t = tensor([1, 2, 3, 4, 5, 100]); // 100 is outlier
+ * mean(t);                    // Returns ~19.17 (affected by outlier)
+ * trimMean(t, 0.2);          // Returns 3.5 (removes 1 and 100)
+ * trimMean(t, 0.1);          // Returns ~22.8 (removes only 100)
+ * ```
+ *
+ * @see {@link https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.trim_mean.html | SciPy stats.trim_mean}
+ */
+declare function trimMean(t: Tensor, proportiontocut: number, axis?: AxisLike): Tensor;
+
+type TestResult = {
+    statistic: number;
+    pvalue: number;
+};
+/**
+ * One-sample t-test.
+ *
+ * Tests whether mean of sample differs from population mean.
+ *
+ * @see {@link https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.ttest_1samp.html | SciPy stats.ttest_1samp}
+ */
+declare function ttest_1samp(a: Tensor, popmean: number): TestResult;
+/**
+ * Independent two-sample t-test.
+ *
+ * Tests whether means of two independent samples are equal.
+ *
+ * @see {@link https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.ttest_ind.html | SciPy stats.ttest_ind}
+ */
+declare function ttest_ind(a: Tensor, b: Tensor, equalVar?: boolean): TestResult;
+/**
+ * Paired-sample t-test.
+ *
+ * Tests whether means of two related samples are equal.
+ *
+ * @see {@link https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.ttest_rel.html | SciPy stats.ttest_rel}
+ */
+declare function ttest_rel(a: Tensor, b: Tensor): TestResult;
+/**
+ * Chi-square goodness of fit test.
+ *
+ * Observed and expected frequencies must be non-negative and sum to the same total
+ * (within floating-point tolerance).
+ *
+ * @see {@link https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.chisquare.html | SciPy stats.chisquare}
+ */
+declare function chisquare(f_obs: Tensor, f_exp?: Tensor): TestResult;
+/**
+ * Kolmogorov-Smirnov test for goodness of fit.
+ *
+ * @see {@link https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.kstest.html | SciPy stats.kstest}
+ */
+declare function kstest(data: Tensor, cdf: string | ((x: number) => number)): TestResult;
+/**
+ * Test for normality.
+ *
+ * Uses D'Agostino-Pearson's omnibus test combining skewness and kurtosis.
+ *
+ * @see {@link https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.normaltest.html | SciPy stats.normaltest}
+ */
+declare function normaltest(a: Tensor): TestResult;
+/**
+ * Shapiro-Wilk test for normality.
+ *
+ * @see {@link https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.shapiro.html | SciPy stats.shapiro}
+ */
+declare function shapiro(x: Tensor): TestResult;
+/**
+ * Anderson-Darling test for normality.
+ *
+ * Uses sample standard deviation and size-adjusted critical values.
+ * For very small samples (n < 10), uses an IQR-based scale estimate to stabilize
+ * the statistic.
+ *
+ * @see {@link https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.anderson.html | SciPy stats.anderson}
+ */
+declare function anderson(x: Tensor): {
+    statistic: number;
+    critical_values: number[];
+    significance_level: number[];
+};
+/**
+ * Mann-Whitney U test (non-parametric).
+ *
+ * Tests whether two independent samples come from same distribution.
+ *
+ * Note: Uses normal approximation for the p-value with tie correction and
+ * continuity correction. No exact method selection is available.
+ *
+ * @see {@link https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.mannwhitneyu.html | SciPy stats.mannwhitneyu}
+ */
+declare function mannwhitneyu(x: Tensor, y: Tensor): TestResult;
+/**
+ * Wilcoxon signed-rank test (non-parametric paired test).
+ *
+ * Note: Uses normal approximation for the p-value with tie correction and
+ * continuity correction. No exact method selection is available.
+ *
+ * @see {@link https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.wilcoxon.html | SciPy stats.wilcoxon}
+ */
+declare function wilcoxon(x: Tensor, y?: Tensor): TestResult;
+/**
+ * Kruskal-Wallis H-test (non-parametric version of ANOVA).
+ *
+ * Note: Uses chi-square approximation for the p-value with tie correction.
+ *
+ * @see {@link https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.kruskal.html | SciPy stats.kruskal}
+ */
+declare function kruskal(...samples: Tensor[]): TestResult;
+/**
+ * Friedman test (non-parametric repeated measures ANOVA).
+ *
+ * Note: Uses chi-square approximation for the p-value with tie correction.
+ *
+ * @see {@link https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.friedmanchisquare.html | SciPy stats.friedmanchisquare}
+ */
+declare function friedmanchisquare(...samples: Tensor[]): TestResult;
+/**
+ * Levene's test for equality of variances.
+ *
+ * Tests whether two or more groups have equal variances.
+ * More robust than Bartlett's test for non-normal data.
+ *
+ * @param center - Method to use for centering: 'median' (default, most robust),
+ *                 'mean' (traditional), or 'trimmed' (10% trimmed mean)
+ * @param samples - Two or more sample tensors to compare
+ * @returns Test result with statistic and p-value
+ *
+ * @example
+ * ```ts
+ * import { levene, tensor } from 'deepbox';
+ *
+ * const group1 = tensor([1, 2, 3, 4, 5]);
+ * const group2 = tensor([2, 4, 6, 8, 10]);
+ * const result = levene('median', group1, group2);
+ * console.log(result.pvalue);  // p-value for equal variances
+ * ```
+ *
+ * @see {@link https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.levene.html | SciPy stats.levene}
+ */
+declare function levene(center: "mean" | "median" | "trimmed", ...samples: Tensor[]): TestResult;
+/**
+ * Bartlett's test for equality of variances.
+ *
+ * Tests whether two or more groups have equal variances.
+ * Assumes data is normally distributed; use Levene's test for non-normal data.
+ *
+ * @param samples - Two or more sample tensors to compare
+ * @returns Test result with statistic and p-value
+ *
+ * @example
+ * ```ts
+ * import { bartlett, tensor } from 'deepbox';
+ *
+ * const group1 = tensor([1, 2, 3, 4, 5]);
+ * const group2 = tensor([2, 4, 6, 8, 10]);
+ * const result = bartlett(group1, group2);
+ * console.log(result.pvalue);  // p-value for equal variances
+ * ```
+ *
+ * @see {@link https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.bartlett.html | SciPy stats.bartlett}
+ */
+declare function bartlett(...samples: Tensor[]): TestResult;
+/**
+ * One-way ANOVA.
+ *
+ * @see {@link https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.f_oneway.html | SciPy stats.f_oneway}
+ */
+declare function f_oneway(...samples: Tensor[]): TestResult;
+
+type index_TestResult = TestResult;
+declare const index_anderson: typeof anderson;
+declare const index_bartlett: typeof bartlett;
+declare const index_chisquare: typeof chisquare;
+declare const index_corrcoef: typeof corrcoef;
+declare const index_cov: typeof cov;
+declare const index_f_oneway: typeof f_oneway;
+declare const index_friedmanchisquare: typeof friedmanchisquare;
+declare const index_geometricMean: typeof geometricMean;
+declare const index_harmonicMean: typeof harmonicMean;
+declare const index_kendalltau: typeof kendalltau;
+declare const index_kruskal: typeof kruskal;
+declare const index_kstest: typeof kstest;
+declare const index_kurtosis: typeof kurtosis;
+declare const index_levene: typeof levene;
+declare const index_mannwhitneyu: typeof mannwhitneyu;
+declare const index_mean: typeof mean;
+declare const index_median: typeof median;
+declare const index_mode: typeof mode;
+declare const index_moment: typeof moment;
+declare const index_normaltest: typeof normaltest;
+declare const index_pearsonr: typeof pearsonr;
+declare const index_percentile: typeof percentile;
+declare const index_quantile: typeof quantile;
+declare const index_shapiro: typeof shapiro;
+declare const index_skewness: typeof skewness;
+declare const index_spearmanr: typeof spearmanr;
+declare const index_std: typeof std;
+declare const index_trimMean: typeof trimMean;
+declare const index_ttest_1samp: typeof ttest_1samp;
+declare const index_ttest_ind: typeof ttest_ind;
+declare const index_ttest_rel: typeof ttest_rel;
+declare const index_variance: typeof variance;
+declare const index_wilcoxon: typeof wilcoxon;
+declare namespace index {
+  export { type index_TestResult as TestResult, index_anderson as anderson, index_bartlett as bartlett, index_chisquare as chisquare, index_corrcoef as corrcoef, index_cov as cov, index_f_oneway as f_oneway, index_friedmanchisquare as friedmanchisquare, index_geometricMean as geometricMean, index_harmonicMean as harmonicMean, index_kendalltau as kendalltau, index_kruskal as kruskal, index_kstest as kstest, index_kurtosis as kurtosis, index_levene as levene, index_mannwhitneyu as mannwhitneyu, index_mean as mean, index_median as median, index_mode as mode, index_moment as moment, index_normaltest as normaltest, index_pearsonr as pearsonr, index_percentile as percentile, index_quantile as quantile, index_shapiro as shapiro, index_skewness as skewness, index_spearmanr as spearmanr, index_std as std, index_trimMean as trimMean, index_ttest_1samp as ttest_1samp, index_ttest_ind as ttest_ind, index_ttest_rel as ttest_rel, index_variance as variance, index_wilcoxon as wilcoxon };
+}
+
+export { levene as A, mannwhitneyu as B, normaltest as C, shapiro as D, ttest_1samp as E, ttest_ind as F, ttest_rel as G, wilcoxon as H, type TestResult as T, cov as a, kurtosis as b, corrcoef as c, median as d, mode as e, moment as f, geometricMean as g, harmonicMean as h, index as i, percentile as j, kendalltau as k, skewness as l, mean as m, std as n, anderson as o, pearsonr as p, quantile as q, bartlett as r, spearmanr as s, trimMean as t, chisquare as u, variance as v, f_oneway as w, friedmanchisquare as x, kruskal as y, kstest as z };