SciPy-1-12-中文文档-十九-

SciPy 1.12 中文文档（十九）

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

`scipy.special.boxcox`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.boxcox.html#scipy.special.boxcox

scipy.special.boxcox(x, lmbda, out=None) = <ufunc 'boxcox'>

计算 Box-Cox 变换。

Box-Cox 变换为：

y = (x**lmbda - 1) / lmbda  if lmbda != 0
    log(x)                  if lmbda == 0

如果 x < 0，返回 nan。如果 x == 0 且 lmbda < 0，返回 -inf。

参数：

xarray_like

待转换的数据。

lmbdaarray_like

Box-Cox 变换的功率参数。

outndarray，可选

可选的输出数组，用于存储函数值

y标量或者 ndarray

转换后的数据。

注释

新版本 0.14.0 中引入。

示例

>>> from scipy.special import boxcox
>>> boxcox([1, 4, 10], 2.5)
array([   0\.        ,   12.4       ,  126.09110641])
>>> boxcox(2, [0, 1, 2])
array([ 0.69314718,  1\.        ,  1.5       ])

`scipy.special.boxcox1p`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.boxcox1p.html#scipy.special.boxcox1p

scipy.special.boxcox1p(x, lmbda, out=None) = <ufunc 'boxcox1p'>

计算 1 + x的 Box-Cox 变换。

由boxcox1p计算的 Box-Cox 变换为：

y = ((1+x)**lmbda - 1) / lmbda  if lmbda != 0
    log(1+x)                    if lmbda == 0

如果x < -1，则返回nan。如果x == -1且lmbda < 0，则返回-inf。

参数：

x array_like

要转换的数据。

lmbda array_like

Box-Cox 变换的功率参数。

out ndarray，可选

函数值的可选输出数组。

y scalar 或 ndarray

转换后的数据。

注意事项

0.14.0 版本中的新功能。

示例

>>> from scipy.special import boxcox1p
>>> boxcox1p(1e-4, [0, 0.5, 1])
array([  9.99950003e-05,   9.99975001e-05,   1.00000000e-04])
>>> boxcox1p([0.01, 0.1], 0.25)
array([ 0.00996272,  0.09645476])

`scipy.special.inv_boxcox`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.inv_boxcox.html#scipy.special.inv_boxcox

scipy.special.inv_boxcox(y, lmbda, out=None) = <ufunc 'inv_boxcox'>

计算 Box-Cox 变换的逆变换。

找到 x 使得：

y = (x**lmbda - 1) / lmbda  if lmbda != 0
    log(x)                  if lmbda == 0

参数：

y 数组类型

待转换的数据。

lmbda 数组类型

Box-Cox 变换的幂参数。

out ndarray，可选

可选的输出数组，用于函数值

返回值：

x 标量或者 ndarray

转换后的数据。

笔记

自版本 0.16.0 新增。

示例

>>> from scipy.special import boxcox, inv_boxcox
>>> y = boxcox([1, 4, 10], 2.5)
>>> inv_boxcox(y, 2.5)
array([1., 4., 10.])

`scipy.special.inv_boxcox1p`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.inv_boxcox1p.html#scipy.special.inv_boxcox1p

scipy.special.inv_boxcox1p(y, lmbda, out=None) = <ufunc 'inv_boxcox1p'>

计算 Box-Cox 变换的逆变换。

找到 x 使得：

y = ((1+x)**lmbda - 1) / lmbda  if lmbda != 0
    log(1+x)                    if lmbda == 0

参数：

y array_like

待转换的数据。

lmbda array_like

Box-Cox 变换的功率参数。

out ndarray，可选

函数值的可选输出数组

x 标量或者 ndarray

转换后的数据。

注意事项

新版在 0.16.0 版本中加入。

示例

>>> from scipy.special import boxcox1p, inv_boxcox1p
>>> y = boxcox1p([1, 4, 10], 2.5)
>>> inv_boxcox1p(y, 2.5)
array([1., 4., 10.])

`scipy.special.logit`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.logit.html#scipy.special.logit

scipy.special.logit(x, out=None) = <ufunc 'logit'>

用于 ndarrays 的 logit ufunc。

logit 函数定义为 logit(p) = log(p/(1-p))。请注意，logit(0) = -inf，logit(1) = inf，而对于 p<0 或 p>1 的 logit(p) 结果为 nan。

参数：

x ndarray

ndarray，逐元素应用 logit。

out ndarray，可选

函数结果的可选输出数组请注意，以上是根据 Markdown 格式要求翻译后的文本。每一句译文都带有前缀（- ），符合指定格式。

返回值：

标量或者 ndarray

与 x 形状相同的 ndarray。其条目是对应 x 条目的 logit。

另请参见：

expit

注意：

作为 ufunc，logit 接受多个可选关键字参数。更多信息请参见 ufuncs

0.10.0 版本新增内容。

示例

>>> import numpy as np
>>> from scipy.special import logit, expit

>>> logit([0, 0.25, 0.5, 0.75, 1])
array([       -inf, -1.09861229,  0\.        ,  1.09861229,         inf])

expit 是 logit 的反函数：

>>> expit(logit([0.1, 0.75, 0.999]))
array([ 0.1  ,  0.75 ,  0.999])

绘制 logit(x) 在 x 属于 [0, 1] 的范围内：

>>> import matplotlib.pyplot as plt
>>> x = np.linspace(0, 1, 501)
>>> y = logit(x)
>>> plt.plot(x, y)
>>> plt.grid()
>>> plt.ylim(-6, 6)
>>> plt.xlabel('x')
>>> plt.title('logit(x)')
>>> plt.show()

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

`scipy.special.expit`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.expit.html#scipy.special.expit

scipy.special.expit(x, out=None) = <ufunc 'expit'>

Expit（又名逻辑 sigmoid）ndarrays 的 ufunc。

expit 函数，也称为逻辑 sigmoid 函数，定义为expit(x) = 1/(1+exp(-x))。它是 logit 函数的反函数。

参数：

xndarray

要对每个元素应用expit的 ndarray。

outndarray，可选

函数值的可选输出数组

标量或 ndarray

与 x 相同形状的 ndarray。其条目是相应 x 条目的expit。

另请参阅

logit

注意事项

作为一个 ufunc，expit接受多个可选的关键字参数。更多信息请参见ufuncs

版本 0.10.0 中的新功能。

示例

>>> import numpy as np
>>> from scipy.special import expit, logit

>>> expit([-np.inf, -1.5, 0, 1.5, np.inf])
array([ 0\.        ,  0.18242552,  0.5       ,  0.81757448,  1\.        ])

logit是expit的反函数：

>>> logit(expit([-2.5, 0, 3.1, 5.0]))
array([-2.5,  0\. ,  3.1,  5\. ])

绘制 expit(x)，其中 x 在[-6, 6]：

>>> import matplotlib.pyplot as plt
>>> x = np.linspace(-6, 6, 121)
>>> y = expit(x)
>>> plt.plot(x, y)
>>> plt.grid()
>>> plt.xlim(-6, 6)
>>> plt.xlabel('x')
>>> plt.title('expit(x)')
>>> plt.show()

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

`scipy.special.log_expit`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.log_expit.html#scipy.special.log_expit

scipy.special.log_expit(x, out=None) = <ufunc 'log_expit'>

逻辑 sigmoid 函数的对数。

SciPy 的逻辑 sigmoid 函数的实现是 scipy.special.expit，因此这个函数被称为 log_expit。

该函数在数学上等价于 log(expit(x))，但其表达式被设计为避免在输入具有大的（正或负）幅度时失去精度。

参数：

x 数组样式

要对每个元素应用 log_expit 的值。

out ndarray，可选

函数结果的可选输出数组

out 标量或 ndarray

计算出的值，一个与 x 形状相同的 ndarray。

另见

expit

注意事项

作为一个 ufunc，log_expit 接受多个可选的关键字参数。更多信息请参见 ufuncs

新版本 1.8.0 中引入。

示例

>>> import numpy as np
>>> from scipy.special import log_expit, expit

>>> log_expit([-3.0, 0.25, 2.5, 5.0])
array([-3.04858735, -0.57593942, -0.07888973, -0.00671535])

大的负值：

>>> log_expit([-100, -500, -1000])
array([ -100.,  -500., -1000.])

注意，expit(-1000) 返回 0，所以朴素实现 log(expit(-1000)) 返回 -inf。

大的正值：

>>> log_expit([29, 120, 400])
array([-2.54366565e-013, -7.66764807e-053, -1.91516960e-174])

将其与朴素实现进行比较：

>>> np.log(expit([29, 120, 400]))
array([-2.54463117e-13,  0.00000000e+00,  0.00000000e+00])

第一个值只准确到小数点后三位，更大的输入则失去所有精度并返回 0。

`scipy.special.tklmbda`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.tklmbda.html#scipy.special.tklmbda

scipy.special.tklmbda(x, lmbda, out=None) = <ufunc 'tklmbda'>

Tukey lambda 分布的累积分布函数。

参数：

x, lmbda array_like

参数

out ndarray，可选

函数结果的可选输出数组

cdf 标量或 ndarray

Tukey lambda CDF 的值

参见

scipy.stats.tukeylambda

Tukey lambda 分布

示例

>>> import numpy as np
>>> import matplotlib.pyplot as plt
>>> from scipy.special import tklmbda, expit

计算lmbda为-1.5 时 Tukey lambda 分布的累积分布函数（CDF）在几个x值处的值。

>>> x = np.linspace(-2, 2, 9)
>>> x
array([-2\. , -1.5, -1\. , -0.5,  0\. ,  0.5,  1\. ,  1.5,  2\. ])
>>> tklmbda(x, -1.5)
array([0.34688734, 0.3786554 , 0.41528805, 0.45629737, 0.5       ,
 0.54370263, 0.58471195, 0.6213446 , 0.65311266])

当lmbda为 0 时，函数为逻辑 sigmoid 函数，在scipy.special中实现为expit。

>>> tklmbda(x, 0)
array([0.11920292, 0.18242552, 0.26894142, 0.37754067, 0.5       ,
 0.62245933, 0.73105858, 0.81757448, 0.88079708])
>>> expit(x)
array([0.11920292, 0.18242552, 0.26894142, 0.37754067, 0.5       ,
 0.62245933, 0.73105858, 0.81757448, 0.88079708])

当lmbda为 1 时，Tukey lambda 分布在区间[-1, 1]上均匀分布，因此 CDF 线性增加。

>>> t = np.linspace(-1, 1, 9)
>>> tklmbda(t, 1)
array([0\.   , 0.125, 0.25 , 0.375, 0.5  , 0.625, 0.75 , 0.875, 1\.   ])

在下文中，我们生成了几个lmbda值的图表。

第一张图显示了当lmbda <= 0 时的图形。

>>> styles = ['-', '-.', '--', ':']
>>> fig, ax = plt.subplots()
>>> x = np.linspace(-12, 12, 500)
>>> for k, lmbda in enumerate([-1.0, -0.5, 0.0]):
...     y = tklmbda(x, lmbda)
...     ax.plot(x, y, styles[k], label=f'$\lambda$ = {lmbda:-4.1f}')

>>> ax.set_title('tklmbda(x, $\lambda$)')
>>> ax.set_label('x')
>>> ax.legend(framealpha=1, shadow=True)
>>> ax.grid(True)

第二张图显示了当lmbda > 0 时的图形。图中的点显示了分布支持的边界。

>>> fig, ax = plt.subplots()
>>> x = np.linspace(-4.2, 4.2, 500)
>>> lmbdas = [0.25, 0.5, 1.0, 1.5]
>>> for k, lmbda in enumerate(lmbdas):
...     y = tklmbda(x, lmbda)
...     ax.plot(x, y, styles[k], label=f'$\lambda$ = {lmbda}')

>>> ax.set_prop_cycle(None)
>>> for lmbda in lmbdas:
...     ax.plot([-1/lmbda, 1/lmbda], [0, 1], '.', ms=8)

>>> ax.set_title('tklmbda(x, $\lambda$)')
>>> ax.set_xlabel('x')
>>> ax.legend(framealpha=1, shadow=True)
>>> ax.grid(True)

>>> plt.tight_layout()
>>> plt.show()

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

Tukey lambda 分布的累积分布函数也实现为scipy.stats.tukeylambda的cdf方法。在下文中，tukeylambda.cdf(x, -0.5)和tklmbda(x, -0.5)计算相同的值：

>>> from scipy.stats import tukeylambda
>>> x = np.linspace(-2, 2, 9)

>>> tukeylambda.cdf(x, -0.5)
array([0.21995157, 0.27093858, 0.33541677, 0.41328161, 0.5       ,
 0.58671839, 0.66458323, 0.72906142, 0.78004843])

>>> tklmbda(x, -0.5)
array([0.21995157, 0.27093858, 0.33541677, 0.41328161, 0.5       ,
 0.58671839, 0.66458323, 0.72906142, 0.78004843])

tukeylambda中的实现还提供了位置和比例参数，以及其他方法，如pdf()（概率密度函数）和ppf()（CDF 的反函数），因此对于处理 Tukey lambda 分布，tukeylambda更加通用。tklmbda的主要优势在于它比tukeylambda.cdf快得多。

`scipy.special.owens_t`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.owens_t.html#scipy.special.owens_t

scipy.special.owens_t(h, a, out=None) = <ufunc 'owens_t'>

Owen’s T Function。

函数 T(h, a) 给出事件的概率（X > h 并且 0 < Y < a * X），其中 X 和 Y 是独立的标准正态随机变量。

参数：

h: array_like

输入值。

a: array_like

输入值。

outndarray, optional

函数结果的可选输出数组

t: scalar or ndarray

事件的概率（X > h 并且 0 < Y < a * X），其中 X 和 Y 是独立的标准正态随机变量。

参考文献

[1]

M. Patefield 和 D. Tandy，“Owen’s T Function 的快速和准确计算”，Statistical Software 第 5 卷，第 1-25 页，2000 年。

示例

>>> from scipy import special
>>> a = 3.5
>>> h = 0.78
>>> special.owens_t(h, a)
0.10877216734852274

`scipy.special.entr`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.entr.html#scipy.special.entr

scipy.special.entr(x, out=None) = <ufunc 'entr'>

用于计算熵的逐元素函数。

