SciPy 1.12 中文文档（五十）

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

`scipy.special.exp1`

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

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

指数积分 E1。

对于复数 (z \ne 0)，指数积分可以定义为 [1]

[E_1(z) = \int_z^\infty \frac{e^{-t}}{t} dt,]

其路径不穿过负实轴或通过原点。

参数：

z：array_like

实数或复数参数。

outndarray，可选

函数结果的可选输出数组

标量或 ndarray

指数积分 (E1) 的值

参见

expi

指数积分 (Ei)

expn

(E_1)的泛化

注意

对于 (x > 0)，它与指数积分 (Ei) 相关（参见 expi）。

[E_1(x) = -Ei(-x).]

参考文献

[1]

数字数学函数库，6.2.1 dlmf.nist.gov/6.2#E1

例子

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

在 0 处有极点。

>>> sc.exp1(0)
inf

它在负实轴上有一个分支切口。

>>> sc.exp1(-1)
nan
>>> sc.exp1(complex(-1, 0))
(-1.8951178163559368-3.141592653589793j)
>>> sc.exp1(complex(-1, -0.0))
(-1.8951178163559368+3.141592653589793j)

它沿着正实轴逼近 0。

>>> sc.exp1([1, 10, 100, 1000])
array([2.19383934e-01, 4.15696893e-06, 3.68359776e-46, 0.00000000e+00])

它与 expi 有关。

>>> x = np.array([1, 2, 3, 4])
>>> sc.exp1(x)
array([0.21938393, 0.04890051, 0.01304838, 0.00377935])
>>> -sc.expi(-x)
array([0.21938393, 0.04890051, 0.01304838, 0.00377935])

`scipy.special.expi`

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

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

指数积分 Ei。

对于实数(x)，指数积分定义为[1]

[Ei(x) = \int_{-\infty}^x \frac{e^t}{t} dt.]

对于(x > 0)，积分理解为柯西主值。

它通过在区间((0, \infty))上的函数的解析延拓来扩展到复平面。复数变体在负实轴上有一个分支切割。

参数：

x数组样式

实数或复数值参数

outndarray，可选

函数结果的可选输出数组

标量或 ndarray

指数积分的值

另见

exp1

指数积分(E_1)

expn

广义指数积分(E_n)

注

指数积分(E_1)和(Ei)满足关系

[E_1(x) = -Ei(-x)]

对于(x > 0)。

参考资料

[1]

数字数学函数库，6.2.5 dlmf.nist.gov/6.2#E5

示例

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

它与exp1有关。

>>> x = np.array([1, 2, 3, 4])
>>> -sc.expi(-x)
array([0.21938393, 0.04890051, 0.01304838, 0.00377935])
>>> sc.exp1(x)
array([0.21938393, 0.04890051, 0.01304838, 0.00377935])

复数变体在负实轴上有一个分支切割。

>>> sc.expi(-1 + 1e-12j)
(-0.21938393439552062+3.1415926535894254j)
>>> sc.expi(-1 - 1e-12j)
(-0.21938393439552062-3.1415926535894254j)

当复数变体接近分支切割时，实部接近实变体的值。

>>> sc.expi(-1)
-0.21938393439552062

SciPy 实现在分支切割处返回复值的实变体。

>>> sc.expi(complex(-1, 0.0))
(-0.21938393439552062-0j)
>>> sc.expi(complex(-1, -0.0))
(-0.21938393439552062-0j)

`scipy.special.factorial`

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

scipy.special.factorial(n, exact=False)

数字或数字数组的阶乘。

非负整数n的阶乘是小于或等于n的所有正整数的乘积：

n! = n * (n - 1) * (n - 2) * ... * 1

参数：

n整数或整数数组

输入值。如果n < 0，则返回值为 0。

exact布尔型，可选

若为 True，则使用长整数算术精确计算答案。若为 False，则使用快速浮点数逼近方法使用gamma函数。默认为 False。

nf浮点数或整数或数组

n的阶乘，根据exact返回整数或浮点数。

注意事项

对于exact=True的数组，阶乘仅计算一次，对于最大的输入，每个其他结果在过程中计算。如果需要，输出数据类型增加到int64或object。

若exact=False，使用 gamma 函数逼近阶乘：

[n! = \Gamma(n+1)]

示例

>>> import numpy as np
>>> from scipy.special import factorial
>>> arr = np.array([3, 4, 5])
>>> factorial(arr, exact=False)
array([   6.,   24.,  120.])
>>> factorial(arr, exact=True)
array([  6,  24, 120])
>>> factorial(5, exact=True)
120

`scipy.special.factorial2`

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

scipy.special.factorial2(n, exact=False)

双阶乘。

这是阶乘，每隔一个值跳过。例如，7!! = 7 * 5 * 3 * 1。可以数值上近似为：

