Members
(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);
(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}
二分法 是一种求根方法, 通过反复将区间一分为二来找到函数的根。
该函数返回一个数值近似值。
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 可以包含任意类型的数据。
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}
Parameters:
| Name | Type | Description |
|---|---|---|
x |
number
|
输入值 |
Returns:
- Type:
-
number
标准逻辑分布累积概率
cumulativeStdNormalProbability(z) → {number}
由于无法为每个正态分布打印概率表(因为正态分布有无限多种),通常的做法是将正态分布转换为标准正态分布, 然后使用标准正态分布表查找概率。
你可以使用 .5 + .5 * errorFunction(x / Math.sqrt(2)) 来计算概率,
而不是从表格中查找。
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),即线性时间,与数组的长度成正比。
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。 负值使用欧拉反射公式进行计算。
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算法来选择在等值区域图中 哪些值被分配给哪些颜色。
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
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>>
|
二维数据数组,格式为
|
Returns:
- Type:
-
Object
包含回归直线斜率和截距的对象
Example
linearRegression([[0, 0], [1, 1]]); // => { m: 1, b: 0 }
linearRegressionLine(mb) → {function}
给定 linearRegression 的输出:一个包含 m 和 b 值的对象,
分别表示斜率和截距,生成一个将 x 值转换为 y 值的线性函数。
- Source:
Parameters:
| Name | Type | Description |
|---|---|---|
mb |
Object
|
包含 |
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分位数函数。
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),即线性时间,与数组的长度成正比。
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),即线性时间,与数组的长度成正比。
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()(均值)偏离时,
中位数通常是“中间值”的良好指标。
这是集中趋势的一种度量方法:
用于寻找一组数字的典型或中心值。
中位数不一定是列表中的元素之一:如果列表长度为偶数且两个中心值不同, 则中位数可以是这两个元素的平均值。
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),即线性时间,与数组的长度成正比。
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)复杂度的众数搜索。
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 个标准差范围内。
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|,但存在两个关键问题:
- 当期望值为零时,任何非零实际值都会产生无限大相对误差,这与直觉相悖(如期望电压为0时,测量到0.1伏特不应视为无穷大误差)
- 该公式不满足数学度量的严格定义[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 个元素的数组中创建一个简单随机样本。
采样值可以是任意顺序,不一定与输入中的顺序相同。
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 是一个函数, 用于提取实数的符号
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>
|
点的标签。其长度必须与 |
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),即线性时间,与数组的长度成正比。
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值,对于一定的显著性水平,
可以确定是否拒绝原假设。
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检验。计算过程包含以下步骤:
- 合并两个样本并进行排序
- 处理相同观测值的并列秩次
- 计算指定样本的秩和
- 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