[\begin{split}\text{entr}(x) = \begin{cases} - x \log(x) & x > 0 \ 0 & x = 0 \ -\infty & \text{否则} \end{cases}\end{split}]

参数：

x ndarray

输入数组。

out ndarray，可选

可选的输出数组，用于函数值

res 标量或 ndarray

给定点x处的逐元素熵函数值。

另请参阅

kl_div，rel_entr，scipy.stats.entropy

注意事项

自版本 0.15.0 起新增。

此函数为凹函数。

该函数的起源在于凸规划；参见[1]。给定概率分布 (p_1, \ldots, p_n)，在信息论的背景下，熵的定义为

[\sum_{i = 1}^n \mathrm{entr}(p_i).]

要计算后一种数量，请使用scipy.stats.entropy。

参考文献

[1]

Boyd, Stephen 和 Lieven Vandenberghe。凸优化。剑桥大学出版社，2004 年。DOI:https://doi.org/10.1017/CBO9780511804441

`scipy.special.rel_entr`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.rel_entr.html#scipy.special.rel_entr

scipy.special.rel_entr(x, y, out=None) = <ufunc 'rel_entr'>

用于计算相对熵的逐元素函数。

[\begin{split}\mathrm{rel_entr}(x, y) = \begin{cases} x \log(x / y) & x > 0, y > 0 \ 0 & x = 0, y \ge 0 \ \infty & \text{otherwise} \end{cases}\end{split}]

参数：

x, yarray_like

输入数组

outndarray，可选

函数结果的可选输出数组

标量或 ndarray

输入的相对熵

另请参阅

entr, kl_div, scipy.stats.entropy

注意事项

新版本 0.15.0 中引入。

此函数在 x 和 y 中是联合凸的。

此函数的起源在于凸优化；参见 [1]。给定两个离散概率分布 (p_1, \ldots, p_n) 和 (q_1, \ldots, q_n)，在信息理论背景下，相对熵的定义为

[\sum_{i = 1}^n \mathrm{rel_entr}(p_i, q_i).]

要计算后一数量，请使用 scipy.stats.entropy。

详细信息请参见 [2]。

参考资料

[1]

Boyd, Stephen 和 Lieven Vandenberghe。《凸优化》。剑桥大学出版社，2004 年。DOI:https://doi.org/10.1017/CBO9780511804441

[2]

Kullback-Leibler 散度，en.wikipedia.org/wiki/Kullback%E2%80%93Leibler_divergence

`scipy.special.kl_div`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.kl_div.html#scipy.special.kl_div

scipy.special.kl_div(x, y, out=None) = <ufunc 'kl_div'>

计算 Kullback-Leibler 散度的逐元素函数。

[\begin{split}\mathrm{kl_div}(x, y) = \begin{cases} x \log(x / y) - x + y & x > 0, y > 0 \ y & x = 0, y \ge 0 \ \infty & \text{otherwise} \end{cases}\end{split}]

参数：

x, y array_like

真实参数

out ndarray，可选

用于函数结果的可选输出数组

标量或 ndarray

Kullback-Liebler 散度的值。

另请参阅

entr, rel_entr, scipy.stats.entropy

注释

从版本 0.15.0 新增。

此函数非负，在 x 和 y 中是联合凸的。

此函数的起源在于凸优化；详细信息请参见 [1]。这也是为什么该函数包含与 Kullback-Leibler 散度不同的额外 (-x + y) 项。如需不带额外项的函数版本，请参见 rel_entr。

参考文献

[1]

Boyd, Stephen and Lieven Vandenberghe. Convex optimization. Cambridge University Press, 2004. DOI:https://doi.org/10.1017/CBO9780511804441

`scipy.special.huber`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.huber.html#scipy.special.huber

scipy.special.huber(delta, r, out=None) = <ufunc 'huber'>

Huber 损失函数。

[\begin{split}\text{huber}(\delta, r) = \begin{cases} \infty & \delta < 0 \ \frac{1}{2}r² & 0 \le \delta, | r | \le \delta \ \delta ( |r| - \frac{1}{2}\delta ) & \text{otherwise} \end{cases}\end{split}]

参数：

deltandarray

输入数组，指示二次与线性损失的变化点。

rndarray

输入数组，可能代表残差。

outndarray, optional

可选的输出数组，用于存放函数值。

标量或 ndarray

计算得到的 Huber 损失函数值。

另请参阅

pseudo_huber

该函数的平滑近似

注意事项

huber在稳健统计或机器学习中作为损失函数非常有用，以减少离群值的影响，与常见的平方误差损失相比，大于delta的残差不会被平方处理[1]。

通常，r代表残差，即模型预测与数据之间的差异。因此，对于( |r| \leq \delta )，huber类似于平方误差；而对于( |r| > \delta )，则类似于绝对误差。这种方式使得 Huber 损失函数在处理小残差（如平方误差损失函数）时能够快速收敛，并且在减小离群值的影响（( |r| > \delta )）时仍能发挥作用。由于(\delta)是平方误差和绝对误差之间的分界点，因此在每个问题中都需要进行仔细调整。huber还是凸函数，适合基于梯度的优化算法。

从版本 0.15.0 开始新增。

参考文献

[1]

Peter Huber. “Robust Estimation of a Location Parameter”, 1964. Annals of Statistics. 53 (1): 73 - 101.

示例

导入所有必要的模块。

>>> import numpy as np
>>> from scipy.special import huber
>>> import matplotlib.pyplot as plt

计算delta=1，r=2时的函数值。

>>> huber(1., 2.)
1.5

通过提供 NumPy 数组或列表来计算不同delta下的函数值。

>>> huber([1., 3., 5.], 4.)
array([3.5, 7.5, 8\. ])

通过提供 NumPy 数组或列表来计算不同点上的函数值r。

>>> huber(2., np.array([1., 1.5, 3.]))
array([0.5  , 1.125, 4\.   ])

可以通过提供形状兼容的delta和r数组来计算不同delta和r下的函数值。

>>> r = np.array([1., 2.5, 8., 10.])
>>> deltas = np.array([[1.], [5.], [9.]])
>>> print(r.shape, deltas.shape)
(4,) (3, 1)

>>> huber(deltas, r)
array([[ 0.5  ,  2\.   ,  7.5  ,  9.5  ],
 [ 0.5  ,  3.125, 27.5  , 37.5  ],
 [ 0.5  ,  3.125, 32\.   , 49.5  ]])

绘制不同delta下的函数图像。

>>> x = np.linspace(-4, 4, 500)
>>> deltas = [1, 2, 3]
>>> linestyles = ["dashed", "dotted", "dashdot"]
>>> fig, ax = plt.subplots()
>>> combined_plot_parameters = list(zip(deltas, linestyles))
>>> for delta, style in combined_plot_parameters:
...     ax.plot(x, huber(delta, x), label=f"$\delta={delta}$", ls=style)
>>> ax.legend(loc="upper center")
>>> ax.set_xlabel("$x$")
>>> ax.set_title("Huber loss function $h_{\delta}(x)$")
>>> ax.set_xlim(-4, 4)
>>> ax.set_ylim(0, 8)
>>> plt.show()

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

`scipy.special.pseudo_huber`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.pseudo_huber.html#scipy.special.pseudo_huber

scipy.special.pseudo_huber(delta, r, out=None) = <ufunc 'pseudo_huber'>

伪 Huber 损失函数。

[\mathrm{pseudo_huber}(\delta, r) = \delta² \left( \sqrt{ 1 + \left( \frac{r}{\delta} \right)² } - 1 \right)]

参数：

deltaarray_like

输入数组，指示软二次 vs 线性损失的变化点。

rarray_like

输入数组，可能表示残差。

outndarray，可选

可选的输出数组，用于函数结果

res标量或 ndarray

计算的伪 Huber 损失函数值。

另请参阅

huber

与该函数近似的类似函数

注意事项

像huber一样，pseudo_huber经常用作统计学或机器学习中的鲁棒损失函数，以减少异常值的影响。与huber不同，pseudo_huber是光滑的。

典型地，r代表残差，即模型预测与数据之间的差异。因此，对于( |r| \leq \delta )，pseudo_huber类似于平方误差，对于( |r| > \delta )，则是绝对误差。这样，伪 Huber 损失函数通常能够在小残差（如平方误差损失函数）的模型拟合中快速收敛，并且仍然减少了异常值（( |r| > \delta )）的影响。因为( \delta )是平方误差和绝对误差区域之间的分界点，对每个问题都需要进行精心调整。pseudo_huber也是凸的，适合基于梯度的优化方法。[1] [2]

新版本 0.15.0 中引入。

参考文献

[1]

Hartley，Zisserman，“计算机视觉中的多视图几何”。2003. 剑桥大学出版社。p. 619

[2]

Charbonnier 等人，“在计算成像中的确定性边缘保持正则化”。1997. IEEE 图像处理期刊。6（2）：298-311。

示例

导入所有必要的模块。

>>> import numpy as np
>>> from scipy.special import pseudo_huber, huber
>>> import matplotlib.pyplot as plt

计算delta=1时r=2的函数。

>>> pseudo_huber(1., 2.)
1.2360679774997898

通过为delta提供列表或 NumPy 数组，对r=2计算不同delta的函数。

>>> pseudo_huber([1., 2., 4.], 3.)
array([2.16227766, 3.21110255, 4\.        ])

通过为r提供列表或 NumPy 数组，对delta=1的多个点计算函数。

>>> pseudo_huber(2., np.array([1., 1.5, 3., 4.]))
array([0.47213595, 1\.        , 3.21110255, 4.94427191])

可以通过提供兼容形状以进行广播的两个数组，对不同的delta和r计算函数。

>>> r = np.array([1., 2.5, 8., 10.])
>>> deltas = np.array([[1.], [5.], [9.]])
>>> print(r.shape, deltas.shape)
(4,) (3, 1)

>>> pseudo_huber(deltas, r)
array([[ 0.41421356,  1.6925824 ,  7.06225775,  9.04987562],
 [ 0.49509757,  2.95084972, 22.16990566, 30.90169944],
 [ 0.49846624,  3.06693762, 27.37435121, 40.08261642]])

绘制不同delta的函数。

>>> x = np.linspace(-4, 4, 500)
>>> deltas = [1, 2, 3]
>>> linestyles = ["dashed", "dotted", "dashdot"]
>>> fig, ax = plt.subplots()
>>> combined_plot_parameters = list(zip(deltas, linestyles))
>>> for delta, style in combined_plot_parameters:
...     ax.plot(x, pseudo_huber(delta, x), label=f"$\delta={delta}$",
...             ls=style)
>>> ax.legend(loc="upper center")
>>> ax.set_xlabel("$x$")
>>> ax.set_title("Pseudo-Huber loss function $h_{\delta}(x)$")
>>> ax.set_xlim(-4, 4)
>>> ax.set_ylim(0, 8)
>>> plt.show()

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

最后，通过绘制huber和pseudo_huber及其关于r的梯度，最终说明它们之间的差异。图表显示pseudo_huber在点(\pm\delta)处是连续可微的，而huber则不是。

>>> def huber_grad(delta, x):
...     grad = np.copy(x)
...     linear_area = np.argwhere(np.abs(x) > delta)
...     grad[linear_area]=delta*np.sign(x[linear_area])
...     return grad
>>> def pseudo_huber_grad(delta, x):
...     return x* (1+(x/delta)**2)**(-0.5)
>>> x=np.linspace(-3, 3, 500)
>>> delta = 1.
>>> fig, ax = plt.subplots(figsize=(7, 7))
>>> ax.plot(x, huber(delta, x), label="Huber", ls="dashed")
>>> ax.plot(x, huber_grad(delta, x), label="Huber Gradient", ls="dashdot")
>>> ax.plot(x, pseudo_huber(delta, x), label="Pseudo-Huber", ls="dotted")
>>> ax.plot(x, pseudo_huber_grad(delta, x), label="Pseudo-Huber Gradient",
...         ls="solid")
>>> ax.legend(loc="upper center")
>>> plt.show()

../../_images/scipy-special-pseudo_huber-1_01_00.png

`scipy.special.gamma`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.gamma.html#scipy.special.gamma

scipy.special.gamma(z, out=None) = <ufunc 'gamma'>

伽玛函数

伽玛函数定义为

[\Gamma(z) = \int_0^\infty t^{z-1} e^{-t} dt]

对于 (\Re(z) > 0)，并通过解析延拓到复平面的其余部分。更多详情请见[dlmf]。

参数：

z 数组型参数

实数或复数值参数

out 数组，可选

可选的输出数组，用于函数值

标量或者数组

伽玛函数的值

注意

伽玛函数通常被称为广义阶乘，因为对于自然数 (n)，(\Gamma(n + 1) = n!)。更一般地，对于复数 (z)，它满足递推关系 (\Gamma(z + 1) = z \cdot \Gamma(z))，结合事实 (\Gamma(1) = 1)，这意味着对于 (z = n) 的上述身份成立。

参考文献

[dlmf]

NIST 数字图书馆数学函数 dlmf.nist.gov/5.2#E1

示例

>>> import numpy as np
>>> from scipy.special import gamma, factorial

>>> gamma([0, 0.5, 1, 5])
array([         inf,   1.77245385,   1\.        ,  24\.        ])

>>> z = 2.5 + 1j
>>> gamma(z)
(0.77476210455108352+0.70763120437959293j)
>>> gamma(z+1), z*gamma(z)  # Recurrence property
((1.2292740569981171+2.5438401155000685j),
 (1.2292740569981158+2.5438401155000658j))

>>> gamma(0.5)**2  # gamma(0.5) = sqrt(pi)
3.1415926535897927

为实数 (x) 绘制伽玛函数 ( \Gamma(x) )

>>> x = np.linspace(-3.5, 5.5, 2251)
>>> y = gamma(x)

>>> import matplotlib.pyplot as plt
>>> plt.plot(x, y, 'b', alpha=0.6, label='gamma(x)')
>>> k = np.arange(1, 7)
>>> plt.plot(k, factorial(k-1), 'k*', alpha=0.6,
...          label='(x-1)!, x = 1, 2, ...')
>>> plt.xlim(-3.5, 5.5)
>>> plt.ylim(-10, 25)
>>> plt.grid()
>>> plt.xlabel('x')
>>> plt.legend(loc='lower right')
>>> plt.show()

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