n!! = 2 ** (n / 2) * gamma(n / 2 + 1) * sqrt(2 / pi)  n odd
    = 2 ** (n / 2) * gamma(n / 2 + 1)                 n even
    = 2 ** (n / 2) * (n / 2)!                         n even

参数：

nint 或 array_like

计算 n!!。如果 n < 0，返回值为 0。

exactbool，可选

结果可以使用上述伽马公式快速近似计算（默认）。如果设置 exact 为 True，则使用整数算术精确计算答案。

nfffloat 或 int

n 的双阶乘，作为 int 或 float，具体取决于 exact。

示例

>>> from scipy.special import factorial2
>>> factorial2(7, exact=False)
array(105.00000000000001)
>>> factorial2(7, exact=True)
105

`scipy.special.factorialk`

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

scipy.special.factorialk(n, k, exact=True)

n 的 k 阶多阶乘，n(!!…!)。

这是跳过 k 值的 n 的多阶乘。例如，

factorialk(17, 4) = 17!!!! = 17 * 13 * 9 * 5 * 1

特别地，对于任何整数 n，我们有

factorialk(n, 1) = factorial(n)

factorialk(n, 2) = factorial2(n)

参数：

nint 或 array_like

计算多阶乘。如果 n < 0，则返回值为 0。

kint

多阶乘的顺序。

exactbool，可选

如果 exact 设置为 True，则使用整数算术精确计算答案。

valint

n 的多阶乘。

引发异常：

未实现错误

当 exact 为 False 时引发异常

示例

>>> from scipy.special import factorialk
>>> factorialk(5, 1, exact=True)
120
>>> factorialk(5, 3, exact=True)
10

`scipy.special.shichi`

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

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

双曲正弦和余弦积分。

双曲正弦积分为

[\int_0^x \frac{\sinh{t}}{t}dt]

双曲余弦积分为

[\gamma + \log(x) + \int_0^x \frac{\cosh{t} - 1}{t} dt]

其中(\gamma)是欧拉常数，(\log)是对数的主分支[1]。

参数：

x数组样式

计算双曲正弦和余弦积分的实数或复数点。

outndarray 的元组，可选

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

si标量或 ndarray

x的双曲正弦积分

ci标量或 ndarray

x的双曲余弦积分

参见

sici

正弦和余弦积分。

exp1

指数积分 E1。

expi

指数积分 Ei。

注意

对于实数参数x < 0，chi是双曲余弦积分的实部。对于这样的点，chi(x)和chi(x + 0j)相差一个因子1j*pi。

对于实数参数，通过调用 Cephes 的[2]shichi例程计算函数。对于复数参数，该算法基于 Mpmath 的[3]shi和chi例程。

参考资料

[1]

Milton Abramowitz 和 Irene A. Stegun，编辑。《数学函数手册：公式、图形和数学表》。纽约：多佛尔，1972 年。（见第 5.2 节。）

[2]

Cephes 数学函数库，www.netlib.org/cephes/

[3]

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

示例

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

shichi 接受实数或复数输入：

>>> shichi(0.5)
(0.5069967498196671, -0.05277684495649357)
>>> shichi(0.5 + 2.5j)
((0.11772029666668238+1.831091777729851j),
 (0.29912435887648825+1.7395351121166562j))

双曲正弦和余弦积分 Shi(z)和 Chi(z)与正弦和余弦积分 Si(z)和 Ci(z)相关

Shi(z) = -iSi(iz)
Chi(z) = Ci(-iz) + ipi/2

>>> z = 0.25 + 5j
>>> shi, chi = shichi(z)
>>> shi, -1j*sici(1j*z)[0]            # Should be the same.
((-0.04834719325101729+1.5469354086921228j),
 (-0.04834719325101729+1.5469354086921228j))
>>> chi, sici(-1j*z)[1] + 1j*np.pi/2  # Should be the same.
((-0.19568708973868087+1.556276312103824j),
 (-0.19568708973868087+1.556276312103824j))

绘制在实轴上评估的函数：

>>> xp = np.geomspace(1e-8, 4.0, 250)
>>> x = np.concatenate((-xp[::-1], xp))
>>> shi, chi = shichi(x)

>>> fig, ax = plt.subplots()
>>> ax.plot(x, shi, label='Shi(x)')
>>> ax.plot(x, chi, '--', label='Chi(x)')
>>> ax.set_xlabel('x')
>>> ax.set_title('Hyperbolic Sine and Cosine Integrals')
>>> ax.legend(shadow=True, framealpha=1, loc='lower right')
>>> ax.grid(True)
>>> plt.show()

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

`scipy.special.sici`

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

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

正弦和余弦积分。

正弦积分是

[\int_0^x \frac{\sin{t}}{t}dt]

而余弦积分为

