Global

Members

(private, constant) bandwidthMethods

常用带宽选择方法

Source:

(constant) chiSquaredDistributionTable

χ2(卡方)分布的百分位点表

χ2(卡方)分布 常用于以下场景:

  • 检验观测分布与理论分布的拟合优度;
  • 检验定性数据分类标准的独立性;
  • 从样本标准差估计正态分布总体标准差的置信区间。

数据来源于 William W. Hines 和 Douglas C. Montgomery 的《工程与管理科学中的概率与统计》附录1,表III,Wiley(1980)。

Source:

(constant) epsilon

我们使用 ε(epsilon)作为迭代过程中的停止准则,直到我们达到“足够接近”的程度。Epsilon 是一个非常小的数字: 在 simple-statistics 中,这个数字是 0.0001

这个值被用于像二项分布这样的计算中,在这些计算中,寻找值的过程是迭代的: 它会一直进行,直到达到足够接近的程度。

下面是一个在梯度下降中使用 epsilon 的例子, 我们试图找到一个函数导数的局部最小值,该导数由 fDerivative 方法给出。

Source:
Example
// 通过计算,我们预计局部最小值出现在 x=9/4
var x_old = 0;
// 算法从 x=6 开始
var x_new = 6;
var stepSize = 0.01;

function fDerivative(x) {
  return 4 * Math.pow(x, 3) - 9 * Math.pow(x, 2);
}

// 循环会一直运行,直到前一个值与当前值之间的差异小于 epsilon —— 这是“足够接近”的一个粗略衡量标准
while (Math.abs(x_new - x_old) > ss.epsilon) {
  x_old = x_new;
  x_new = x_old - stepSize * fDerivative(x_old);
}

console.log('局部最小值出现在', x_new);

kernelDensityEstimation

核密度估计是 一种通过样本数据估计潜在概率分布形态的非参数方法

Source:

(private, constant) kernels

Source:

(constant) standardNormalTable

标准正态分布表,也称为单位正态表或Z表, 是一个数学表,用于表示Φ(phi)的值,这些值是 累积分布函数 的值。它用于查找统计量在标准正态分布下 低于、高于或介于某些值之间的概率,并由此扩展到任何正态分布。

Source:

Methods

addToMean(mean, n, newValue) → {number}

在向列表中添加新值时,不必重新线性计算列表的均值。 可以通过提供当前均值、生成该均值的列表元素数量以及要添加的新值, 使用此函数计算新的均值。

Since:
  • 2.5.0
Source:
Parameters:
Name Type Description
mean number

当前均值

n number

列表中元素的数量

newValue number

要添加的新值

Returns:
Type:
number

新的均值

Example
addToMean(14, 5, 53); // => 20.5

approxEqual(actual, expected, tolerance) → {boolean}

近似相等。

该函数用于判断两个数值在给定的相对误差范围内是否近似相等。 在统计学和数值分析中,由于浮点数计算的精度限制,直接比较两个数值是否相等可能不适用, 因此通过设定一个容差范围来评估它们的近似相等性。

Source:
Parameters:
Name Type Description
actual number

实际值(待测试的数值)。

expected number

预期值(参考数值)。

tolerance number

容差(可接受的相对差异,默认为 epsilon)。

Returns:
Type:
boolean

如果实际值与预期值之间的相对误差小于或等于容差,则返回 true;否则返回 false。

bernoulliDistribution(p) → {Array.<number>}

伯努利分布 是一个离散概率分布,描述了一个随机变量以成功概率 p 取值为 1, 以失败概率 q = 1 - p 取值为 0 的情况。 它可以用于表示抛硬币实验,其中 "1" 表示 "正面","0" 表示 "反面"(或反之亦然)。 它是二项分布的一个特例,其中试验次数 n = 1。

Source:
Parameters:
Name Type Description
p number

输入值,范围在 0 到 1 之间(包含 0 和 1)

Throws:

如果 p 不在 0 到 1 之间

Type
Error
Returns:
Type:
Array.<number>

在该点的伯努利分布值

Example
bernoulliDistribution(0.3); // => [0.7, 0.3]

binomialDistribution(trials, probability) → {Array.<number>}

二项分布 是离散概率分布, 表示在 n 次相互独立的成功/失败实验中,成功的次数。这类成功/失败实验也称为 伯努利试验(Bernoulli trial);当试验次数 trials = 1 时,二项分布退化为 伯努利分布(Bernoulli Distribution)。

Source:
Parameters:
Name Type Description
trials number

试验次数

probability number

成功的概率

Returns:
Type:
Array.<number>

输出概率分布

bisect(func, start, end, maxIterations, errorTolerance) → {number}

二分法 是一种求根方法, 通过反复将区间一分为二来找到函数的根。

该函数返回一个数值近似值。

Source:
Parameters:
Name Type Description
func function

输入函数

start number

区间起点

end number

区间终点

maxIterations number

最大迭代次数

errorTolerance number

误差容忍度

Throws:

参数 func 必须是一个函数

Type
TypeError
Returns:
Type:
number

估计的根值

Example
bisect(Math.cos,0,4,100,0.003); // => 1.572265625

(private) calculateAllDistances(points) → {Array.<Array.<number>>}

创建全量点间距离查找表

Source:
Parameters:
Name Type Description
points Array.<Array.<number>>

N维数据点的坐标数组

Returns:
Type:
Array.<Array.<number>>

对称方阵形式的点间距离矩阵(主对角线为零)

(private) calculateCentroids(points, labels, numCluster) → {Array.<Array.<number>>}

根据数据点标签计算新的聚类中心

Source:
Parameters:
Name Type Description
points Array.<Array.<number>>

数据点坐标数组

labels Array.<number>

数据点簇标签数组

numCluster number

聚类总数

Throws:

当存在无关联数据点的聚类中心时抛出异常

Type
Error
Returns:
Type:
Array.<Array.<number>>

计算得到的新聚类中心数组

(private) calculateChange(left, right) → {number}

计算新旧聚类中心的总变化量

Source:
Parameters:
Name Type Description
left Array.<Array.<number>>

新聚类中心数组

right Array.<Array.<number>>

旧聚类中心数组

Returns:
Type:
number

聚类中心坐标变化总和

chiSquaredGoodnessOfFit(data, distributionType, significance) → {number}

χ2 (卡方) 拟合优度检验 使用一个拟合优度的度量,该度量是观测频率与期望频率之间差异的平方和, 并除以期望的观测数。由此产生的 χ2 统计量 chiSquared 可以与卡方分布进行比较, 以确定拟合优度。为了确定卡方分布的自由度,取观测频率的总数并减去估计参数的数量。 检验统计量近似服从自由度为 (k − c) 的卡方分布,其中 k 是非空单元格的数量, c 是分布中估计参数的数量。

Source:
Parameters:
Name Type Description
data Array.<number>

数据样本

distributionType function

返回分布在某一点的函数: 例如二项分布、伯努利分布或泊松分布

significance number

显著性水平

Returns:
Type:
number

卡方拟合优度检验结果

