SciPy-1-12-中文文档-十八-
SciPy 1.12 中文文档(十八)
scipy.special.fdtr
原文:
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.fdtr.html#scipy.special.fdtr
scipy.special.fdtr(dfn, dfd, x, out=None) = <ufunc 'fdtr'>
F 累积分布函数。
返回 F 分布的累积分布函数值,也称为斯内德科尔 F 分布或费舍尔-斯内德科尔分布。
参数 (d_n) 和 (d_d) 的 F 分布是随机变量的分布,
[X = \frac{U_n/d_n}{U_d/d_d},]
其中 (U_n) 和 (U_d) 是分别具有 (d_n) 和 (d_d) 自由度的随机变量 (\chi²) 分布。
参数:
dfn 数组类
第一个参数(正浮点数)。
dfd 数组类
第二个参数(正浮点数)。
x 数组类
参数(非负浮点数)。
out ndarray,可选
可选输出数组用于函数值。
返回:
y 标量或 ndarray
F-分布的累积分布函数,参数为 dfn 和 dfd,在 x 处的值。
另请参阅
fdtrc
F 分布的生存函数。
fdtri
F 分布的反累积分布函数。
scipy.stats.f
F 分布
注意
根据以下公式使用正则化不完全贝塔函数,
[F(d_n, d_d; x) = I_{xd_n/(d_d + xd_n)}(d_n/2, d_d/2).]
Cephes 的包装器 [1],用于调用 fdtr
函数。F 分布也可以通过 scipy.stats.f
获得。直接调用 fdtr
可以提高性能,与 scipy.stats.f
的 cdf
方法相比(见下面的最后一个例子)。
参考文献
[1]
Cephes 数学函数库,www.netlib.org/cephes/
示例
计算 dfn=1
和 dfd=2
时 x=1
处的函数值。
>>> import numpy as np
>>> from scipy.special import fdtr
>>> fdtr(1, 2, 1)
0.5773502691896258
通过提供 NumPy 数组 x 来计算多个点的函数值。
>>> x = np.array([0.5, 2., 3.])
>>> fdtr(1, 2, x)
array([0.4472136 , 0.70710678, 0.77459667])
绘制多个参数集的函数。
>>> import matplotlib.pyplot as plt
>>> dfn_parameters = [1, 5, 10, 50]
>>> dfd_parameters = [1, 1, 2, 3]
>>> linestyles = ['solid', 'dashed', 'dotted', 'dashdot']
>>> parameters_list = list(zip(dfn_parameters, dfd_parameters,
... linestyles))
>>> x = np.linspace(0, 30, 1000)
>>> fig, ax = plt.subplots()
>>> for parameter_set in parameters_list:
... dfn, dfd, style = parameter_set
... fdtr_vals = fdtr(dfn, dfd, x)
... ax.plot(x, fdtr_vals, label=rf"$d_n={dfn},\, d_d={dfd}$",
... ls=style)
>>> ax.legend()
>>> ax.set_xlabel("$x$")
>>> ax.set_title("F distribution cumulative distribution function")
>>> plt.show()
F 分布也可以通过 scipy.stats.f
获得。直接使用 fdtr
比调用 scipy.stats.f
的 cdf
方法更快,特别是对于小数组或单个值。为了获得相同的结果,必须使用以下参数化形式:stats.f(dfn, dfd).cdf(x)=fdtr(dfn, dfd, x)
。
>>> from scipy.stats import f
>>> dfn, dfd = 1, 2
>>> x = 1
>>> fdtr_res = fdtr(dfn, dfd, x) # this will often be faster than below
>>> f_dist_res = f(dfn, dfd).cdf(x)
>>> fdtr_res == f_dist_res # test that results are equal
True
scipy.special.gdtr
原文链接:
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.gdtr.html#scipy.special.gdtr
scipy.special.gdtr(a, b, x, out=None) = <ufunc 'gdtr'>
伽马分布的累积分布函数。
返回从零到x的伽马概率密度函数的积分,
[F = \int_0^x \frac{a^b}{\Gamma(b)} t^{b-1} e^{-at},dt,]
其中(\Gamma)为伽马函数。
参数:
a 类型为 array_like
伽马分布的率参数,有时标记为(\beta)(浮点数)。它也是尺度参数(\theta)的倒数。
b 类型为 array_like
伽马分布的形状参数,有时标记为(\alpha)(浮点数)。
x 类型为 array_like
分位数(积分的上限;浮点数)。
out ndarray,可选
可选的输出数组用于函数值
返回:
F标量或者 ndarray
参数为a和b的伽马分布的累积分布函数在x处的值。
参见
gdtrc
伽马分布的累积分布的补函数。
scipy.stats.gamma
伽马分布
注意事项
评估使用到不完全伽马积分(正则化伽马函数)的关系。
Cephes 库的包装器[1] gdtr
函数。直接调用gdtr
可以改善性能,与scipy.stats.gamma
的cdf
方法相比(见下面的最后一个示例)。
参考文献
[1]
Cephes 数学函数库,www.netlib.org/cephes/
示例
计算a=1
,b=2
,x=5
处的函数值。
>>> import numpy as np
>>> from scipy.special import gdtr
>>> import matplotlib.pyplot as plt
>>> gdtr(1., 2., 5.)
0.9595723180054873
通过提供 NumPy 数组x,计算a=1
和b=2
的函数值在几个点上。
>>> xvalues = np.array([1., 2., 3., 4])
>>> gdtr(1., 1., xvalues)
array([0.63212056, 0.86466472, 0.95021293, 0.98168436])
gdtr
可以通过提供适合广播的形状的数组来评估不同的参数集合,用于a、b和x。在这里,我们计算三个不同a在四个位置x和b=3
的函数值,得到一个 3x4 数组。
>>> a = np.array([[0.5], [1.5], [2.5]])
>>> x = np.array([1., 2., 3., 4])
>>> a.shape, x.shape
((3, 1), (4,))
>>> gdtr(a, 3., x)
array([[0.01438768, 0.0803014 , 0.19115317, 0.32332358],
[0.19115317, 0.57680992, 0.82642193, 0.9380312 ],
[0.45618688, 0.87534798, 0.97974328, 0.9972306 ]])
绘制四组不同参数设置下的函数图。
>>> a_parameters = [0.3, 1, 2, 6]
>>> b_parameters = [2, 10, 15, 20]
>>> linestyles = ['solid', 'dashed', 'dotted', 'dashdot']
>>> parameters_list = list(zip(a_parameters, b_parameters, linestyles))
>>> x = np.linspace(0, 30, 1000)
>>> fig, ax = plt.subplots()
>>> for parameter_set in parameters_list:
... a, b, style = parameter_set
... gdtr_vals = gdtr(a, b, x)
... ax.plot(x, gdtr_vals, label=f"$a= {a},\, b={b}$", ls=style)
>>> ax.legend()
>>> ax.set_xlabel("$x$")
>>> ax.set_title("Gamma distribution cumulative distribution function")
>>> plt.show()
伽马分布也可以使用scipy.stats.gamma
获得。直接使用gdtr
比调用scipy.stats.gamma
的cdf
方法要快得多,特别是对于小数组或单个值。要获得相同的结果,必须使用以下参数化方法:stats.gamma(b, scale=1/a).cdf(x)=gdtr(a, b, x)
。
>>> from scipy.stats import gamma
>>> a = 2.
>>> b = 3
>>> x = 1.
>>> gdtr_result = gdtr(a, b, x) # this will often be faster than below
>>> gamma_dist_result = gamma(b, scale=1/a).cdf(x)
>>> gdtr_result == gamma_dist_result # test that results are equal
True
scipy.special.gdtrc
原文链接:
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.gdtrc.html#scipy.special.gdtrc
scipy.special.gdtrc(a, b, x, out=None) = <ufunc 'gdtrc'>
Gamma 分布生存函数。
gamma 概率密度函数的从 x 到无穷大的积分,
[F = \int_x^\infty \frac{a^b}{\Gamma(b)} t^{b-1} e^{-at},dt,]
这里 (\Gamma) 是 gamma 函数。
参数:
aarray_like
gamma 分布的率参数,有时表示为 (\beta)(float)。它也是尺度参数 (\theta) 的倒数。
barray_like
gamma 分布的形状参数,有时表示为 (\alpha)(float)。
xarray_like
分位数(积分下限;float)。
outndarray,可选
可选的输出数组用于函数值
返回:
F标量或 ndarray
评估在参数为 a 和 b 的 gamma 分布的生存函数在 x 处的值。
另请参见
gdtr
Gamma 分布累积分布函数
scipy.stats.gamma
Gamma 分布
gdtrix
注意事项
使用与不完全 gamma 积分(正则化 gamma 函数)的关系进行评估。
Cephes 的包装器 [1] gdtrc
程序。直接调用 gdtrc
可以提高性能,相比于 scipy.stats.gamma
的 sf
方法(参见下面的最后一个示例)。
参考文献
[1]
Cephes 数学函数库,www.netlib.org/cephes/
示例
在 x=5
处计算 a=1
和 b=2
的函数。
>>> import numpy as np
>>> from scipy.special import gdtrc
>>> import matplotlib.pyplot as plt
>>> gdtrc(1., 2., 5.)
0.04042768199451279
通过提供一个 NumPy 数组 x 在几个点上计算 a=1
,b=2
的函数。
>>> xvalues = np.array([1., 2., 3., 4])
>>> gdtrc(1., 1., xvalues)
array([0.36787944, 0.13533528, 0.04978707, 0.01831564])
gdtrc
可以通过提供与 a、b 和 x 的广播兼容形状的数组来评估不同的参数集。这里我们计算了三个不同 a 和四个位置 x,b=3
的函数,得到一个 3x4 的数组。
>>> a = np.array([[0.5], [1.5], [2.5]])
>>> x = np.array([1., 2., 3., 4])
>>> a.shape, x.shape
((3, 1), (4,))
>>> gdtrc(a, 3., x)
array([[0.98561232, 0.9196986 , 0.80884683, 0.67667642],
[0.80884683, 0.42319008, 0.17357807, 0.0619688 ],
[0.54381312, 0.12465202, 0.02025672, 0.0027694 ]])
绘制四组不同参数设置的函数。
>>> a_parameters = [0.3, 1, 2, 6]
>>> b_parameters = [2, 10, 15, 20]
>>> linestyles = ['solid', 'dashed', 'dotted', 'dashdot']
>>> parameters_list = list(zip(a_parameters, b_parameters, linestyles))
>>> x = np.linspace(0, 30, 1000)
>>> fig, ax = plt.subplots()
>>> for parameter_set in parameters_list:
... a, b, style = parameter_set
... gdtrc_vals = gdtrc(a, b, x)
... ax.plot(x, gdtrc_vals, label=f"$a= {a},\, b={b}$", ls=style)
>>> ax.legend()
>>> ax.set_xlabel("$x$")
>>> ax.set_title("Gamma distribution survival function")
>>> plt.show()
gamma 分布也可以通过 scipy.stats.gamma
获取。直接使用 gdtrc
比调用 scipy.stats.gamma
的 sf
方法要快得多,尤其对于小数组或单个值。要获得相同的结果,必须使用以下参数化方式:stats.gamma(b, scale=1/a).sf(x)=gdtrc(a, b, x)
。
>>> from scipy.stats import gamma
>>> a = 2
>>> b = 3
>>> x = 1.
>>> gdtrc_result = gdtrc(a, b, x) # this will often be faster than below
>>> gamma_dist_result = gamma(b, scale=1/a).sf(x)
>>> gdtrc_result == gamma_dist_result # test that results are equal
True
scipy.special.gdtria
原文链接:
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.gdtria.html#scipy.special.gdtria
scipy.special.gdtria(p, b, x, out=None) = <ufunc 'gdtria'>
gdtr
的反函数相对于a。
返回伽玛分布累积分布函数gdtr(a, b, x)关于参数a的反函数。
参数:
parray_like
概率值。
barray_like
gdtr(a, b, x)的b参数值。b是伽玛分布的“形状”参数。
xarray_like
伽玛分布域内的非负实数值。
outndarray,可选
如果给出第四个参数,必须是 numpy.ndarray,其大小与a、b和x的广播结果匹配。此时out是函数返回的数组。
返回:
a标量或 ndarray
参数a的取值使得p = gdtr(a, b, x)成立。1/a是伽玛分布的“尺度”参数。
另见
gdtr
伽玛分布的累积分布函数。
gdtrib
gdtr(a, b, x)关于b的反函数。
gdtrix
gdtr(a, b, x)关于x的反函数。
注意事项
cdfgam的 Fortran 库 CDFLIB [1]的封装器。
使用 DiDinato 和 Morris 的例程[2]计算累积分布函数p。计算参数a涉及搜索产生期望p值的值。该搜索依赖于p随a的单调性。
参考文献
[1]
Barry Brown, James Lovato, 和 Kathy Russell,CDFLIB: 用于累积分布函数、反函数和其他参数的 Fortran 库。
[2]
DiDinato, A. R. 和 Morris, A. H.,计算不完全伽玛函数比率及其反函数。ACM Trans. Math. Softw. 12 (1986), 377-393.
示例
首先计算gdtr
。
>>> from scipy.special import gdtr, gdtria
>>> p = gdtr(1.2, 3.4, 5.6)
>>> print(p)
0.94378087442
验证反函数。
>>> gdtria(p, 3.4, 5.6)
1.2
scipy.special.gdtr
原文:
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.gdtr.html#scipy.special.gdtr
scipy.special.gdtr(a, b, x, out=None) = <ufunc 'gdtr'>
伽玛分布的累积分布函数。
返回从零到 x 的伽玛概率密度函数的积分,
[F = \int_0^x \frac{a^b}{\Gamma(b)} t^{b-1} e^{-at},dt,]
其中 (\Gamma) 是伽玛函数。
参数:
a 数组样式
伽玛分布的速率参数,有时表示为 (\beta)(浮点数)。也是尺度参数 (\theta) 的倒数。
b 数组样式
伽玛分布的形状参数,有时用 (\alpha) 表示(浮点数)。
x 数组样式
分位数(积分的上限;浮点数)。
out 数组,可选
用于函数值的可选输出数组
返回:
F标量或者数组
以参数 a 和 b 评估在 x 处的伽玛分布的累积分布函数。
参见
gdtrc
1 - 伽玛分布的累积分布函数。
scipy.stats.gamma
伽玛分布
注意
通过与不完全伽玛积分(正则化伽玛函数)的关系进行评估。
Cephes 的包装器 [1] gdtr
例程。直接调用 gdtr
可以比 scipy.stats.gamma
的 cdf
方法提高性能(见下面的最后一个例子)。
参考文献
[1]
Cephes 数学函数库,www.netlib.org/cephes/
示例
计算 a=1
,b=2
,x=5
处的函数。
>>> import numpy as np
>>> from scipy.special import gdtr
>>> import matplotlib.pyplot as plt
>>> gdtr(1., 2., 5.)
0.9595723180054873
通过提供 NumPy 数组的 x,计算 a=1
和 b=2
在多个点上的函数。
>>> xvalues = np.array([1., 2., 3., 4])
>>> gdtr(1., 1., xvalues)
array([0.63212056, 0.86466472, 0.95021293, 0.98168436])
gdtr
可以通过提供广播兼容形状的数组来评估不同的参数集,用于 a, b 和 x。这里我们计算三个不同 a 在四个位置 x 上的函数,且 b=3
,结果是一个 3x4 的数组。
>>> a = np.array([[0.5], [1.5], [2.5]])
>>> x = np.array([1., 2., 3., 4])
>>> a.shape, x.shape
((3, 1), (4,))
>>> gdtr(a, 3., x)
array([[0.01438768, 0.0803014 , 0.19115317, 0.32332358],
[0.19115317, 0.57680992, 0.82642193, 0.9380312 ],
[0.45618688, 0.87534798, 0.97974328, 0.9972306 ]])
绘制四种不同参数集的函数。
>>> a_parameters = [0.3, 1, 2, 6]
>>> b_parameters = [2, 10, 15, 20]
>>> linestyles = ['solid', 'dashed', 'dotted', 'dashdot']
>>> parameters_list = list(zip(a_parameters, b_parameters, linestyles))
>>> x = np.linspace(0, 30, 1000)
>>> fig, ax = plt.subplots()
>>> for parameter_set in parameters_list:
... a, b, style = parameter_set
... gdtr_vals = gdtr(a, b, x)
... ax.plot(x, gdtr_vals, label=f"$a= {a},\, b={b}$", ls=style)
>>> ax.legend()
>>> ax.set_xlabel("$x$")
>>> ax.set_title("Gamma distribution cumulative distribution function")
>>> plt.show()
伽玛分布也可用 scipy.stats.gamma
。直接使用 gdtr
比调用 scipy.stats.gamma
的 cdf
方法更快,尤其适用于小数组或单个值。要获得相同的结果,必须使用以下参数化方法:stats.gamma(b, scale=1/a).cdf(x)=gdtr(a, b, x)
。
>>> from scipy.stats import gamma
>>> a = 2.
>>> b = 3
>>> x = 1.
>>> gdtr_result = gdtr(a, b, x) # this will often be faster than below
>>> gamma_dist_result = gamma(b, scale=1/a).cdf(x)
>>> gdtr_result == gamma_dist_result # test that results are equal
True
scipy.special.gdtrib
原文:
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.gdtrib.html#scipy.special.gdtrib
scipy.special.gdtrib(a, p, x, out=None) = <ufunc 'gdtrib'>
gdtr
的逆与 b。
返回与 p = gdtr(a, b, x)
,伽玛分布的累积分布函数的参数 b 相对应的逆。
参数:
a 类似数组
gdtr(a, b, x) 的 a 参数值。1/a 是伽玛分布的“尺度”参数。
p 类似数组
概率值。
x 类似数组
非负实值,来自伽玛分布的定义域。
out ndarray,可选
如果给出第四个参数,它必须是一个 numpy.ndarray,其大小与 a、b 和 x 的广播结果匹配。out 然后是函数返回的数组。
返回:
b 标量或 ndarray
b 参数值,使得 p = gdtr(a, b, x)。b 是伽玛分布的“形状”参数。
另请参阅
伽玛分布的累积分布函数。
gdtr(a, b, x) 相对于 a 的逆。
x 相对于 gdtr(a, b, x) 的逆。
注意
封装了 CDFLIB [1] 中 Fortran 例程 cdfgam 的包装器。
使用 DiDinato 和 Morris 的例程计算累积分布函数 p [2]。计算 b 包括搜索一个值,该值产生所需的 p 值。搜索依赖于 p 随 b 的单调性。
参考文献
[1]
Barry Brown, James Lovato, 和 Kathy Russell,CDFLIB:用于累积分布函数、逆和其他参数的 Fortran 例程库。
[2]
DiDinato, A. R. 和 Morris, A. H.,不完全伽玛函数比值及其逆的计算。ACM Trans. Math. Softw. 12 (1986), 377-393。
示例
首先评估 gdtr
。
>>> from scipy.special import gdtr, gdtrib
>>> p = gdtr(1.2, 3.4, 5.6)
>>> print(p)
0.94378087442
验证逆。
>>> gdtrib(1.2, p, 5.6)
3.3999999999723882
scipy.special.gdtr
原文链接:
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.gdtr.html#scipy.special.gdtr
scipy.special.gdtr(a, b, x, out=None) = <ufunc 'gdtr'>
伽马分布累积分布函数。
返回伽马概率密度函数从零到 x 的积分,
[F = \int_0^x \frac{a^b}{\Gamma(b)} t^{b-1} e^{-at},dt,]
其中 (\Gamma) 是伽马函数。
参数:
a:array_like
伽马分布的速率参数,有时表示为 (\beta)(浮点数)。它也是比例参数 (\theta) 的倒数。
b:array_like
伽马分布的形状参数,有时表示为 (\alpha)(浮点数)。
x:array_like
伽马分布的分位数(积分的上限;浮点数)。
out:ndarray,可选
可选输出数组的函数值
返回:
F:标量或 ndarray
在参数 a 和 b 下评估的伽马分布累积分布函数 x 处的累积分布函数。
参见
gdtrc
伽马分布的 1 - CDF。
scipy.stats.gamma
伽马分布
注意
评估是通过与不完全伽马积分(正则化伽马函数)的关系进行的。
对 Cephes 的包装 [1] 例程 gdtr
。直接调用 gdtr
可以提高性能,相较于 scipy.stats.gamma
的 cdf
方法(参见下面的最后一个例子)。
参考
[1]
Cephes 数学函数库,www.netlib.org/cephes/
示例
计算 a=1
,b=2
在 x=5
的函数。
>>> import numpy as np
>>> from scipy.special import gdtr
>>> import matplotlib.pyplot as plt
>>> gdtr(1., 2., 5.)
0.9595723180054873
通过提供一个 NumPy 数组 x,计算 a=1
和 b=2
在几个点的函数。
>>> xvalues = np.array([1., 2., 3., 4])
>>> gdtr(1., 1., xvalues)
array([0.63212056, 0.86466472, 0.95021293, 0.98168436])
gdtr
可以通过提供广播兼容形状的数组评估不同的参数集 a、b 和 x。在这里,我们计算三个不同 a 在四个位置 x 和 b=3
的函数,结果是一个 3x4 的数组。
>>> a = np.array([[0.5], [1.5], [2.5]])
>>> x = np.array([1., 2., 3., 4])
>>> a.shape, x.shape
((3, 1), (4,))
>>> gdtr(a, 3., x)
array([[0.01438768, 0.0803014 , 0.19115317, 0.32332358],
[0.19115317, 0.57680992, 0.82642193, 0.9380312 ],
[0.45618688, 0.87534798, 0.97974328, 0.9972306 ]])
为四组不同参数集绘制函数图。
>>> a_parameters = [0.3, 1, 2, 6]
>>> b_parameters = [2, 10, 15, 20]
>>> linestyles = ['solid', 'dashed', 'dotted', 'dashdot']
>>> parameters_list = list(zip(a_parameters, b_parameters, linestyles))
>>> x = np.linspace(0, 30, 1000)
>>> fig, ax = plt.subplots()
>>> for parameter_set in parameters_list:
... a, b, style = parameter_set
... gdtr_vals = gdtr(a, b, x)
... ax.plot(x, gdtr_vals, label=f"$a= {a},\, b={b}$", ls=style)
>>> ax.legend()
>>> ax.set_xlabel("$x$")
>>> ax.set_title("Gamma distribution cumulative distribution function")
>>> plt.show()
伽马分布也可以作为 scipy.stats.gamma
获取。直接使用 gdtr
比调用 scipy.stats.gamma
的 cdf
方法要快得多,尤其对于小数组或单个值。为了获得相同的结果,必须使用以下参数化方法:stats.gamma(b, scale=1/a).cdf(x)=gdtr(a, b, x)
。
>>> from scipy.stats import gamma
>>> a = 2.
>>> b = 3
>>> x = 1.
>>> gdtr_result = gdtr(a, b, x) # this will often be faster than below
>>> gamma_dist_result = gamma(b, scale=1/a).cdf(x)
>>> gdtr_result == gamma_dist_result # test that results are equal
True
scipy.special.gdtrix
原文链接:
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.gdtrix.html#scipy.special.gdtrix
scipy.special.gdtrix(a, b, p, out=None) = <ufunc 'gdtrix'>
gdtr
的反函数 vs x。
返回与伽玛分布的累积分布函数p = gdtr(a, b, x)
的参数x相关的反函数,也称为分布的第p分位数。
参数:
aarray_like
gdtr(a, b, x)的a参数值。1/a是伽玛分布的“尺度”参数。
barray_like
gdtr(a, b, x)的b参数值。b是伽玛分布的“形状”参数。
parray_like
概率值。
outndarray,可选
如果给出第四个参数,则必须是大小与a、b和x广播结果匹配的 numpy.ndarray。out然后是函数返回的数组。
返回:
x标量或 ndarray
p = gdtr(a, b, x)的x参数值。
另请参阅
gdtr
伽玛分布的累积分布函数。
gdtria
gdtr(a, b, x)的a相关的反函数。
gdtrib
gdtr(a, b, x)的b相关的反函数。
注意事项
对 CDFLIB [1] Fortran 例程cdfgam的包装器。
使用 DiDinato 和 Morris 的例程[2]计算累积分布函数p。计算x涉及搜索产生所需p值的值。搜索依赖于p随x的单调性。
参考文献
[1]
Barry Brown, James Lovato, and Kathy Russell, CDFLIB: 用于累积分布函数、反函数和其他参数的 Fortran 例程库。
[2]
DiDinato, A. R.和 Morris, A. H.,计算不完全伽玛函数比率及其反函数。ACM Trans. Math. Softw. 12 (1986), 377-393。
示例
首先评估gdtr
。
>>> from scipy.special import gdtr, gdtrix
>>> p = gdtr(1.2, 3.4, 5.6)
>>> print(p)
0.94378087442
验证反函数。
>>> gdtrix(1.2, 3.4, p)
5.5999999999999996
scipy.special.gdtr
原文链接:
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.gdtr.html#scipy.special.gdtr
scipy.special.gdtr(a, b, x, out=None) = <ufunc 'gdtr'>
伽玛分布累积分布函数。
返回从零到x的伽玛概率密度函数的积分,
[F = \int_0^x \frac{a^b}{\Gamma(b)} t^{b-1} e^{-at},dt,]
其中(\Gamma)是伽玛函数。
参数:
a类似数组
伽玛分布的速率参数,有时表示为(\beta)(浮点数)。它也是比例参数(\theta)的倒数。
b类似数组
伽玛分布的形状参数,有时表示为(\alpha)(浮点数)。
x类似数组
分位数(积分的上限;浮点数)。
outndarray,可选
函数值的可选输出数组
返回:
F标量或 ndarray
具有参数a和b在x处评估的伽玛分布的 CDF。
另请参阅
gdtrc
1 - 伽玛分布的 CDF。
scipy.stats.gamma
伽玛分布
注意
评估是通过与不完全伽玛积分(正则化伽玛函数)的关系进行的。
Cephes [1]例程gdtr
的包装器。直接调用gdtr
可以提高性能,与scipy.stats.gamma
的cdf
方法相比(请参见下面的最后一个示例)。
参考
[1]
Cephes 数学函数库,www.netlib.org/cephes/
示例
计算a=1
,b=2
在x=5
处的函数。
>>> import numpy as np
>>> from scipy.special import gdtr
>>> import matplotlib.pyplot as plt
>>> gdtr(1., 2., 5.)
0.9595723180054873
通过为x提供一个 NumPy 数组,在几个点上计算a=1
和b=2
的函数。
>>> xvalues = np.array([1., 2., 3., 4])
>>> gdtr(1., 1., xvalues)
array([0.63212056, 0.86466472, 0.95021293, 0.98168436])
通过提供广播兼容形状的数组来评估不同参数设置的gdtr
。在这里,我们为三个不同的a在四个位置x和b=3
计算函数,得到一个 3x4 数组。
>>> a = np.array([[0.5], [1.5], [2.5]])
>>> x = np.array([1., 2., 3., 4])
>>> a.shape, x.shape
((3, 1), (4,))
>>> gdtr(a, 3., x)
array([[0.01438768, 0.0803014 , 0.19115317, 0.32332358],
[0.19115317, 0.57680992, 0.82642193, 0.9380312 ],
[0.45618688, 0.87534798, 0.97974328, 0.9972306 ]])
为四组不同参数设置绘制函数。
>>> a_parameters = [0.3, 1, 2, 6]
>>> b_parameters = [2, 10, 15, 20]
>>> linestyles = ['solid', 'dashed', 'dotted', 'dashdot']
>>> parameters_list = list(zip(a_parameters, b_parameters, linestyles))
>>> x = np.linspace(0, 30, 1000)
>>> fig, ax = plt.subplots()
>>> for parameter_set in parameters_list:
... a, b, style = parameter_set
... gdtr_vals = gdtr(a, b, x)
... ax.plot(x, gdtr_vals, label=f"$a= {a},\, b={b}$", ls=style)
>>> ax.legend()
>>> ax.set_xlabel("$x$")
>>> ax.set_title("Gamma distribution cumulative distribution function")
>>> plt.show()
伽玛分布也可以作为scipy.stats.gamma
使用。直接使用gdtr
可能比调用scipy.stats.gamma
的cdf
方法更快,特别是对于小数组或单个值。要获得相同的结果,必须使用以下参数化:stats.gamma(b, scale=1/a).cdf(x)=gdtr(a, b, x)
.
>>> from scipy.stats import gamma
>>> a = 2.
>>> b = 3
>>> x = 1.
>>> gdtr_result = gdtr(a, b, x) # this will often be faster than below
>>> gamma_dist_result = gamma(b, scale=1/a).cdf(x)
>>> gdtr_result == gamma_dist_result # test that results are equal
True
scipy.special.nbdtr
原文:
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.nbdtr.html#scipy.special.nbdtr
scipy.special.nbdtr(k, n, p, out=None) = <ufunc 'nbdtr'>
负二项分布累积分布函数。
返回负二项分布概率质量函数从 0 到k项的总和,
[F = \sum_{j=0}^k {{n + j - 1}\choose{j}} p^n (1 - p)^j.]
在一系列伯努利试验中,单次成功概率为p,这是k或更少次失败在第n次成功之前发生的概率。
参数:
karray_like
允许的最大失败次数(非负整数)。
narray_like
成功次数的目标数(正整数)。
parray_like
单次事件中成功的概率(浮点数)。
outndarray, 可选
可选的函数结果输出数组
返回:
F标量或 ndarray
在一系列事件中,成功概率为p,在n次成功之前发生k或更少次失败的概率。
参见
nbdtrc
负二项分布生存函数
nbdtrik
负二项分布分位数函数
scipy.stats.nbinom
负二项分布
注意事项
如果将浮点数值传递给k或n,它们将被截断为整数。
这些项不直接求和;相反,使用正则化不完全贝塔函数,根据公式,
[\mathrm{nbdtr}(k, n, p) = I_{p}(n, k + 1).]
Cephes 的包装器[1]例程nbdtr
。
负二项分布也可以作为scipy.stats.nbinom
获得。直接使用nbdtr
相对于scipy.stats.nbinom
的cdf
方法可以提高性能(见最后一个示例)。
参考文献
[1]
Cephes 数学函数库,www.netlib.org/cephes/
示例
计算在p=0.5时k=10和n=5的函数。
>>> import numpy as np
>>> from scipy.special import nbdtr
>>> nbdtr(10, 5, 0.5)
0.940765380859375
通过提供 NumPy 数组或列表用于k,计算p=0.5时n=10的函数的多个点。
>>> nbdtr([5, 10, 15], 10, 0.5)
array([0.15087891, 0.58809853, 0.88523853])
绘制四组不同参数集的函数图。
>>> import matplotlib.pyplot as plt
>>> k = np.arange(130)
>>> n_parameters = [20, 20, 20, 80]
>>> p_parameters = [0.2, 0.5, 0.8, 0.5]
>>> linestyles = ['solid', 'dashed', 'dotted', 'dashdot']
>>> parameters_list = list(zip(p_parameters, n_parameters,
... linestyles))
>>> fig, ax = plt.subplots(figsize=(8, 8))
>>> for parameter_set in parameters_list:
... p, n, style = parameter_set
... nbdtr_vals = nbdtr(k, n, p)
... ax.plot(k, nbdtr_vals, label=rf"$n={n},\, p={p}$",
... ls=style)
>>> ax.legend()
>>> ax.set_xlabel("$k$")
>>> ax.set_title("Negative binomial cumulative distribution function")
>>> plt.show()
负二项分布也可作为scipy.stats.nbinom
来使用。直接使用nbdtr
比调用scipy.stats.nbinom
的cdf
方法要快得多,特别是对于小数组或单个值。要获得相同的结果,必须使用以下参数化:nbinom(n, p).cdf(k)=nbdtr(k, n, p)
。
>>> from scipy.stats import nbinom
>>> k, n, p = 5, 3, 0.5
>>> nbdtr_res = nbdtr(k, n, p) # this will often be faster than below
>>> stats_res = nbinom(n, p).cdf(k)
>>> stats_res, nbdtr_res # test that results are equal
(0.85546875, 0.85546875)
nbdtr
可以通过提供与k、n和p的广播兼容形状的数组来评估不同的参数集。在这里,我们计算了三个不同的k和四个p的函数值,结果是一个 3x4 数组。
>>> k = np.array([[5], [10], [15]])
>>> p = np.array([0.3, 0.5, 0.7, 0.9])
>>> k.shape, p.shape
((3, 1), (4,))
>>> nbdtr(k, 5, p)
array([[0.15026833, 0.62304687, 0.95265101, 0.9998531 ],
[0.48450894, 0.94076538, 0.99932777, 0.99999999],
[0.76249222, 0.99409103, 0.99999445, 1\. ]])
scipy.special.nbdtrc
原文:
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.nbdtrc.html#scipy.special.nbdtrc
scipy.special.nbdtrc(k, n, p, out=None) = <ufunc 'nbdtrc'>
负二项生存函数。
返回负二项分布概率质量函数的* k + 1 *到无穷大的项的总和,
[F = \sum_{j=k + 1}^\infty {{n + j - 1}\choose{j}} p^n (1 - p)^j.]
在具有独立成功概率 p 的伯努利试验序列中,这是在第 n 次成功之前发生更多于 k 次失败的概率。
参数:
karray_like
允许的最大失败次数(非负整数)。
narray_like
目标成功次数(正整数)。
parray_like
在单次事件中成功的概率(浮点数)。
outndarray, 可选
用于函数结果的可选输出数组
返回:
F标量或 ndarray
在一系列具有独立成功概率 p 的伯努利试验中,这是更多于 k 次失败在第 n 次成功之前发生的概率。
另请参阅
nbdtr
负二项累积分布函数
nbdtrik
负二项分布的百分位函数
scipy.stats.nbinom
负二项分布
注意事项
如果传递给 k 或 n 的值是浮点数,则它们将被截断为整数。
项并非直接求和;相反,根据以下公式使用了正则化不完全贝塔函数,
[\mathrm{nbdtrc}(k, n, p) = I_{1 - p}(k + 1, n).]
Cephes 的包装 [1] 函数 nbdtrc
。
负二项分布也可以作为 scipy.stats.nbinom
提供。直接使用 nbdtrc
相比于 scipy.stats.nbinom
的 sf
方法能够提高性能(见最后的例子)。
参考文献
[1]
Cephes 数学函数库,www.netlib.org/cephes/
Examples
在 k=10
和 n=5
时,计算在 p=0.5
处的函数。
>>> import numpy as np
>>> from scipy.special import nbdtrc
>>> nbdtrc(10, 5, 0.5)
0.059234619140624986
通过提供 k 的 NumPy 数组或列表,在n=10
和p=0.5
的情况下计算函数的多个点。
>>> nbdtrc([5, 10, 15], 10, 0.5)
array([0.84912109, 0.41190147, 0.11476147])
为四种不同的参数集绘制函数。
>>> import matplotlib.pyplot as plt
>>> k = np.arange(130)
>>> n_parameters = [20, 20, 20, 80]
>>> p_parameters = [0.2, 0.5, 0.8, 0.5]
>>> linestyles = ['solid', 'dashed', 'dotted', 'dashdot']
>>> parameters_list = list(zip(p_parameters, n_parameters,
... linestyles))
>>> fig, ax = plt.subplots(figsize=(8, 8))
>>> for parameter_set in parameters_list:
... p, n, style = parameter_set
... nbdtrc_vals = nbdtrc(k, n, p)
... ax.plot(k, nbdtrc_vals, label=rf"$n={n},\, p={p}$",
... ls=style)
>>> ax.legend()
>>> ax.set_xlabel("$k$")
>>> ax.set_title("Negative binomial distribution survival function")
>>> plt.show()
负二项分布也可以使用 scipy.stats.nbinom
获得。直接使用 nbdtrc
可以比调用 scipy.stats.nbinom
的 sf
方法更快,特别是对于小数组或单个值。要获得相同的结果,必须使用以下参数化方式:nbinom(n, p).sf(k)=nbdtrc(k, n, p)
。
>>> from scipy.stats import nbinom
>>> k, n, p = 3, 5, 0.5
>>> nbdtr_res = nbdtrc(k, n, p) # this will often be faster than below
>>> stats_res = nbinom(n, p).sf(k)
>>> stats_res, nbdtr_res # test that results are equal
(0.6367187499999999, 0.6367187499999999)
nbdtrc
可以通过提供与 k, n 和 p 的形状兼容的数组来评估不同的参数集。在这里,我们计算三个不同 k 在四个 p 的位置上的函数,结果是一个 3x4 的数组。
>>> k = np.array([[5], [10], [15]])
>>> p = np.array([0.3, 0.5, 0.7, 0.9])
>>> k.shape, p.shape
((3, 1), (4,))
>>> nbdtrc(k, 5, p)
array([[8.49731667e-01, 3.76953125e-01, 4.73489874e-02, 1.46902600e-04],
[5.15491059e-01, 5.92346191e-02, 6.72234070e-04, 9.29610100e-09],
[2.37507779e-01, 5.90896606e-03, 5.55025308e-06, 3.26346760e-13]])
scipy.special.nbdtri
原文:
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.nbdtri.html#scipy.special.nbdtri
scipy.special.nbdtri(k, n, y, out=None) = <ufunc 'nbdtri'>
返回参数 p 关于 y = nbdtr(k, n, p) 的反函数。
参数:
karray_like
允许的最大故障数(非负整数)。
narray_like
成功目标数(正整数)。
yarray_like
在 n 成功之前的 k 或更少故障的概率(浮点数)。
outndarray,可选
可选输出数组的函数结果
返回:
p标量或 ndarray
单次事件成功的概率(浮点数),使得 nbdtr(k, n, p) = y。
另请参阅
nbdtr
负二项分布的累积分布函数。
nbdtrc
负二项生存函数。
scipy.stats.nbinom
负二项分布。
nbdtrik
nbdtr(k, n, p) 关于 k 的反函数。
nbdtrin
nbdtr(k, n, p) 关于 n 的反函数。
scipy.stats.nbinom
负二项分布
注释
包装器用于 Cephes [1] 程序 nbdtri
。
负二项分布也可以使用 scipy.stats.nbinom
。直接使用 nbdtri
可以提高性能,相对于 scipy.stats.nbinom
的 ppf
方法。
参考文献
[1]
Cephes 数学函数库,www.netlib.org/cephes/
示例
nbdtri
是 nbdtr
关于 p 的反函数。浮点数误差的情况下,以下成立:nbdtri(k, n, nbdtr(k, n, p))=p
。
>>> import numpy as np
>>> from scipy.special import nbdtri, nbdtr
>>> k, n, y = 5, 10, 0.2
>>> cdf_val = nbdtr(k, n, y)
>>> nbdtri(k, n, cdf_val)
0.20000000000000004
通过提供 NumPy 数组或列表 y 来在几个点上计算 k=10
和 n=5
的函数。
>>> y = np.array([0.1, 0.4, 0.8])
>>> nbdtri(3, 5, y)
array([0.34462319, 0.51653095, 0.69677416])
绘制三个不同参数集的函数。
>>> import matplotlib.pyplot as plt
>>> n_parameters = [5, 20, 30, 30]
>>> k_parameters = [20, 20, 60, 80]
>>> linestyles = ['solid', 'dashed', 'dotted', 'dashdot']
>>> parameters_list = list(zip(n_parameters, k_parameters, linestyles))
>>> cdf_vals = np.linspace(0, 1, 1000)
>>> fig, ax = plt.subplots(figsize=(8, 8))
>>> for parameter_set in parameters_list:
... n, k, style = parameter_set
... nbdtri_vals = nbdtri(k, n, cdf_vals)
... ax.plot(cdf_vals, nbdtri_vals, label=rf"$k={k},\ n={n}$",
... ls=style)
>>> ax.legend()
>>> ax.set_ylabel("$p$")
>>> ax.set_xlabel("$CDF$")
>>> title = "nbdtri: inverse of negative binomial CDF with respect to $p$"
>>> ax.set_title(title)
>>> plt.show()
通过提供与 k、n 和 p 广播兼容的形状的数组,nbdtri
可以评估不同的参数集。在这里,我们计算三个不同的 k 和四个位置 p 的函数,结果为 3x4 数组。
>>> k = np.array([[5], [10], [15]])
>>> y = np.array([0.3, 0.5, 0.7, 0.9])
>>> k.shape, y.shape
((3, 1), (4,))
>>> nbdtri(k, 5, y)
array([[0.37258157, 0.45169416, 0.53249956, 0.64578407],
[0.24588501, 0.30451981, 0.36778453, 0.46397088],
[0.18362101, 0.22966758, 0.28054743, 0.36066188]])
scipy.special.nbdtrik
原文:
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.nbdtrik.html#scipy.special.nbdtrik
scipy.special.nbdtrik(y, n, p, out=None) = <ufunc 'nbdtrik'>
负二项分布百分位函数。
返回 y = nbdtr(k, n, p) 的相对于参数 k 的逆,负二项分布累积分布函数。
参数:
y,array_like
k 或 n 成功之前失败的概率(浮点数)。
n,array_like
目标成功数(正整数)。
p,array_like
单个事件成功的概率(浮点数)。
out,ndarray,可选
可选输出数组以获得函数结果
返回:
k,标量或 ndarray
允许的最大失败次数,使 nbdtr(k, n, p) = y。
另见
nbdtr
负二项分布的累积分布函数。
nbdtrc
负二项分布的生存函数。
nbdtri
nbdtr(k, n, p) 相对于 p 的逆。
nbdtrin
nbdtr(k, n, p) 相对于 n 的逆。
scipy.stats.nbinom
负二项分布
注释
对 CDFLIB [1] Fortran 程序库 cdfnbn 的包装器。
公式 26.5.26 参见 [2],
[\sum_{j=k + 1}^\infty {{n + j - 1} \choose{j}} p^n (1 - p)^j = I_{1 - p}(k + 1, n),]
用于将累积分布函数的计算减少到正则不完全贝塔函数 (I) 的形式。
计算 k 涉及查找产生期望值 y 的 k 值。该查找依赖于 y 随 k 的单调性。
参考文献
[1]
Barry Brown, James Lovato 和 Kathy Russell, CDFLIB:Fortran 累积分布函数,逆函数和其他参数的库。
[2]
Milton Abramowitz 和 Irene A. Stegun 编辑,数学函数手册,公式,图表及数学表。纽约:Dover 出版社,1972 年。
示例
计算具有示例参数集的负二项分布累积分布函数。
>>> import numpy as np
>>> from scipy.special import nbdtr, nbdtrik
>>> k, n, p = 5, 2, 0.5
>>> cdf_value = nbdtr(k, n, p)
>>> cdf_value
0.9375
验证 nbdtrik
是否恢复了 k 的原始值。
>>> nbdtrik(cdf_value, n, p)
5.0
绘制不同参数集的函数图。
>>> import matplotlib.pyplot as plt
>>> p_parameters = [0.2, 0.5, 0.7, 0.5]
>>> n_parameters = [30, 30, 30, 80]
>>> linestyles = ['solid', 'dashed', 'dotted', 'dashdot']
>>> parameters_list = list(zip(p_parameters, n_parameters, linestyles))
>>> cdf_vals = np.linspace(0, 1, 1000)
>>> fig, ax = plt.subplots(figsize=(8, 8))
>>> for parameter_set in parameters_list:
... p, n, style = parameter_set
... nbdtrik_vals = nbdtrik(cdf_vals, n, p)
... ax.plot(cdf_vals, nbdtrik_vals, label=rf"$n={n},\ p={p}$",
... ls=style)
>>> ax.legend()
>>> ax.set_ylabel("$k$")
>>> ax.set_xlabel("$CDF$")
>>> ax.set_title("Negative binomial percentile function")
>>> plt.show()
负二项分布也可用作scipy.stats.nbinom
。百分位函数方法 ppf
返回了nbdtrik
的结果四舍五入到整数:
>>> from scipy.stats import nbinom
>>> q, n, p = 0.6, 5, 0.5
>>> nbinom.ppf(q, n, p), nbdtrik(q, n, p)
(5.0, 4.800428460273882)
scipy.special.nbdtrin
原文链接:
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.nbdtrin.html#scipy.special.nbdtrin
scipy.special.nbdtrin(k, y, p, out=None) = <ufunc 'nbdtrin'>
nbdtr
的逆数与 n。
返回参数 n 对应的 y = nbdtr(k, n, p) 的逆数,即负二项累积分布函数。
参数:
k数组类
允许的最大失败次数(非负整数)。
y数组类
k 或者在 n 成功之前的失败概率(浮点数)。
p数组类
单个事件成功的概率(浮点数)。
out数组,可选
函数结果的可选输出数组
返回:
n标量或者数组
使得 nbdtr(k, n, p) = y 的成功次数 n。
另请参见
负二项累积分布函数。
逆数与 nbdtr(k, n, p) 关于 p 的。
逆数与 nbdtr(k, n, p) 关于 k 的。
注意事项
CDFLIB 的包装器 [1] Fortran 例程 cdfnbn。
第二章第五节第二十六个公式的 [2],
[\sum_{j=k + 1}^\infty {{n + j - 1} \choose{j}} p^n (1 - p)^j = I_{1 - p}(k + 1, n),]
用于将累积分布函数的计算减少为正则化不完全贝塔函数 (I) 的计算。
计算 n 涉及搜索产生期望 y 值的值。搜索依赖于 y 随 n 的单调性。
参考文献
[1]
Barry Brown、James Lovato 和 Kathy Russell,CDFLIB:用于累积分布函数、逆数和其他参数的 Fortran 例程库。
[2]
Milton Abramowitz 和 Irene A. Stegun 编辑,数学函数手册:公式、图表和数学表。纽约:多佛尔出版社,1972 年。
示例
计算具有示例参数集的负二项累积分布函数。
>>> from scipy.special import nbdtr, nbdtrin
>>> k, n, p = 5, 2, 0.5
>>> cdf_value = nbdtr(k, n, p)
>>> cdf_value
0.9375
验证 nbdtrin
对 n 的原始值的浮点精度恢复。
>>> nbdtrin(k, cdf_value, p)
1.999999999998137
scipy.special.nbdtr
原文链接:
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.nbdtr.html#scipy.special.nbdtr
scipy.special.nbdtr(k, n, p, out=None) = <ufunc 'nbdtr'>
负二项分布累积分布函数。
返回负二项分布概率质量函数的前 k 项之和,
[F = \sum_{j=0}^k {{n + j - 1}\choose{j}} p^n (1 - p)^j.]
在具有各自成功概率 p 的伯努利试验序列中,这是第 n 次成功之前有 k 或更少次失败的概率。
参数:
k,array_like
允许的最大失败次数(非负整数)。
n,array_like
目标成功次数(正整数)。
p,array_like
单次事件成功的概率(浮点数)。
out,可选的 ndarray
函数结果的可选输出数组
返回:
F,标量或 ndarray
在具有各自成功概率 p 的事件序列中,在第 n 次成功之前有 k 或更少次失败的概率。
另请参阅
nbdtrc
负二项分布生存函数
nbdtrik
负二项分布分位函数
scipy.stats.nbinom
负二项分布
注释
如果 k 或 n 传递浮点值,它们将被截断为整数。
项不直接求和;而是根据公式使用正则化不完全贝塔函数,
[\mathrm{nbdtr}(k, n, p) = I_{p}(n, k + 1).]
Cephes [1] 程序的包装器 nbdtr
。
负二项分布也可作为 scipy.stats.nbinom
使用。与 scipy.stats.nbinom
的 cdf
方法相比,直接使用 nbdtr
可以提高性能(见最后一个示例)。
参考
[1]
Cephes 数学函数库,www.netlib.org/cephes/
示例
计算 k=10
,n=5
,p=0.5
的函数。
>>> import numpy as np
>>> from scipy.special import nbdtr
>>> nbdtr(10, 5, 0.5)
0.940765380859375
通过提供 NumPy 数组或列表作为 k,计算 n=10
,p=0.5
的函数在多个点上的值。
>>> nbdtr([5, 10, 15], 10, 0.5)
array([0.15087891, 0.58809853, 0.88523853])
绘制四组不同参数设置的函数。
>>> import matplotlib.pyplot as plt
>>> k = np.arange(130)
>>> n_parameters = [20, 20, 20, 80]
>>> p_parameters = [0.2, 0.5, 0.8, 0.5]
>>> linestyles = ['solid', 'dashed', 'dotted', 'dashdot']
>>> parameters_list = list(zip(p_parameters, n_parameters,
... linestyles))
>>> fig, ax = plt.subplots(figsize=(8, 8))
>>> for parameter_set in parameters_list:
... p, n, style = parameter_set
... nbdtr_vals = nbdtr(k, n, p)
... ax.plot(k, nbdtr_vals, label=rf"$n={n},\, p={p}$",
... ls=style)
>>> ax.legend()
>>> ax.set_xlabel("$k$")
>>> ax.set_title("Negative binomial cumulative distribution function")
>>> plt.show()
负二项分布也可以使用scipy.stats.nbinom
来获取。直接使用nbdtr
可能比调用scipy.stats.nbinom
的cdf
方法要快得多,特别是对于小数组或单个值。为了获得相同的结果,必须使用以下参数化方式:nbinom(n, p).cdf(k)=nbdtr(k, n, p)
。
>>> from scipy.stats import nbinom
>>> k, n, p = 5, 3, 0.5
>>> nbdtr_res = nbdtr(k, n, p) # this will often be faster than below
>>> stats_res = nbinom(n, p).cdf(k)
>>> stats_res, nbdtr_res # test that results are equal
(0.85546875, 0.85546875)
通过提供与k、n和p的形状兼容的数组,nbdtr
可以评估不同的参数集。在这里,我们计算了在四个位置p处三个不同k的函数,结果是一个 3x4 的数组。
>>> k = np.array([[5], [10], [15]])
>>> p = np.array([0.3, 0.5, 0.7, 0.9])
>>> k.shape, p.shape
((3, 1), (4,))
>>> nbdtr(k, 5, p)
array([[0.15026833, 0.62304687, 0.95265101, 0.9998531 ],
[0.48450894, 0.94076538, 0.99932777, 0.99999999],
[0.76249222, 0.99409103, 0.99999445, 1\. ]])
scipy.special.ncfdtr
原文链接:
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.ncfdtr.html#scipy.special.ncfdtr
scipy.special.ncfdtr(dfn, dfd, nc, f, out=None) = <ufunc 'ncfdtr'>
非中心 F 分布的累积分布函数。
非中心 F 分布描述了分布,
[Z = \frac{X/d_n}{Y/d_d}]
其中(X)和(Y)独立分布,(X)为具有非中心参数nc和(d_n)自由度的非中心(\chi²)分布,(Y)为具有(d_d)自由度的(\chi²)分布。
参数:
dfnarray_like
分子平方和的自由度。范围为(0, inf)。
dfdarray_like
分母平方和的自由度。范围为(0, inf)。
ncarray_like
非中心参数。应在范围(0, 1e4)内。
farray_like
分位数,即积分的上限。
outndarray,可选
该函数结果的可选输出数组
返回值:
cdf标量或 ndarray
计算得到的累积分布函数。如果所有输入都是标量,则返回浮点数;否则返回数组。
另见
ncfdtri
分位函数;与f相关的ncfdtr
的逆。
ncfdtridfd
与dfd相关的ncfdtr
的逆。
ncfdtridfn
与dfn相关的ncfdtr
的逆。
ncfdtrinc
与nc相关的ncfdtr
的逆。
注释
CDFLIB 的包装器,对应于 Fortran 例程cdffnc。
使用《数学函数手册》第 26.6.20 式计算累积分布函数[2]:
[F(d_n, d_d, n_c, f) = \sum_{j=0}^\infty e^{-n_c/2} \frac{(n_c/2)^j}{j!} I_{x}(\frac{d_n}{2} + j, \frac{d_d}{2}),]
其中(I)是正则不完全 Beta 函数,且(x = f d_n/(f d_n + d_d))。
此例程所需的计算时间与非中心参数nc成正比。该参数的非常大值可能会消耗巨大的计算资源。这就是为什么搜索范围被限制在 10,000 的原因。
参考文献
[1]
Barry Brown,James Lovato 和 Kathy Russell,CDFLIB:Fortran 例程库用于累积分布函数,逆函数和其他参数。
[2]
Milton Abramowitz 和 Irene A. Stegun,主编。数学函数手册及公式,图表和数学表。纽约:多佛尔出版社,1972 年。
示例
>>> import numpy as np
>>> from scipy import special
>>> from scipy import stats
>>> import matplotlib.pyplot as plt
绘制非中心 F 分布的累积分布函数,当 nc=0 时。与 scipy.stats 中的 F 分布进行比较:
>>> x = np.linspace(-1, 8, num=500)
>>> dfn = 3
>>> dfd = 2
>>> ncf_stats = stats.f.cdf(x, dfn, dfd)
>>> ncf_special = special.ncfdtr(dfn, dfd, 0, x)
>>> fig = plt.figure()
>>> ax = fig.add_subplot(111)
>>> ax.plot(x, ncf_stats, 'b-', lw=3)
>>> ax.plot(x, ncf_special, 'r-')
>>> plt.show()
scipy.special.ncfdtridfd
scipy.special.ncfdtridfd(dfn, p, nc, f, out=None) = <ufunc 'ncfdtridfd'>
计算非中心 F 分布的自由度(分母)。
这是与dfd相关的ncfdtr
的反函数。详情请参见ncfdtr
。
参数:
dfn类似数组
分子平方和的自由度。范围为(0,inf)。
p类似数组
累积分布函数的值。必须在[0, 1]范围内。
nc类似数组
非中心参数。应在范围(0,1e4)内。
f类似数组
分位数,即积分的上限。
outndarray,可选
函数结果的可选输出数组
返回:
dfd标量或 ndarray
分母平方和的自由度。
另请参阅
ncfdtr
非中心 F 分布的累积分布函数。
ncfdtri
分位数函数;与f相关的ncfdtr
的反函数。
ncfdtridfn
与dfn相关的ncfdtr
的反函数。
ncfdtrinc
与nc相关的ncfdtr
的反函数。
注释
非中心 F 分布的累积分布值在自由度上不一定单调。因此,可能存在两个值提供给定的 CDF 值。此例程假定单调性,并将找到两个值中的任意一个。
示例
>>> from scipy.special import ncfdtr, ncfdtridfd
计算几个dfd值的累积分布函数:
>>> dfd = [1, 2, 3]
>>> p = ncfdtr(2, dfd, 0.25, 15)
>>> p
array([ 0.8097138 , 0.93020416, 0.96787852])
计算反函数。如预期,我们恢复了dfd的值:
>>> ncfdtridfd(2, p, 0.25, 15)
array([ 1., 2., 3.])
scipy.special.ncfdtridfn
scipy.special.ncfdtridfn(p, dfd, nc, f, out=None) = <ufunc 'ncfdtridfn'>
计算非中心 F 分布的自由度(分子)。
这是相对于dfn的ncfdtr
的逆函数。有关更多详细信息,请参阅ncfdtr
。
参数:
p类似数组
累积分布函数的值。必须在[0, 1]范围内。
dfd类似数组
分母平方和的自由度。范围为(0, 无穷)。
nc类似数组
非中心参数。应在范围(0, 1e4)内。
f浮点数
分位数,即积分的上限。
out数组,可选
函数结果的可选输出数组
返回:
dfn标量或数组
分子平方和的自由度。
另请参阅
ncfdtr
非中心 F 分布的累积分布函数。
ncfdtri
分位数函数;相对于f的ncfdtr
的逆函数。
ncfdtridfd
相对于dfd的ncfdtr
的逆函数。
ncfdtrinc
相对于nc的ncfdtr
的逆函数。
注意
累积非中心 F 分布的值在自由度上不一定单调。因此可能存在两个值提供给定的 CDF 值。此例程假定单调性,并将找到两个值中的任意一个。
示例
>>> from scipy.special import ncfdtr, ncfdtridfn
计算几个dfn值的累积分布函数:
>>> dfn = [1, 2, 3]
>>> p = ncfdtr(dfn, 2, 0.25, 15)
>>> p
array([ 0.92562363, 0.93020416, 0.93188394])
计算逆。我们恢复了dfn的值,正如预期的那样:
>>> ncfdtridfn(p, 2, 0.25, 15)
array([ 1., 2., 3.])
scipy.special.ncfdtri
Original text:
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.ncfdtri.html#scipy.special.ncfdtri
scipy.special.ncfdtri(dfn, dfd, nc, p, out=None) = <ufunc 'ncfdtri'>
Inverse with respect to f of the CDF of the non-central F distribution.
See ncfdtr
for more details.
Parameters:
dfnarray_like
Degrees of freedom of the numerator sum of squares. Range (0, inf).
dfdarray_like
Degrees of freedom of the denominator sum of squares. Range (0, inf).
ncarray_like
Noncentrality parameter. Should be in range (0, 1e4).
parray_like
Value of the cumulative distribution function. Must be in the range [0, 1].
outndarray, optional
Optional output array for the function results
Returns:
fscalar or ndarray
Quantiles, i.e., the upper limit of integration.
See also
ncfdtr
CDF of the non-central F distribution.
ncfdtridfd
Inverse of ncfdtr
with respect to dfd.
ncfdtridfn
Inverse of ncfdtr
with respect to dfn.
ncfdtrinc
Inverse of ncfdtr
with respect to nc.
Examples
>>> from scipy.special import ncfdtr, ncfdtri
Compute the CDF for several values of f:
>>> f = [0.5, 1, 1.5]
>>> p = ncfdtr(2, 3, 1.5, f)
>>> p
array([ 0.20782291, 0.36107392, 0.47345752])
Compute the inverse. We recover the values of f, as expected:
>>> ncfdtri(2, 3, 1.5, p)
array([ 0.5, 1\. , 1.5])
scipy.special.ncfdtrinc
scipy.special.ncfdtrinc(dfn, dfd, p, f, out=None) = <ufunc 'ncfdtrinc'>
计算非中心 F 分布的非中心参数。
这是ncfdtr相对于nc的反函数。更多细节参见ncfdtr。
参数:
dfnarray_like
分子平方和的自由度。范围(0, inf)。
dfdarray_like
分母平方和的自由度。范围(0, inf)。
parray_like
累积分布函数的值。必须在[0, 1]范围内。
farray_like
分位数,即积分的上限。
outndarray, 可选
函数结果的可选输出数组
返回:
nc标量或 ndarray
非中心参数。
参见
非中心 F 分布的累积分布函数。
分位数函数;相对于f的反函数。
相对于dfd的ncfdtr的反函数。
相对于dfn的ncfdtr的反函数。
示例
>>> from scipy.special import ncfdtr, ncfdtrinc
计算几个nc值的累积分布函数:
>>> nc = [0.5, 1.5, 2.0]
>>> p = ncfdtr(2, 3, nc, 15)
>>> p
array([ 0.96309246, 0.94327955, 0.93304098])
计算逆函数。我们恢复了nc的值,如预期:
>>> ncfdtrinc(2, 3, p, 15)
array([ 0.5, 1.5, 2\. ])
scipy.special.nctdtr
原文链接:
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.nctdtr.html#scipy.special.nctdtr
scipy.special.nctdtr(df, nc, t, out=None) = <ufunc 'nctdtr'>
非中心t分布的累积分布函数。
参数:
df array_like
分布的自由度。应在范围(0, inf)内。
nc array_like
非中心参数。应在范围(-1e6, 1e6)内。
t array_like
分位数,即积分的上限。
out ndarray,可选
用于函数结果的可选输出数组
返回:
cdf 标量或 ndarray
计算的 CDF。如果所有输入都是标量,则返回一个浮点数。否则,将返回一个数组。
参见
nctdtrit
非中心 t 分布的逆 CDF(iCDF)。
nctdtridf
计算自由度,给定 CDF 和 iCDF 值。
nctdtrinc
计算非中心参数,给定 CDF iCDF 值。
示例
>>> import numpy as np
>>> from scipy import special
>>> from scipy import stats
>>> import matplotlib.pyplot as plt
绘制非中心 t 分布的 CDF,对于 nc=0 进行比较。与 scipy.stats 中的 t 分布比较:
>>> x = np.linspace(-5, 5, num=500)
>>> df = 3
>>> nct_stats = stats.t.cdf(x, df)
>>> nct_special = special.nctdtr(df, 0, x)
>>> fig = plt.figure()
>>> ax = fig.add_subplot(111)
>>> ax.plot(x, nct_stats, 'b-', lw=3)
>>> ax.plot(x, nct_special, 'r-')
>>> plt.show()
scipy.special.nctdtridf
scipy.special.nctdtridf(p, nc, t, out=None) = <ufunc 'nctdtridf'>
计算非中心 t 分布的自由度。
查看 nctdtr
获取更多详细信息。
参数:
parray_like
CDF 值,取值范围为 (0, 1]。
ncarray_like
非中心参数。应在范围 (-1e6, 1e6) 内。
tarray_like
分位数,即积分的上限。
outndarray,可选
可选输出数组,用于函数结果
返回值:
cdf标量或 ndarray
计算得到的累积分布函数(CDF)。如果所有输入都是标量,则返回一个浮点数。否则,返回一个数组。
另见
非中心 t 分布的累积分布函数。
非中心 t 分布的逆累积分布函数(iCDF)。
计算给定 CDF iCDF 值的非中心参数。
scipy.special.nctdtrit
scipy.special.nctdtrit(df, nc, p, out=None) = <ufunc 'nctdtrit'>
非中心 t 分布的累积分布逆函数。
查看更多详情,请参考nctdtr
。
参数:
df,array_like
分布的自由度。应在范围(0, inf)内。
nc,array_like
非中心参数。应在范围(-1e6, 1e6)内。
p,array_like
CDF 值,在范围(0, 1]。
out,ndarray,可选
函数结果的可选输出数组
返回:
t,标量或 ndarray
分位数
另请参阅
nctdtr
非中心t分布的 CDF。
nctdtridf
根据 CDF 和 iCDF 值计算自由度。
nctdtrinc
根据 CDF iCDF 值计算非中心参数。
scipy.special.nctdtrinc
scipy.special.nctdtrinc(df, p, t, out=None) = <ufunc 'nctdtrinc'>
计算非中心 t 分布的非中心参数。
更多详情请参阅 nctdtr
。
参数:
df array_like
分布的自由度。应该在 (0, inf) 范围内。
p array_like
CDF 值,范围在 (0, 1]。
t array_like
分位数,即积分的上限。
out ndarray,可选项
函数结果的可选输出数组
返回:
nc 标量或 ndarray
非中心参数
另请参见
nctdtr
非中心 t 分布的累积分布函数(CDF)。
nctdtrit
非中心 t 分布的反向累积分布函数(iCDF)。
nctdtridf
计算给定 CDF 和 iCDF 值的自由度。
scipy.special.nrdtrimn
scipy.special.nrdtrimn(p, x, std, out=None) = <ufunc 'nrdtrimn'>
给定其他参数计算正态分布的均值。
参数:
p数组或类数组
CDF 值,范围为(0, 1]。
x数组或类数组
分位数,即积分的上限。
std数组或类数组
标准差。
outndarray,可选
用于函数结果的可选输出数组
返回:
mn标量或 ndarray
正态分布的均值。
参见
nrdtrimn
,ndtr
scipy.special.nrdtrisd
scipy.special.nrdtrisd(p, x, mn, out=None) = <ufunc 'nrdtrisd'>
根据其他参数计算正态分布的标准差。
参数:
parray_like
CDF 值,范围在 (0, 1]。
xarray_like
分位数,即积分的上限。
mn标量或 ndarray
正态分布的平均值。
outndarray,可选
可选输出数组以存储函数结果
返回:
std标量或 ndarray
标准差。
参见
scipy.special.ndtr
原文:
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.ndtr.html#scipy.special.ndtr
scipy.special.ndtr(x, out=None) = <ufunc 'ndtr'>
标准正态分布的累积分布。
返回标准高斯概率密度函数下的区域,从负无穷到x积分
[\frac{1}{\sqrt{2\pi}} \int_{-\infty}^x \exp(-t²/2) dt]
参数:
x:array_like,实数或复数
参数
out:ndarray,可选
函数结果的可选输出数组
返回:
标量或 ndarray
在x处评估的正态分布 CDF 的值
另请参阅
log_ndtr
ndtr 的对数
ndtri
ndtr 的反函数,标准正态百分位函数
erf
误差函数
erfc
1 - erf
scipy.stats.norm
正态分布
示例
在一个点评估ndtr
。
>>> import numpy as np
>>> from scipy.special import ndtr
>>> ndtr(0.5)
0.6914624612740131
通过提供 NumPy 数组或列表来在几个点评估函数的值x。
>>> ndtr([0, 0.5, 2])
array([0.5 , 0.69146246, 0.97724987])
绘制函数。
>>> import matplotlib.pyplot as plt
>>> x = np.linspace(-5, 5, 100)
>>> fig, ax = plt.subplots()
>>> ax.plot(x, ndtr(x))
>>> ax.set_title("Standard normal cumulative distribution function $\Phi$")
>>> plt.show()
scipy.special.log_ndtr
scipy.special.log_ndtr(x, out=None) = <ufunc 'log_ndtr'>
高斯累积分布函数的对数。
返回标准高斯概率密度函数下面积的对数,从负无穷积分到x:
log(1/sqrt(2*pi) * integral(exp(-t**2 / 2), t=-inf..x))
参数:
x类似数组,实数或复数
参数
out数组,可选
函数结果的可选输出数组
返回:
标量或数组
x处正态 CDF 的对数值
参见
示例
>>> import numpy as np
>>> from scipy.special import log_ndtr, ndtr
log_ndtr(x)
相对于天真实现np.log(ndtr(x))
的优势,在于中等到大的正x值时最为明显:
>>> x = np.array([6, 7, 9, 12, 15, 25])
>>> log_ndtr(x)
array([-9.86587646e-010, -1.27981254e-012, -1.12858841e-019,
-1.77648211e-033, -3.67096620e-051, -3.05669671e-138])
对于中等x值的天真计算结果仅有 5 或 6 位正确有效数字。对于大约大于 8.3 的x值,天真表达式返回 0:
>>> np.log(ndtr(x))
array([-9.86587701e-10, -1.27986510e-12, 0.00000000e+00,
0.00000000e+00, 0.00000000e+00, 0.00000000e+00])
scipy.special.ndtri
原文链接:
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.ndtri.html#scipy.special.ndtri
scipy.special.ndtri(y, out=None) = <ufunc 'ndtri'>
ndtr
的逆函数 vs x
返回使得标准正态概率密度函数下方面积(从负无穷积分到x)等于y的参数x。
参数:
parray_like
概率
outndarray,可选
函数结果的可选输出数组
返回:
x标量或 ndarray
值为 x,使得ndtr(x) == p
。
参见
ndtr
标准正态累积概率分布
ndtri_exp
逆 log_ndtr
示例
ndtri
是标准正态分布的百分位函数。这意味着它返回累积密度ndtr
的逆函数。首先,让我们计算一个累积密度值。
>>> import numpy as np
>>> from scipy.special import ndtri, ndtr
>>> cdf_val = ndtr(2)
>>> cdf_val
0.9772498680518208
验证ndtri
在浮点数误差范围内返回原始值x。
>>> ndtri(cdf_val)
2.0000000000000004
绘制函数图像。为此,我们提供一个 NumPy 数组作为参数。
>>> import matplotlib.pyplot as plt
>>> x = np.linspace(0.01, 1, 200)
>>> fig, ax = plt.subplots()
>>> ax.plot(x, ndtri(x))
>>> ax.set_title("Standard normal percentile function")
>>> plt.show()
scipy.special.ndtr
原文:
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.ndtr.html#scipy.special.ndtr
scipy.special.ndtr(x, out=None) = <ufunc 'ndtr'>
标准正态分布的累积分布。
返回从负无穷到x处标准高斯概率密度函数的积分面积
[\frac{1}{\sqrt{2\pi}} \int_{-\infty}^x \exp(-t²/2) dt]
参数:
x类似数组,实数或复数
参数
out ndarray,可选
函数结果的可选输出数组
返回:
标量或者数组
正态分布的累积分布函数在x处的值
另见
log_ndtr
ndtr 的对数
ndtri
ndtr 的反函数,标准正态分布的百分位函数
erf
误差函数
erfc
1 - erf
scipy.stats.norm
正态分布
示例
在一个点处评估ndtr
。
>>> import numpy as np
>>> from scipy.special import ndtr
>>> ndtr(0.5)
0.6914624612740131
通过提供 NumPy 数组或列表x来评估多个点的函数。
>>> ndtr([0, 0.5, 2])
array([0.5 , 0.69146246, 0.97724987])
绘制函数。
>>> import matplotlib.pyplot as plt
>>> x = np.linspace(-5, 5, 100)
>>> fig, ax = plt.subplots()
>>> ax.plot(x, ndtr(x))
>>> ax.set_title("Standard normal cumulative distribution function $\Phi$")
>>> plt.show()
scipy.special.ndtri_exp
scipy.special.ndtri_exp(y, out=None) = <ufunc 'ndtri_exp'>
log_ndtr
的反函数与 x 的关系。允许在 y 非常小或接近 0 时比由ndtri
结合numpy.exp
提供更高精度。
参数:
y:浮点数的 array_like
函数参数
out:ndarray,可选
函数结果的可选输出数组
返回:
标量或 ndarray
标准正态分布的对数 CDF 的反函数,在 y 处评估。
另请参阅
log_ndtr
标准正态累积分布函数的对数
ndtr
标准正态累积分布函数
ndtri
标准正态百分位函数
示例
>>> import numpy as np
>>> import scipy.special as sc
当后者不受下溢影响时,ndtri_exp
与朴素实现一致。
>>> sc.ndtri_exp(-1)
-0.33747496376420244
>>> sc.ndtri(np.exp(-1))
-0.33747496376420244
对于极端值 y,朴素方法失败
>>> sc.ndtri(np.exp(-800))
-inf
>>> sc.ndtri(np.exp(-1e-20))
inf
而ndtri_exp
仍能高精度计算结果。
>>> sc.ndtri_exp(-800)
-39.88469483825668
>>> sc.ndtri_exp(-1e-20)
9.262340089798409
scipy.special.log_ndtr
scipy.special.log_ndtr(x, out=None) = <ufunc 'log_ndtr'>
高斯累积分布函数的对数。
返回标准高斯概率密度函数下面积的对数,从负无穷积到x:
log(1/sqrt(2*pi) * integral(exp(-t**2 / 2), t=-inf..x))
参数:
x:array_like,实数或复数
参数
out:ndarray,可选
可选的函数结果输出数组
返回:
标量或者 ndarray
在x处评估正态 CDF 的对数值
另请参阅
erf
erfc
scipy.stats.norm
ndtr
示例
>>> import numpy as np
>>> from scipy.special import log_ndtr, ndtr
log_ndtr(x)
相较于天真实现np.log(ndtr(x))
的优势在于对于中等到大的正x值最为明显:
>>> x = np.array([6, 7, 9, 12, 15, 25])
>>> log_ndtr(x)
array([-9.86587646e-010, -1.27981254e-012, -1.12858841e-019,
-1.77648211e-033, -3.67096620e-051, -3.05669671e-138])
对于中等x值的天真计算结果仅有 5 或 6 个正确有效数字。对于大约大于 8.3 的x值,天真表达式返回 0:
>>> np.log(ndtr(x))
array([-9.86587701e-10, -1.27986510e-12, 0.00000000e+00,
0.00000000e+00, 0.00000000e+00, 0.00000000e+00])
scipy.special.pdtr
原文链接:
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.pdtr.html#scipy.special.pdtr
scipy.special.pdtr(k, m, out=None) = <ufunc 'pdtr'>
泊松累积分布函数。
定义为泊松分布随机变量事件率 (m) 小于或等于 (k) 的概率。更具体地说,这可以计算为 [1]
[\exp(-m) \sum_{j = 0}^{\lfloor{k}\rfloor} \frac{m^j}{j!}.]
参数:
karray_like
发生次数(非负实数)
marray_like
形状参数(非负实数)
outndarray,可选
函数结果的可选输出数组
返回:
标量或 ndarray
泊松累积分布函数的值
参见
泊松生存函数
与 k 相关的 pdtr
的逆函数
与 m 相关的 pdtr
的逆函数
参考文献
en.wikipedia.org/wiki/Poisson_distribution
示例
>>> import numpy as np
>>> import scipy.special as sc
它是一个累积分布函数,因此当 k 趋向无穷大时,它单调地收敛到 1。
>>> sc.pdtr([1, 10, 100, np.inf], 1)
array([0.73575888, 0.99999999, 1\. , 1\. ])
在整数处不连续,在整数之间是常数。
>>> sc.pdtr([1, 1.5, 1.9, 2], 1)
array([0.73575888, 0.73575888, 0.73575888, 0.9196986 ])
scipy.special.pdtrc
原文链接:
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.pdtrc.html#scipy.special.pdtrc
scipy.special.pdtrc(k, m, out=None) = <ufunc 'pdtrc'>
泊松生存函数
返回泊松分布的从 k+1 到无穷大项的总和:sum(exp(-m) * m**j / j!, j=k+1..inf) = gammainc( k+1, m)。参数必须为非负 double 类型。
参数:
karray_like
发生次数(非负实数)
marray_like
形状参数(非负实数)
outndarray,可选
函数结果的可选输出数组
返回值:
标量或者 ndarray
泊松生存函数的值
参见
泊松累积分布函数
与 k 相关的 pdtr
的逆
与 m 相关的 pdtr
的逆
scipy.special.pdtri
原文:
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.pdtri.html#scipy.special.pdtri
scipy.special.pdtri(k, y, out=None) = <ufunc 'pdtri'>
相对于 pdtr
的逆函数 vs m
返回泊松变量 m,使得泊松密度从 0 到 k 的总和等于给定概率 y:由 gammaincinv(k + 1, y)
计算。k 必须是非负整数,y 在 0 到 1 之间。
参数:
karray_like
发生次数(非负实数)
yarray_like
概率
outndarray,可选
函数结果的可选输出数组
返回:
标量或者 ndarray
形状参数 m 的取值,使得 pdtr(k, m) = p
另见
泊松累积分布函数
泊松生存函数
相对于 k 的 pdtr
的逆函数
scipy.special.pdtr
原文链接:
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.pdtr.html#scipy.special.pdtr
scipy.special.pdtr(k, m, out=None) = <ufunc 'pdtr'>
泊松累积分布函数
定义为泊松分布随机变量事件率为(m)时小于或等于(k)的概率。更具体地说,这实际上等于[1]
[\exp(-m) \sum_{j = 0}^{\lfloor{k}\rfloor} \frac{m^j}{j!}.]
参数:
k数组样式
发生次数(非负实数)
m数组样式
形状参数(非负实数)
outndarray,可选
可选的输出数组以获得函数结果
返回:
标量或者 ndarray
泊松累积分布函数的值
另请参见
泊松生存函数
相对于k
相对于m的pdtr
的反函数
参考文献
[1]
示例
>>> import numpy as np
>>> import scipy.special as sc
这是一个累积分布函数,因此随着k趋向于无穷大,它单调地收敛到 1。
>>> sc.pdtr([1, 10, 100, np.inf], 1)
array([0.73575888, 0.99999999, 1\. , 1\. ])
在整数处不连续,在整数之间保持恒定。
>>> sc.pdtr([1, 1.5, 1.9, 2], 1)
array([0.73575888, 0.73575888, 0.73575888, 0.9196986 ])
scipy.special.pdtrik
原文:
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.pdtrik.html#scipy.special.pdtrik
scipy.special.pdtrik(p, m, out=None) = <ufunc 'pdtrik'>
相对于 m 的 pdtr
的逆。
参数:
m array_like
形状参数(非负实数)
p array_like
概率
out ndarray,可选
函数结果的可选输出数组
返回:
标量或 ndarray
发生次数 k 满足 pdtr(k, m) = p
的数量
另见
pdtr
Poisson 累积分布函数
pdtrc
Poisson 生存函数
pdtri
相对于 m 的逆函数 pdtr
的逆
scipy.special.pdtr
原文链接:
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.pdtr.html#scipy.special.pdtr
scipy.special.pdtr(k, m, out=None) = <ufunc 'pdtr'>
泊松累积分布函数。
定义为泊松分布随机变量事件率为 (m) 小于或等于 (k) 的概率。更具体地说,这将变为 [1]
[\exp(-m) \sum_{j = 0}^{\lfloor{k}\rfloor} \frac{m^j}{j!}.]
参数:
k类似数组
出现次数(非负实数)
m类似数组
形状参数(非负实数)
out数组,可选
函数结果的可选输出数组
返回:
标量或数组
泊松累积分布函数的值
另请参见
泊松生存函数
相对于 k 的 pdtr
的逆
相对于 m 的 pdtr
的逆
参考文献
[1]
en.wikipedia.org/wiki/Poisson_distribution
示例
>>> import numpy as np
>>> import scipy.special as sc
这是一个累积分布函数,因此随着 k 趋向无穷大,它单调收敛于 1。
>>> sc.pdtr([1, 10, 100, np.inf], 1)
array([0.73575888, 0.99999999, 1\. , 1\. ])
在整数处不连续,在整数之间恒定。
>>> sc.pdtr([1, 1.5, 1.9, 2], 1)
array([0.73575888, 0.73575888, 0.73575888, 0.9196986 ])
scipy.special.stdtr
原文:
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.stdtr.html#scipy.special.stdtr
scipy.special.stdtr(df, t, out=None) = <ufunc 'stdtr'>
学生 t 分布累积分布函数
返回积分:
[\frac{\Gamma((df+1)/2)}{\sqrt{\pi df} \Gamma(df/2)} \int_{-\infty}^t (1+x²/df)^{-(df+1)/2}, dx]
参数:
df数组样式
自由度
t数组样式
积分的上限
out ndarray,可选
函数结果的可选输出数组
返回:
标量或 ndarray
t 的学生 CDF 的值
另请参阅
stdtridf
与df相关的 stdtr 的逆
stdtrit
与t相关的 stdtr 的逆
scipy.stats.t
学生 t 分布
注
学生 t 分布也可以作为scipy.stats.t
使用。与scipy.stats.t
的cdf
方法相比,直接调用stdtr
可以提高性能(见下面的最后一个示例)。
示例
计算df=3
时在t=1
处的函数。
>>> import numpy as np
>>> from scipy.special import stdtr
>>> import matplotlib.pyplot as plt
>>> stdtr(3, 1)
0.8044988905221148
绘制三个不同自由度的函数。
>>> x = np.linspace(-10, 10, 1000)
>>> fig, ax = plt.subplots()
>>> parameters = [(1, "solid"), (3, "dashed"), (10, "dotted")]
>>> for (df, linestyle) in parameters:
... ax.plot(x, stdtr(df, x), ls=linestyle, label=f"$df={df}$")
>>> ax.legend()
>>> ax.set_title("Student t distribution cumulative distribution function")
>>> plt.show()
通过为df提供 NumPy 数组或列表,可以同时计算多个自由度的函数。
>>> stdtr([1, 2, 3], 1)
array([0.75 , 0.78867513, 0.80449889])
通过为df和t提供适合广播的形状的数组,可以同时在几个不同的自由度上计算几个点的函数值。在 3 个自由度的情况下,为 4 个点计算stdtr
,得到一个形状为 3x4 的数组。
>>> dfs = np.array([[1], [2], [3]])
>>> t = np.array([2, 4, 6, 8])
>>> dfs.shape, t.shape
((3, 1), (4,))
>>> stdtr(dfs, t)
array([[0.85241638, 0.92202087, 0.94743154, 0.96041658],
[0.90824829, 0.97140452, 0.98666426, 0.99236596],
[0.93033702, 0.98599577, 0.99536364, 0.99796171]])
t 分布也可以作为scipy.stats.t
使用。直接调用stdtr
比调用scipy.stats.t
的cdf
方法要快得多。为了获得相同的结果,必须使用以下参数化方式:scipy.stats.t(df).cdf(x) = stdtr(df, x)
。
>>> from scipy.stats import t
>>> df, x = 3, 1
>>> stdtr_result = stdtr(df, x) # this can be faster than below
>>> stats_result = t(df).cdf(x)
>>> stats_result == stdtr_result # test that results are equal
True
scipy.special.stdtridf
scipy.special.stdtridf(p, t, out=None) = <ufunc 'stdtridf'>
stdtr
的逆与 df
返回参数 df,使得 stdtr(df, t) 等于 p。
参数:
p,类似于数组
概率
t,类似于数组
积分的上限
out,可选项
函数结果的可选输出数组
返回:
df,标量或数组
值 df,使得 stdtr(df, t) == p
参见
stdtr
学生 t 分布函数
stdtrit
t的逆 stdtr
scipy.stats.t
学生 t 分布
示例
计算一个参数集的学生 t 累积分布函数。
>>> from scipy.special import stdtr, stdtridf
>>> df, x = 5, 2
>>> cdf_value = stdtr(df, x)
>>> cdf_value
0.9490302605850709
验证当给定 CDF 值和 x 时,stdtridf
恢复原始值 df。
>>> stdtridf(cdf_value, x)
5.0
scipy.special.stdtr
原文链接:
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.stdtr.html#scipy.special.stdtr
scipy.special.stdtr(df, t, out=None) = <ufunc 'stdtr'>
学生 t 分布累积分布函数
返回积分:
[\frac{\Gamma((df+1)/2)}{\sqrt{\pi df} \Gamma(df/2)} \int_{-\infty}^t (1+x²/df)^{-(df+1)/2}, dx]
参数:
dfarray_like
自由度
tarray_like
积分的上界
outndarray,可选
用于输出函数结果的可选输出数组
返回:
标量或 ndarray
t 处的学生 t CDF 值
另见
stdtridf
stdtr 的逆函数关于df
stdtrit
stdtr 的逆函数关于t
scipy.stats.t
学生 t 分布
注意
学生 t 分布也可以作为scipy.stats.t
调用。与scipy.stats.t
的cdf
方法相比,直接调用stdtr
可以提高性能(见下面的最后一个例子)。
示例
在df=3
和t=1
处计算函数。
>>> import numpy as np
>>> from scipy.special import stdtr
>>> import matplotlib.pyplot as plt
>>> stdtr(3, 1)
0.8044988905221148
绘制三种不同自由度的函数。
>>> x = np.linspace(-10, 10, 1000)
>>> fig, ax = plt.subplots()
>>> parameters = [(1, "solid"), (3, "dashed"), (10, "dotted")]
>>> for (df, linestyle) in parameters:
... ax.plot(x, stdtr(df, x), ls=linestyle, label=f"$df={df}$")
>>> ax.legend()
>>> ax.set_title("Student t distribution cumulative distribution function")
>>> plt.show()
通过为df提供 NumPy 数组或列表,可以同时计算几个自由度的函数:
>>> stdtr([1, 2, 3], 1)
array([0.75 , 0.78867513, 0.80449889])
可以通过为df和t提供广播兼容形状的数组,在几个不同自由度同时计算几个点的函数。计算 3 自由度下 4 点的stdtr
,得到形状为 3x4 的数组。
>>> dfs = np.array([[1], [2], [3]])
>>> t = np.array([2, 4, 6, 8])
>>> dfs.shape, t.shape
((3, 1), (4,))
>>> stdtr(dfs, t)
array([[0.85241638, 0.92202087, 0.94743154, 0.96041658],
[0.90824829, 0.97140452, 0.98666426, 0.99236596],
[0.93033702, 0.98599577, 0.99536364, 0.99796171]])
学生 t 分布也可以作为scipy.stats.t
调用。直接调用stdtr
比调用scipy.stats.t
的cdf
方法速度要快得多。为了得到相同的结果,必须使用以下参数化方式:scipy.stats.t(df).cdf(x) = stdtr(df, x)
。
>>> from scipy.stats import t
>>> df, x = 3, 1
>>> stdtr_result = stdtr(df, x) # this can be faster than below
>>> stats_result = t(df).cdf(x)
>>> stats_result == stdtr_result # test that results are equal
True
scipy.special.stdtrit
原文:
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.stdtrit.html#scipy.special.stdtrit
scipy.special.stdtrit(df, p, out=None) = <ufunc 'stdtrit'>
学生 t 分布的p分位数。
此函数是学生 t 分布累积分布函数的逆,返回t,使得stdtr(df, t) = p。
返回参数t,使得 stdtr(df, t)等于p。
参数:
dfarray_like
自由度
parray_like
概率
outndarray,可选
可选的输出数组用于函数结果
返回:
t标量或 ndarray
根据stdtr(df, t) == p
计算使得t等于p的值。
另请参阅
stdtr
学生 t 分布的累积分布函数
stdtridf
df的 stdtr 的逆
scipy.stats.t
学生 t 分布
注释
学生 t 分布也可以作为scipy.stats.t
使用。直接调用stdtrit
相对于scipy.stats.t
的ppf
方法可以提高性能(见下面的最后一个例子)。
示例
stdtrit
表示学生 t 分布的累积分布函数的逆,该函数可作为stdtr
获得。在此,我们计算df
在x=1
时的累积分布函数。stdtrit
然后返回 1,直到浮点误差给出相同的值用于df和计算的累积分布函数值。
>>> import numpy as np
>>> from scipy.special import stdtr, stdtrit
>>> import matplotlib.pyplot as plt
>>> df = 3
>>> x = 1
>>> cdf_value = stdtr(df, x)
>>> stdtrit(df, cdf_value)
0.9999999994418539
绘制三个不同自由度的函数。
>>> x = np.linspace(0, 1, 1000)
>>> parameters = [(1, "solid"), (2, "dashed"), (5, "dotted")]
>>> fig, ax = plt.subplots()
>>> for (df, linestyle) in parameters:
... ax.plot(x, stdtrit(df, x), ls=linestyle, label=f"$df={df}$")
>>> ax.legend()
>>> ax.set_ylim(-10, 10)
>>> ax.set_title("Student t distribution quantile function")
>>> plt.show()
通过提供df的 NumPy 数组或列表,可以同时计算几个自由度的函数。
>>> stdtrit([1, 2, 3], 0.7)
array([0.72654253, 0.6172134 , 0.58438973])
通过提供形状兼容进行广播的df和p数组,可以同时计算几个不同自由度的点的函数值。在 3 个自由度的情况下为 4 个点计算stdtrit
,返回形状为 3x4 的数组。
>>> dfs = np.array([[1], [2], [3]])
>>> p = np.array([0.2, 0.4, 0.7, 0.8])
>>> dfs.shape, p.shape
((3, 1), (4,))
>>> stdtrit(dfs, p)
array([[-1.37638192, -0.3249197 , 0.72654253, 1.37638192],
[-1.06066017, -0.28867513, 0.6172134 , 1.06066017],
[-0.97847231, -0.27667066, 0.58438973, 0.97847231]])
学生 t 分布也可以作为scipy.stats.t
使用。直接调用stdtrit
比调用scipy.stats.t
的ppf
方法更快。要获得相同的结果,必须使用以下参数化:scipy.stats.t(df).ppf(x) = stdtrit(df, x)
。
>>> from scipy.stats import t
>>> df, x = 3, 0.5
>>> stdtrit_result = stdtrit(df, x) # this can be faster than below
>>> stats_result = t(df).ppf(x)
>>> stats_result == stdtrit_result # test that results are equal
True
scipy.special.chdtr
原文:
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.chdtr.html#scipy.special.chdtr
scipy.special.chdtr(v, x, out=None) = <ufunc 'chdtr'>
卡方累积分布函数。
返回自由度为v的卡方概率密度函数左尾(从 0 到x)下的面积:
[\frac{1}{2^{v/2} \Gamma(v/2)} \int_0^x t^{v/2 - 1} e^{-t/2} dt]
这里(\Gamma)是 Gamma 函数;见gamma
。此积分可用正则化的下不完全 Gamma 函数gammainc
表示为gammainc(v / 2, x / 2)
。[1]
参数:
varray_like
自由度。
xarray_like
积分的上界。
outndarray, optional
可选的输出数组以获取函数结果。
返回:
标量或 ndarray
累积分布函数的值。
另请参阅
chdtrc
, chdtri
, chdtriv
, gammainc
参考文献
[1]
卡方分布,www.itl.nist.gov/div898/handbook/eda/section3/eda3666.htm
示例
>>> import numpy as np
>>> import scipy.special as sc
可以用正则化的下不完全 Gamma 函数表示。
>>> v = 1
>>> x = np.arange(4)
>>> sc.chdtr(v, x)
array([0\. , 0.68268949, 0.84270079, 0.91673548])
>>> sc.gammainc(v / 2, x / 2)
array([0\. , 0.68268949, 0.84270079, 0.91673548])
scipy.special.chdtrc
原文:
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.chdtrc.html#scipy.special.chdtrc
scipy.special.chdtrc(v, x, out=None) = <ufunc 'chdtrc'>
卡方生存函数。
返回自由度为 v 的卡方概率密度函数右尾部分(从 x 到无穷大)下面积分的面积:
[\frac{1}{2^{v/2} \Gamma(v/2)} \int_x^\infty t^{v/2 - 1} e^{-t/2} dt]
这里 (\Gamma) 是 Gamma 函数;参见gamma
。这个积分可以用常规化的上不完全 Gamma 函数gammaincc
表示为 gammaincc(v / 2, x / 2)
。[1]
参数:
v 数组型
自由度。
x 数组型
积分的下限。
out ndarray,可选
可选输出数组的函数结果。
返回值:
标量或 ndarray
生存函数的值。
参见
chdtr
, chdtri
, chdtriv
, gammaincc
参考文献
[1]
卡方分布,www.itl.nist.gov/div898/handbook/eda/section3/eda3666.htm
示例
>>> import numpy as np
>>> import scipy.special as sc
可以用常规化的上不完全 Gamma 函数表示。
>>> v = 1
>>> x = np.arange(4)
>>> sc.chdtrc(v, x)
array([1\. , 0.31731051, 0.15729921, 0.08326452])
>>> sc.gammaincc(v / 2, x / 2)
array([1\. , 0.31731051, 0.15729921, 0.08326452])
scipy.special.chdtri
原文:
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.chdtri.html#scipy.special.chdtri
scipy.special.chdtri(v, p, out=None) = <ufunc 'chdtri'>
相对于x,与chdtrc
相反。
返回x,使得chdtrc(v, x) == p
。
参数:
varray_like
自由度。
parray_like
概率。
outndarray,可选
函数结果的可选输出数组。
返回:
x标量或 ndarray
使卡方随机变量的概率(自由度为v)大于x的值等于p。
另请参阅
chdtrc
,chdtr
,chdtriv
参考文献
[1]
卡方分布,www.itl.nist.gov/div898/handbook/eda/section3/eda3666.htm
示例
>>> import scipy.special as sc
它反转了chdtrc
。
>>> v, p = 1, 0.3
>>> sc.chdtrc(v, sc.chdtri(v, p))
0.3
>>> x = 1
>>> sc.chdtri(v, sc.chdtrc(v, x))
1.0
scipy.special.chdtrc
原文链接:
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.chdtrc.html#scipy.special.chdtrc
scipy.special.chdtrc(v, x, out=None) = <ufunc 'chdtrc'>
卡方生存函数。
返回卡方概率密度函数右尾(从 x 到无穷大)下的面积,具有 v 自由度:
[\frac{1}{2^{v/2} \Gamma(v/2)} \int_x^\infty t^{v/2 - 1} e^{-t/2} dt]
这里 (\Gamma) 是伽马函数;参见 gamma
。这个积分可以用正则化的上不完全伽马函数 gammaincc
表示为 gammaincc(v / 2, x / 2)
。 [1]
参数:
varray_like
自由度。
xarray_like
积分的下界。
outndarray, 可选
该函数结果的可选输出数组。
返回:
标量或 ndarray
生存函数的值。
见下文
chdtr
, chdtri
, chdtriv
, gammaincc
参考文献
[1]
卡方分布,www.itl.nist.gov/div898/handbook/eda/section3/eda3666.htm
示例
>>> import numpy as np
>>> import scipy.special as sc
可以用正则化的上不完全伽马函数来表示。
>>> v = 1
>>> x = np.arange(4)
>>> sc.chdtrc(v, x)
array([1\. , 0.31731051, 0.15729921, 0.08326452])
>>> sc.gammaincc(v / 2, x / 2)
array([1\. , 0.31731051, 0.15729921, 0.08326452])
scipy.special.chdtriv
原文链接:
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.chdtriv.html#scipy.special.chdtriv
scipy.special.chdtriv(p, x, out=None) = <ufunc 'chdtriv'>
关于v的chdtr
的反函数。
返回v,使得chdtr(v, x) == p
。
参数:
parray_like
卡方随机变量小于或等于x的概率。
xarray_like
非负输入。
outndarray,可选
可选的输出数组,用于存储函数结果。
返回:
标量或 ndarray
自由度。
另见
参考文献
[1]
卡方分布,www.itl.nist.gov/div898/handbook/eda/section3/eda3666.htm
示例
>>> import scipy.special as sc
它反转chdtr
。
>>> p, x = 0.5, 1
>>> sc.chdtr(sc.chdtriv(p, x), x)
0.5000000000202172
>>> v = 1
>>> sc.chdtriv(sc.chdtr(v, x), v)
1.0000000000000013
scipy.special.chdtr
原文:
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.chdtr.html#scipy.special.chdtr
scipy.special.chdtr(v, x, out=None) = <ufunc 'chdtr'>
卡方累积分布函数。
返回自由度为v的卡方概率密度函数左尾(从 0 到x)下的面积:
[\frac{1}{2^{v/2} \Gamma(v/2)} \int_0^x t^{v/2 - 1} e^{-t/2} dt]
这里(\Gamma)是 Gamma 函数;参见gamma
。这个积分可以用正则化的下不完全 Gamma 函数gammainc
表示为gammainc(v / 2, x / 2)
。[1]
参数:
varray_like
自由度。
xarray_like
积分的上界。
outndarray,可选
函数结果的可选输出数组。
返回:
标量或 ndarray
累积分布函数的值。
另请参见
chdtrc
,chdtri
,chdtriv
,gammainc
参考文献
[1]
卡方分布,www.itl.nist.gov/div898/handbook/eda/section3/eda3666.htm
示例
>>> import numpy as np
>>> import scipy.special as sc
可以用正则化的下不完全 Gamma 函数表示。
>>> v = 1
>>> x = np.arange(4)
>>> sc.chdtr(v, x)
array([0\. , 0.68268949, 0.84270079, 0.91673548])
>>> sc.gammainc(v / 2, x / 2)
array([0\. , 0.68268949, 0.84270079, 0.91673548])
scipy.special.chndtr
原文:
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.chndtr.html#scipy.special.chndtr
scipy.special.chndtr(x, df, nc, out=None) = <ufunc 'chndtr'>
非中心卡方累积分布函数
累积分布函数由以下公式给出:
[P(\chi^{\prime 2} \vert \nu, \lambda) =\sum_{j=0}^{\infty} e^{-\lambda /2} \frac{(\lambda /2)^j}{j!} P(\chi^{\prime 2} \vert \nu + 2j),]
其中 (\nu > 0) 是自由度 (df
),(\lambda \geq 0) 是非中心参数 (nc
)。
参数:
x array_like
积分的上限;必须满足x >= 0
df array_like
自由度;必须满足df > 0
nc array_like
非中心参数;必须满足nc >= 0
out ndarray,可选
可选的输出数组,用于存储函数结果
返回值:
x 标量或者 ndarray
非中心卡方累积分布函数的值。
另请参阅
chndtrix
, chndtridf
, chndtrinc
scipy.special.chndtridf
scipy.special.chndtridf(x, p, nc, out=None) = <ufunc 'chndtridf'>
chndtr
的逆函数 vs df
使用搜索找到一个值为 df 的值,以得到所需的 p 值。
参数:
x 数组或类似数组
积分的上界;必须满足 x >= 0
p 数组或类似数组
概率;必须满足 0 <= p < 1
nc 数组或类似数组
非中心参数;必须满足 nc >= 0
out ndarray,可选
函数结果的可选输出数组
返回:
df 标量或者 ndarray
自由度
另请参阅
scipy.special.chndtr
原文:
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.chndtr.html#scipy.special.chndtr
scipy.special.chndtr(x, df, nc, out=None) = <ufunc 'chndtr'>
非中心卡方分布累积分布函数
累积分布函数由以下给出:
[P(\chi^{\prime 2} \vert \nu, \lambda) =\sum_{j=0}^{\infty} e^{-\lambda /2} \frac{(\lambda /2)^j}{j!} P(\chi^{\prime 2} \vert \nu + 2j),]
其中 (\nu > 0) 是自由度 (df
),(\lambda \geq 0) 是非中心参数 (nc
)。
参数:
xarray_like
积分的上限;必须满足 x >= 0
dfarray_like
自由度;必须满足 df > 0
ncarray_like
非中心参数;必须满足 nc >= 0
outndarray, 可选
可选的输出数组用于函数结果
返回:
x标量或数组
非中心卡方分布累积分布函数的值。
另见
chndtrix
, chndtridf
, chndtrinc
scipy.special.chndtrinc
scipy.special.chndtrinc(x, df, p, out=None) = <ufunc 'chndtrinc'>
逆函数为chndtr
与nc的比例
使用搜索计算df的值,以得到期望的p值。
参数:
x数组类型
积分的上限;必须满足x >= 0
df数组类型
自由度;必须满足df > 0
p数组类型
概率;必须满足0 <= p < 1
out数组类型,可选
可选的输出数组用于函数结果
返回:
nc标量或数组
非中心性
另请参见
chndtr
, chndtrix
, chndtrinc
scipy.special.chndtr
原文链接:
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.chndtr.html#scipy.special.chndtr
scipy.special.chndtr(x, df, nc, out=None) = <ufunc 'chndtr'>
非中心卡方累积分布函数
累积分布函数由以下给出:
[P(\chi^{\prime 2} \vert \nu, \lambda) =\sum_{j=0}^{\infty} e^{-\lambda /2} \frac{(\lambda /2)^j}{j!} P(\chi^{\prime 2} \vert \nu + 2j),]
其中 (\nu > 0) 是自由度(df
),(\lambda \geq 0) 是非中心参数(nc
)。
参数:
xarray_like
积分的上限;必须满足 x >= 0
dfarray_like
自由度;必须满足 df > 0
ncarray_like
非中心参数;必须满足 nc >= 0
outndarray,可选
函数结果的可选输出数组
返回:
x标量或数组
非中心卡方累积分布函数的值。
另请参阅
chndtrix
, chndtridf
, chndtrinc
scipy.special.chndtrix
scipy.special.chndtrix(p, df, nc, out=None) = <ufunc 'chndtrix'>
逆chndtr
对应的x
使用搜索计算得到使得p的概率为目标的x的值。
参数:
parray_like
概率;必须满足 0 <= p < 1
dfarray_like
自由度;必须满足 df > 0
ncarray_like
非中心参数;必须满足 nc >= 0
outndarray,可选
函数结果的可选输出数组
返回:
x标量或 ndarray
使得自由度为df、非中心度nc的非中心卡方随机变量大于x的概率等于p的值。
参见
scipy.special.chndtr
原文:
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.chndtr.html#scipy.special.chndtr
scipy.special.chndtr(x, df, nc, out=None) = <ufunc 'chndtr'>
非中心卡方累积分布函数
累积分布函数如下所示:
[P(\chi^{\prime 2} \vert \nu, \lambda) =\sum_{j=0}^{\infty} e^{-\lambda /2} \frac{(\lambda /2)^j}{j!} P(\chi^{\prime 2} \vert \nu + 2j),]
其中 (\nu > 0) 是自由度(df
),(\lambda \geq 0) 是非中心参数(nc
)。
参数:
x数组
积分的上限;必须满足x >= 0
df数组
自由度;必须满足df > 0
nc数组
非中心参数;必须满足nc >= 0
out数组,可选
函数结果的可选输出数组
返回:
x标量或数组
非中心卡方累积分布函数的值。
另请参见
scipy.special.smirnov
原文链接:
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.smirnov.html#scipy.special.smirnov
scipy.special.smirnov(n, d, out=None) = <ufunc 'smirnov'>
Kolmogorov-Smirnov 互补累积分布函数
返回确切的 Kolmogorov-Smirnov 互补累积分布函数(也称为生存函数),Dn+(或 Dn-)的单侧相等性检验的理论分布和经验分布之间的最大差异的概率。它等于基于n个样本的理论分布和经验分布之间的最大差异大于 d 的概率。
参数:
nint
样本数量
dfloat array_like
经验 CDF(ECDF)与目标 CDF 之间的偏差。
outndarray,可选
函数结果的可选输出数组
返回:
标量或 ndarray
smirnov(n, d)的值,Prob(Dn+ >= d)(也是 Prob(Dn- >= d))
另请参见
smirnovi
分布的逆生存函数
scipy.stats.ksone
提供作为连续分布的功能
kolmogorov
, kolmogi
用于双侧分布的函数
注意事项
smirnov
被stats.kstest在 Kolmogorov-Smirnov 拟合度检验中使用。出于历史原因,此函数在scipy.special中公开,但实现最精确的 CDF/SF/PDF/PPF/ISF 计算的推荐方法是使用stats.ksone分布。
示例
>>> import numpy as np
>>> from scipy.special import smirnov
>>> from scipy.stats import norm
显示大小为 5 的样本至少大于等于 0、0.5 和 1.0 的间隙的概率。
>>> smirnov(5, [0, 0.5, 1.0])
array([ 1\. , 0.056, 0\. ])
将大小为 5 的样本与 N(0, 1)(均值为 0,标准差为 1)进行比较。
x是样本。
>>> x = np.array([-1.392, -0.135, 0.114, 0.190, 1.82])
>>> target = norm(0, 1)
>>> cdfs = target.cdf(x)
>>> cdfs
array([0.0819612 , 0.44630594, 0.5453811 , 0.57534543, 0.9656205 ])
构建经验 CDF 和 K-S 统计量(Dn+、Dn-、Dn)。
>>> n = len(x)
>>> ecdfs = np.arange(n+1, dtype=float)/n
>>> cols = np.column_stack([x, ecdfs[1:], cdfs, cdfs - ecdfs[:n],
... ecdfs[1:] - cdfs])
>>> with np.printoptions(precision=3):
... print(cols)
[[-1.392 0.2 0.082 0.082 0.118]
[-0.135 0.4 0.446 0.246 -0.046]
[ 0.114 0.6 0.545 0.145 0.055]
[ 0.19 0.8 0.575 -0.025 0.225]
[ 1.82 1\. 0.966 0.166 0.034]]
>>> gaps = cols[:, -2:]
>>> Dnpm = np.max(gaps, axis=0)
>>> print(f'Dn-={Dnpm[0]:f}, Dn+={Dnpm[1]:f}')
Dn-=0.246306, Dn+=0.224655
>>> probs = smirnov(n, Dnpm)
>>> print(f'For a sample of size {n} drawn from N(0, 1):',
... f' Smirnov n={n}: Prob(Dn- >= {Dnpm[0]:f}) = {probs[0]:.4f}',
... f' Smirnov n={n}: Prob(Dn+ >= {Dnpm[1]:f}) = {probs[1]:.4f}',
... sep='\n')
For a sample of size 5 drawn from N(0, 1):
Smirnov n=5: Prob(Dn- >= 0.246306) = 0.4711
Smirnov n=5: Prob(Dn+ >= 0.224655) = 0.5245
绘制经验 CDF 和标准正态 CDF。
>>> import matplotlib.pyplot as plt
>>> plt.step(np.concatenate(([-2.5], x, [2.5])),
... np.concatenate((ecdfs, [1])),
... where='post', label='Empirical CDF')
>>> xx = np.linspace(-2.5, 2.5, 100)
>>> plt.plot(xx, target.cdf(xx), '--', label='CDF for N(0, 1)')
添加标记 Dn+和 Dn-的垂直线。
>>> iminus, iplus = np.argmax(gaps, axis=0)
>>> plt.vlines([x[iminus]], ecdfs[iminus], cdfs[iminus], color='r',
... alpha=0.5, lw=4)
>>> plt.vlines([x[iplus]], cdfs[iplus], ecdfs[iplus+1], color='m',
... alpha=0.5, lw=4)
>>> plt.grid(True)
>>> plt.legend(framealpha=1, shadow=True)
>>> plt.show()
scipy.special.smirnovi
scipy.special.smirnovi(n, p, out=None) = <ufunc 'smirnovi'>
逆函数 smirnov
返回 d,使得 smirnov(n, d) == p
,与 p 对应的临界值。
参数:
nint
样本数量
pfloat array_like
概率
outndarray,可选
函数结果的可选输出数组
返回:
标量或 ndarray
smirnovi(n, p) 的值(或值的集合),关键值。
另请参见
smirnov
分布的生存函数(SF)
scipy.stats.ksone
作为连续分布的功能
kolmogorov
,kolmogi
两边分布的函数
scipy.stats.kstwobign
双边 Kolmogorov-Smirnov 分布,大 n
注意事项
stats.kstest 应用了 Kolmogorov-Smirnov 拟合优度检验中的smirnov
。出于历史原因,此函数暴露在 scpy.special 中,但实现最精确的 CDF/SF/PDF/PPF/ISF 计算的推荐方法是使用 stats.ksone 分布。
示例
>>> from scipy.special import smirnovi, smirnov
>>> n = 24
>>> deviations = [0.1, 0.2, 0.3]
使用 smirnov
来计算给定样本数量和偏差的 Smirnov 分布的互补 CDF。
>>> p = smirnov(n, deviations)
>>> p
array([0.58105083, 0.12826832, 0.01032231])
逆函数 smirnovi(n, p)
返回 deviations
。
>>> smirnovi(n, p)
array([0.1, 0.2, 0.3])
scipy.special.smirnov
原文链接:
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.smirnov.html#scipy.special.smirnov
scipy.special.smirnov(n, d, out=None) = <ufunc 'smirnov'>
Kolmogorov-Smirnov 单侧累积分布函数
返回 Kolmogorov-Smirnov 单侧检验(即生存函数)的确切值 Dn+(或 Dn-),用于衡量经验分布与理论分布的一致性。它等于理论分布与基于 n 个样本的经验分布之间的最大差异大于 d 的概率。
参数:
n 整数
样本数量
d 浮点数数组
经验 CDF(ECDF)与目标 CDF 之间的偏差。
out ndarray,可选
可选的输出数组,用于函数结果
返回:
标量或者 ndarray
smirnov(n, d) 的值,Prob(Dn+ >= d)(也是 Prob(Dn- >= d))
参见
smirnovi
分布的逆生存函数
scipy.stats.ksone
提供连续分布的功能
kolmogorov
,kolmogi
两侧分布的函数
注意:
smirnov
在 Kolmogorov-Smirnov 拟合优度检验中由 stats.kstest 应用。出于历史原因,此函数在 scpy.special 中公开,但建议以最准确的 CDF/SF/PDF/PPF/ISF 计算方式使用 stats.ksone 分布。
示例
>>> import numpy as np
>>> from scipy.special import smirnov
>>> from scipy.stats import norm
显示大小至少为 0、0.5 和 1.0 的间隙的概率,对于大小为 5 的样本。
>>> smirnov(5, [0, 0.5, 1.0])
array([ 1\. , 0.056, 0\. ])
比较大小为 5 的样本与 N(0, 1) 的标准正态分布,其中均值为 0,标准差为 1。
x 是样本。
>>> x = np.array([-1.392, -0.135, 0.114, 0.190, 1.82])
>>> target = norm(0, 1)
>>> cdfs = target.cdf(x)
>>> cdfs
array([0.0819612 , 0.44630594, 0.5453811 , 0.57534543, 0.9656205 ])
构造经验 CDF 和 K-S 统计量(Dn+、Dn-、Dn)。
>>> n = len(x)
>>> ecdfs = np.arange(n+1, dtype=float)/n
>>> cols = np.column_stack([x, ecdfs[1:], cdfs, cdfs - ecdfs[:n],
... ecdfs[1:] - cdfs])
>>> with np.printoptions(precision=3):
... print(cols)
[[-1.392 0.2 0.082 0.082 0.118]
[-0.135 0.4 0.446 0.246 -0.046]
[ 0.114 0.6 0.545 0.145 0.055]
[ 0.19 0.8 0.575 -0.025 0.225]
[ 1.82 1\. 0.966 0.166 0.034]]
>>> gaps = cols[:, -2:]
>>> Dnpm = np.max(gaps, axis=0)
>>> print(f'Dn-={Dnpm[0]:f}, Dn+={Dnpm[1]:f}')
Dn-=0.246306, Dn+=0.224655
>>> probs = smirnov(n, Dnpm)
>>> print(f'For a sample of size {n} drawn from N(0, 1):',
... f' Smirnov n={n}: Prob(Dn- >= {Dnpm[0]:f}) = {probs[0]:.4f}',
... f' Smirnov n={n}: Prob(Dn+ >= {Dnpm[1]:f}) = {probs[1]:.4f}',
... sep='\n')
For a sample of size 5 drawn from N(0, 1):
Smirnov n=5: Prob(Dn- >= 0.246306) = 0.4711
Smirnov n=5: Prob(Dn+ >= 0.224655) = 0.5245
绘制经验 CDF 和标准正态 CDF。
>>> import matplotlib.pyplot as plt
>>> plt.step(np.concatenate(([-2.5], x, [2.5])),
... np.concatenate((ecdfs, [1])),
... where='post', label='Empirical CDF')
>>> xx = np.linspace(-2.5, 2.5, 100)
>>> plt.plot(xx, target.cdf(xx), '--', label='CDF for N(0, 1)')
添加标记 Dn+ 和 Dn- 的垂直线。
>>> iminus, iplus = np.argmax(gaps, axis=0)
>>> plt.vlines([x[iminus]], ecdfs[iminus], cdfs[iminus], color='r',
... alpha=0.5, lw=4)
>>> plt.vlines([x[iplus]], cdfs[iplus], ecdfs[iplus+1], color='m',
... alpha=0.5, lw=4)
>>> plt.grid(True)
>>> plt.legend(framealpha=1, shadow=True)
>>> plt.show()
scipy.special.kolmogorov
scipy.special.kolmogorov(y, out=None) = <ufunc 'kolmogorov'>
Kolmogorov 分布的补充累积分布(Survival Function)函数。
返回两边检验(empirical 与 theoretical distribution 之间的)Kolmogorov 极限分布的补充累积分布函数(当 n 趋向无穷时,D_n*\sqrt(n)
)。等于(n 趋向无穷时的极限)概率,即sqrt(n) * max absolute deviation > y
。
参数:
y 浮点数数组
经验累积分布函数(ECDF)与目标 CDF 之间的绝对偏差,乘以 sqrt(n)。
out ndarray,可选
函数结果的可选输出数组
返回值:
标量或 ndarray
kolmogorov(y)
的值
另请参阅
kolmogi
分布的逆存活函数
scipy.stats.kstwobign
提供作为连续分布的功能
smirnov
,smirnovi
一侧分布函数
注意事项
kolmogorov
被stats.kstest在 Kolmogorov-Smirnov 拟合优度检验中使用。出于历史原因,此函数暴露在scipy.special中,但建议获取最精确的 CDF/SF/PDF/PPF/ISF 计算的方法是使用stats.kstwobign分布。
示例
显示至少大于 0、0.5 和 1.0 的间隙的概率。
>>> import numpy as np
>>> from scipy.special import kolmogorov
>>> from scipy.stats import kstwobign
>>> kolmogorov([0, 0.5, 1.0])
array([ 1\. , 0.96394524, 0.26999967])
将大小为 1000 的拉普拉斯(0, 1)分布样本与目标分布,正态(0, 1)分布进行比较。
>>> from scipy.stats import norm, laplace
>>> rng = np.random.default_rng()
>>> n = 1000
>>> lap01 = laplace(0, 1)
>>> x = np.sort(lap01.rvs(n, random_state=rng))
>>> np.mean(x), np.std(x)
(-0.05841730131499543, 1.3968109101997568)
构建经验累积分布函数(ECDF)和 K-S 统计量 Dn。
>>> target = norm(0,1) # Normal mean 0, stddev 1
>>> cdfs = target.cdf(x)
>>> ecdfs = np.arange(n+1, dtype=float)/n
>>> gaps = np.column_stack([cdfs - ecdfs[:n], ecdfs[1:] - cdfs])
>>> Dn = np.max(gaps)
>>> Kn = np.sqrt(n) * Dn
>>> print('Dn=%f, sqrt(n)*Dn=%f' % (Dn, Kn))
Dn=0.043363, sqrt(n)*Dn=1.371265
>>> print(chr(10).join(['For a sample of size n drawn from a N(0, 1) distribution:',
... ' the approximate Kolmogorov probability that sqrt(n)*Dn>=%f is %f' %
... (Kn, kolmogorov(Kn)),
... ' the approximate Kolmogorov probability that sqrt(n)*Dn<=%f is %f' %
... (Kn, kstwobign.cdf(Kn))]))
For a sample of size n drawn from a N(0, 1) distribution:
the approximate Kolmogorov probability that sqrt(n)*Dn>=1.371265 is 0.046533
the approximate Kolmogorov probability that sqrt(n)*Dn<=1.371265 is 0.953467
绘制经验累积分布函数(Empirical CDF)与目标 N(0, 1)累积分布函数的对比图。
>>> import matplotlib.pyplot as plt
>>> plt.step(np.concatenate([[-3], x]), ecdfs, where='post', label='Empirical CDF')
>>> x3 = np.linspace(-3, 3, 100)
>>> plt.plot(x3, target.cdf(x3), label='CDF for N(0, 1)')
>>> plt.ylim([0, 1]); plt.grid(True); plt.legend();
>>> # Add vertical lines marking Dn+ and Dn-
>>> iminus, iplus = np.argmax(gaps, axis=0)
>>> plt.vlines([x[iminus]], ecdfs[iminus], cdfs[iminus],
... color='r', linestyle='dashed', lw=4)
>>> plt.vlines([x[iplus]], cdfs[iplus], ecdfs[iplus+1],
... color='r', linestyle='dashed', lw=4)
>>> plt.show()
scipy.special.kolmogi
原文:
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.kolmogi.html#scipy.special.kolmogi
scipy.special.kolmogi(p, out=None) = <ufunc 'kolmogi'>
Kolmogorov 分布的反生存函数
它是 kolmogorov
的反函数。返回 y
使得 kolmogorov(y) == p
。
参数:
p 浮点数数组
概率
out 数组,可选
可选的输出数组用于函数结果
返回:
标量或者多维数组
kolmogi(p)
的值(或值)
另请参见
kolmogorov
分布的生存函数
scipy.stats.kstwobign
作为连续分布的功能
smirnov
, smirnovi
单边分布的函数
注释
kolmogorov
被 stats.kstest 在 Kolmogorov-Smirnov 拟合优度检验中应用。由于历史原因,此函数在 scpy.special 中暴露,但实现最准确的 CDF/SF/PDF/PPF/ISF 计算的推荐方法是使用 stats.kstwobign 分布。
示例
>>> from scipy.special import kolmogi
>>> kolmogi([0, 0.1, 0.25, 0.5, 0.75, 0.9, 1.0])
array([ inf, 1.22384787, 1.01918472, 0.82757356, 0.67644769,
0.57117327, 0\. ])