[\gamma + \log(x) + \int_0^x \frac{\cos{t} - 1}{t}dt]

其中 (\gamma) 是欧拉常数，(\log) 是对数的主分支 [1]。

参数：

xarray_like

计算正弦和余弦积分的实数或复数点。

out的 ndarray 元组，可选

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

si标量或 ndarray

正弦积分在 x

ci标量或 ndarray

x 处的余弦积分

另请参阅

shichi

双曲正弦和余弦积分。

exp1

指数积分 E1。

expi

指数积分 Ei。

注意

对于实数参数，当 x < 0 时，ci 是余弦积分的实部。对于这样的点，ci(x) 和 ci(x + 0j) 相差一个因子 1j*pi。

对于实数参数，通过调用 Cephes 的 [2] sici 程序计算。对于复数参数，算法基于 Mpmath 的 [3] si 和 ci 程序。

参考文献

[1] (1,2)

Milton Abramowitz 和 Irene A. Stegun 编，Handbook of Mathematical Functions with Formulas, Graphs, and Mathematical Tables。New York: Dover, 1972.（参见第 5.2 节。）

[2]

Cephes 数学函数库，www.netlib.org/cephes/

[3]

Fredrik Johansson 和其他人，“mpmath: a Python library for arbitrary-precision floating-point arithmetic”（版本 0.19）mpmath.org/

示例

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

sici 接受实数或复数输入：

>>> sici(2.5)
(1.7785201734438267, 0.2858711963653835)
>>> sici(2.5 + 3j)
((4.505735874563953+0.06863305018999577j),
(0.0793644206906966-2.935510262937543j))

对于右半平面的 z，正弦和余弦积分与指数积分 E1（在 SciPy 中实现为 scipy.special.exp1）相关

Si(z) = (E1(iz) - E1(-iz))/2i + pi/2
Ci(z) = -(E1(iz) + E1(-iz))/2

见 [1]（方程 5.2.21 和 5.2.23）。

我们可以验证以下关系：

>>> z = 2 - 3j
>>> sici(z)
((4.54751388956229-1.3991965806460565j),
(1.408292501520851+2.9836177420296055j))

>>> (exp1(1j*z) - exp1(-1j*z))/2j + np.pi/2  # Same as sine integral
(4.54751388956229-1.3991965806460565j)

>>> -(exp1(1j*z) + exp1(-1j*z))/2            # Same as cosine integral
(1.408292501520851+2.9836177420296055j)

绘制在实轴上评估的函数；虚线水平线在 pi/2 和 -pi/2 处：

>>> x = np.linspace(-16, 16, 150)
>>> si, ci = sici(x)

>>> fig, ax = plt.subplots()
>>> ax.plot(x, si, label='Si(x)')
>>> ax.plot(x, ci, '--', label='Ci(x)')
>>> ax.legend(shadow=True, framealpha=1, loc='upper left')
>>> ax.set_xlabel('x')
>>> ax.set_title('Sine and Cosine Integrals')
>>> ax.axhline(np.pi/2, linestyle=':', alpha=0.5, color='k')
>>> ax.axhline(-np.pi/2, linestyle=':', alpha=0.5, color='k')
>>> ax.grid(True)
>>> plt.show()

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

`scipy.special.softmax`

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

scipy.special.softmax(x, axis=None)

计算 softmax 函数。

softmax 函数通过计算每个元素的指数除以所有元素的指数之和来转换集合的每个元素。也就是说，如果 x 是一维 numpy 数组：

softmax(x) = np.exp(x)/sum(np.exp(x))

参数：

xarray_like

输入数组。

轴int 或 int 元组，可选

计算值的轴。默认为 None，softmax 将在整个数组 x 上计算。

sndarray

与 x 相同形状的数组。结果将沿指定轴总和为 1。

注意事项

对于向量 ( x = {x_0, x_1, ..., x_{n-1}} )，softmax 函数 (\sigma(x)) 的公式为：

[\sigma(x)_j = \frac{e^{x_j}}{\sum_k e^{x_k}}]

softmax 函数是 logsumexp 的梯度。

该实现使用移位来避免溢出。更多详细信息见 [1]。

新版本 1.2.0 中引入。

参考文献

[1]

P. Blanchard, D.J. Higham, N.J. Higham, “精确计算 log-sum-exp 和 softmax 函数”, IMA 数值分析杂志, Vol.41(4), DOI:10.1093/imanum/draa038.

示例

>>> import numpy as np
>>> from scipy.special import softmax
>>> np.set_printoptions(precision=5)

>>> x = np.array([[1, 0.5, 0.2, 3],
...               [1,  -1,   7, 3],
...               [2,  12,  13, 3]])
...

在整个数组上计算 softmax 转换。