Example
// 数据来自 William W. Hines 和 Douglas C. Montgomery 的《工程与管理科学中的概率与统计》中的泊松拟合优度示例 10-19
var data1019 = [
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
    2, 2, 2, 2, 2, 2, 2, 2, 2,
    3, 3, 3, 3
];
ss.chiSquaredGoodnessOfFit(data1019, ss.poissonDistribution, 0.05); //= false

chunk(x, chunkSize) → {Array.<Array>}

将数组按指定大小分割为若干子数组。此函数的行为与PHP的array_chunk函数一致, 因此如果输入数组的长度不能被分割大小整除,则会在末尾插入较小的子数组。

x 应为一个数组,chunkSize 应为一个正整数。 数组 x 可以包含任意类型的数据。

Source:
Parameters:
Name Type Description
x Array

样本数据数组

chunkSize number

每个子数组的大小,必须为正整数

Throws:

如果分割大小小于1或不是整数,则抛出错误

Type
Error
Returns:
Type:
Array.<Array>

分割后的二维数组

Example
chunk([1, 2, 3, 4, 5, 6], 2);
// => [[1, 2], [3, 4], [5, 6]]

ckmeans(x, nClusters) → {Array.<Array.<number>>}

Ckmeans聚类算法是一种基于动态规划的改进聚类方法,相比启发式的Jenks算法更为优化。 该算法由Haizhou Wang和Mingzhou Song 提出,通过最小化组内平方偏差和来实现数值数据的最优分组。

该实现基于Ckmeans 3.4.6版本,采用分治法将时间复杂度从O(kn²)优化至O(kn log(n))。

核心特性

  • 动态规划构建代价矩阵和回溯矩阵
  • 数值稳定性优化:通过中值平移技术
  • 分治策略加速计算过程

参考文献

《Ckmeans.1d.dp: Optimal k-means Clustering in One Dimension by Dynamic Programming》 作者:Haizhou Wang和Mingzhou Song,刊于The R Journal Vol. 3/2, December 2011

Source:
Parameters:
Name Type Description
x Array.<number>

输入数据集(数值数组)

nClusters number

期望的聚类数目(需小于等于数据长度)

Throws:

当请求聚类数大于数据长度时抛出异常

Type
Error
Returns:
Type:
Array.<Array.<number>>

分组后的聚类结果

Example
ckmeans([-1, 2, -1, 2, 4, 5, 6, -1, 2, -1], 3);
// 返回:[[-1, -1, -1, -1], [2, 2, 2], [4, 5, 6]]

coefficientOfVariation(x) → {number}

变异系数_ 是标准差与均值的比值。 .._变异系数: https://en.wikipedia.org/wiki/Coefficient_of_variation

Source:
Parameters:
Name Type Description
x Array

输入数据

Returns:
Type:
number

变异系数

Example
coefficientOfVariation([1, 2, 3, 4]).toFixed(3); // => 0.516
coefficientOfVariation([1, 2, 3, 4, 5]).toFixed(3); // => 0.527
coefficientOfVariation([-1, 0, 1, 2, 3, 4]).toFixed(3); // => 1.247

combinations(x, k) → {Array.<Array>}

组合的实现 组合是集合的唯一子集 - 在本例中,每次从集合中取出 k 个元素。 https://en.wikipedia.org/wiki/Combination

Source:
Parameters:
Name Type Description
x Array

任何类型的数据

k int

每组对象的数量(无放回)

Returns:
Type:
Array.<Array>

组合的数组

Example
combinations([1, 2, 3], 2); // => [[1,2], [1,3], [2,3]]

combinationsReplacement(x, k) → {Array.<Array>}

实现组合的替换版本 组合是集合的唯一子集 - 在此情况下,每次从集合中选取 k 个元素。 '替换'意味着一个给定的元素可以被多次选择。 与排列不同,组合不关心顺序。

Source:
Parameters:
Name Type Description
x Array

任意类型的数据

k int

每组对象的数量(允许重复)

Returns:
Type:
Array.<Array>

组合的数组

Example
combinationsReplacement([1, 2], 2); // => [[1, 1], [1, 2], [2, 2]]

combineMeans(mean1, n1, mean2, n2) → {number}

当需要合并两个已知均值的数值列表时, 不必重新以线性时间计算合并后列表的均值。 可以通过提供第一个列表的均值和数值数量,以及第二个列表的均值和数值数量, 使用此函数来计算合并后的均值。

Since:
  • 3.0.0
Source:
Parameters:
Name Type Description
mean1 number

第一个列表的均值

n1 number

第一个列表中的数值数量

mean2 number

第二个列表的均值

n2 number

第二个列表中的数值数量

Returns:
Type:
number

合并后的均值

Example
combineMeans(5, 3, 4, 3); // => 4.5

combineVariances(variance1, mean1, n1, variance2, mean2, n2) → {number}

当需要合并两个已知方差的数值列表时,不必重新线性计算合并后列表的方差。 可以使用此函数通过提供第一个列表的方差、均值、数量, 以及第二个列表的方差、均值、数量来计算合并后的方差。

Since:
  • 3.0.0
Source:
Parameters:
Name Type Description
variance1 number

第一个列表的方差

mean1 number

第一个列表的均值

n1 number

第一个列表中的项目数量

variance2 number

第二个列表的方差

mean2 number

第二个列表的均值

n2 number

第二个列表中的项目数量

Returns:
Type:
number

合并后的均值

Example
combineVariances(14 / 3, 5, 3, 8 / 3, 4, 3); // => 47 / 12

(private) createGroups(labels) → {Array.<Array.<number>>}

创建组ID到点ID的查找表

Source:
Parameters:
Name Type Description
labels Array.<number>

数据点标签数组,长度必须与points一致, 且取值范围为[0..G-1],其中G为分组总数

Returns:
Type:
Array.<Array.<number>>

长度G的数组,每个元素为对应组内数据点索引的数组

cumulativeStdLogisticProbability(x) → {number}

Source:
Parameters:
Name Type Description
x number

输入值

Returns:
Type:
number

标准逻辑分布累积概率

cumulativeStdNormalProbability(z) → {number}

累积标准正态概率

由于无法为每个正态分布打印概率表(因为正态分布有无限多种),通常的做法是将正态分布转换为标准正态分布, 然后使用标准正态分布表查找概率。

你可以使用 .5 + .5 * errorFunction(x / Math.sqrt(2)) 来计算概率, 而不是从表格中查找。

Source:
Parameters:
Name Type Description
z number

标准正态分布的z值

Returns:
Type:
number

累积标准正态概率

equalIntervalBreaks(x, nClasses) → {Array.<number>}

给定一个数组 x,此函数将找到 x 的范围,并返回一个可用于将 x 分类为多个类别的断点数组。 返回的数组总是比类别数多 1,因为它包含最小值。

Source:
Parameters:
Name Type Description
x Array.<number>

一个数值数组

nClasses number

所需的类别数

Returns:
Type:
Array.<number>

类别断点位置的数组