`scipy.special.gammaln`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.gammaln.html#scipy.special.gammaln

scipy.special.gammaln(x, out=None) = <ufunc 'gammaln'>

Gamma 函数绝对值的对数。

定义为

[\ln(\lvert\Gamma(x)\rvert)]

其中(\Gamma)是 Gamma 函数。有关 Gamma 函数的更多详细信息，请参见[dlmf]。

参数：

x：array_like

实数参数

out：ndarray，可选

用于函数结果的可选输出数组

返回值：

标量或 ndarray

绝对值的对数的值

另请参阅

gammasgn

Gamma 函数的符号

loggamma

Gamma 函数对数的主分支

注意事项

它与 Python 标准库函数math.lgamma相同。

当与gammasgn结合使用时，此函数对于在实轴上的对数空间中工作而无需处理复数非常有用，关系为exp(gammaln(x)) = gammasgn(x) * gamma(x)。

对于复值对数 Gamma 函数，请使用loggamma而不是gammaln。

参考文献

[dlmf]

NIST 数学函数数字图书馆dlmf.nist.gov/5

示例

>>> import numpy as np
>>> import scipy.special as sc

它有两个正零点。

>>> sc.gammaln([1, 2])
array([0., 0.])

它在非正整数处有极点。

>>> sc.gammaln([0, -1, -2, -3, -4])
array([inf, inf, inf, inf, inf])

它渐近地趋近于x * log(x)（Stirling 公式）。

>>> x = np.array([1e10, 1e20, 1e40, 1e80])
>>> sc.gammaln(x)
array([2.20258509e+11, 4.50517019e+21, 9.11034037e+41, 1.83206807e+82])
>>> x * np.log(x)
array([2.30258509e+11, 4.60517019e+21, 9.21034037e+41, 1.84206807e+82])

`scipy.special.loggamma`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.loggamma.html#scipy.special.loggamma

scipy.special.loggamma(z, out=None) = <ufunc 'loggamma'>

伽玛函数的主分支的对数。

定义为对于(x > 0)的情况为(\log(\Gamma(x)))，并通过解析延续扩展到复平面。该函数在负实轴上有一个单一的分支切割。

新功能在版本 0.18.0 中引入。

参数：

zarray_like

在复平面上计算loggamma的值。

outndarray, 可选

计算所得的loggamma值的输出数组。

loggamma标量或 ndarray

loggamma在 z 处的值。

另见

gammaln

伽玛函数绝对值的对数。

gammasgn

伽玛函数的符号

注意

一般而言，并非总是成立(\log\Gamma(z) = \log(\Gamma(z)))，尽管函数的实部是一致的。不将loggamma定义为(\log(\Gamma(z)))的好处在于，后者具有复杂的分支切割结构，而loggamma在负实轴上除外是解析的。

标识

[\begin{split}\exp(\log\Gamma(z)) &= \Gamma(z) \ \log\Gamma(z + 1) &= \log(z) + \log\Gamma(z)\end{split}]

使loggamma在复对数空间中的工作变得有用。

在实轴上，通过exp(loggamma(x + 0j)) = gammasgn(x)*exp(gammaln(x))，loggamma与gammaln相关，误差可忽略不计。

此处的实现基于[hare1997]。

参考资料

[hare1997]

作者 D.E.G. Hare，《计算对数伽玛的主分支》，《算法期刊》，1997 年 11 月，第 25 卷，第 2 期，页码 221-236。

`scipy.special.gammasgn`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.gammasgn.html#scipy.special.gammasgn

scipy.special.gammasgn(x, out=None) = <ufunc 'gammasgn'>

gamma 函数的符号。

定义如下

[\begin{split}\text{gammasgn}(x) = \begin{cases} +1 & \Gamma(x) > 0 \ -1 & \Gamma(x) < 0 \end{cases}\end{split}]

其中 (\Gamma) 是 gamma 函数；参见 gamma。该定义是完备的，因为 gamma 函数从不为零；参见 [dlmf] 后的讨论。

参数：

xarray_like

实数参数

outndarray，可选

函数值的可选输出数组

标量或 ndarray

gamma 函数的符号

另请参阅

gamma

gamma 函数

gammaln

gamma 函数绝对值的对数

loggamma

gamma 函数对数的解析延拓

注释

gamma 函数可以计算为 gammasgn(x) * np.exp(gammaln(x))。

参考文献

[dlmf]

NIST 数字数学函数图书馆 dlmf.nist.gov/5.2#E1

示例

>>> import numpy as np
>>> import scipy.special as sc

当 x > 0 时为 1。

>>> sc.gammasgn([1, 2, 3, 4])
array([1., 1., 1., 1.])

对于负整数，它在 -1 和 1 之间交替。

>>> sc.gammasgn([-0.5, -1.5, -2.5, -3.5])
array([-1.,  1., -1.,  1.])

它可用于计算 gamma 函数。

>>> x = [1.5, 0.5, -0.5, -1.5]
>>> sc.gammasgn(x) * np.exp(sc.gammaln(x))
array([ 0.88622693,  1.77245385, -3.5449077 ,  2.3632718 ])
>>> sc.gamma(x)
array([ 0.88622693,  1.77245385, -3.5449077 ,  2.3632718 ])

`scipy.special.gammainc`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.gammainc.html#scipy.special.gammainc

scipy.special.gammainc(a, x, out=None) = <ufunc 'gammainc'>

正则化的下不完全伽玛函数。

定义为

[P(a, x) = \frac{1}{\Gamma(a)} \int_0^x t^{a - 1}e^{-t} dt]

对于(a > 0) 和 (x \geq 0)。详细信息请参见[dlmf]。

参数：

aarray_like

正参数

xarray_like

非负参数

outndarray, optional

函数值的可选输出数组

标量或 ndarray

下不完全伽玛函数的值

另请参见

gammaincc

正则化的上不完全伽玛函数

gammaincinv

正则化的下不完全伽玛函数的逆

gammainccinv

正则化的上不完全伽玛函数的逆

注释

函数满足关系 gammainc(a, x) + gammaincc(a, x) = 1，其中gammaincc 是正则化的上不完全伽玛函数。

实现主要遵循[boost]的那个。

参考文献

[dlmf]

NIST 数字数学函数库dlmf.nist.gov/8.2#E4

[boost]

Maddock 等人，“不完全伽玛函数”，www.boost.org/doc/libs/1_61_0/libs/math/doc/html/math_toolkit/sf_gamma/igamma.html

示例

>>> import scipy.special as sc

它是伽玛分布的累积分布函数，因此从 0 开始单调增加到 1。

>>> sc.gammainc(0.5, [0, 1, 10, 100])
array([0\.        , 0.84270079, 0.99999226, 1\.        ])

它等于一减去上不完全伽玛函数。

>>> a, x = 0.5, 0.4
>>> sc.gammainc(a, x)
0.6289066304773024
>>> 1 - sc.gammaincc(a, x)
0.6289066304773024

`scipy.special.gammaincinv`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.gammaincinv.html#scipy.special.gammaincinv

scipy.special.gammaincinv(a, y, out=None) = <ufunc 'gammaincinv'>

正则化的下不完全伽马函数的反函数。

给定介于 0 和 1 之间的输入( y )，返回( x )，使得( y = P(a, x) )。这里的( P )是正则化的下不完全伽马函数；参见gammainc。这是明确定义的，因为下不完全伽马函数如其在[dlmf]中的定义所示是单调的。

参数：

a，类似数组

正参数

y，类似数组

参数在 0 到 1 之间，包括边界

out，可选的 ndarray

函数值的可选输出数组

标量或 ndarray

下不完全伽马函数的反函数的值

另见

gammainc

正则化的下不完全伽马函数

gammaincc

正则化的上不完全伽马函数

gammainccinv

正则化的上不完全伽马函数的反函数

参考

[dlmf]

NIST 数字数学函数库dlmf.nist.gov/8.2#E4

示例

>>> import scipy.special as sc

它从 0 开始单调增加到无穷大。

>>> sc.gammaincinv(0.5, [0, 0.1 ,0.5, 1])
array([0\.        , 0.00789539, 0.22746821,        inf])

它反转了下不完全伽马函数。

>>> a, x = 0.5, [0, 0.1, 0.5, 1]
>>> sc.gammainc(a, sc.gammaincinv(a, x))
array([0\. , 0.1, 0.5, 1\. ])

>>> a, x = 0.5, [0, 10, 25]
>>> sc.gammaincinv(a, sc.gammainc(a, x))
array([ 0\.        , 10\.        , 25.00001465])

`scipy.special.gammaincc`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.gammaincc.html#scipy.special.gammaincc

scipy.special.gammaincc(a, x, out=None) = <ufunc 'gammaincc'>

规则化的上不完全伽玛函数。

定义为

[Q(a, x) = \frac{1}{\Gamma(a)} \int_x^\infty t^{a - 1}e^{-t} dt]

当 (a > 0) 和 (x \geq 0) 时。详见 [dlmf]。

参数：

aarray_like

正参数

xarray_like

非负参数

outndarray，可选

函数值的可选输出数组

标量或者 ndarray

上不完全伽玛函数的值

另请参阅

gammainc

规则化的下不完全伽玛函数

gammaincinv

规则化的下不完全伽玛函数的反函数

gammainccinv

规则化的上不完全伽玛函数的反函数

注意事项

函数满足关系 gammainc(a, x) + gammaincc(a, x) = 1，其中 gammainc 是规则化的下不完全伽玛函数。

实现大部分遵循 [boost]。

参考资料

[dlmf]

NIST 数字数学函数库 dlmf.nist.gov/8.2#E4

[boost]

Maddock 等人，“不完全伽玛函数”，www.boost.org/doc/libs/1_61_0/libs/math/doc/html/math_toolkit/sf_gamma/igamma.html

示例

>>> import scipy.special as sc

它是伽玛分布的生存函数，因此从 1 开始单调递减到 0。

>>> sc.gammaincc(0.5, [0, 1, 10, 100, 1000])
array([1.00000000e+00, 1.57299207e-01, 7.74421643e-06, 2.08848758e-45,
 0.00000000e+00])

它等于 1 减去下不完全伽玛函数。

>>> a, x = 0.5, 0.4
>>> sc.gammaincc(a, x)
0.37109336952269756
>>> 1 - sc.gammainc(a, x)
0.37109336952269756

`scipy.special.gammainccinv`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.gammainccinv.html#scipy.special.gammainccinv

scipy.special.gammainccinv(a, y, out=None) = <ufunc 'gammainccinv'>

正则化的上不完全伽马函数的反函数。

给定介于 0 和 1 之间的输入 (y)，返回 (x)，使得 (y = Q(a, x))。这里 (Q) 是正则化的上不完全伽马函数；参见 gammaincc。这是合理的，因为上不完全伽马函数从其在[dlmf]中的定义中可以看出是单调的。

参数：

a 数组类似

正参数

y 数组类似

介于 0 和 1 之间的参数

out 数组，可选的

函数值的可选输出数组

标量或数组

上不完全伽马函数的反函数值

另请参阅

gammaincc

正则化的上不完全伽马函数

gammainc

正则化的下不完全伽马函数

gammaincinv

正则化的下不完全伽马函数的反函数

参考

[dlmf]

NIST 数学函数数字图书馆 dlmf.nist.gov/8.2#E4

示例

>>> import scipy.special as sc

它从无穷大开始单调减少到 0。

>>> sc.gammainccinv(0.5, [0, 0.1, 0.5, 1])
array([       inf, 1.35277173, 0.22746821, 0\.        ])

它反转了上不完全伽马函数。

>>> a, x = 0.5, [0, 0.1, 0.5, 1]
>>> sc.gammaincc(a, sc.gammainccinv(a, x))
array([0\. , 0.1, 0.5, 1\. ])

>>> a, x = 0.5, [0, 10, 50]
>>> sc.gammainccinv(a, sc.gammaincc(a, x))
array([ 0., 10., 50.])

`scipy.special.beta`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.beta.html#scipy.special.beta

scipy.special.beta(a, b, out=None) = <ufunc 'beta'>

Beta 函数。

此函数在[1]中定义为

[B(a, b) = \int_0¹ t^{a-1}(1-t)dt = \frac{\Gamma(a)\Gamma(b)}{\Gamma(a+b)},]

其中 (\Gamma) 是 Gamma 函数。

参数:

a, barray_like

实数参数

outndarray, 可选的

函数结果的可选输出数组

标量或者 ndarray

Beta 函数的值

另请参阅

gamma

Gamma 函数

betainc

正则不完全 Beta 函数

betaln

Beta 函数的绝对值的自然对数

参考文献

[1]

NIST 数字数学函数库，Eq. 5.12.1. dlmf.nist.gov/5.12

例子

>>> import scipy.special as sc

Beta 函数通过上述定义与 Gamma 函数相关联：

>>> sc.beta(2, 3)
0.08333333333333333
>>> sc.gamma(2)*sc.gamma(3)/sc.gamma(2 + 3)
0.08333333333333333

正如这个关系所示，Beta 函数是对称的：

>>> sc.beta(1.7, 2.4)
0.16567527689031739
>>> sc.beta(2.4, 1.7)
0.16567527689031739

此函数满足 (B(1, b) = 1/b):

>>> sc.beta(1, 4)
0.25

`scipy.special.betaln`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.betaln.html#scipy.special.betaln

scipy.special.betaln(a, b, out=None) = <ufunc 'betaln'>

beta 函数绝对值的自然对数。

计算 ln(abs(beta(a, b)))。

参数：

a, barray_like

正实数参数

outndarray，可选

函数值的可选输出数组

标量或 ndarray

betaln 函数的值

另请参阅

gamma

伽马函数

betainc

正则化不完全贝塔函数

beta

beta 函数

示例

>>> import numpy as np
>>> from scipy.special import betaln, beta

验证，在中等值的情况下 a 和 b，betaln(a, b) 等同于 log(beta(a, b))：

>>> betaln(3, 4)
-4.0943445622221

>>> np.log(beta(3, 4))
-4.0943445622221

在下面的情况下 beta(a, b) 衰减为 0，所以我们不能计算实际值的对数。

>>> a = 400
>>> b = 900
>>> beta(a, b)
0.0

我们可以通过使用 betaln 来计算 beta(a, b) 的对数：