>>> m = softmax(x)
>>> m
array([[  4.48309e-06,   2.71913e-06,   2.01438e-06,   3.31258e-05],
 [  4.48309e-06,   6.06720e-07,   1.80861e-03,   3.31258e-05],
 [  1.21863e-05,   2.68421e-01,   7.29644e-01,   3.31258e-05]])

>>> m.sum()
1.0

沿第一轴（即列）计算 softmax 转换。

>>> m = softmax(x, axis=0)

>>> m
array([[  2.11942e-01,   1.01300e-05,   2.75394e-06,   3.33333e-01],
 [  2.11942e-01,   2.26030e-06,   2.47262e-03,   3.33333e-01],
 [  5.76117e-01,   9.99988e-01,   9.97525e-01,   3.33333e-01]])

>>> m.sum(axis=0)
array([ 1.,  1.,  1.,  1.])

沿第二轴（即行）计算 softmax 转换。

>>> m = softmax(x, axis=1)
>>> m
array([[  1.05877e-01,   6.42177e-02,   4.75736e-02,   7.82332e-01],
 [  2.42746e-03,   3.28521e-04,   9.79307e-01,   1.79366e-02],
 [  1.22094e-05,   2.68929e-01,   7.31025e-01,   3.31885e-05]])

>>> m.sum(axis=1)
array([ 1.,  1.,  1.])

`scipy.special.log_softmax`

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

scipy.special.log_softmax(x, axis=None)

计算 softmax 函数的对数。

原则上：

log_softmax(x) = log(softmax(x))

但使用更精确的实现。

参数：

x 类似数组

输入数组。

axis 整数或整数元组，可选

计算值的轴。默认为 None，softmax 将在整个数组 x 上计算。

s 数组或标量

与 x 具有相同形状的数组。结果的指数将沿指定轴总和为 1。如果 x 是标量，则返回标量。

注意事项

log_softmax 比使用使 softmax 饱和的输入更精确的 np.log(softmax(x)) 更准确（见下面的示例）。

新版本为 1.5.0。

示例

>>> import numpy as np
>>> from scipy.special import log_softmax
>>> from scipy.special import softmax
>>> np.set_printoptions(precision=5)

>>> x = np.array([1000.0, 1.0])

>>> y = log_softmax(x)
>>> y
array([   0., -999.])

>>> with np.errstate(divide='ignore'):
...   y = np.log(softmax(x))
...
>>> y
array([  0., -inf])

`scipy.special.spence`

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

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

Spence 函数，也称为二阶对数函数。

它的定义如下

[\int_1^z \frac{\log(t)}{1 - t}dt]

对于复数 (z)，积分的路径避开对数的分支切割。Spence 函数在除了负实轴外的所有地方都是解析的。

参数：

zarray_like

评估 Spence 函数的点

outndarray，可选项

可选的输出数组以获取函数结果

s标量或 ndarray

计算得到的 Spence 函数值

注意事项

通过积分定义 Spence 函数的另一种约定如下：

[-\int_0^z \frac{\log(1 - t)}{t}dt;]

这是我们的 spence(1 - z)。

示例

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

该函数定义适用于复数输入：

>>> spence([1-1j, 1.5+2j, 3j, -10-5j])
array([-0.20561676+0.91596559j, -0.86766909-1.39560134j,
 -0.59422064-2.49129918j, -1.14044398+6.80075924j])

对于复数输入的分支切割，即负实轴，函数在具有正虚部的 z 上返回限制。例如，在以下情况下，请注意输出的虚部对于 z = -2 和 z = -2 - 1e-8j 的符号变化：

>>> spence([-2 + 1e-8j, -2, -2 - 1e-8j])
array([2.32018041-3.45139229j, 2.32018042-3.4513923j ,
 2.32018041+3.45139229j])

函数在实数输入处的分支切割处返回 nan：

>>> spence(-1.5)
nan

验证一些特定值：spence(0) = pi**2/6，spence(1) = 0 和 spence(2) = -pi**2/12。

>>> spence([0, 1, 2])
array([ 1.64493407,  0\.        , -0.82246703])
>>> np.pi**2/6, -np.pi**2/12
(1.6449340668482264, -0.8224670334241132)

验证身份：

spence(z) + spence(1 - z) = pi**2/6 - log(z)*log(1 - z)

>>> z = 3 + 4j
>>> spence(z) + spence(1 - z)
(-2.6523186143876067+1.8853470951513935j)
>>> np.pi**2/6 - np.log(z)*np.log(1 - z)
(-2.652318614387606+1.885347095151394j)

绘制正实数输入的函数。

>>> fig, ax = plt.subplots()
>>> x = np.linspace(0, 6, 400)
>>> ax.plot(x, spence(x))
>>> ax.grid()
>>> ax.set_xlabel('x')
>>> ax.set_title('spence(x)')
>>> plt.show()

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