Example
equalIntervalBreaks([1, 2, 3, 4, 5, 6], 4); // => [1, 2.25, 3.5, 4.75, 6]

errorFunction(x) → {number}

高斯误差函数

errorFunction(x/(sd * Math.sqrt(2))) 表示在标准偏差为 sd 的正态分布中,一个值在距离均值 x 范围内的概率。

该函数返回对精确值的数值近似。它使用 Horner 方法来计算 τ (tau) 的多项式。

Source:
Parameters:
Name Type Description
x number

输入值

Returns:
Type:
number

误差估计值

Example
errorFunction(1).toFixed(2); // => '0.84'

euclideanDistance(left, right) → {number}

计算两个点之间的欧几里得距离。

Source:
Parameters:
Name Type Description
left Array.<number>

第一个N维点。

right Array.<number>

第二个N维点。

Returns:
Type:
number

距离。

extent(x) → {Array.<number>}

计算数组中的最小值和最大值。

该函数的时间复杂度为 O(n),即线性时间,与数组的长度成正比。

Source:
Parameters:
Name Type Description
x Array.<number>

包含一个或多个数据点的样本

Throws:

如果数组 x 的长度小于1

Type
Error
Returns:
Type:
Array.<number>

最小值和最大值

Example
extent([1, 2, 3, 4]);
// => [1, 4]

extentSorted(x) → {Array.<number>}

范围是指数组中的最小值和最大值。对于一个已排序的数组, 数组中的第一个元素始终是最小值,而最后一个元素始终是最大值,因此这个计算可以在一步内完成,即常数时间复杂度。

Source:
Parameters:
Name Type Description
x Array.<number>

输入数组

Returns:
Type:
Array.<number>

最小值和最大值

Example
extentSorted([-100, -10, 1, 2, 5]); // => [-100, 5]

factorial(n) → {number}

阶乘,通常写作 n!,是所有小于或等于 n 的正整数的乘积。 阶乘通常以递归方式实现,但这种迭代方法显著更快且更简单。

Source:
Parameters:
Name Type Description
n number

输入,必须为大于或等于 1 的整数

Throws:

如果 n 小于 0 或不是整数

Type
Error
Returns:
Type:
number

阶乘:n!

Example
factorial(5); // => 120

(private) fillMatrices(data, matrix, backtrackMatrix)

初始化Ckmeans算法的主矩阵并启动分治聚类计算策略

Source:
Parameters:
Name Type Description
data Array.<number>

已排序的数值数组

matrix Array.<Array.<number>>

动态规划矩阵

backtrackMatrix Array.<Array.<number>>

回溯矩阵

(private) fillMatrixColumn(iMin, iMax, cluster, matrix, backtrackMatrix, sums, sumsOfSquares)

递归执行分治策略计算指定簇的矩阵列

Source:
Parameters:
Name Type Description
iMin number

当前簇计算的最小索引

iMax number

当前簇计算的最大索引

cluster number

当前计算的簇索引

matrix Array.<Array.<number>>

动态规划矩阵

backtrackMatrix Array.<Array.<number>>

回溯矩阵

sums Array.<number>

累积和数组

sumsOfSquares Array.<number>

平方累积和数组

gamma(n) → {number}

使用Nemes近似法计算值的伽马函数。 n的伽马函数等价于(n-1)!,但与阶乘函数不同的是,伽马函数对所有实数n(除了零和负整数)都有定义(此时返回NaN)。 注意,伽马函数也对复数有定义,但此实现目前不处理复数作为输入值。 Nemes近似法在这里定义为定理2.2。 负值使用欧拉反射公式进行计算。

Source:
Parameters:
Name Type Description
n number

任何实数,除了零和负整数。

Returns:
Type:
number

输入值的伽马函数值。

Example
gamma(11.5); // 11899423.084037038
gamma(-11.5); // 2.29575810481609e-8
gamma(5); // 24

gammaln(n) → {number}

使用Lanczos近似法计算伽马函数的对数值。 该函数接受任何大于0的实数n作为输入。 该函数对于普通伽马函数无法处理的大数值n(n > 165)非常有用。 代码基于Lanczos的伽马近似法,定义见此处

Source:
Parameters:
Name Type Description
n number

任何大于零的实数。

Returns:
Type:
number

输入值的伽马函数的对数值。

Example
gammaln(500); // 2605.1158503617335
gammaln(2.4); // 0.21685932244884043

geometricMean(x) → {number}

几何平均数是一种适用于不同量级数据的均值计算方法。

该方法计算n个数字乘积的n次方根。

几何平均数在分析**比例增长**时特别有用: 当给定多年增长率(如_80%, 16.66% 和 42.85%_)时,算术平均数会错误估计平均增长率, 而几何平均数能准确计算出与多年增长结果等效的复合增长率。

算法时间复杂度为O(n),与数组长度呈线性关系。

Source:
Parameters:
Name Type Description
x Array.<number>

包含一个或多个数据点的样本

Throws:
  • 当x为空时抛出

    Type
    Error
  • 当x包含负数时抛出

    Type
    Error
Returns:
Type:
number

几何平均数

Example
var growthRates = [1.80, 1.166666, 1.428571];
var averageGrowth = ss.geometricMean(growthRates);
var averageGrowthRates = [averageGrowth, averageGrowth, averageGrowth];
var startingValue = 10;
var startingValueMean = 10;
growthRates.forEach(function(rate) {
  startingValue *= rate;
});
averageGrowthRates.forEach(function(rate) {
  startingValueMean *= rate;
});
startingValueMean === startingValue;

harmonicMean(x) → {number}

调和平均数是一种 通常用于计算比率平均值的均值函数。 该均值通过取输入数字倒数算术平均数的倒数来计算。

这是一种集中趋势度量: 用于寻找一组数字的典型值或中心值的方法。

该函数的时间复杂度为O(n),即线性时间,与数组长度成正比。

Source:
Parameters:
Name Type Description
x Array.<number>

包含一个或多个数据点的样本

Throws:
  • 如果x为空

    Type
    Error
  • 如果x包含负数

    Type
    Error
Returns:
Type:
number

调和平均数

Example
harmonicMean([2, 3]).toFixed(2) // => '2.40'

interquartileRange(x) → {number}

四分位距是 一种衡量统计离散度的指标,用于描述分布的分散、扩展或集中程度。 它通过计算第三四分位数与第一四分位数之间的差值得出。

Source:
Parameters:
Name Type Description
x Array.<number>

包含一个或多个数字的样本

Returns:
Type:
number

四分位距:下四分位数和上四分位数之间的跨度, 分别为0.25和0.75

Example
interquartileRange([0, 1, 2, 3]); // => 2

inverseErrorFunction(x) → {number}

高斯误差函数 返回一个数值近似值,该值会导致errorFunction()返回x。

Source:
Parameters:
Name Type Description
x number

误差函数的值

Returns:
Type:
number

估计的逆值

jenks(data, nClasses) → {Array.<number>}

Jenks自然间断优化算法 是一种常用于制图和可视化中的算法,用于决定数据值的分组,以最小化组内方差并最大化组间差异。