>>> betaln(a, b)
-804.3069951764146

`scipy.special.betainc`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.betainc.html#scipy.special.betainc

scipy.special.betainc(a, b, x, out=None) = <ufunc 'betainc'>

正则化不完全贝塔函数。

计算定义为 [1] 的正则化不完全贝塔函数:

[I_x(a, b) = \frac{\Gamma(a+b)}{\Gamma(a)\Gamma(b)} \int_0^x t^{a-1}(1-t)dt]

对于 (0 \leq x \leq 1)。

该函数是贝塔分布的累积分布函数；其范围为 [0, 1]。

参数：

a, b 数组形式

正数实数值参数

x 数组形式

实数值，使得 (0 \leq x \leq 1)，积分的上限

out 数组，可选

函数值的可选输出数组

标量或者数组

正则化不完全贝塔函数的值

参见

beta

贝塔函数

betaincinv

正则化不完全贝塔函数的反函数

betaincc

正则化不完全贝塔函数的补函数

scipy.stats.beta

贝塔分布

注释

函数名称中的 regularized 指的是通过公式中显示的 gamma 函数项对函数进行缩放。当未标明为 regularized 时，函数名称 incomplete beta function 通常仅指积分表达式，不包括 gamma 项。可以使用 scipy.special 中的函数 beta，通过将 betainc(a, b, x) 的结果乘以 beta(a, b) 来获取这种“非正则化”的不完全贝塔函数。

参考文献

[1]

NIST 数学函数数字图书馆 dlmf.nist.gov/8.17

示例

设 (B(a, b)) 为 beta 函数。

>>> import scipy.special as sc

通过 gamma 的系数等于 (1/B(a, b))。此外，当 (x=1) 时，积分等于 (B(a, b))。因此，对于任意的 (a, b)，(I_{x=1}(a, b) = 1)。

>>> sc.betainc(0.2, 3.5, 1.0)
1.0

满足 (I_x(a, b) = x^a F(a, 1-b, a+1, x)/ (aB(a, b)))，其中 (F) 是超几何函数 hyp2f1:

>>> a, b, x = 1.4, 3.1, 0.5
>>> x**a * sc.hyp2f1(a, 1 - b, a + 1, x)/(a * sc.beta(a, b))
0.8148904036225295
>>> sc.betainc(a, b, x)
0.8148904036225296

此函数满足关系式 (I_x(a, b) = 1 - I_{1-x}(b, a))：

>>> sc.betainc(2.2, 3.1, 0.4)
0.49339638807619446
>>> 1 - sc.betainc(3.1, 2.2, 1 - 0.4)
0.49339638807619446

`scipy.special.betaincc`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.betaincc.html#scipy.special.betaincc

scipy.special.betaincc(a, b, x, out=None) = <ufunc 'betaincc'>

正则化不完全贝塔函数的补数

计算定义为[1]的正则化不完全贝塔函数的补数：

[\bar{I}_x(a, b) = 1 - I_x(a, b) = 1 - \frac{\Gamma(a+b)}{\Gamma(a)\Gamma(b)} \int_0^x t^{a-1}(1-t)dt,]

对于 (0 \leq x \leq 1)。

参数：

a, b array_like

正数实数参数

x array_like

实数，使得 (0 \leq x \leq 1)，积分的上限

out ndarray，可选

函数值的可选输出数组

标量或 ndarray

正则化不完全贝塔函数的值

另请参见

正则化不完全贝塔函数

正则化不完全贝塔函数的逆

正则化不完全贝塔函数的补数的逆

贝塔函数

贝塔分布

注意事项

版本 1.11.0 中的新功能。

参考文献

[1]

NIST 数字数学函数库 dlmf.nist.gov/8.17

示例

>>> from scipy.special import betaincc, betainc

当 betainc(a, b, x) 的值接近 1 时，朴素计算 1 - betainc(a, b, x) 会失去精度：

>>> 1 - betainc(0.5, 8, [0.9, 0.99, 0.999])
array([2.0574632e-09, 0.0000000e+00, 0.0000000e+00])

通过使用 betaincc，我们得到正确的值：

>>> betaincc(0.5, 8, [0.9, 0.99, 0.999])
array([2.05746321e-09, 1.97259354e-17, 1.96467954e-25])

`scipy.special.betaincinv`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.betaincinv.html#scipy.special.betaincinv

scipy.special.betaincinv(a, b, y, out=None) = <ufunc 'betaincinv'>

正则化不完全贝塔函数的反函数。

计算 (x) 使得：

[y = I_x(a, b) = \frac{\Gamma(a+b)}{\Gamma(a)\Gamma(b)} \int_0^x t^{a-1}(1-t)dt,]

其中，(I_x)是标准化的不完全贝塔函数betainc，(\Gamma)是gamma函数[1]。

参数：

a, barray_like

正实数值参数

yarray_like

实值输入

outndarray, 可选

函数值的可选输出数组

返回值：

标量或者 ndarray

正则化不完全贝塔函数的倒数值

另请参阅

betainc

正则化不完全贝塔函数

gamma

gamma 函数

参考文献

[1]

NIST 数学函数数字库 dlmf.nist.gov/8.17

示例

>>> import scipy.special as sc

对于固定的 (a) 和 (b) 值，该函数是 betainc 的反函数。

>>> a, b = 1.2, 3.1
>>> y = sc.betainc(a, b, 0.2)
>>> sc.betaincinv(a, b, y)
0.2
>>>
>>> a, b = 7.5, 0.4
>>> x = sc.betaincinv(a, b, 0.5)
>>> sc.betainc(a, b, x)
0.5

`scipy.special.betainccinv`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.betainccinv.html#scipy.special.betainccinv

scipy.special.betainccinv(a, b, y, out=None) = <ufunc 'betainccinv'>

正则化不完全贝塔函数的互补

计算 (x) 使得：

[y = 1 - I_x(a, b) = 1 - \frac{\Gamma(a+b)}{\Gamma(a)\Gamma(b)} \int_0^x t^{a-1}(1-t)dt,]

其中 (I_x) 是归一化不完全贝塔函数 betainc，(\Gamma) 是 gamma 函数 [1]。

参数：

a, b array_like

正实数参数

y array_like

实值输入

out ndarray, 可选

可选的输出数组用于函数值

标量或者 ndarray

正则化不完全贝塔函数的反函数的值

另请参阅

betainc

正则化不完全贝塔函数

betaincc

正则化不完全贝塔函数的互补

注意

版本 1.11.0 中的新功能。

参考文献

[1]

美国国家标准与技术研究院数学函数数字图书馆 dlmf.nist.gov/8.17

示例

>>> from scipy.special import betainccinv, betaincc

对于固定的 (a) 和 (b) 值，此函数是 betaincc 的反函数。

>>> a, b = 1.2, 3.1
>>> y = betaincc(a, b, 0.2)
>>> betainccinv(a, b, y)
0.2

>>> a, b = 7, 2.5
>>> x = betainccinv(a, b, 0.875)
>>> betaincc(a, b, x)
0.875

`scipy.special.psi`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.psi.html#scipy.special.psi

scipy.special.psi(z, out=None) = <ufunc 'psi'>

Digamma 函数。

在z处评估的伽玛函数的对数导数。

参数：

zarray_like

实数或复数参数。

out ndarray，可选

用于计算psi值的数组。

digamma标量或 ndarray

计算出的psi值。

注意

对于不接近负实轴的大值，使用渐近级数（5.11.2）来计算psi，参见[1]。对于不接近负实轴的小参数，使用递推关系（5.5.2），直到参数足够大以使用渐近级数。对于接近负实轴的值，首先使用反射公式（5.5.4）参见[1]。注意，psi在负实轴上有一系列零点，这些零点出现在非正整数极点之间。在这些零点周围，反射公式会由于抵消而导致实现精度下降。然而，第一个正零点和第一个负零点通过预先计算级数展开来单独处理，参见[2]，因此函数应在原点周围保持完全准确。

参考文献

[1] (1,2,3)

NIST 数字数学函数库 dlmf.nist.gov/5

[2]

Fredrik Johansson 等人。“mpmath：用于任意精度浮点算术的 Python 库”（版本 0.19）mpmath.org/

示例

>>> from scipy.special import psi
>>> z = 3 + 4j
>>> psi(z)
(1.55035981733341+1.0105022091860445j)

验证 psi(z) = psi(z + 1) - 1/z：

>>> psi(z + 1) - 1/z
(1.55035981733341+1.0105022091860445j)

`scipy.special.rgamma`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.rgamma.html#scipy.special.rgamma

scipy.special.rgamma(z, out=None) = <ufunc 'rgamma'>

Gamma 函数的倒数。

定义为(1 / \Gamma(z))，其中(\Gamma)为 Gamma 函数。有关 Gamma 函数的更多信息，请参见gamma。

参数：

zarray_like

实数或复数输入

outndarray，可选

可选的输出数组用于函数结果

标量或者 ndarray

函数结果

另请参见

gamma、gammaln、loggamma

注意事项

Gamma 函数在非正整数处没有零点，且在非正整数处有简单的极点，因此rgamma是一个在非正整数处有零点的整函数。详见[dlmf]中的讨论以获取更多详情。

参考文献

[dlmf]

Nist, 数学函数数字化图书馆, dlmf.nist.gov/5.2#i

示例

>>> import scipy.special as sc

它是 Gamma 函数的倒数。

>>> sc.rgamma([1, 2, 3, 4])
array([1\.        , 1\.        , 0.5       , 0.16666667])
>>> 1 / sc.gamma([1, 2, 3, 4])
array([1\.        , 1\.        , 0.5       , 0.16666667])

它在非正整数处为零。

>>> sc.rgamma([0, -1, -2, -3])
array([0., 0., 0., 0.])

它在正实轴上迅速地向零下溢。

>>> sc.rgamma([10, 100, 179])
array([2.75573192e-006, 1.07151029e-156, 0.00000000e+000])

`scipy.special.polygamma`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.polygamma.html#scipy.special.polygamma

scipy.special.polygamma(n, x)

Polygamma 函数。

定义为 (\psi^{(n)}(x))，其中 (\psi) 是digamma 函数。详细信息请参见[dlmf]。

参数：

narray_like

digamma 函数的导数阶数；必须是整数

xarray_like

实数值输入

ndarray

函数结果

参见

digamma

参考

[dlmf]

NIST，数字数学函数库，dlmf.nist.gov/5.15

示例

>>> from scipy import special
>>> x = [2, 3, 25.5]
>>> special.polygamma(1, x)
array([ 0.64493407,  0.39493407,  0.03999467])
>>> special.polygamma(0, x) == special.psi(x)
array([ True,  True,  True], dtype=bool)

`scipy.special.multigammaln`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.multigammaln.html#scipy.special.multigammaln

scipy.special.multigammaln(a, d)

返回多变量伽马函数的对数，有时也称为广义伽马函数。

参数：

andarray

为每个 a 的项计算多变量伽马函数。

dint

积分空间的维度。

resndarray

在给定点 a 处的对数多变量伽马函数的值。

注意事项

对于实数 a 的多变量伽马函数的形式定义是

[\Gamma_d(a) = \int_{A>0} e^{-tr(A)} |A|^{a - (d+1)/2} dA]

条件是 (a > (d-1)/2)，且 (A > 0) 是所有正定矩阵集合的维度 d。注意 a 是标量：被积函数是多变量的，但参数不是（该函数在实数集的一个子集上定义）。

可以证明这等于更友好的方程式

[\Gamma_d(a) = \pi^{d(d-1)/4} \prod_{i=1}^{d} \Gamma(a - (i-1)/2).]

参考文献

R. J. Muirhead，《多元统计理论的各个方面》（Wiley Series in probability and mathematical statistics）。

示例

>>> import numpy as np
>>> from scipy.special import multigammaln, gammaln
>>> a = 23.5
>>> d = 10
>>> multigammaln(a, d)
454.1488605074416

验证结果是否与上述方程的对数一致：

>>> d*(d-1)/4*np.log(np.pi) + gammaln(a - 0.5*np.arange(0, d)).sum()
454.1488605074416

`scipy.special.digamma`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.digamma.html#scipy.special.digamma

scipy.special.digamma(z, out=None) = <ufunc 'psi'>

Digamma 函数。

伽玛函数的对数导数，在z处评估。

参数：

z数组型

实部或复数参数。

out ndarray，可选

用于计算psi值的数组。

digamma标量或 ndarray

计算出的psi值。

注意事项

对于大值，而非接近负实轴的情况，使用渐近级数(5.11.2)计算psi，见[1]。对于小参数，而非接近负实轴的情况，使用递归关系(5.5.2)，直至参数足够大可使用渐近级数。对于接近负实轴的值，首先使用反射公式(5.5.4)，见[1]。请注意，psi在负实轴上具有一族零点，这些零点位于非正整数的极点之间。在这些零点周围，反射公式会遭遇抵消问题，导致实现失去精度。然而，正零点和第一个负零点通过预计算使用[2]的级数展开来单独处理，因此该函数应在原点周围保持完全精度。

参考文献

[1] (1,2,3)

NIST 数学函数数字图书馆 dlmf.nist.gov/5

[2]

Fredrik Johansson 及其它。“mpmath: 一种用于任意精度浮点运算的 Python 库”（版本 0.19） mpmath.org/

例子

>>> from scipy.special import psi
>>> z = 3 + 4j
>>> psi(z)
(1.55035981733341+1.0105022091860445j)

验证 psi(z) = psi(z + 1) - 1/z：

>>> psi(z + 1) - 1/z
(1.55035981733341+1.0105022091860445j)

`scipy.special.poch`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.poch.html#scipy.special.poch

scipy.special.poch(z, m, out=None) = <ufunc 'poch'>

Pochhammer 符号。

Pochhammer 符号（上升阶乘）定义如下：

[(z)_m = \frac{\Gamma(z + m)}{\Gamma(z)}]

对于正整数 m，它读取

[(z)_m = z (z + 1) ... (z + m - 1)]

更多详细信息请参见[dlmf]。

参数：

z, marray_like

实数参数。

outndarray, 可选

函数结果的可选输出数组

标量或者 ndarray

函数的值。

参考资料

[dlmf]

Nist, 数学函数数字图书馆 dlmf.nist.gov/5.2#iii