`scipy.special.zeta`

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

scipy.special.zeta(x, q=None, out=None)

黎曼或 Hurwitz zeta 函数。

参数:

x 浮点数数组

输入数据，必须为实数

q 浮点数数组, 可选项

输入数据，必须为实数。默认情况是瑞曼 zeta。

out 数组, 可选项

计算得到的数值的输出数组。

out 数组

zeta(x)的数值。

另见

zetac

说明

两个参数的版本是 Hurwitz zeta 函数

[\zeta(x, q) = \sum_{k=0}^{\infty} \frac{1}{(k + q)^x};]

有关详细信息，请参见[dlmf]。当q = 1时，瑞曼 zeta 函数对应的是该情形。

参考资料

[dlmf]

NIST，数字数学函数数字化图书馆, dlmf.nist.gov/25.11#i

例子

>>> import numpy as np
>>> from scipy.special import zeta, polygamma, factorial

一些特定数值:

>>> zeta(2), np.pi**2/6
(1.6449340668482266, 1.6449340668482264)

>>> zeta(4), np.pi**4/90
(1.0823232337111381, 1.082323233711138)

与polygamma函数的关系:

>>> m = 3
>>> x = 1.25
>>> polygamma(m, x)
array(2.782144009188397)
>>> (-1)**(m+1) * factorial(m) * zeta(m+1, x)
2.7821440091883969

`scipy.special.zetac`

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

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

黎曼 zeta 函数减 1。

此函数定义如下

[\zeta(x) = \sum_{k=2}^{\infty} 1 / k^x,]

其中 x > 1。对于 x < 1，进行解析延伸计算。有关黎曼 zeta 函数的更多信息，请参见[dlmf]。

参数：

x 浮点数的数组

计算 zeta(x) - 1 的值的位置（必须是实数）。

out ndarray，可选

函数结果的可选输出数组

标量或 ndarray

zeta(x) - 1 的值。

另请参阅

zeta

参考文献

[dlmf]

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

例子

>>> import numpy as np
>>> from scipy.special import zetac, zeta

一些特殊值：

>>> zetac(2), np.pi**2/6 - 1
(0.64493406684822641, 0.6449340668482264)

>>> zetac(-1), -1.0/12 - 1
(-1.0833333333333333, -1.0833333333333333)

比较zetac(x)和zeta(x) - 1对于大的x：

>>> zetac(60), zeta(60) - 1
(8.673617380119933e-19, 0.0)

`scipy.special.cbrt`

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

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

x 的逐元素立方根。

参数：

xarray_like

x 必须包含实数。

outndarray，可选

函数值的可选输出数组

返回值：

标量或者 ndarray

x 中每个值的立方根。

示例

>>> from scipy.special import cbrt

>>> cbrt(8)
2.0
>>> cbrt([-8, -3, 0.125, 1.331])
array([-2\.        , -1.44224957,  0.5       ,  1.1       ])

`scipy.special.exp10`

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

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

逐元素计算10**x。

参数：

xarray_like

x必须包含实数。

outndarray，可选

函数值的可选输出数组

返回值：

标量或数组

逐元素计算10**x。

示例

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

>>> exp10(3)
1000.0
>>> x = np.array([[-1, -0.5, 0], [0.5, 1, 1.5]])
>>> exp10(x)
array([[  0.1       ,   0.31622777,   1\.        ],
 [  3.16227766,  10\.        ,  31.6227766 ]])

`scipy.special.exp2`

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

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

逐元素计算2**x。

参数：

xarray_like

x必须包含实数。

输出ndarray，可选

函数值的可选输出数组

返回值：

标量或 ndarray

2**x，逐元素计算。

示例

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

>>> exp2(3)
8.0
>>> x = np.array([[-1, -0.5, 0], [0.5, 1, 1.5]])
>>> exp2(x)
array([[ 0.5       ,  0.70710678,  1\.        ],
 [ 1.41421356,  2\.        ,  2.82842712]])

`scipy.special.radian`

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

scipy.special.radian(d, m, s, out=None) = <ufunc 'radian'>

将角度从度转换为弧度。

返回用弧度表示的角度，其中包括度(d)、分钟(m)和秒(s)。

参数：

darray_like

度，可以是实值。

marray_like

分钟，可以是实值。

sarray_like

秒，可以是实值。

outndarray，可选

函数结果的可选输出数组。

标量或者 ndarray

输入的数值以弧度为单位。

示例

>>> import scipy.special as sc

指定角度的方式有很多种。

>>> sc.radian(90, 0, 0)
1.5707963267948966
>>> sc.radian(0, 60 * 90, 0)
1.5707963267948966
>>> sc.radian(0, 0, 60**2 * 90)
1.5707963267948966

输入可以是实值。