例如,制图师通常使用Jenks算法来选择在等值区域图中 哪些值被分配给哪些颜色。

Source:
Parameters:
Name Type Description
data Array.<number>

输入数据,作为数字值的数组

nClasses number

期望的类别数量

Returns:
Type:
Array.<number>

类别间断点的数组 // 将数据分成3个间断点 jenks([1, 2, 4, 5, 7, 9, 10, 20], 3) // = [1, 7, 20, 20]

kMeansCluster(points, numCluster, randomSource) → {kMeansReturn}

执行k均值聚类算法

Source:
Parameters:
Name Type Description
points Array.<Array.<number>>

待聚类点的N维坐标数组

numCluster number

需要创建的聚类数量

randomSource function

可选随机源,生成[0,1)区间的均匀分布值

Throws:

当存在无关联数据点的聚类中心时抛出异常

Type
Error
Returns:
Type:
kMeansReturn

包含标签数组和聚类中心数组的对象

Example
kMeansCluster([[0.0, 0.5], [1.0, 0.5]], 2); // => {labels: [0, 1], centroids: [[0.0, 0.5], [1.0 0.5]]}

(private) labelPoints(points, centroids) → {Array.<number>}

根据当前聚类中心为数据点分配簇标签

Source:
Parameters:
Name Type Description
points Array.<Array.<number>>

数据点坐标数组

centroids Array.<Array.<number>>

当前聚类中心坐标数组

Returns:
Type:
Array.<number>

数据点对应的簇标签数组

linearRegression(data) → {Object}

简单线性回归 用于在坐标点集中寻找最佳拟合直线。本算法通过最小二乘法 计算回归直线的斜率和截距。

Source:
Parameters:
Name Type Description
data Array.<Array.<number>>

二维数据数组,格式为 [[0, 1], [2, 3]]

Returns:
Type:
Object

包含回归直线斜率和截距的对象

Example
linearRegression([[0, 0], [1, 1]]); // => { m: 1, b: 0 }

linearRegressionLine(mb) → {function}

给定 linearRegression 的输出:一个包含 mb 值的对象, 分别表示斜率和截距,生成一个将 x 值转换为 y 值的线性函数。

Source:
Parameters:
Name Type Description
mb Object

包含 mb 成员的对象,表示所需直线的斜率和截距

Returns:
Type:
function

计算直线上任意给定 x 值对应的 y 值的方法

Example
var l = linearRegressionLine(linearRegression([[0, 0], [1, 1]]));
l(0) // = 0
l(2) // = 2
linearRegressionLine({ b: 0, m: 1 })(1); // => 1
linearRegressionLine({ b: 1, m: 1 })(1); // => 2

logAverage(x) → {number}

对数平均值 是一种适用于大或小乘积数组的几何平均值的等效计算方法。

它通过计算元素的对数平均值并取指数来得到。

Source:
Parameters:
Name Type Description
x Array.<number>

包含一个或多个数据点的样本

Throws:
  • 如果 x 为空

    Type
    Error
  • 如果 x 包含负数

    Type
    Error
Returns:
Type:
number

几何平均值

logit(p) → {number}

Logit 是累积标准Logistic概率的反函数, 也被称为Logistic分位数函数。

Source:
Parameters:
Name Type Description
p number
Returns:
Type:
number

logit

lowerBound(x, value) → {number}

二分查找下界索引(第一个大于等于目标值的位置)

Source:
Parameters:
Name Type Description
x Array.<number>

已排序数组

value number

目标值

Returns:
Type:
number

下界索引

(private) makeMatrix(columns, rows) → {Array.<Array.<number>>}

创建一个新的列 x 行矩阵。

Source:
Parameters:
Name Type Description
columns number

列数

rows number

行数

Returns:
Type:
Array.<Array.<number>>

矩阵

Example
makeMatrix(10, 10);

max(x) → {number}

计算数组中的最大值。

该算法的时间复杂度为 O(n),即线性时间,与数组的长度成正比。

Source:
Parameters:
Name Type Description
x Array.<number>

包含一个或多个数据点的样本

Throws:

如果数组 x 的长度小于 1

Type
Error
Returns:
Type:
number

最大值

Example
max([1, 2, 3, 4]);
// => 4

maxSorted(x) → {number}

最大值是数组中的最高数值。对于已排序的数组, 数组的最后一个元素始终是最大的,因此这个计算 可以在一步内完成,即常数时间复杂度。

Source:
Parameters:
Name Type Description
x Array.<number>

输入数组

Returns:
Type:
number

最大值

Example
maxSorted([-100, -10, 1, 2, 5]); // => 5

mean(x) → {number}

均值,也称为平均数, 是所有值的和除以值的数量。 这是一种集中趋势的度量: 一种寻找一组数字的典型或中心值的方法。

该算法的时间复杂度为O(n),即线性时间,与数组的长度成正比。

Source:
Parameters:
Name Type Description
x Array.<number>

包含一个或多个数据点的样本

Throws:

如果x的长度小于1

Type
Error
Returns:
Type:
number

均值

Example
mean([0, 10]); // => 5

(private) meanDistanceFromPointToGroup(which, group, distances) → {number}

计算点到指定组的平均距离(可包含自身所在组)

Source:
Parameters:
Name Type Description
which number

当前点索引

group Array.<number>

目标组的数据点索引数组

distances Array.<Array.<number>>

对称方阵形式的点间距离矩阵

Returns:
Type:
number

当前点到目标组的平均距离

(private) meanDistanceToNearestGroup(which, labels, groupings, distances) → {number}

计算当前点到最近组(由最近邻点确定)的平均距离

Source:
Parameters:
Name Type Description
which number

当前点索引

labels Array.<number>

数据点标签数组

groupings Array.<Array.<number>>

组结构数组,每个元素为对应组内数据点索引的数组

distances Array.<Array.<number>>

对称方阵形式的点间距离矩阵

Returns:
Type:
number

当前点到最近组的平均距离

meanSimple(x) → {number}

均值(算术平均数)是数据集中所有观测值的总和除以观测数量, 属于集中趋势度量方法, 用于寻找数据集的典型中心值。

本简单均值函数内部采用逐次累加法计算,未考虑浮点加法误差。 如需更高计算精度,应改用标准mean方法。

时间复杂度为O(n),与数组长度成线性关系。

Source:
Parameters:
Name Type Description
x Array.<number>

包含一个或多个数据点的样本

Throws:

当数组为空时抛出异常

Type
Error
Returns:
Type:
number

算术平均数

Example
meanSimple([0, 10]); // => 5

median(x) → {number}

中位数是 一组数字的中间值。当存在异常值导致mean()(均值)偏离时, 中位数通常是“中间值”的良好指标。 这是集中趋势的一种度量方法: 用于寻找一组数字的典型或中心值。

中位数不一定是列表中的元素之一:如果列表长度为偶数且两个中心值不同, 则中位数可以是这两个元素的平均值。

Source:
Parameters:
Name Type Description
x Array.<number>