示例

>>> import scipy.special as sc

当 m 为 0 时为 1。

>>> sc.poch([1, 2, 3, 4], 0)
array([1., 1., 1., 1.])

当 z 等于 1 时，它缩减为阶乘函数。

>>> sc.poch(1, 5)
120.0
>>> 1 * 2 * 3 * 4 * 5
120

可用 gamma 函数表示。

>>> z, m = 3.7, 2.1
>>> sc.poch(z, m)
20.529581933776953
>>> sc.gamma(z + m) / sc.gamma(z)
20.52958193377696

`scipy.special.erf`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.erf.html#scipy.special.erf

scipy.special.erf(z, out=None) = <ufunc 'erf'>

返回复数参数的误差函数。

定义为2/sqrt(pi)*integral(exp(-t**2), t=0..z)。

参数：

xndarray

输入数组。

outndarray, optional

函数值的可选输出数组

res标量或 ndarray

在给定点x处的误差函数值。

另见

erfc, erfinv, erfcinv, wofz, erfcx, erfi

注释

单位正态分布的累积由Phi(z) = 1/2[1 + erf(z/sqrt(2))]给出。

参考

[1]

en.wikipedia.org/wiki/Error_function

[2]

Milton Abramowitz 和 Irene A. Stegun，编辑。数学函数手册，包含公式、图表和数学表。纽约：Dover，1972 年。 www.math.sfu.ca/~cbm/aands/page_297.htm

[3]

Steven G. Johnson，Faddeeva W 函数实现。 ab-initio.mit.edu/Faddeeva

示例

>>> import numpy as np
>>> from scipy import special
>>> import matplotlib.pyplot as plt
>>> x = np.linspace(-3, 3)
>>> plt.plot(x, special.erf(x))
>>> plt.xlabel('$x$')
>>> plt.ylabel('$erf(x)$')
>>> plt.show()

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

`scipy.special.erfc`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.erfc.html#scipy.special.erfc

scipy.special.erfc(x, out=None) = <ufunc 'erfc'>

补充误差函数，1 - erf(x)。

参数：

x array_like

实数或复数参数

out ndarray，可选

用于函数结果的可选输出数组

标量或 ndarray

补充误差函数的值

另请参阅

erf, erfi, erfcx, dawsn, wofz

参考文献

[1]

Steven G. Johnson，Faddeeva W 函数实现。ab-initio.mit.edu/Faddeeva

示例

>>> import numpy as np
>>> from scipy import special
>>> import matplotlib.pyplot as plt
>>> x = np.linspace(-3, 3)
>>> plt.plot(x, special.erfc(x))
>>> plt.xlabel('$x$')
>>> plt.ylabel('$erfc(x)$')
>>> plt.show()

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

`scipy.special.erfcx`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.erfcx.html#scipy.special.erfcx

scipy.special.erfcx(x, out=None) = <ufunc 'erfcx'>

缩放的余补误差函数，exp(x**2) * erfc(x)。

参数：

xarray_like

实数或复数值的参数

outndarray，可选

函数结果的可选输出数组

标量或者 ndarray

缩放的余补误差函数的值

参见

erf，erfc，erfi，dawsn，wofz

注释

版本 0.12.0 中的新功能。

参考文献

[1]

Steven G. Johnson，Faddeeva W 函数实现。ab-initio.mit.edu/Faddeeva

示例

>>> import numpy as np
>>> from scipy import special
>>> import matplotlib.pyplot as plt
>>> x = np.linspace(-3, 3)
>>> plt.plot(x, special.erfcx(x))
>>> plt.xlabel('$x$')
>>> plt.ylabel('$erfcx(x)$')
>>> plt.show()

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

`scipy.special.erfi`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.erfi.html#scipy.special.erfi

scipy.special.erfi(z, out=None) = <ufunc 'erfi'>

虚误差函数，-i erf(i z)。

参数：

zarray_like

实数或复数值参数

outndarray，可选

函数结果的可选输出数组

标量或者 ndarray

虚误差函数的值

另请参见

erf, erfc, erfcx, dawsn, wofz

注意

新版本 0.12.0 中的内容。

参考文献

[1]

Steven G. Johnson，Faddeeva W 函数实现。ab-initio.mit.edu/Faddeeva

示例

>>> import numpy as np
>>> from scipy import special
>>> import matplotlib.pyplot as plt
>>> x = np.linspace(-3, 3)
>>> plt.plot(x, special.erfi(x))
>>> plt.xlabel('$x$')
>>> plt.ylabel('$erfi(x)$')
>>> plt.show()

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

`scipy.special.erfinv`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.erfinv.html#scipy.special.erfinv

scipy.special.erfinv(y, out=None) = <ufunc 'erfinv'>

误差函数的逆函数。

计算误差函数的逆函数。

在复数域中，没有唯一的复数 w 满足 erf(w)=z。这表明真正的逆函数将是多值的。当域限制为实数，-1 < x < 1 时，有一个唯一的实数满足 erf(erfinv(x)) = x。

参数：

y ndarray

评估位置的参数。域：[-1, 1]

out ndarray, 可选

函数值的可选输出数组

erfinv 标量或 ndarray

y 的 erf 的逆函数，逐元素

参见

erf

复数参数的误差函数

erfc

互补误差函数，1 - erf(x)

erfcinv

互补误差函数的逆函数

示例

>>> import numpy as np
>>> import matplotlib.pyplot as plt
>>> from scipy.special import erfinv, erf

>>> erfinv(0.5)
0.4769362762044699

>>> y = np.linspace(-1.0, 1.0, num=9)
>>> x = erfinv(y)
>>> x
array([       -inf, -0.81341985, -0.47693628, -0.22531206,  0\.        ,
 0.22531206,  0.47693628,  0.81341985,         inf])

验证 erf(erfinv(y)) 等于 y。

>>> erf(x)
array([-1\.  , -0.75, -0.5 , -0.25,  0\.  ,  0.25,  0.5 ,  0.75,  1\.  ])

绘制函数：

>>> y = np.linspace(-1, 1, 200)
>>> fig, ax = plt.subplots()
>>> ax.plot(y, erfinv(y))
>>> ax.grid(True)
>>> ax.set_xlabel('y')
>>> ax.set_title('erfinv(y)')
>>> plt.show()

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

`scipy.special.erfcinv`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.erfcinv.html#scipy.special.erfcinv

scipy.special.erfcinv(y, out=None) = <ufunc 'erfcinv'>

补充误差函数的逆函数。

计算补充误差函数的逆函数。

在复数域中，不存在唯一复数 w 满足 erfc(w)=z。这表明真正的逆函数将是多值的。当定义域限制在实数，0 < x < 2 时，存在唯一的实数满足 erfc(erfcinv(x)) = erfcinv(erfc(x))。

它与误差函数的逆相关，通过 erfcinv(1-x) = erfinv(x)

参数：

y ndarray

评估的参数。定义域：[0, 2]

out ndarray，可选

函数值的可选输出数组

erfcinv 标量或者 ndarray

y 的 erfc 的逆函数，逐元素

参见

erf

复数参数的误差函数

erfc

补充误差函数，1 - erf(x)

erfinv

误差函数的逆函数

示例

>>> import numpy as np
>>> import matplotlib.pyplot as plt
>>> from scipy.special import erfcinv

>>> erfcinv(0.5)
0.4769362762044699

>>> y = np.linspace(0.0, 2.0, num=11)
>>> erfcinv(y)
array([        inf,  0.9061938 ,  0.59511608,  0.37080716,  0.17914345,
 -0\.        , -0.17914345, -0.37080716, -0.59511608, -0.9061938 ,
 -inf])

绘制函数：

>>> y = np.linspace(0, 2, 200)
>>> fig, ax = plt.subplots()
>>> ax.plot(y, erfcinv(y))
>>> ax.grid(True)
>>> ax.set_xlabel('y')
>>> ax.set_title('erfcinv(y)')
>>> plt.show()

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

`scipy.special.wofz`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.wofz.html#scipy.special.wofz

scipy.special.wofz(z, out=None) = <ufunc 'wofz'>

Faddeeva 函数

返回复数参数的 Faddeeva 函数的值：

exp(-z**2) * erfc(-i*z)

参数：

z 数组形式

复数参数

out ndarray，可选

可选的输出数组，用于函数结果

标量或 ndarray

Faddeeva 函数的值

另请参阅

dawsn，erf，erfc，erfcx，erfi

参考文献

[1]

Steven G. Johnson，Faddeeva W 函数实现。ab-initio.mit.edu/Faddeeva

示例

>>> import numpy as np
>>> from scipy import special
>>> import matplotlib.pyplot as plt

>>> x = np.linspace(-3, 3)
>>> z = special.wofz(x)

>>> plt.plot(x, z.real, label='wofz(x).real')
>>> plt.plot(x, z.imag, label='wofz(x).imag')
>>> plt.xlabel('$x$')
>>> plt.legend(framealpha=1, shadow=True)
>>> plt.grid(alpha=0.25)
>>> plt.show()

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

`scipy.special.dawsn`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.dawsn.html#scipy.special.dawsn

scipy.special.dawsn(x, out=None) = <ufunc 'dawsn'>

Dawson 积分。

计算：

exp(-x**2) * integral(exp(t**2), t=0..x).

参数：

xarray_like

函数参数。

输出ndarray，可选

函数值的可选输出数组

y标量或 ndarray

积分值。

参见

wofz，erf，erfc，erfcx，erfi

参考文献

[1]

Steven G. Johnson，Faddeeva W 函数实现。ab-initio.mit.edu/Faddeeva

示例

>>> import numpy as np
>>> from scipy import special
>>> import matplotlib.pyplot as plt
>>> x = np.linspace(-15, 15, num=1000)
>>> plt.plot(x, special.dawsn(x))
>>> plt.xlabel('$x$')
>>> plt.ylabel('$dawsn(x)$')
>>> plt.show()

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

`scipy.special.fresnel`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.fresnel.html#scipy.special.fresnel

scipy.special.fresnel(z, out=None) = <ufunc 'fresnel'>

Fresnel 积分

Fresnel 积分被定义为

[\begin{split}S(z) &= \int_0^z \sin(\pi t² /2) dt \ C(z) &= \int_0^z \cos(\pi t² /2) dt.\end{split}]

详细信息请参见[dlmf]。

参数：

z类似数组

实数或复数值的参数

out2 个 ndarray 数组，可选

函数结果的可选输出数组

返回值：

S, C2 个标量或 ndarray 数组

Fresnel 积分的值

参见

fresnel_zeros

Fresnel 积分的零点

参考文献

[dlmf]

美国国家标准与技术研究院数字数学函数库dlmf.nist.gov/7.2#iii

示例

>>> import numpy as np
>>> import scipy.special as sc

当 z 沿着实轴趋向无穷时，S 和 C 收敛于 0.5。

>>> S, C = sc.fresnel([0.1, 1, 10, 100, np.inf])
>>> S
array([0.00052359, 0.43825915, 0.46816998, 0.4968169 , 0.5       ])
>>> C
array([0.09999753, 0.7798934 , 0.49989869, 0.4999999 , 0.5       ])

它们与误差函数erf相关。

>>> z = np.array([1, 2, 3, 4])
>>> zeta = 0.5 * np.sqrt(np.pi) * (1 - 1j) * z
>>> S, C = sc.fresnel(z)
>>> C + 1j*S
array([0.7798934 +0.43825915j, 0.48825341+0.34341568j,
 0.60572079+0.496313j  , 0.49842603+0.42051575j])
>>> 0.5 * (1 + 1j) * sc.erf(zeta)
array([0.7798934 +0.43825915j, 0.48825341+0.34341568j,
 0.60572079+0.496313j  , 0.49842603+0.42051575j])

`scipy.special.fresnel_zeros`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.fresnel_zeros.html#scipy.special.fresnel_zeros

scipy.special.fresnel_zeros(nt)

计算正弦和余弦 Fresnel 积分 S(z) 和 C(z) 的 nt 个复数零点。

Parameters:

ntint

需要计算的零点数量

Returns:

zeros_sine: ndarray

正弦 Fresnel 积分的零点

zeros_cosinendarray

余弦 Fresnel 积分的零点

References

[1]

张善杰和金建明，“特殊函数的计算”，John Wiley and Sons，1996 年。people.sc.fsu.edu/~jburkardt/f77_src/special_functions/special_functions.html

`scipy.special.modfresnelp`

Original text：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.modfresnelp.html#scipy.special.modfresnelp

scipy.special.modfresnelp(x, out=None) = <ufunc 'modfresnelp'>

修改的 Fresnel 正积分

参数:

x类似数组

函数参数

outndarray 元组，可选

可选的输出数组，用于函数结果

fp标量或数组

积分 F_+(x): integral(exp(1j*t*t), t=x..inf)

kp标量或数组

积分 K_+(x): 1/sqrt(pi)*exp(-1j*(x*x+pi/4))*fp

另见

modfresnelm

`scipy.special.modfresnelm`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.modfresnelm.html#scipy.special.modfresnelm

scipy.special.modfresnelm(x, out=None) = <ufunc 'modfresnelm'>

修改的 Fresnel 负积分

参数:

x类似数组

函数参数

outndarray 的元组，可选

函数结果的可选输出数组

fm标量或者 ndarray

积分 F_-(x): integral(exp(-1j*t*t), t=x..inf)

km标量或者 ndarray

积分 K_-(x): 1/sqrt(pi)*exp(1j*(x*x+pi/4))*fp

参见

modfresnelp

`scipy.special.voigt_profile`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.voigt_profile.html#scipy.special.voigt_profile

scipy.special.voigt_profile(x, sigma, gamma, out=None) = <ufunc 'voigt_profile'>

Voigt 分布。

Voigt 分布是一个由标准差为 sigma 的一维正态分布和半高宽为 gamma 的一维柯西分布卷积而成的分布。

如果 sigma = 0，则返回柯西分布的概率密度函数。相反，如果 gamma = 0，则返回正态分布的概率密度函数。如果 sigma = gamma = 0，对于 x = 0 返回值为 Inf，对于其他所有 x 返回值为 0。

参数：

xarray_like

实数参数

sigmaarray_like

正态分布部分的标准差

gammaarray_like

柯西分布部分的半高宽

outndarray, 可选参数

