SciPy 1.12 中文文档（四十三）

原文：docs.scipy.org/doc/scipy-1.12.0/index.html

`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()

../../_images/scipy-special-nbdtrc-1_00_00.png

负二项分布也可以使用 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()

../../_images/scipy-special-nbdtri-1_00_00.png

通过提供与 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()

../../_images/scipy-special-nbdtrik-1_00_00.png

负二项分布也可用作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

负二项累积分布函数。

nbdtri

逆数与 nbdtr(k, n, p) 关于 p 的。

nbdtrik

逆数与 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()

../../_images/scipy-special-nbdtr-1_00_00.png

负二项分布也可以使用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()

../../_images/scipy-special-ncfdtr-1.png

`scipy.special.ncfdtridfd`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.ncfdtridfd.html#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`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.ncfdtridfn.html#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.

`scipy.special.ncfdtrinc`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.ncfdtrinc.html#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

非中心参数。

参见

ncfdtr

非中心 F 分布的累积分布函数。

ncfdtri

分位数函数；相对于f的反函数。

ncfdtridfd

相对于dfd的ncfdtr的反函数。

ncfdtridfn

相对于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()

../../_images/scipy-special-nctdtr-1.png

`scipy.special.nctdtridf`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.nctdtridf.html#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）。如果所有输入都是标量，则返回一个浮点数。否则，返回一个数组。

另见

nctdtr

非中心 t 分布的累积分布函数。

nctdtrit

非中心 t 分布的逆累积分布函数（iCDF）。

nctdtrinc

计算给定 CDF iCDF 值的非中心参数。

`scipy.special.nctdtrit`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.nctdtrit.html#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`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.nctdtrinc.html#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`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.nrdtrimn.html#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`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.nrdtrisd.html#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

标准差。

参见

ndtr

`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()

../../_images/scipy-special-ndtr-1.png

`scipy.special.log_ndtr`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.log_ndtr.html#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()

../../_images/scipy-special-ndtri-1.png

`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()

../../_images/scipy-special-ndtr-1.png

`scipy.special.ndtri_exp`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.ndtri_exp.html#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`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.log_ndtr.html#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

泊松累积分布函数的值

参见

pdtrc

泊松生存函数

pdtrik

与 k 相关的 pdtr 的逆函数

pdtri

与 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.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

泊松生存函数的值

参见

pdtr

泊松累积分布函数

pdtrik

与 k 相关的 pdtr 的逆

pdtri

与 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

另见

pdtr

泊松累积分布函数

pdtrc

泊松生存函数

pdtrik

相对于 k 的 pdtr 的逆函数

SciPy-1-12-中文文档-四十三-

SciPy 1.12 中文文档（四十三）

scipy.special.nbdtrc

scipy.special.nbdtri

scipy.special.nbdtrik

scipy.special.nbdtrin

scipy.special.nbdtr

scipy.special.ncfdtr

scipy.special.ncfdtridfd

scipy.special.ncfdtridfn

scipy.special.ncfdtri

scipy.special.ncfdtrinc

scipy.special.nctdtr

scipy.special.nctdtridf

scipy.special.nctdtrit

scipy.special.nctdtrinc

scipy.special.nrdtrimn

scipy.special.nrdtrisd

scipy.special.ndtr

scipy.special.log_ndtr

scipy.special.ndtri

scipy.special.ndtr

scipy.special.ndtri_exp

scipy.special.log_ndtr

scipy.special.pdtr

scipy.special.pdtrc

scipy.special.pdtri

`scipy.special.nbdtrc`

`scipy.special.nbdtri`

`scipy.special.nbdtrik`

`scipy.special.nbdtrin`

`scipy.special.nbdtr`

`scipy.special.ncfdtr`

`scipy.special.ncfdtridfd`

`scipy.special.ncfdtridfn`

`scipy.special.ncfdtri`

`scipy.special.ncfdtrinc`

`scipy.special.nctdtr`

`scipy.special.nctdtridf`

`scipy.special.nctdtrit`

`scipy.special.nctdtrinc`

`scipy.special.nrdtrimn`

`scipy.special.nrdtrisd`

`scipy.special.ndtr`

`scipy.special.log_ndtr`

`scipy.special.ndtri`

`scipy.special.ndtr`

`scipy.special.ndtri_exp`

`scipy.special.log_ndtr`

`scipy.special.pdtr`

`scipy.special.pdtrc`

`scipy.special.pdtri`