输入数组

Returns:
Type:
number

中位数值

Example
median([10, 2, 5, 100, 2, 1]); // => 3.5

medianAbsoluteDeviation(x) → {number}

中位绝对偏差是一种 鲁棒的统计离散度量。相比标准差,它对异常值更具抵抗力。

Source:
Parameters:
Name Type Description
x Array.<number>

输入数组

Returns:
Type:
number

中位绝对偏差

Example
medianAbsoluteDeviation([1, 1, 2, 2, 4, 6, 9]); // => 1

medianSorted(sorted) → {number}

中位数是 数据集的中间值。当存在偏离平均值的异常值时, 该指标能更好地反映数据的中心位置。属于 集中趋势度量方法, 用于寻找数据集的典型中心值。

中位数不一定是数据集中的元素:当数据量为偶数时, 其值可能为两个中间元素的平均值。

Source:
Parameters:
Name Type Description
sorted Array.<number>

已排序数组

Returns:
Type:
number

中位数值

Example
medianSorted([10, 2, 5, 100, 2, 1]); // => 52.5

min(x) → {number}

最小值是数组中的最低数字。 该算法的时间复杂度为 O(n),即线性时间,与数组的长度成正比。

Source:
Parameters:
Name Type Description
x Array.<number>

包含一个或多个数据点的样本

Throws:

如果数组 x 的长度小于1

Type
Error
Returns:
Type:
number

最小值

Example
min([1, 5, -10, 100, 2]); // => -10

minSorted(x) → {number}

最小值是数组中的最小数字。对于一个已排序的数组, 数组的第一个元素总是最小的,因此这个计算可以在一步内完成,即常数时间复杂度。

Source:
Parameters:
Name Type Description
x Array.<number>

输入数组

Returns:
Type:
number

最小值

Example
minSorted([-100, -10, 1, 2, 5]); // => -100

mode(x) → {number}

众数是 数据集中出现频率最高的元素。当存在多个相同频率的众数时, 本算法将返回最后遇到的那个值。

这是集中趋势度量方法, 用于寻找数据集的典型中心值。

本算法时间复杂度为O(n log(n)),因为需要先对数组进行排序, 再进行O(n)复杂度的众数搜索。

Source:
Parameters:
Name Type Description
x Array.<number>

输入数组

Returns:
Type:
number

众数

Example
mode([0, 0, 1]); // => 0

modeFast(x) → (nullable) {*}

众数是 数据集中出现频率最高的元素。一个数据集可能包含 多个众数:当出现频率相同时,本算法将返回最近遇到的众数。

modeFast使用Map对象替代mode方法的排序数组方案来跟踪状态, 因此效率更高且支持所有可通过==比较的数据类型。 要求 JavaScript环境支持Map对象, 若不可用将抛出错误。

这是集中趋势度量方法, 用于寻找数据集的典型中心值。

Source:
Parameters:
Name Type Description
x Array.<*>

包含一个或多个数据点的样本数组

Throws:
  • 当JavaScript环境不支持Map时抛出

    Type
    ReferenceError
  • 输入数组为空时抛出

    Type
    Error
Returns:
Type:
*

众数

Example
modeFast(['rabbits', 'rabbits', 'squirrels']); // => 'rabbits'

modeSorted(sorted) → {number}

众数是数据集中出现次数最多的数值。 一个数据集可能存在多个众数:当出现频率相同的多个值时,本算法将返回最后出现的众数。 这是集中趋势的度量方法: 用于寻找数据集的典型值或中心值。

由于输入已排序,算法时间复杂度为O(n)

Source:
Parameters:
Name Type Description
sorted Array.<number>

已排序的数据样本(需包含至少一个数据点)

Throws:

当输入为空时抛出错误

Type
Error
Returns:
Type:
number

众数值

Example
modeSorted([0, 0, 1]); // => 0

multiQuantileSelect(arr, p)

多分位点选择优化算法

Source:
Parameters:
Name Type Description
arr Array

目标数组

p Array

分位点数组

(private) numericSort(x) → {Array.<number>}

对数字数组按其数值大小进行排序,确保数组不会原地修改。

这是必要的,因为 JavaScript 中 .sort 的默认行为是将数组作为字符串值进行排序

[1, 10, 12, 102, 20].sort()
// 输出
[1, 10, 102, 12, 20]
Source:
Parameters:
Name Type Description
x Array.<number>

输入数组

Returns:
Type:
Array.<number>

排序后的数组

Example
numericSort([3, 2, 1]) // => [1, 2, 3]

permutationTest(sampleX, sampleY, alternative, k, randomSourceopt) → {number}

执行置换检验 用于判断两个数据集是否具有显著性差异,使用组间均值差作为检验统计量。 支持以下假设类型:

  • two_side = 零假设:两个分布相同(双尾检验)
  • greater = 零假设:样本X观测值通常小于样本Y(右尾检验)
  • less = 零假设:样本X观测值通常大于样本Y(左尾检验) 了解单尾与双尾检验的区别
Source:
Parameters:
Name Type Attributes Default Description
sampleX Array.<number>

第一数据集(如实验组)

sampleY Array.<number>

第二数据集(如对照组)

alternative string

备择假设类型,可选'two_sided'(默认), 'greater', 或'less'

k number

置换分布生成值数量

randomSource function <optional>
Math.random

可选随机源

Returns:
Type:
number

p值 在零假设下观测到当前(或更极端)组间差异的概率

Example
var control = [2, 5, 3, 6, 7, 2, 5];
var treatment = [20, 5, 13, 12, 7, 2, 2];
permutationTest(control, treatment); // ~0.1324

permutationsHeap(elements) → {Array.<Array>}

Heap算法的实现, 用于生成排列。

Source:
Parameters:
Name Type Description
elements Array

任意类型的数据

Returns:
Type:
Array.<Array>

排列的数组

poissonDistribution(lambda) → {Array.<number>}

泊松分布是离散概率分布, 表示在固定时间/空间间隔内事件发生次数的概率,当事件以已知平均速率独立发生时适用。 其特征由严格正数的平均到达率(发生率)λ决定。

Source:
Parameters:
Name Type Description
lambda number

泊松分布参数(事件平均发生率)

Returns:
Type:
Array.<number>

泊松分布概率值数组

probit(p) → {number}

Probit 是 cumulativeStdNormalProbability() 的反函数, 也被称为正态分位数函数。

它返回与均值相差的标准差数量,表示在正态分布中可以找到第 p 个分位数的位置。 例如,probit(0.5 + 0.6827/2) ≈ 1,因为 68.27% 的值通常分布在均值上下 1 个标准差范围内。

Source:
Parameters:
Name Type Description
p number
Returns:
Type:
number

probit

product(x) → {number}

乘积 是一个数组中所有数字相乘的结果,从1作为乘法单位元开始。

该算法的时间复杂度为 O(n),即线性时间,与数组的长度成正比。

Source:
Parameters:
Name Type Description
x Array.<number>

输入数组

Returns:
Type:
number

输入数组中所有数字的乘积