>>> sc.radian(1.5, 0, 0)
0.02617993877991494
>>> sc.radian(1, 30, 0)
0.02617993877991494

`scipy.special.cosdg`

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

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

角度x的余弦，单位为度。

参数：

xarray_like

给定的角度，单位为度。

outndarray，可选

函数结果的可选输出数组。

标量或 ndarray

输入的余弦。

另请参见

sindg, tandg, cotdg

Examples

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

比直接使用余弦更准确。

>>> x = 90 + 180 * np.arange(3)
>>> sc.cosdg(x)
array([-0.,  0., -0.])
>>> np.cos(x * np.pi / 180)
array([ 6.1232340e-17, -1.8369702e-16,  3.0616170e-16])

`scipy.special.sindg`

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

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

输入角度x的正弦值。

参数：

xarray_like

角度，以度为单位。

outndarray，可选

函数结果的可选输出数组。

标量或 ndarray

输入角度的正弦值。

参见

cosdg，tandg，cotdg

示例

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

比直接使用正弦更精确。

>>> x = 180 * np.arange(3)
>>> sc.sindg(x)
array([ 0., -0.,  0.])
>>> np.sin(x * np.pi / 180)
array([ 0.0000000e+00,  1.2246468e-16, -2.4492936e-16])

`scipy.special.tandg`

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

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

给定以度为单位的角度x的正切。

参数：

xarray_like

角度，以度为单位。

outndarray，可选

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

标量或 ndarray

输入处的正切值。

参见

sindg，cosdg，cotdg

示例

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

比直接使用正切更精确。

>>> x = 180 * np.arange(3)
>>> sc.tandg(x)
array([0., 0., 0.])
>>> np.tan(x * np.pi / 180)
array([ 0.0000000e+00, -1.2246468e-16, -2.4492936e-16])

`scipy.special.cotdg`

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

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

给定以度数表示的角度 x 的余切。

参数：

xarray_like

角度，以度数给出。

outndarray, 可选

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

返回值：

标量或者 ndarray

输入的余切值。

参见

sindg, cosdg, tandg

示例

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

比直接使用余切函数更加精确。

>>> x = 90 + 180 * np.arange(3)
>>> sc.cotdg(x)
array([0., 0., 0.])
>>> 1 / np.tan(x * np.pi / 180)
array([6.1232340e-17, 1.8369702e-16, 3.0616170e-16])

`scipy.special.log1p`

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

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

当x接近零时，计算 log(1 + x)。

参数：

x，array_like

实数或复数输入。

out，可选的 ndarray

函数结果的可选输出数组。

标量或 ndarray

log(1 + x) 的值。

参见

expm1, cosm1

示例

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

对于x接近 0，这比直接使用log(1 + x)更精确。请注意，在下面的例子中，1 + 1e-17 == 1可达双精度。

>>> sc.log1p(1e-17)
1e-17
>>> np.log(1 + 1e-17)
0.0

`scipy.special.expm1`

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

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

计算 exp(x) - 1。

当 x 接近零时，exp(x) 接近 1，因此在计算 exp(x) - 1 时可能会遭受灾难性的精度损失。expm1(x) 的实现旨在避免 x 接近零时发生的精度损失。

参数：

x 数组样式

x 必须包含实数。

out ndarray，可选

函数值的可选输出数组

标量或者 ndarray

逐元素计算 exp(x) - 1。

示例

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

>>> expm1(1.0)
1.7182818284590451
>>> expm1([-0.2, -0.1, 0, 0.1, 0.2])
array([-0.18126925, -0.09516258,  0\.        ,  0.10517092,  0.22140276])

exp(7.5e-13) - 1 的确切值是：

7.5000000000028125000000007031250000001318...*10**-13.

这里是 expm1(7.5e-13) 的结果：

>>> expm1(7.5e-13)
7.5000000000028135e-13

将其与 exp(7.5e-13) - 1 比较，其中减法导致“灾难性”的精度损失：

>>> np.exp(7.5e-13) - 1
7.5006667543675576e-13

`scipy.special.cosm1`

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

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

当x接近零时，用于计算cos(x) - 1。

参数：

x：array_like

实数值的参数。

out：ndarray，可选

函数结果的可选输出数组。

标量或者 ndarray

值为cos(x) - 1。

参见

expm1，log1p

示例

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

对于x接近 0，比直接计算cos(x) - 1更精确。

>>> x = 1e-30
>>> np.cos(x) - 1
0.0
>>> sc.cosm1(x)
-5.0000000000000005e-61

`scipy.special.powm1`

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

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

计算x**y - 1。

当y接近 0 或x接近 1 时，此函数非常有用。

该函数仅适用于实数类型（与numpy.power不同，后者接受复数输入）。

参数：

xarray_like

底数。必须是实数类型（即整数或浮点数，而不是复数）。

yarray_like