可选输出数组以存储函数值

标量或 ndarray

给定参数的 Voigt 分布

参见

wofz

Faddeeva 函数

注意事项

可以用 Faddeeva 函数来表达

[V(x; \sigma, \gamma) = \frac{Re[w(z)]}{\sigma\sqrt{2\pi}},][z = \frac{x + i\gamma}{\sqrt{2}\sigma}]

其中 (w(z)) 是 Faddeeva 函数。

参考资料

[1]

[zh.wikipedia.org/wiki/Voigt 分布](https://zh.wikipedia.org/wiki/Voigt 分布)

示例

计算 sigma=1 和 gamma=1 时在点 2 的函数值。

>>> from scipy.special import voigt_profile
>>> import numpy as np
>>> import matplotlib.pyplot as plt
>>> voigt_profile(2, 1., 1.)
0.09071519942627544

通过提供 NumPy 数组 x 来计算几个点的函数值。

>>> values = np.array([-2., 0., 5])
>>> voigt_profile(values, 1., 1.)
array([0.0907152 , 0.20870928, 0.01388492])

为不同的参数集绘制函数图像。

>>> fig, ax = plt.subplots(figsize=(8, 8))
>>> x = np.linspace(-10, 10, 500)
>>> parameters_list = [(1.5, 0., "solid"), (1.3, 0.5, "dashed"),
...                    (0., 1.8, "dotted"), (1., 1., "dashdot")]
>>> for params in parameters_list:
...     sigma, gamma, linestyle = params
...     voigt = voigt_profile(x, sigma, gamma)
...     ax.plot(x, voigt, label=rf"$\sigma={sigma},\, \gamma={gamma}$",
...             ls=linestyle)
>>> ax.legend()
>>> plt.show()

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

可视化验证 Voigt 分布确实是正态分布和柯西分布的卷积。

>>> from scipy.signal import convolve
>>> x, dx = np.linspace(-10, 10, 500, retstep=True)
>>> def gaussian(x, sigma):
...     return np.exp(-0.5 * x**2/sigma**2)/(sigma * np.sqrt(2*np.pi))
>>> def cauchy(x, gamma):
...     return gamma/(np.pi * (np.square(x)+gamma**2))
>>> sigma = 2
>>> gamma = 1
>>> gauss_profile = gaussian(x, sigma)
>>> cauchy_profile = cauchy(x, gamma)
>>> convolved = dx * convolve(cauchy_profile, gauss_profile, mode="same")
>>> voigt = voigt_profile(x, sigma, gamma)
>>> fig, ax = plt.subplots(figsize=(8, 8))
>>> ax.plot(x, gauss_profile, label="Gauss: $G$", c='b')
>>> ax.plot(x, cauchy_profile, label="Cauchy: $C$", c='y', ls="dashed")
>>> xx = 0.5*(x[1:] + x[:-1])  # midpoints
>>> ax.plot(xx, convolved[1:], label="Convolution: $G * C$", ls='dashdot',
...         c='k')
>>> ax.plot(x, voigt, label="Voigt", ls='dotted', c='r')
>>> ax.legend()
>>> plt.show()

../../_images/scipy-special-voigt_profile-1_01_00.png

`scipy.special.erf_zeros`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.erf_zeros.html#scipy.special.erf_zeros

scipy.special.erf_zeros(nt)

在第一象限按绝对值排序，计算第一个 nt 个零点。

可通过使用 erf(-z) = erf(z) 和 erf(conj(z)) = conj(erf(z)) 的对称性来获取其他象限的零点。

参数：

ntint

要计算的零点数量

erf 的零点位置 ndarray（复数）

计算 erf(z) 的零点的复数值

参考文献

[1]

Zhang, Shanjie 和 Jin, Jianming。“特殊函数的计算”，John Wiley and Sons，1996 年。people.sc.fsu.edu/~jburkardt/f77_src/special_functions/special_functions.html

示例

>>> from scipy import special
>>> special.erf_zeros(1)
array([1.45061616+1.880943j])

检查 erf 对于 erf_zeros 返回的值是否（接近）为零。

>>> special.erf(special.erf_zeros(1))
array([4.95159469e-14-1.16407394e-16j])

`scipy.special.fresnelc_zeros`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.fresnelc_zeros.html#scipy.special.fresnelc_zeros

scipy.special.fresnelc_zeros(nt)

计算余弦 Fresnel 积分 C(z) 的 nt 个复零点。

参数：

ntint

要计算的零点数量

fresnelc_zeros：ndarray

余弦 Fresnel 积分的零点

参考文献

[1]

张善杰和金建明。“特殊函数的计算”，John Wiley and Sons，1996。people.sc.fsu.edu/~jburkardt/f77_src/special_functions/special_functions.html

`scipy.special.fresnels_zeros`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.fresnels_zeros.html#scipy.special.fresnels_zeros

scipy.special.fresnels_zeros(nt)

计算正弦弗雷内尔积分 S(z) 的 nt 个复零点。

参数：

ntint

要计算的零点数

fresnels_zeros: ndarray

正弦弗雷内尔积分的零点

参考文献

[1]

张善杰和金建明。“特殊函数的计算”，约翰·威利和儿子，1996 年。people.sc.fsu.edu/~jburkardt/f77_src/special_functions/special_functions.html

`scipy.special.lpmv`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.lpmv.html#scipy.special.lpmv

scipy.special.lpmv(m, v, x, out=None) = <ufunc 'lpmv'>

整数阶及实数次数的关联勒让德函数。

定义为

[P_v^m = (-1)^m (1 - x²)^{m/2} \frac{d^m}{dxm} P_v(x)]

其中

[P_v = \sum_{k = 0}^\infty \frac{(-v)_k (v + 1)_k}{(k!)²} \left(\frac{1 - x}{2}\right)^k]

是第一类勒讪德函数。这里((\cdot)_k)是 Pochhammer 符号；参见poch。

参数：

marray_like

阶数（整数或浮点）。如果传入浮点数而不是整数，则函数返回 NaN。

varray_like

次数（浮点）。

xarray_like

参数（浮点）。必须满足|x| <= 1。

outndarray，可选

作为函数结果的可选输出数组

pmv标量或数组

关联勒让德函数的值。

亦参见

lpmn

计算所有阶数0, ..., m和次数0, ..., n的关联勒让德函数。

clpmn

计算复参数的关联勒让德函数。

注意事项

请注意，此实现包含 Condon-Shortley 相位。

参考文献

[1]

张津，“特殊函数的计算”，约翰·威利和儿子出版公司，1996 年。

`scipy.special.sph_harm`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.sph_harm.html#scipy.special.sph_harm

scipy.special.sph_harm(m, n, theta, phi, out=None) = <ufunc 'sph_harm'>

计算球谐函数。

球谐函数定义如下：

[Y^m_n(\theta,\phi) = \sqrt{\frac{2n+1}{4\pi} \frac{(n-m)!}{(n+m)!}} e^{i m \theta} P^m_n(\cos(\phi))]

其中 (P_n^m) 是相关的 Legendre 函数；详见 lpmv。

参数：

marray_like

谐波的阶数（整数）；必须满足 |m| <= n。

narray_like

谐波的度数（整数）；必须满足 n >= 0。在球谐函数的描述中，通常用 l（小写 L）表示。

thetaarray_like

方位角（经度）坐标；必须在 [0, 2*pi] 范围内。

phiarray_like

极坐标（极角）；必须在 [0, pi] 范围内。

outndarray, optional

函数值的可选输出数组

y_mn复数标量或 ndarray

谐波 (Y^m_n) 在 theta 和 phi 处的采样。

Notes

对于输入参数 theta 和 phi 的含义有不同的约定。在 SciPy 中，theta 是方位角，phi 是极角。通常会看到相反的约定，即 theta 是极角，phi 是方位角。

注意，SciPy 的球谐函数包括 Condon-Shortley 相位 [2]，因为它是 lpmv 的一部分。

根据 SciPy 的惯例，前几个球谐函数是

[\begin{split}Y_0⁰(\theta, \phi) &= \frac{1}{2} \sqrt{\frac{1}{\pi}} \ Y_1^{-1}(\theta, \phi) &= \frac{1}{2} \sqrt{\frac{3}{2\pi}} e^{-i\theta} \sin(\phi) \ Y_1⁰(\theta, \phi) &= \frac{1}{2} \sqrt{\frac{3}{\pi}} \cos(\phi) \ Y_1¹(\theta, \phi) &= -\frac{1}{2} \sqrt{\frac{3}{2\pi}} e^{i\theta} \sin(\phi).\end{split}]

References

[1]

数字数学函数库，14.30。dlmf.nist.gov/14.30

[2]

en.wikipedia.org/wiki/Spherical_harmonics#Condon.E2.80.93Shortley_phase

`scipy.special.clpmn`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.clpmn.html#scipy.special.clpmn

scipy.special.clpmn(m, n, z, type=3)

复变量的第一类关联 Legendre 函数。

计算阶数为 m 和阶数为 n 的第一类关联 Legendre 函数 Pmn(z) = (P_n^m(z))，及其导数 Pmn'(z)。返回两个大小为 (m+1, n+1) 的数组，包含所有阶数从 0..m 和阶数从 0..n 的 Pmn(z) 和 Pmn'(z)。

参数：

mint

|m| <= n；Legendre 函数的阶数。

nint

其中 n >= 0；Legendre 函数的阶数。通常在相关的 Legendre 函数描述中称为 l（小写字母 L）。

zfloat 或复数

输入值。

typeint，可选

取值为 2 或 3。2：在实轴上的截断条件为|x| > 1。3：在实轴上的截断条件为-1 < x < 1（默认值）。

Pmn_z(m+1, n+1) 数组

所有阶数 0..m 和阶数 0..n 的数值。

Pmn_d_z(m+1, n+1) 数组

所有阶数 0..m 和阶数 0..n 的导数。

参见

lpmn

实数 z 的第一类关联 Legendre 函数

注意

默认情况下，即 type=3，根据[1]中的相位约定选择。截断位于区间(-1, 1)。一般从上方或下方逼近截断会得到与 Ferrer 第一类函数相关的相位因子（参考lpmn）。

对于 type=2，选择截断在 |x| > 1。在复平面上的实值逼近区间(-1, 1)给出 Ferrer 第一类函数。

参考文献

[1]

Zhang, Shanjie 和 Jin, Jianming。《特殊函数的计算》，John Wiley 和 Sons，1996 年。people.sc.fsu.edu/~jburkardt/f77_src/special_functions/special_functions.html

[2]

NIST 数学函数数字图书馆 dlmf.nist.gov/14.21

`scipy.special.lpn`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.lpn.html#scipy.special.lpn

scipy.special.lpn(n, z)

第一类 Legendre 函数。

计算第一类 Legendre 函数（多项式）Pn(z)及其所有次数从 0 到 n（包括）的导数。

参见多项式类 special.legendre。

参考资料

[1]

张善杰、金建明著，《特殊函数计算》，John Wiley and Sons，1996 年。people.sc.fsu.edu/~jburkardt/f77_src/special_functions/special_functions.html

`scipy.special.lqn`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.lqn.html#scipy.special.lqn

scipy.special.lqn(n, z)

第二类 Legendre 函数。

计算第二类 Legendre 函数 Qn(z)及其从 0 到 n（包括）的所有阶数的导数序列。

参考资料

[1]

张善杰，金建明。“特殊函数的计算”，John Wiley and Sons，1996。people.sc.fsu.edu/~jburkardt/f77_src/special_functions/special_functions.html

`scipy.special.lpmn`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.lpmn.html#scipy.special.lpmn

scipy.special.lpmn(m, n, z)

相关勒让德函数的序列，第一类。

计算阶数为 m 和角度为 n 的第一类相关勒让德函数，Pmn(z) = (P_n^m(z))，及其导数，Pmn'(z)。返回大小为(m+1, n+1)的两个数组，包含0..m阶和0..n角度的Pmn(z)和Pmn'(z)。

此函数采用实数参数 z。对于复数参数 z，请使用 clpmn。

参数：

mint

|m| <= n; 勒让德函数的阶数。

nint

其中 n >= 0; 勒让德函数的阶数。在描述相关勒让德函数时通常称为 l（小写 L）。

zfloat

输入值。

Pmn_z(m+1, n+1) 数组

所有阶数 0..m 和角度 0..n 的值

Pmn_d_z(m+1, n+1) 数组

所有阶数 0..m 和角度 0..n 的导数

另见

clpmn

复数 z 的第一类相关勒让德函数

注

在区间(-1, 1)内返回费雷尔函数的第一类。用于区间(1, inf)和(-inf, -1)的相位约定使得结果始终是实数。

参考

[1]

张善杰和金建明。“特殊函数的计算”，约翰·威利和儿子，1996 年。people.sc.fsu.edu/~jburkardt/f77_src/special_functions/special_functions.html

[2]

NIST 数字数学函数库 dlmf.nist.gov/14.3

`scipy.special.lqmn`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.lqmn.html#scipy.special.lqmn

scipy.special.lqmn(m, n, z)

第二类相关勒让德函数序列。

计算阶数为 m 和次数为 n 的第二类相关勒让德函数 Qmn(z) = (Q_n^m(z))，及其导数 Qmn'(z)。返回大小为 (m+1, n+1) 的两个数组，包含所有阶数从 0..m 和次数从 0..n 的 Qmn(z) 和 Qmn'(z)。

参数：

m整数

|m| <= n；勒让德函数的阶数。

n整数

其中 n >= 0；Legendre 函数的次数。在相关勒让德函数的描述中通常称为 l（小写 L）

z复数

输入值。

返回值：

Qmn_z(m+1, n+1) 数组

所有阶数 0..m 和次数 0..n 的值

Qmn_d_z(m+1, n+1) 数组

所有阶数 0..m 和次数 0..n 的导数

参考文献

[1]

张善杰、金建明著。“特殊函数的计算”，John Wiley and Sons，1996。people.sc.fsu.edu/~jburkardt/f77_src/special_functions/special_functions.html

`scipy.special.ellip_harm`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.ellip_harm.html#scipy.special.ellip_harm

scipy.special.ellip_harm(h2, k2, n, p, s, signm=1, signn=1)

椭球谐波函数 E^p_n(l)

这些也被称为第一类 Lame 函数，是 Lame 方程的解：

[(s² - h²)(s² - k²)E''(s) + s(2s² - h² - k²)E'(s) + (a - q s²)E(s) = 0]

其中(q = (n+1)n)，(a)是对应解的特征值（不返回）。

参数：

h2float

h**2

k2float

k**2应大于h**2

n整数

度

s浮点数

坐标

p整数

顺序，可在[1,2n+1]范围内变化

signm，可选

函数前缀的符号。可为+/-1。详见注释。

signn，可选

函数前缀的符号。可为+/-1。详见注释。

E浮点数

谐波(E^p_n(s))

请参见

ellip_harm_2，ellip_normal

注释

椭球函数的几何解释详见[2]，[3]，[4]。signm和signn参数根据它们的类型控制函数的前缀符号：

K : +1
L : signm
M : signn
N : signm*signn

版本 0.15.0 的新功能。

参考文献

[1]

数字数学函数库 29.12 dlmf.nist.gov/29.12

[2]

Bardhan and Knepley，《计算科学与重发现：椭球谐波的开源实现用于潜在理论问题》，Comput. Sci. Disc. 5, 014006 (2012) DOI:10.1088/1749-4699/5/1/014006。

[3]

David J.and Dechambre P，《计算小型太阳系天体的椭球引力场谐波》，第 30-36 页，2000 年

[4]

George Dassios，《椭球谐波：理论与应用》，第 418 页，2012 年

示例

>>> from scipy.special import ellip_harm
>>> w = ellip_harm(5,8,1,1,2.5)
>>> w
2.5

检查这些函数确实是 Lame 方程的解：

>>> import numpy as np
>>> from scipy.interpolate import UnivariateSpline
>>> def eigenvalue(f, df, ddf):
...     r = (((s**2 - h**2) * (s**2 - k**2) * ddf
...           + s * (2*s**2 - h**2 - k**2) * df
...           - n * (n + 1)*s**2*f) / f)
...     return -r.mean(), r.std()
>>> s = np.linspace(0.1, 10, 200)
>>> k, h, n, p = 8.0, 2.2, 3, 2
>>> E = ellip_harm(h**2, k**2, n, p, s)
>>> E_spl = UnivariateSpline(s, E)
>>> a, a_err = eigenvalue(E_spl(s), E_spl(s,1), E_spl(s,2))
>>> a, a_err
(583.44366156701483, 6.4580890640310646e-11)

`scipy.special.ellip_harm_2`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.ellip_harm_2.html#scipy.special.ellip_harm_2

scipy.special.ellip_harm_2(h2, k2, n, p, s)

椭球谐函数 (F^p_n(l))

这些也被称为第二类拉梅函数，是拉梅方程的解：

[(s² - h²)(s² - k²)F''(s) + s(2s² - h² - k²)F'(s) + (a - q s²)F(s) = 0]

其中 (q = (n+1)n) 和 (a) 是与解对应的特征值（不返回）。

参数：

h2float

h**2

k2float

k**2；应大于 h**2

nint

度数。

pint

顺序，可以在 [1,2n+1] 范围内变化。

sfloat

坐标

Ffloat

谐波 (F^p_n(s))

参见

ellip_harm，ellip_normal

注意

第二类拉梅函数与第一类函数相关联：

[F^p_n(s)=(2n + 1)E^{p_n(s)\int_{0}} \frac{du}{(E^p_n(1/u))²\sqrt{(1-u²k²)(1-u²h²)}}]

新版本 0.15.0 中新增。

例子

>>> from scipy.special import ellip_harm_2
>>> w = ellip_harm_2(5,8,2,1,10)
>>> w
0.00108056853382

`scipy.special.ellip_normal`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.ellip_normal.html#scipy.special.ellip_normal。

scipy.special.ellip_normal(h2, k2, n, p)

椭球谐波规范化常数 (\gamma^p_n)

规范化常数被定义为

[\gamma^{p_n=8\int_{0}}dx\int_{h}^{k}dy \frac{(y²-x²)(E^p_n(y)Ep_n(x))²}{\sqrt((k²-y²)(y²-h²)(h²-x²)(k²-x²)}]

参数：

h2 浮点数。

h**2。

k2 浮点数。

k**2；应该大于h**2。

n 整数。

度数。

p 整数。

顺序可以在[1,2n+1]范围内变化。

gamma 浮点数。

规范化常数 (\gamma^p_n)。

另请参阅：

ellip_harm，ellip_harm_2。

注意事项。

新版本为 0.15.0。

示例

>>> from scipy.special import ellip_normal
>>> w = ellip_normal(5,8,3,7)
>>> w
1723.38796997

`scipy.special.assoc_laguerre`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.assoc_laguerre.html#scipy.special.assoc_laguerre

scipy.special.assoc_laguerre(x, n, k=0.0)

计算广义（关联的）Laguerre 多项式，其次数为 n，阶数为 k。

多项式 (L^{(k)}_n(x)) 在 0, inf) 区间上是正交的，权重函数为 exp(-x) * x**k，其中 k > -1。

参数：

xfloat 或 ndarray

Laguerre 多项式的计算点

nint

Laguerre 多项式的次数

kint

Laguerre 多项式的阶数

返回值：

assoc_laguerre: float 或 ndarray

`scipy.special.eval_legendre`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.eval_legendre.html#scipy.special.eval_legendre

scipy.special.eval_legendre(n, x, out=None) = <ufunc 'eval_legendre'>

在某一点评估 Legendre 多项式。

可以通过 Gauss 超几何函数({}_2F_1)定义 Legendre 多项式为

[P_n(x) = {}_2F_1(-n, n + 1; 1; (1 - x)/2).]

当(n)是整数时，结果是一个阶数为(n)的多项式。详见[AS]中的 22.5.49 节。

参数：

narray_like

多项式的次数。如果不是整数，则结果通过与 Gauss 超几何函数的关系确定。

xarray_like

评估 Legendre 多项式的点

outndarray，可选

可选输出数组的函数值

Pscalar 或 ndarray

Legendre 多项式的值

另请参阅

roots_legendre

Legendre 多项式的根和积分权重

legendre

Legendre 多项式对象

hyp2f1

Gauss 超几何函数

numpy.polynomial.legendre.Legendre

Legendre 级数

参考文献

[AS]

Milton Abramowitz 和 Irene A. Stegun，eds. Handbook of Mathematical Functions with Formulas, Graphs, and Mathematical Tables. New York: Dover, 1972.

示例

>>> import numpy as np
>>> from scipy.special import eval_legendre

在 x = 0 处评估零阶 Legendre 多项式

>>> eval_legendre(0, 0)
1.0

在-1 到 1 之间评估一阶 Legendre 多项式

>>> X = np.linspace(-1, 1, 5)  # Domain of Legendre polynomials
>>> eval_legendre(1, X)
array([-1\. , -0.5,  0\. ,  0.5,  1\. ])

评估阶数为 0 至 4 的 Legendre 多项式在 x = 0 处

>>> N = range(0, 5)
>>> eval_legendre(N, 0)
array([ 1\.   ,  0\.   , -0.5  ,  0\.   ,  0.375])

绘制阶数为 0 至 4 的 Legendre 多项式

>>> X = np.linspace(-1, 1)

>>> import matplotlib.pyplot as plt
>>> for n in range(0, 5):
...     y = eval_legendre(n, X)
...     plt.plot(X, y, label=r'$P_{}(x)$'.format(n))

>>> plt.title("Legendre Polynomials")
>>> plt.xlabel("x")
>>> plt.ylabel(r'$P_n(x)$')
>>> plt.legend(loc='lower right')
>>> plt.show()

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

`scipy.special.eval_chebyt`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.eval_chebyt.html#scipy.special.eval_chebyt

scipy.special.eval_chebyt(n, x, out=None) = <ufunc 'eval_chebyt'>

在某点评估第一类切比雪夫多项式。

第一类切比雪夫多项式可以通过高斯超几何函数 ({}_2F_1) 定义为

[T_n(x) = {}_2F_1(n, -n; 1/2; (1 - x)/2).]

当 (n) 是整数时，结果是一个次数为 (n) 的多项式。详情参见 [AS] 中的 22.5.47。

参数：

narray_like

多项式的次数。如果不是整数，则通过与高斯超几何函数的关系确定结果。

xarray_like

要评估切比雪夫多项式的点

outndarray，可选

为函数值的可选输出数组

Tscalar 或 ndarray

切比雪夫多项式的值

另请参阅

roots_chebyt

第一类切比雪夫多项式的根和积分权重

chebyu

切比雪夫多项式对象

eval_chebyu

评估第二类切比雪夫多项式

hyp2f1

高斯超几何函数

numpy.polynomial.chebyshev.Chebyshev

切比雪夫级数

注意

在 x 范围为 [-1, 1] 时，这个例程至少对 10000 阶的数值是稳定的。

参考资料

[AS]

Milton Abramowitz 和 Irene A. Stegun 编。数学函数、图表与数学表格手册。纽约：多佛尔出版社，1972 年。

`scipy.special.eval_chebyu`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.eval_chebyu.html#scipy.special.eval_chebyu

scipy.special.eval_chebyu(n, x, out=None) = <ufunc 'eval_chebyu'>

在某一点评估第二类切比雪夫多项式

第二类切比雪夫多项式可以通过高斯超几何函数 ({}_2F_1) 定义为

[U_n(x) = (n + 1) {}_2F_1(-n, n + 2; 3/2; (1 - x)/2).]

当 (n) 是整数时，结果是一个 (n) 次多项式。详情请参见《数学函数、公式、图表手册》22.5.48 中的 [AS]。

参数：

narray_like

多项式的度。如果不是整数，则结果通过与高斯超几何函数的关系确定。

xarray_like

评估切比雪夫多项式的点

outndarray，可选

函数值的可选输出数组

U标量或 ndarray

切比雪夫多项式的值

另请参见

roots_chebyu

第二类切比雪夫多项式的根和积分权重

chebyu

切比雪夫多项式对象

eval_chebyt

评估第一类切比雪夫多项式

hyp2f1

高斯超几何函数

参考文献

[AS]

Milton Abramowitz 和 Irene A. Stegun 编。《数学函数、公式、图表手册》。纽约：多佛尔出版社，1972 年。

`scipy.special.eval_chebyc`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.eval_chebyc.html#scipy.special.eval_chebyc

scipy.special.eval_chebyc(n, x, out=None) = <ufunc 'eval_chebyc'>

在[-2, 2]上求切比雪夫一类多项式的点。

这些多项式定义为

[C_n(x) = 2 T_n(x/2)]

其中(T_n)是切比雪夫一类多项式。详情参见[AS]的 22.5.11。

参数：

n数组样

多项式的度。如果不是整数，结果通过与eval_chebyt的关系来确定。

x数组样

评价切比雪夫多项式的点

outndarray, 可选

函数值的可选输出数组

C标量或 ndarray

切比雪夫多项式的值

另见

roots_chebyc

切比雪夫一类多项式在[-2, 2]上的根和积分权重

chebyc

切比雪夫多项式对象

numpy.polynomial.chebyshev.Chebyshev

切比雪夫级数

eval_chebyt

评价切比雪夫一类多项式

参考资料

[AS]

米尔顿·阿布拉莫维奇和爱琳·A·斯特根, 编辑。数学函数手册，包括公式，图表和数学表格。纽约：多佛尔，1972 年。

示例

>>> import numpy as np
>>> import scipy.special as sc

它们是切比雪夫一类多项式的等比例版本

>>> x = np.linspace(-2, 2, 6)
>>> sc.eval_chebyc(3, x)
array([-2\.   ,  1.872,  1.136, -1.136, -1.872,  2\.   ])
>>> 2 * sc.eval_chebyt(3, x / 2)
array([-2\.   ,  1.872,  1.136, -1.136, -1.872,  2\.   ])

`scipy.special.eval_chebys`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.eval_chebys.html#scipy.special.eval_chebys

scipy.special.eval_chebys(n, x, out=None) = <ufunc 'eval_chebys'>

在[-2, 2]上评估第二类切比雪夫多项式的点。

这些多项式定义为

[S_n(x) = U_n(x/2)]

其中(U_n)是第二类切比雪夫多项式。详见[AS]中的 22.5.13。

参数：

narray_like

多项式的次数。如果不是整数，则结果通过与eval_chebyu的关系确定。

xarray_like

要评估切比雪夫多项式的点

outndarray, 可选

函数值的可选输出数组

S标量或 ndarray

切比雪夫多项式的值

另请参阅

roots_chebys

第二类切比雪夫多项式在[-2, 2]上的根和积分权重

chebys

第二类切比雪夫多项式对象

eval_chebyu

评估第二类切比雪夫多项式

参考文献

[AS]

米尔顿·阿布拉莫维茨和艾琳·A·斯蒂甘，编。带有公式、图表和数学表的数学函数手册。纽约：多佛，1972 年。

示例

>>> import numpy as np
>>> import scipy.special as sc

它们是第二类切比雪夫多项式的缩放版本。

>>> x = np.linspace(-2, 2, 6)
>>> sc.eval_chebys(3, x)
array([-4\.   ,  0.672,  0.736, -0.736, -0.672,  4\.   ])
>>> sc.eval_chebyu(3, x / 2)
array([-4\.   ,  0.672,  0.736, -0.736, -0.672,  4\.   ])

`scipy.special.eval_jacobi`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.eval_jacobi.html#scipy.special.eval_jacobi

scipy.special.eval_jacobi(n, alpha, beta, x, out=None) = <ufunc 'eval_jacobi'>

在特定点评估 Jacobi 多项式。

Jacobi 多项式可以通过 Gauss 超几何函数 ({}_2F_1) 定义为

[P_n^{(\alpha, \beta)}(x) = \frac{(\alpha + 1)_n}{\Gamma(n + 1)} {}_2F_1(-n, 1 + \alpha + \beta + n; \alpha + 1; (1 - z)/2)]

其中 ((\cdot)_n) 是 Pochhammer 符号；参见 poch。当 (n) 是整数时，结果是次数为 (n) 的多项式。详见 [AS] 的 22.5.42。

参数：

narray_like

多项式的次数。如果不是整数，则通过与 Gauss 超几何函数的关系确定结果。

alphaarray_like

参数

betaarray_like

参数

xarray_like

评估多项式的点

outndarray，可选

函数值的可选输出数组

Pscalar 或 ndarray

Jacobi 多项式的值

另见

roots_jacobi

Jacobi 多项式的根和积分权重

jacobi

Jacobi 多项式对象

hyp2f1

Gauss 超几何函数

参考文献

[AS]

Milton Abramowitz 和 Irene A. Stegun 编著。《数学函数手册：公式、图表和数学表》。纽约：多佛尔出版社，1972 年。

`scipy.special.eval_laguerre`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.eval_laguerre.html#scipy.special.eval_laguerre

scipy.special.eval_laguerre(n, x, out=None) = <ufunc 'eval_laguerre'>

在某一点评估拉盖尔多项式。

拉盖尔多项式可以通过广义超几何函数({}_1F_1)定义为

[L_n(x) = {}_1F_1(-n, 1, x).]

详细内容请参阅[AS]中的 22.5.16 和 22.5.54。当(n)是整数时，结果是一个(n)次多项式。

参数：

narray_like

多项式的度。如果不是整数，则结果通过与广义超几何函数的关系确定。

xarray_like

评估拉盖尔多项式的点

outndarray, optional

函数值的可选输出数组

返回值：

L标量或 ndarray

拉盖尔多项式的值

另请参见

roots_laguerre

拉盖尔多项式的根和积分权重

laguerre

拉盖尔多项式对象

numpy.polynomial.laguerre.Laguerre

拉盖尔级数

eval_genlaguerre

评估广义拉盖尔多项式

参考资料

[AS]

Milton Abramowitz 和 Irene A. Stegun 编，《数学函数手册：公式、图表和数学表》。纽约：多佛出版社，1972 年。

`scipy.special.eval_genlaguerre`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.eval_genlaguerre.html#scipy.special.eval_genlaguerre

scipy.special.eval_genlaguerre(n, alpha, x, out=None) = <ufunc 'eval_genlaguerre'>

在某一点评估广义拉盖尔多项式。

广义拉盖尔多项式可以通过共轭超几何函数({}_1F_1)定义，如下所示：

[L_n^{(\alpha)}(x) = \binom{n + \alpha}{n} {}_1F_1(-n, \alpha + 1, x).]

当 (n) 是整数时，结果是次数为 (n) 的多项式。详细信息请参见《AS》（#r66458ca93e03-as）第 22.5.54 节。拉盖尔多项式是 (\alpha = 0) 时的特殊情况。

参数：

n数组样式

多项式的次数。如果不是整数，则结果通过与共轭超几何函数的关系确定。

alpha数组样式

参数；必须有alpha > -1

x数组样式

评估广义拉盖尔多项式的点

out ndarray，可选

函数值的可选输出数组

L标量或 ndarray

广义拉盖尔多项式的值

另见

roots_genlaguerre

广义拉盖尔多项式的根和积分权重

genlaguerre

广义拉盖尔多项式对象

hyp1f1

共轭超几何函数

eval_laguerre

评估拉盖尔多项式

参考文献

[AS]

Milton Abramowitz 和 Irene A. Stegun 编辑。Handbook of Mathematical Functions with Formulas, Graphs, and Mathematical Tables. 纽约：Dover, 1972。

`scipy.special.eval_hermite`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.eval_hermite.html#scipy.special.eval_hermite

scipy.special.eval_hermite(n, x, out=None) = <ufunc 'eval_hermite'>

在某一点评估物理学家的埃尔米特多项式。

由...定义

[H_n(x) = (-1)^n e^{x²} \frac{d^n}{dxn} e^{-x²};]

(H_n)是一个次数为(n)的多项式。详见[AS] 22.11.7。

参数：

narray_like

多项式的次数

xarray_like

评估埃尔米特多项式的点

outndarray，可选

函数值的可选输出数组

H标量或 ndarray

埃尔米特多项式的值

另请参见

roots_hermite

物理学家埃尔米特多项式的根和积分权重

hermite

物理学家的埃尔米特多项式对象

numpy.polynomial.hermite.Hermite

物理学家埃尔米特级数

eval_hermitenorm

评估概率学家的埃尔米特多项式

参考文献

[AS]

Milton Abramowitz 和 Irene A. Stegun 编辑。数学函数、图表和数学表格手册。纽约：多佛出版社，1972 年。

`scipy.special.eval_hermitenorm`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.eval_hermitenorm.html#scipy.special.eval_hermitenorm

scipy.special.eval_hermitenorm(n, x, out=None) = <ufunc 'eval_hermitenorm'>

在某一点评估概率学家（标准化的）Hermite 多项式。

由以下定义

[He_n(x) = (-1)^n e^{x²/2} \frac{d^n}{dxn} e^{-x²/2};]

(He_n) 是一个 (n) 次多项式。详情见 [AS] 的 22.11.8 节。

参数：

n 类似数组

多项式的度数

x 类似数组

评估 Hermite 多项式的点

out ndarray，可选

函数值的可选输出数组

He 标量或者 ndarray

Hermite 多项式的值

参见

roots_hermitenorm

概率学家的 Hermite 多项式的根和积分权重

hermitenorm

概率学家的 Hermite 多项式对象

numpy.polynomial.hermite_e.HermiteE

概率学家的 Hermite 级数

eval_hermite

评估物理学家的 Hermite 多项式

参考文献

[AS]

Milton Abramowitz 和 Irene A. Stegun 编辑。 Handbook of Mathematical Functions with Formulas, Graphs, and Mathematical Tables. New York: Dover, 1972.

`scipy.special.eval_gegenbauer`

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.eval_gegenbauer.html#scipy.special.eval_gegenbauer

scipy.special.eval_gegenbauer(n, alpha, x, out=None) = <ufunc 'eval_gegenbauer'>

在某点评估 Gegenbauer 多项式。

Gegenbauer 多项式可以通过 Gauss 超几何函数 ({}_2F_1) 定义为

[C_n^{(\alpha)} = \frac{(2\alpha)_n}{\Gamma(n + 1)} {}_2F_1(-n, 2\alpha + n; \alpha + 1/2; (1 - z)/2).]

当 (n) 是整数时，结果是一个 (n) 次多项式。详见 [AS] 的 22.5.46 节。

参数：

narray_like

多项式的阶数。如果不是整数，结果由与 Gauss 超几何函数的关系确定。

alphaarray_like

参数

xarray_like

用于评估 Gegenbauer 多项式的点

outndarray，可选

函数值的可选输出数组

C标量或 ndarray

Gegenbauer 多项式的值

另见

roots_gegenbauer

Gegenbauer 多项式的根和积分权重

gegenbauer

Gegenbauer 多项式对象

hyp2f1

Gauss 超几何函数

参考文献

[AS]

Milton Abramowitz 和 Irene A. Stegun 编著。Handbook of Mathematical Functions with Formulas, Graphs, and Mathematical Tables。纽约：Dover，1972。

`scipy.special.eval_sh_legendre`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.eval_sh_legendre.html#scipy.special.eval_sh_legendre

scipy.special.eval_sh_legendre(n, x, out=None) = <ufunc 'eval_sh_legendre'>

在某一点评估移位勒让德多项式。

这些多项式定义为

[P_n^*(x) = P_n(2x - 1)]

其中(P_n)是勒让德多项式。详情请参见[AS]中的 2.2.11。

参数：

narray_like

多项式的阶数。如果不是整数，则通过与eval_legendre的关系确定其值。

xarray_like

用于评估移位勒让德多项式的点

outndarray，可选

可选输出数组的函数值

P标量或 ndarray

移位勒让德多项式的值

另请参阅

roots_sh_legendre

移位勒让德多项式的根和积分权重

sh_legendre

移位勒让德多项式对象

eval_legendre

评估勒让德多项式

numpy.polynomial.legendre.Legendre

勒让德级数

参考文献

[AS]

Milton Abramowitz 和 Irene A. Stegun 编著。Handbook of Mathematical Functions with Formulas, Graphs, and Mathematical Tables. 纽约：Dover，1972 年。

`scipy.special.eval_sh_chebyt`

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.eval_sh_chebyt.html#scipy.special.eval_sh_chebyt

scipy.special.eval_sh_chebyt(n, x, out=None) = <ufunc 'eval_sh_chebyt'>

在某一点评估 shifted Chebyshev polynomial 的第一种

这些多项式被定义为

[T_n^*(x) = T_n(2x - 1)]

其中(T_n)是第一种 Chebyshev 多项式。详细信息请参见[AS]的 22.5.14 节。

参数：

n array_like

多项式的次数。如果不是整数，则通过与eval_chebyt的关系确定结果。

x array_like

用于评估 shifted Chebyshev polynomial 的点

out ndarray，可选

用于函数值的可选输出数组

T 标量或 ndarray

shifted Chebyshev polynomial 的值

另请参见

roots_sh_chebyt

shifted Chebyshev polynomials of the first kind 的根和积分权重

sh_chebyt

shifted Chebyshev polynomial 对象

eval_chebyt

评估第一类 Chebyshev 多项式

numpy.polynomial.chebyshev.Chebyshev

Chebyshev 级数

参考文献

[AS]

米尔顿·阿布拉莫维奇和艾琳·斯特根（Milton Abramowitz and Irene A. Stegun）编辑。《数学函数手册：公式、图表和数学表格》。纽约：多佛尔出版社，1972 年。

posted @ 2024-06-27 17:09 绝不原创的飞龙阅读(7) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

龙哥盟

掠夺·扩张·投机·博弈

SciPy-1-12-中文文档-十九-

SciPy 1.12 中文文档（十九）

scipy.special.boxcox

scipy.special.boxcox1p

scipy.special.inv_boxcox

scipy.special.inv_boxcox1p

scipy.special.logit

scipy.special.expit

scipy.special.log_expit

scipy.special.tklmbda

scipy.special.owens_t

scipy.special.entr

scipy.special.rel_entr

scipy.special.kl_div

scipy.special.huber

scipy.special.pseudo_huber

scipy.special.gamma

scipy.special.gammaln

scipy.special.loggamma

scipy.special.gammasgn

scipy.special.gammainc

scipy.special.gammaincinv

scipy.special.gammaincc

scipy.special.gammainccinv

scipy.special.beta

scipy.special.betaln

scipy.special.betainc

scipy.special.betaincc

scipy.special.betaincinv

scipy.special.betainccinv

scipy.special.psi

scipy.special.rgamma

scipy.special.polygamma

scipy.special.multigammaln

scipy.special.digamma

scipy.special.poch

scipy.special.erf

scipy.special.erfc

scipy.special.erfcx

scipy.special.erfi

scipy.special.erfinv

scipy.special.erfcinv

scipy.special.wofz

scipy.special.dawsn

scipy.special.fresnel

scipy.special.fresnel_zeros

scipy.special.modfresnelp

scipy.special.modfresnelm

scipy.special.voigt_profile

scipy.special.erf_zeros

scipy.special.fresnelc_zeros

scipy.special.fresnels_zeros

scipy.special.lpmv

scipy.special.sph_harm

scipy.special.clpmn

scipy.special.lpn

scipy.special.lqn

scipy.special.lpmn

scipy.special.lqmn

scipy.special.ellip_harm

scipy.special.ellip_harm_2

scipy.special.ellip_normal

scipy.special.assoc_laguerre

scipy.special.eval_legendre

scipy.special.eval_chebyt

scipy.special.eval_chebyu

scipy.special.eval_chebyc

scipy.special.eval_chebys

scipy.special.eval_jacobi

scipy.special.eval_laguerre

scipy.special.eval_genlaguerre

scipy.special.eval_hermite

scipy.special.eval_hermitenorm

scipy.special.eval_gegenbauer

scipy.special.eval_sh_legendre

scipy.special.eval_sh_chebyt

公告

`scipy.special.boxcox`

`scipy.special.boxcox1p`

`scipy.special.inv_boxcox`

`scipy.special.inv_boxcox1p`

`scipy.special.logit`

`scipy.special.expit`

`scipy.special.log_expit`

`scipy.special.tklmbda`

`scipy.special.owens_t`

`scipy.special.entr`

`scipy.special.rel_entr`

`scipy.special.kl_div`

`scipy.special.huber`

`scipy.special.pseudo_huber`

`scipy.special.gamma`

`scipy.special.gammaln`

`scipy.special.loggamma`

`scipy.special.gammasgn`

`scipy.special.gammainc`

`scipy.special.gammaincinv`

`scipy.special.gammaincc`

`scipy.special.gammainccinv`

`scipy.special.beta`

`scipy.special.betaln`

`scipy.special.betainc`

`scipy.special.betaincc`

`scipy.special.betaincinv`

`scipy.special.betainccinv`

`scipy.special.psi`

`scipy.special.rgamma`

`scipy.special.polygamma`

`scipy.special.multigammaln`

`scipy.special.digamma`

`scipy.special.poch`

`scipy.special.erf`

`scipy.special.erfc`

`scipy.special.erfcx`

`scipy.special.erfi`

`scipy.special.erfinv`

`scipy.special.erfcinv`

`scipy.special.wofz`

`scipy.special.dawsn`

`scipy.special.fresnel`

`scipy.special.fresnel_zeros`

`scipy.special.modfresnelp`

`scipy.special.modfresnelm`

`scipy.special.voigt_profile`

`scipy.special.erf_zeros`

`scipy.special.fresnelc_zeros`

`scipy.special.fresnels_zeros`

`scipy.special.lpmv`

`scipy.special.sph_harm`

`scipy.special.clpmn`

`scipy.special.lpn`

`scipy.special.lqn`

`scipy.special.lpmn`

`scipy.special.lqmn`

`scipy.special.ellip_harm`

`scipy.special.ellip_harm_2`

`scipy.special.ellip_normal`

`scipy.special.assoc_laguerre`

`scipy.special.eval_legendre`

`scipy.special.eval_chebyt`

`scipy.special.eval_chebyu`

`scipy.special.eval_chebyc`

`scipy.special.eval_chebys`

`scipy.special.eval_jacobi`

`scipy.special.eval_laguerre`

`scipy.special.eval_genlaguerre`

`scipy.special.eval_hermite`

`scipy.special.eval_hermitenorm`

`scipy.special.eval_gegenbauer`

`scipy.special.eval_sh_legendre`

`scipy.special.eval_sh_chebyt`