Example
product([1, 2, 3, 4]); // => 24

quantile(x, p) → {number}

分位数计算函数: 本实现基于总体分位数算法,假设已知完整数据集。遵循维基百科 总体分位数算法。

Source:
Parameters:
Name Type Description
x Array.<number>

数值型数据数组(需包含至少一个元素)

p Array.<number> | number

分位点或分位点数组(取值范围[0,1])

Returns:
Type:
number

分位数值或分位数数组

Example
quantile([3, 6, 7, 8, 8, 9, 10, 13, 15, 16, 20], 0.5); // => 9

quantileIndex(len, p) → {number}

分位数索引计算函数

Source:
Parameters:
Name Type Description
len number

数组长度

p number

分位点

Returns:
Type:
number

计算后的索引值

quantileRank(x) → {number}

该函数返回给定值在给定数组中的分位数位置。它会在每次运行前复制并排序数组, 因此如果你知道数组已经排序,应该使用 quantileRankSorted 代替。

Source:
Parameters:
Name Type Description
x Array.<number>

输入数组

Returns:
Type:
number

Example
quantileRank([4, 3, 1, 2], 3); // => 0.75
quantileRank([4, 3, 2, 3, 1], 3); // => 0.7
quantileRank([2, 4, 1, 3], 6); // => 1
quantileRank([5, 3, 1, 2, 3], 4); // => 0.8

quantileRankSorted(x, value) → {number}

本函数计算给定值在已排序数组中的分位数排名。通过二分查找算法,可在对数时间内完成计算。

Source:
Parameters:
Name Type Description
x Array.<number>

已排序输入数组

value number

目标数值

Returns:
Type:
number

分位数排名(范围[0,1])

Example
quantileRankSorted([1, 2, 3, 4], 3); // => 0.75
quantileRankSorted([1, 2, 3, 3, 4], 3); // => 0.7
quantileRankSorted([1, 2, 3, 4], 6); // => 1
quantileRankSorted([1, 2, 3, 3, 5], 4); // => 0.8

quantileSelect(arr, k, left, right)

分位数选择函数(基于快速选择算法)

Source:
Parameters:
Name Type Description
arr Array

目标数组

k number

目标索引

left number

左边界

right number

右边界

quantileSorted(x, p) → {number}

分位数计算内部实现(输入已排序数组时可避免重复排序,提升计算效率)

Source:
Parameters:
Name Type Description
x Array.<number>

已排序数据样本(需包含至少一个数据点)

p number

分位点:取值范围[0, 1]的数值

Throws:
  • 当p超出[0,1]范围时抛出错误

    Type
    Error
  • 当输入数组为空时抛出错误

    Type
    Error
Returns:
Type:
number

分位数值

Example
quantileSorted([3, 6, 7, 8, 8, 9, 10, 13, 15, 16, 20], 0.5); // => 9

quickselect(arr, k, leftopt, rightopt) → {void}

重新排列 arr 中的元素,使得 [left, k] 范围内的所有元素都是最小的。 第 k 个元素将是 [left, right] 范围内第 (k - left + 1) 小的值。

实现 Floyd-Rivest 选择算法 https://en.wikipedia.org/wiki/Floyd-Rivest_algorithm

Source:
Parameters:
Name Type Attributes Description
arr Array.<number>

输入数组

k number

枢轴索引

left number <optional>

左索引

right number <optional>

右索引

Returns:
Type:
void

会修改输入数组

Example
var arr = [65, 28, 59, 33, 21, 56, 22, 95, 50, 12, 90, 53, 28, 77, 39];
quickselect(arr, 8);
// = [39, 28, 28, 33, 21, 12, 22, 50, 53, 56, 59, 65, 90, 77, 95]

rSquared(x, func) → {number}

决定系数(R²) 用于评估回归函数f对数据的拟合程度,计算预测值与实际值的平方差异和。

Source:
Parameters:
Name Type Description
x Array.<Array.<number>>

输入数据:二维数组结构,每项格式为[自变量, 因变量]

func function

回归函数(接受自变量值返回预测值)

Returns:
Type:
number

R²值(范围[0,1])

Example
var samples = [[0, 0], [1, 1]];
var regressionLine = linearRegressionLine(linearRegression(samples));
rSquared(samples, regressionLine); // = 1 表示完美拟合

relativeError(actual, expected) → {number}

相对误差计算函数。

相对误差计算比表面更为复杂[1,2]。传统计算公式为|(A-E)/E|,但存在两个关键问题:

  1. 当期望值为零时,任何非零实际值都会产生无限大相对误差,这与直觉相悖(如期望电压为0时,测量到0.1伏特不应视为无穷大误差)
  2. 该公式不满足数学度量的严格定义[3]。[4]提出使用|ln(|A/E|)|定义,但仅适用于正值场景(如-10与10的误差会被误判为0)

本实现遵循常规方案:

  • 当实际值与期望值均为零时返回0
  • 当期望值为零而实际值非零时返回Infinity
  • 其他情况返回|(A-E)/E|

[1] 零点相对误差计算问题 https://math.stackexchange.com/questions/677852/how-to-calculate-relative-error-when-true-value-is-zero [2] 相对变化与差异 https://en.wikipedia.org/wiki/Relative_change_and_difference [3] 数学度量定义 https://en.wikipedia.org/wiki/Metric_(mathematics)#Definition [4] F.W.J.奥尔弗,《误差算术新方法》SIAM数值分析期刊, 15(2), 1978, DOI:10.1137/0715024

Source:
Parameters:
Name Type Description
actual number

实际测量值

expected number

期望理论值

Returns:
Type:
number

相对误差计算结果

rootMeanSquare(x) → {number}

均方根(Root Mean Square, RMS)是一种均值函数, 用于衡量一组数的大小,而不考虑它们的符号。 它是输入数值平方的平均值的平方根。 该算法的时间复杂度为 O(n),即线性时间,与数组的长度成正比。

Source:
Parameters:
Name Type Description
x Array.<number>

包含一个或多个数据点的样本

Throws:

如果 x 为空

Type
Error
Returns:
Type:
number

均方根

Example
rootMeanSquare([-1, 1, -1, 1]); // => 1

sample(x, n, randomSourceopt) → {Array}

从给定的包含 n 个元素的数组中创建一个简单随机样本

采样值可以是任意顺序,不一定与输入中的顺序相同。

Source:
Parameters:
Name Type Attributes Default Description
x Array.<any>

输入数组,可以包含任何类型

n number

需要采样的元素数量

randomSource function <optional>
Math.random

一个可选的熵源,返回 [0, 1) 范围内的数字

Returns:
Type:
Array

原始数组中的 n 个元素的子集

Example
var values = [1, 2, 4, 5, 6, 7, 8, 9];
sample(values, 3); // 返回 3 个随机值,例如 [2, 5, 8];

sampleCorrelation(x, y) → {number}

相关系数是衡量两个数据集相关性的指标,取值范围在-1到1之间

Source:
Parameters:
Name Type Description
x Array.<number>

