Central Tendency
mean
Computes the arithmetic mean along specified axes.
function mean(
t: Tensor,
axis?: number | number[],
keepdims?: boolean
): Tensor
Axis or axes along which to compute the mean. If undefined, computes mean of all elements.
If true, reduced axes are retained with size 1
Tensor containing mean values
const t = tensor([[1, 2, 3], [4, 5, 6]]);
mean(t); // tensor([3.5]) - mean of all elements
mean(t, 0); // tensor([2.5, 3.5, 4.5]) - column means
mean(t, 1); // tensor([2, 5]) - row means
mean(t, 1, true); // tensor([[2], [5]]) - keepdims
Computes the median (50th percentile) along specified axes.
function median(
t: Tensor,
axis?: number | number[],
keepdims?: boolean
): Tensor
Axis or axes along which to compute the median. If undefined, computes median of all elements.
If true, reduced axes are retained with size 1
Tensor containing median values
const t = tensor([1, 2, 3, 4, 5]);
median(t); // tensor([3])
const t2 = tensor([1, 2, 3, 4]);
median(t2); // tensor([2.5]) - average of 2 and 3
mode
Computes the mode (most frequent value) along specified axis.
function mode(
t: Tensor,
axis?: number | number[]
): Tensor
Axis or axes along which to compute the mode. If undefined, computes mode of all elements.
Tensor containing mode values
const t = tensor([1, 2, 2, 3, 3, 3]);
mode(t); // tensor([3]) - most frequent value
const t2 = tensor([[1, 2, 2], [3, 3, 4]]);
mode(t2, 1); // tensor([2, 3]) - mode of each row
geometricMean
Computes the geometric mean along specified axis.
function geometricMean(
t: Tensor,
axis?: number | number[]
): Tensor
Input tensor (all values must be > 0)
Axis or axes along which to compute geometric mean
Tensor containing geometric mean values
exp(mean(log(x))) for numerical stability.
Statistical Context: Useful for averaging ratios, growth rates, and multiplicative processes. Requires all values to be positive. More appropriate than arithmetic mean for data that grows exponentially.
const t = tensor([1, 2, 4, 8]);
geometricMean(t); // ~2.83 (⁴√(1*2*4*8))
// Growth rates: 10% and 20% growth
const growth = tensor([1.1, 1.2]);
geometricMean(growth); // ~1.149 (average growth rate)
harmonicMean
Computes the harmonic mean along specified axis.
function harmonicMean(
t: Tensor,
axis?: number | number[]
): Tensor
Input tensor (all values must be > 0)
Axis or axes along which to compute harmonic mean
Tensor containing harmonic mean values
n / sum(1/x).
Statistical Context: Useful for averaging rates and ratios (e.g., speeds, densities). Gives more weight to smaller values. Appropriate when averaging quantities defined as ratios.
const t = tensor([1, 2, 4]);
harmonicMean(t); // ~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); // 48 mph (correct average)
trimMean
Computes the trimmed mean (mean after removing outliers from both tails).
function trimMean(
t: Tensor,
proportiontocut: number,
axis?: number | number[]
): Tensor
Fraction to cut from each tail, in range [0, 0.5)
Axis or axes along which to compute trimmed mean
Tensor containing trimmed mean values
const t = tensor([1, 2, 3, 4, 5, 100]); // 100 is outlier
mean(t); // ~19.17 (affected by outlier)
trimMean(t, 0.2); // 3.5 (removes 1 and 100)
trimMean(t, 0.1); // ~22.8 (removes only 100)
Dispersion
variance
Computes the variance along specified axes.
function variance(
t: Tensor,
axis?: number | number[],
keepdims?: boolean,
ddof?: number
): Tensor
Axis or axes along which to compute variance
If true, reduced axes are retained with size 1
Delta degrees of freedom. Use 0 for population variance, 1 for sample variance.
Tensor containing variance values
const t = tensor([1, 2, 3, 4, 5]);
variance(t); // 2.0 - population variance
variance(t, 0, false, 1); // 2.5 - sample variance
std
Computes the standard deviation along specified axes.
function std(
t: Tensor,
axis?: number | number[],
keepdims?: boolean,
ddof?: number
): Tensor
Axis or axes along which to compute standard deviation
If true, reduced axes are retained with size 1
Delta degrees of freedom. Use 0 for population std, 1 for sample std.
Tensor containing standard deviation values
const t = tensor([1, 2, 3, 4, 5]);
std(t); // Population std (ddof=0)
std(t, 0, false, 1); // Sample std (ddof=1)
Shape
skewness
Computes the skewness (third standardized moment) along specified axis.
function skewness(
t: Tensor,
axis?: number | number[],
bias?: boolean
): Tensor
Axis or axes along which to compute skewness
If false, applies the unbiased Fisher-Pearson correction
Tensor containing skewness values
- Negative skew: Left tail is longer (mean < median), data concentrated on the right
- Zero skew: Symmetric distribution (normal distribution)
- Positive skew: Right tail is longer (mean > median), data concentrated on the left
Uses Fisher’s moment coefficient: E[(X - μ)³] / σ³. Unbiased correction requires at least 3 samples.
const t = tensor([1, 2, 3, 4, 5]);
skewness(t); // ~0 (symmetric)
const t2 = tensor([1, 2, 2, 3, 3, 3, 4, 4, 4, 4]);
skewness(t2); // Positive skew (right-tailed)
kurtosis
Computes the kurtosis (fourth standardized moment) along specified axis.
function kurtosis(
t: Tensor,
axis?: number | number[],
fisher?: boolean,
bias?: boolean
): Tensor
Axis or axes along which to compute kurtosis
If true, returns excess kurtosis (subtract 3). If false, returns raw kurtosis.
If false, applies bias correction (requires at least 4 samples)
Tensor containing kurtosis values
- Negative excess kurtosis: Lighter tails than normal (platykurtic), fewer outliers
- Zero excess kurtosis: Same tails as normal distribution (mesokurtic)
- Positive excess kurtosis: Heavier tails than normal (leptokurtic), more outliers
Uses Fisher’s definition: E[(X - μ)⁴] / σ⁴ - 3 (excess kurtosis). The normal distribution has excess kurtosis of 0.
const t = tensor([1, 2, 3, 4, 5]);
kurtosis(t, undefined, true); // Excess kurtosis (Fisher)
kurtosis(t, undefined, false); // Raw kurtosis (Pearson)
moment
Computes the n-th central moment about the mean.
function moment(
t: Tensor,
n: number,
axis?: number | number[]
): Tensor
Order of the moment (must be non-negative integer)
Axis or axes along which to compute moment
Tensor containing moment values
- n=1: Always 0 (by definition of mean)
- n=2: Variance
- n=3: Related to skewness
- n=4: Related to kurtosis
Higher moments describe increasingly subtle aspects of the distribution shape.
const t = tensor([1, 2, 3, 4, 5]);
moment(t, 1); // ~0 (first moment about mean)
moment(t, 2); // variance
moment(t, 3); // third moment (related to skewness)
Quantiles
quantile
Computes quantiles along specified axes.
function quantile(
t: Tensor,
q: number | number[],
axis?: number | number[]
): Tensor
q
number | number[]
required
Quantile(s) to compute, in range [0, 1] (0.5 = median)
Axis or axes along which to compute quantiles
Tensor containing quantile values. If multiple quantiles requested, first dimension contains quantile values.
const t = tensor([1, 2, 3, 4, 5]);
quantile(t, 0.5); // tensor([3]) - median
quantile(t, [0.25, 0.75]); // tensor([2, 4]) - quartiles
quantile(t, 0.95); // tensor([4.8]) - 95th percentile
percentile
Computes percentiles along specified axes.
function percentile(
t: Tensor,
q: number | number[],
axis?: number | number[]
): Tensor
q
number | number[]
required
Percentile(s) to compute, in range [0, 100] (50 = median)
Axis or axes along which to compute percentiles
Tensor containing percentile values
quantile().
Statistical Context: Percentiles are commonly used in standardized testing and growth charts. The 90th percentile means 90% of values are below this point.
const t = tensor([1, 2, 3, 4, 5]);
percentile(t, 50); // tensor([3]) - median
percentile(t, [25, 75]); // tensor([2, 4]) - quartiles
percentile(t, 95); // tensor([4.8]) - 95th percentile