指数。必须是实数类型（即整数或浮点数，而不是复数）。

array_like

计算结果

注意事项

新版本 1.10.0 中推出。

该基础代码仅适用于单精度和双精度浮点数。与numpy.power不同，输入为整数的powm1会被转换为浮点数，而复数输入则不被接受。

请注意以下边界情况：

powm1(x, 0)对于任何x都会返回 0，包括 0、inf和nan。
powm1(1, y)对于任何y都将返回 0，包括nan和inf。

示例

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

>>> x = np.array([1.2, 10.0, 0.9999999975])
>>> y = np.array([1e-9, 1e-11, 0.1875])
>>> powm1(x, y)
array([ 1.82321557e-10,  2.30258509e-11, -4.68749998e-10])

可以验证这些结果中的相对误差都小于 2.5e-16。

将其与x**y - 1的结果进行比较，其中相对误差都大于 8e-8：

>>> x**y - 1
array([ 1.82321491e-10,  2.30258035e-11, -4.68750039e-10])

`scipy.special.round`

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

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

四舍五入到最接近的整数。

返回最接近x的整数。如果x恰好以 0.5 结尾，则选择最接近的偶数整数。

参数：

x：array_like

实值输入。

out：ndarray，可选

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

标量或 ndarray

x元素的最接近整数。结果为浮点类型，而非整数类型。

示例

>>> import scipy.special as sc

它四舍五入为偶数。

>>> sc.round([0.5, 1.5])
array([0., 2.])

`scipy.special.xlogy`

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

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

计算 x*log(y)，如果 x = 0 则结果为 0。

参数：

xarray_like

乘法器

yarray_like

参数

out数组，可选

函数结果的可选输出数组

z标量或数组

计算 x*log(y)

注意

计算中使用的对数函数是自然对数。

从版本 0.13.0 开始新增。

示例

我们可以使用此函数来计算二元逻辑损失，也称为二元交叉熵。这种损失函数用于二元分类问题，定义如下：

[L = 1/n * \sum_{i=0}^n -(y_i*log(y_pred_i) + (1-y_i)*log(1-y_pred_i))]

我们可以将参数 x 和 y 定义为 y 和 y_pred，y 是实际标签的数组，这里可以是 0 或 1。y_pred 是相对于正类（1）的预测概率数组。

>>> import numpy as np
>>> from scipy.special import xlogy
>>> y = np.array([0, 1, 0, 1, 1, 0])
>>> y_pred = np.array([0.3, 0.8, 0.4, 0.7, 0.9, 0.2])
>>> n = len(y)
>>> loss = -(xlogy(y, y_pred) + xlogy(1 - y, 1 - y_pred)).sum()
>>> loss /= n
>>> loss
0.29597052165495025

较低的损失通常更好，因为它表明预测与实际标签相似。在这个例子中，由于我们的预测概率接近实际标签，我们得到的总体损失是合理低且适当的。

`scipy.special.xlog1py`

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

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

计算 x*log1p(y)，使得当 x = 0 时结果为 0。

参数：

x：类似数组

乘法器

y：类似数组

参数

out：数组，可选

函数结果的可选输出数组

z：标量或者数组

计算得到的 x*log1p(y)

注意

新版本 0.13.0 中新增。

示例

本例展示了如何使用该函数计算几何离散随机变量的概率质量函数的对数。几何分布的概率质量函数定义如下：

[f(k) = (1-p)^{k-1} p]

其中( p )是单次成功的概率，( 1-p )是单次失败的概率，( k )是获得第一个成功的尝试次数。

>>> import numpy as np
>>> from scipy.special import xlog1py
>>> p = 0.5
>>> k = 100
>>> _pmf = np.power(1 - p, k - 1) * p
>>> _pmf
7.888609052210118e-31

如果我们取 k 为相对较大的数，概率质量函数的值可能会变得非常低。在这种情况下，取概率质量函数的对数可能更合适，因为对数函数可以将值变换到更适合处理的比例。

>>> _log_pmf = xlog1py(k - 1, -p) + np.log(p)
>>> _log_pmf
-69.31471805599453

我们可以通过将 log pmf 的指数取出来来确认我们获得了接近原始 pmf 值的值。

>>> _orig_pmf = np.exp(_log_pmf)
>>> np.isclose(_pmf, _orig_pmf)
True

`scipy.special.logsumexp`

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

scipy.special.logsumexp(a, axis=None, b=None, keepdims=False, return_sign=False)

计算输入元素的指数之和的对数。

参数：

aarray_like

输入数组。

axisNone 或 int 或 int 元组，可选

要对其求和的轴或轴。默认情况下 axis 为 None，将对所有元素求和。

自版本 0.11.0 起新增。

barray-like，可选

exp(a) 的缩放因子必须与 a 具有相同的形状或可广播到 a。这些值可以为负，以实现减法。