第一个输入数据集

y Array.<number>

第二个输入数据集

Returns:
Type:
number

样本相关系数

Example
sampleCorrelation([1, 2, 3, 4, 5, 6], [2, 2, 3, 4, 5, 60]).toFixed(2);
// => '0.69'

sampleCovariance(x, y) → {number}

样本协方差计算两个数据集的协同变化程度: 评估两个数据集的变动趋势是否一致。 x 和 y 是两个数据集,表示为数值数组。

Source:
Parameters:
Name Type Description
x Array.<number>

至少包含两个数据点的样本数据

y Array.<number>

至少包含两个数据点的样本数据

Throws:
  • 如果 x 和 y 的长度不相等

    Type
    Error
  • 如果 x 或 y 的长度小于 2

    Type
    Error
Returns:
Type:
number

样本协方差

Example
sampleCovariance([1, 2, 3, 4, 5, 6], [6, 5, 4, 3, 2, 1]); // => -3.5

sampleKurtosis(x) → {number}

峰度 是 衡量分布尾部相对于其方差的厚度的指标。峰度值可以是正数、负数,甚至未定义。

实现基于 Fisher 的超额峰度定义,并使用无偏矩估计。这是 Excel 中使用的版本, 并在多个统计软件包中可用,包括 SAS 和 SciPy。

Source:
Parameters:
Name Type Description
x Array.<number>

包含 4 个或更多数据点的样本

Throws:

如果 x 的长度小于 4

Type
Error
Returns:
Type:
number

样本峰度

Example
sampleKurtosis([1, 2, 2, 3, 5]); // => 1.4555765595463122

sampleRankCorrelation(x, y) → {number}

秩相关系数是 衡量两个数组之间单调关系强度的指标

Source:
Parameters:
Name Type Description
x Array.<number>

第一个输入数组

y Array.<number>

第二个输入数组

Returns:
Type:
number

样本秩相关系数

sampleSkewness(x) → {number}

偏度 是衡量实值随机变量的概率分布 在均值一侧“倾斜”程度的统计量。 偏度的值可以为正、负,甚至未定义。

该实现基于调整后的 Fisher-Pearson 标准化矩系数, 该方法被 Excel 及多个统计软件(如 Minitab、SAS 和 SPSS)采用。

Since:
  • 4.1.0
Source:
Parameters:
Name Type Description
x Array.<number>

至少包含 3 个数据点的样本数据

Throws:

如果 x 的长度小于 3

Type
Error
Returns:
Type:
number

样本偏度

Example
sampleSkewness([2, 4, 6, 3, 1]); // => 0.590128656384365

sampleStandardDeviation(x) → {number}

样本标准差 是样本方差的平方根。

Source:
Parameters:
Name Type Description
x Array.<number>

输入数组

Returns:
Type:
number

样本标准差

Example
sampleStandardDeviation([2, 4, 4, 4, 5, 5, 7, 9]).toFixed(2);
// => '2.14'

sampleVariance(x) → {number}

样本方差 是各数据点与均值偏离程度的平方和。样本方差通过贝塞尔校正 与普通方差区分:不使用输入数据长度直接除平方和,而是采用长度减一作为除数。 该方法可修正从未知完整性的数据集中进行估计时产生的偏差。

参考文献:

Source:
Parameters:
Name Type Description
x Array.<number>

包含两个及以上数据点的样本集

Throws:

当输入数据长度小于2时抛出异常

Type
Error
Returns:
Type:
number

样本方差值

Example
sampleVariance([1, 2, 3, 4, 5]); // => 2.5

sampleWithReplacement(x, n, randomSourceopt) → {Array}

有放回抽样是一种允许从总体中多次抽取同一项目的抽样方法。

Source:
Parameters:
Name Type Attributes Default Description
x Array.<*>

任意类型的数组

n number

需要抽取的元素数量

randomSource function <optional>
Math.random

一个可选的熵源,返回介于0(包含)和1(不包含)之间的数字:[0, 1)

Returns:
Type:
Array

从总体中抽取的n个样本

Example
var values = [1, 2, 3, 4];
sampleWithReplacement(values, 2); // 返回2个随机值,例如 [2, 4];

shuffle(x, randomSourceopt) → {Array}

Fisher-Yates shuffle 是一种快速生成有限集合随机排列的方法。 这是一个围绕 shuffle_in_place 的函数,保证不会修改输入。

Source:
Parameters:
Name Type Attributes Default Description
x Array

包含0个或多个数字的样本

randomSource function <optional>
Math.random

一个可选的熵源,返回范围在 [0, 1) 之间的数字

Returns:
Type:
Array

输入数组的随机排列版本

Example
var shuffled = shuffle([1, 2, 3, 4]);
shuffled; // = [2, 3, 1, 4] 或其他随机排列

shuffleInPlace(x, randomSourceopt) → {Array}

费舍尔-耶茨洗牌算法 原地洗牌实现(直接修改原始数组顺序)

该算法用于生成集合的随机排列。 注意:此方法会通过引用直接修改原始数组顺序。

Source:
Parameters:
Name Type Attributes Default Description
x Array

包含一个或多个数值的样本集

randomSource function <optional>
Math.random

可选随机数源,需返回[0,1)区间的数值

Returns:
Type:
Array

原数组x(已洗牌)

Example
var x = [1, 2, 3, 4];
shuffleInPlace(x);
// x将被洗牌为类似[2, 1, 4, 3]的随机排列

(private) sign(x) → {number}

Sign 是一个函数, 用于提取实数的符号

Source:
Parameters:
Name Type Description
x number

输入值

Throws:

如果输入参数 x 不是数字

Type
TypeError
Returns:
Type:
number

符号值,可能是 1、0 或 -1

Example
sign(2); // => 1

silhouette(points, labels) → {Array.<number>}

计算聚类数据的轮廓系数

Source:
Parameters:
Name Type Description
points Array.<Array.<number>>

N维数据点的坐标数组

labels Array.<number>

数据点标签数组,长度必须与points一致, 且取值范围为[0..G-1],其中G为分组总数

Returns:
Type:
Array.<number>

各数据点的轮廓系数值

Example
silhouette([[0.25], [0.75]], [0, 0]); // => [1.0, 1.0]

silhouetteMetric(points, labels) → {number}

计算一组N维点的轮廓系数。 该指标是数据中最大的单个轮廓值。

Source:
Parameters:
Name Type Description
points Array.<Array.<number>>

N维点的坐标。

labels Array.<number>

点的标签。其长度必须与points相同, 并且值必须在[0..G-1]范围内,其中G是组的数量。

Returns:
Type:
number

分组的轮廓系数。

Example
silhouetteMetric([[0.25], [0.75]], [0, 0]); // => 1.0

(private) ssq(j, i, sums, sumsOfSquares) → {number}

基于数据数组的累积和及平方累积和,生成增量计算值

Source:
Parameters:
Name Type Description
j number

起始索引

i number

结束索引

sums Array.<number>

累积和数组

sumsOfSquares Array.<number>

平方累积和数组