自版本 0.12.0 起新增。

keepdimsbool，可选

如果设置为 True，则减少的轴将保留在结果中，作为具有大小为一的维度。使用此选项，结果将正确广播到原始数组。

自版本 0.15.0 起新增。

return_signbool，可选

如果设置为 True，则结果将是包含符号信息的一对；如果为 False，则负数结果将返回为 NaN。默认为 False（无符号信息）。

自版本 0.16.0 起新增。

resndarray

结果 np.log(np.sum(np.exp(a))) 以更稳定的方式计算。如果给定 b，则返回 np.log(np.sum(b*np.exp(a)))。

sgnndarray

如果 return_sign 设置为 True，则将返回与结果匹配的浮点数数组和 +1、0 或 -1，具体取决于结果的符号。如果设置为 False，则只返回一个结果。

另请参阅

numpy.logaddexp，numpy.logaddexp2

注意

NumPy 有一个 logaddexp 函数，非常类似于 logsumexp，但只处理两个参数。logaddexp.reduce 与此函数类似，但可能不太稳定。

示例

>>> import numpy as np
>>> from scipy.special import logsumexp
>>> a = np.arange(10)
>>> logsumexp(a)
9.4586297444267107
>>> np.log(np.sum(np.exp(a)))
9.4586297444267107

带有权重

>>> a = np.arange(10)
>>> b = np.arange(10, 0, -1)
>>> logsumexp(a, b=b)
9.9170178533034665
>>> np.log(np.sum(b*np.exp(a)))
9.9170178533034647

返回一个标志符号

>>> logsumexp([1,2],b=[1,-1],return_sign=True)
(1.5413248546129181, -1.0)

请注意，logsumexp 不直接支持掩码数组。要在掩码数组上使用它，请将掩码转换为零权重：

>>> a = np.ma.array([np.log(2), 2, np.log(3)],
...                  mask=[False, True, False])
>>> b = (~a.mask).astype(int)
>>> logsumexp(a.data, b=b), np.log(5)
1.6094379124341005, 1.6094379124341005

`scipy.special.exprel`

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

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

相对误差的指数形式，(exp(x) - 1)/x。

当x接近零时，exp(x)接近 1，因此在计算exp(x) - 1时可能会出现严重的精度损失。 exprel(x) 被实现以避免x接近零时出现的精度损失。

参数:

xndarray

输入数组。 x必须包含实数。

outndarray，可选

该功能值的可选输出数组

返回值:

标量或 ndarray

(exp(x) - 1)/x，按元素计算。

另请参阅

expm1

注意事项

在 0.17.0 版中新增。

例子

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

>>> exprel(0.01)
1.0050167084168056
>>> exprel([-0.25, -0.1, 0, 0.1, 0.25])
array([ 0.88479687,  0.95162582,  1\.        ,  1.05170918,  1.13610167])

比较exprel(5e-9)与朴素计算的结果。准确值为1.00000000250000000416...。

>>> exprel(5e-9)
1.0000000025

>>> (np.exp(5e-9) - 1)/5e-9
0.99999999392252903

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

SciPy 1.12 中文文档（五十）

scipy.special.exp1

scipy.special.expi

scipy.special.factorial

scipy.special.factorial2

scipy.special.factorialk

scipy.special.shichi

scipy.special.sici

scipy.special.softmax

scipy.special.log_softmax

scipy.special.spence

scipy.special.zeta

scipy.special.zetac

scipy.special.cbrt

scipy.special.exp10

scipy.special.exp2

scipy.special.radian

scipy.special.cosdg

scipy.special.sindg

scipy.special.tandg

scipy.special.cotdg

scipy.special.log1p

scipy.special.expm1

scipy.special.cosm1

scipy.special.powm1

scipy.special.round

scipy.special.xlogy

scipy.special.xlog1py

scipy.special.logsumexp

scipy.special.exprel

`scipy.special.exp1`

`scipy.special.expi`

`scipy.special.factorial`

`scipy.special.factorial2`

`scipy.special.factorialk`

`scipy.special.shichi`

`scipy.special.sici`

`scipy.special.softmax`

`scipy.special.log_softmax`

`scipy.special.spence`

`scipy.special.zeta`

`scipy.special.zetac`

`scipy.special.cbrt`

`scipy.special.exp10`

`scipy.special.exp2`

`scipy.special.radian`

`scipy.special.cosdg`

`scipy.special.sindg`

`scipy.special.tandg`

`scipy.special.cotdg`

`scipy.special.log1p`

`scipy.special.expm1`

`scipy.special.cosm1`

`scipy.special.powm1`

`scipy.special.round`

`scipy.special.xlogy`

`scipy.special.xlog1py`

`scipy.special.logsumexp`

`scipy.special.exprel`