Returns:
Type:
number

计算得到的平方偏差值

Example
ssq(0, 1, [-1, 0, 2], [1, 1, 5]);

standardDeviation(x) → {number}

标准差 是方差的平方根。这也被称为总体标准差。它用于衡量一组值中的变异或离散程度。

标准差仅适用于全总体数据:对于样本数据,使用 sampleStandardDeviation 更为合适。

Source:
Parameters:
Name Type Description
x Array.<number>

输入数组

Returns:
Type:
number

标准差

Example
variance([2, 4, 4, 4, 5, 5, 7, 9]); // => 4
standardDeviation([2, 4, 4, 4, 5, 5, 7, 9]); // => 2

subtractFromMean(mean, n, value) → {number}

当从列表中移除一个值时,不必线性地重新计算列表的均值。相反,可以通过提供当前均值、 列表中的元素数量以及要移除的值,使用此函数来计算新的均值。

Since:
  • 3.0.0
Source:
Parameters:
Name Type Description
mean number

当前均值

n number

列表中的元素数量

value number

要移除的值

Returns:
Type:
number

新的均值

Example
subtractFromMean(20.5, 6, 53); // => 14

sum(x) → {number}

我们的默认求和算法是 Kahan-Babuska算法。 该算法是对经典的 Kahan求和算法 的改进。 它旨在计算一组数字的总和,同时纠正浮点误差。传统上,求和是通过多次连续的加法运算来完成的,每次加法都会产生自己的浮点舍入误差。 随着数字数量的增加,这些精度损失会累积。该替代算法比简单的加法求和更精确。

该算法的时间复杂度为 O(n),即线性时间,与数组的长度成正比。

Source:
Parameters:
Name Type Description
x Array.<number>

输入数组

Returns:
Type:
number

所有输入数字的总和

Example
sum([1, 2, 3]); // => 6

sumNthPowerDeviations(x, n) → {number}

计算N次方偏差之和 当n=2时为平方偏差之和 当n=3时为立方偏差之和

Source:
Parameters:
Name Type Description
x Array.<number>

数据数组

n number

次方数

Returns:
Type:
number

N次方偏差之和

Example
var input = [1, 2, 3];
// 由于数据集的方差是均方偏差,可以通过sumNthPowerDeviations计算:
sumNthPowerDeviations(input, 2) / input.length;

sumSimple(x) → {number}

简单的求和操作, 即将数组中的所有数字相加,从零开始。

该算法的时间复杂度为 O(n),即线性时间,与数组的长度成正比。

Source:
Parameters:
Name Type Description
x Array.<number>

输入数组

Returns:
Type:
number

所有输入数字的和

Example
sumSimple([1, 2, 3]); // => 6

tTest(x, expectedValue) → {number}

用于计算单样本t检验,将样本均值与已知值x进行比较。

在这种情况下,我们试图确定总体均值是否等于我们已知的值,即这里的x。 通常,这里的结果用于查找p值,对于一定的显著性水平, 可以确定是否拒绝原假设。

Source:
Parameters:
Name Type Description
x Array.<number>

一个或多个数字的样本

expectedValue number

总体均值的期望值

Returns:
Type:
number

t值

Example
tTest([1, 2, 3, 4, 5, 6], 3.385).toFixed(2); // => '0.16'

tTestTwoSample(sampleX, sampleY, differenceopt) → {number|null}

本函数用于计算双样本t检验 检验"mean(X)-mean(Y) = difference"的假设(最常见情况是当difference == 0时, 检验两个样本是否可能来自具有相同均值的总体),在未知两样本标准差但假设它们具有相同标准差时使用。

通常计算结果用于查找P值, 根据给定的显著性水平判断是否可以拒绝零假设。

当差值为0时,diff参数可省略。

本检验用于拒绝 样本X和样本Y来自相同总体均值的零假设。

Source:
Parameters:
Name Type Attributes Default Description
sampleX Array.<number>

样本数据,以数字数组表示

sampleY Array.<number>

样本数据,以数字数组表示

difference number <optional>
0

期望均值差

Returns:
Type:
number | null

检验统计量

Example
tTestTwoSample([1, 2, 3, 4], [3, 4, 5, 6], 0); // => -2.1908902300206643

uniqueCountSorted(x) → {number}

对于一个已排序的输入,计算唯一值的数量可以在常数时间和常数内存内完成。 这是该算法的一个简单实现。

值使用 === 进行比较,因此对象和非原始对象不会以任何特殊方式处理。

Source:
Parameters:
Name Type Description
x Array.<*>

包含任意类型值的数组

Returns:
Type:
number

唯一值的数量

Example
uniqueCountSorted([1, 2, 3]); // => 3
uniqueCountSorted([1, 1, 1]); // => 1

upperBound(x, value) → {number}

二分查找上界索引(第一个大于目标值的位置)

Source:
Parameters:
Name Type Description
x Array.<number>

已排序数组

value number

目标值

Returns:
Type:
number

上界索引

variance(x) → {number}

方差 是数据点与均值之间偏差的平方和。

这是方差的实现,不是样本方差: 如果你需要一个样本度量,请使用 sampleVariance 方法。

Source:
Parameters:
Name Type Description
x Array.<number>

一个包含一个或多个数据点的总体

Throws:

如果 x 的长度为 0

Type
Error
Returns:
Type:
number

方差:一个大于或等于零的值。 零表示所有值都相同。

Example
variance([1, 2, 3, 4, 5, 6]); // => 2.9166666666666665

wilcoxonRankSum(sampleX, sampleY) → {number}

本函数计算第一个样本相对于第二个样本的威尔科克森秩和统计量。 该检验是t检验的非参数替代方法,等价于曼-惠特尼U检验。计算过程包含以下步骤:

  1. 合并两个样本并进行排序
  2. 处理相同观测值的并列秩次
  3. 计算指定样本的秩和
Source:
Parameters:
Name Type Description
sampleX Array.<number>

第一个样本数值数组

sampleY Array.<number>

第二个样本数值数组

Returns:
Type:
number

样本X的秩和统计量

Example
wilcoxonRankSum([1, 4, 8], [9, 12, 15]); // => 6

zScore(x, mean, standardDeviation) → {number}

Z分数(标准分数)计算函数。

标准分数表示观测值与均值的偏离程度,以标准差为单位计量。正值表示高于均值, 负值表示低于均值。其计算方式为:原始分数减去总体均值,再除以总体标准差, 结果为无量纲量。

注意:Z分数的计算需要已知总体参数(μ和σ);若仅有样本数据, 使用样本均值和样本标准差计算将得到学生t统计量。

Source:
Parameters:
Name Type Description
x number

观测值

mean number

总体均值

standardDeviation number

总体标准差

Returns:
Type:
number

Z分数

Example
zScore(78, 80, 5); // => -0.4

Type Definitions

kMeansReturn

Properties:
Name Type Description
labels Array.<number>

数据点所属簇的标签数组

centroids Array.<Array.<number>>

聚类中心坐标数组

Source:
Type:
  • Object