SciPy 1.12 中文文档（三十九）

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

scipy.special.elliprd

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

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

第二类对称椭圆积分。

函数 RD 的定义如下 [1]

[R_{\mathrm{D}}(x, y, z) = \frac{3}{2} \int_0^{+\infty} [(t + x) (t + y)]^{-1/2} (t + z)^{-3/2} dt]

参数：

x, y, zarray_like

实数或复数输入参数。x 或 y 可以是复平面上的任意数，但最多只能有一个为零，而 z 必须非零。

outndarray，可选

函数值的可选输出数组

返回：

R标量或 ndarray

积分的值。如果 x、y 和 z 都是实数，则返回值为实数。否则，返回值为复数。

参见

elliprc

退化对称椭圆积分。

elliprf

第一类完全对称椭圆积分。

elliprg

第二类完全对称椭圆积分。

elliprj

第三类对称椭圆积分。

注解

RD 是椭圆积分 RJ 的退化情况：elliprd(x, y, z) == elliprj(x, y, z, z)。

此代码实现了基于复制定理和直到第 7 阶级的级数展开的 Carlson 算法。[2]

新版本 1.8.0 中引入。

参考文献

[1]

B. C. Carlson，ed.，“Digital Library of Mathematical Functions”，NIST，US Dept. of Commerce，第十九章。dlmf.nist.gov/19.16.E5

[2]

B. C. Carlson，“Numerical computation of real or complex elliptic integrals”，Numer. Algorithm，vol. 10，no. 1，pp. 13-26，1995。arxiv.org/abs/math/9409227 doi.org/10.1007/BF02198293

示例

基本均匀性质：

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

>>> x = 1.2 + 3.4j
>>> y = 5.
>>> z = 6.
>>> scale = 0.3 + 0.4j
>>> elliprd(scale*x, scale*y, scale*z)
(-0.03703043835680379-0.24500934665683802j) 

>>> elliprd(x, y, z)*np.power(scale, -1.5)
(-0.0370304383568038-0.24500934665683805j) 

所有三个参数重合：

>>> x = 1.2 + 3.4j
>>> elliprd(x, x, x)
(-0.03986825876151896-0.14051741840449586j) 

>>> np.power(x, -1.5)
(-0.03986825876151894-0.14051741840449583j) 

所谓的“第二总蕾米那斯常数”：

>>> elliprd(0, 2, 1)/3
0.5990701173677961 

>>> from scipy.special import gamma
>>> gamma(0.75)**2/np.sqrt(2*np.pi)
0.5990701173677959 

scipy.special.elliprf

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

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

完全对称椭圆积分的第一类。

函数 RF 定义如下：[1]

[R_{\mathrm{F}}(x, y, z) = \frac{1}{2} \int_0^{+\infty} [(t + x) (t + y) (t + z)]^{-1/2} dt]

参数：

x, y, zarray_like

实数或复数输入参数。x、y或z可以是复平面上的任意数，但最多只能有一个为零。

outndarray, optional

函数值的可选输出数组

返回：

R标量或 ndarray

积分的值。如果x、y和z都是实数，则返回值为实数。否则，返回值为复数。

另请参阅

elliprc

退化对称积分。

elliprd

对称椭圆积分的第二类。

elliprg

完全对称椭圆积分的第二类。

elliprj

对称椭圆积分的第三类。

注释

该代码实现了基于重复定理和至第 7 阶的级数展开的 Carlson 算法（参见：dlmf.nist.gov/19.36.i）以及完全积分的 AGM 算法。[2]

自 1.8.0 版起新增。

参考文献

[1]

B. C. Carlson 编，NIST“数学函数数字图书馆”第十九章，美国商务部。dlmf.nist.gov/19.16.E1

[2]

B. C. Carlson，《数值计算的实数或复数椭圆积分》，Numer. Algorithm, vol. 10, no. 1, pp. 13-26, 1995。arxiv.org/abs/math/9409227 doi.org/10.1007/BF02198293

示例

基本齐次性质：

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

>>> x = 1.2 + 3.4j
>>> y = 5.
>>> z = 6.
>>> scale = 0.3 + 0.4j
>>> elliprf(scale*x, scale*y, scale*z)
(0.5328051227278146-0.4008623567957094j) 

>>> elliprf(x, y, z)/np.sqrt(scale)
(0.5328051227278147-0.4008623567957095j) 

三个参数都相等：

>>> x = 1.2 + 3.4j
>>> elliprf(x, x, x)
(0.42991731206146316-0.30417298187455954j) 

>>> 1/np.sqrt(x)
(0.4299173120614631-0.30417298187455954j) 

所谓的“第一极线常数”：

>>> elliprf(0, 1, 2)
1.3110287771460598 

>>> from scipy.special import gamma
>>> gamma(0.25)**2/(4*np.sqrt(2*np.pi))
1.3110287771460598 

scipy.special.elliprg

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

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

第二类完全对称椭圆积分。

函数 RG 定义为[1]

[R_{\mathrm{G}}(x, y, z) = \frac{1}{4} \int_0^{+\infty} [(t + x) (t + y) (t + z)]^{-1/2} \left(\frac{x}{t + x} + \frac{y}{t + y} + \frac{z}{t + z}\right) t dt]

参数：

x, y, zarray_like

输入参数为实数或复数。x、y 或 z 可以是复平面上任何沿负实轴切割的数。

outndarray, 可选

函数值的可选输出数组

返回：

R 标量或 ndarray

积分的值。如果 x、y 和 z 都是实数，则返回值是实数。否则，返回值是复数。

参见

elliprc

退化对称积分。

elliprd

第二类对称椭圆积分。

elliprf

第一类完全对称椭圆积分。

elliprj

第三类对称椭圆积分。

注释

实现使用关系[1]

[2 R_{\mathrm{G}}(x, y, z) = z R_{\mathrm{F}}(x, y, z) - \frac{1}{3} (x - z) (y - z) R_{\mathrm{D}}(x, y, z) + \sqrt{\frac{x y}{z}}]

当至少一个非零参数可以选择为枢轴时，x、y 或 z 的对称性。当其中一个参数接近零时，应用 AGM 方法。其他特殊情况根据参考[2]计算。

新增于版本 1.8.0。

参考文献

[1] (1,2)

B. C. Carlson，“实数或复数椭圆积分的数值计算”，Numer. Algorithm, vol. 10, no. 1, pp. 13-26, 1995. arxiv.org/abs/math/9409227 doi.org/10.1007/BF02198293

[2]

B. C. Carlson, 编辑，见于“数学函数数字库”，NIST，美国商务部。dlmf.nist.gov/19.16.E1 dlmf.nist.gov/19.20.ii

示例

基本的齐次性质：

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

>>> x = 1.2 + 3.4j
>>> y = 5.
>>> z = 6.
>>> scale = 0.3 + 0.4j
>>> elliprg(scale*x, scale*y, scale*z)
(1.195936862005246+0.8470988320464167j) 

>>> elliprg(x, y, z)*np.sqrt(scale)
(1.195936862005246+0.8470988320464165j) 

简化：

>>> elliprg(0, y, y)
1.756203682760182 

>>> 0.25*np.pi*np.sqrt(y)
1.7562036827601817 

>>> elliprg(0, 0, z)
1.224744871391589 

>>> 0.5*np.sqrt(z)
1.224744871391589 

具有半轴 a、b 和 c 的三轴椭球的表面积由以下公式给出：

[S = 4 \pi a b c R_{\mathrm{G}}(1 / a², 1 / b², 1 / c²).]

>>> def ellipsoid_area(a, b, c):
...     r = 4.0 * np.pi * a * b * c
...     return r * elliprg(1.0 / (a * a), 1.0 / (b * b), 1.0 / (c * c))
>>> print(ellipsoid_area(1, 3, 5))
108.62688289491807 

scipy.special.elliprj

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

scipy.special.elliprj(x, y, z, p, out=None) = <ufunc 'elliprj'>

对称的第三类椭圆积分。

函数 RJ 定义如下 [1]

[R_{\mathrm{J}}(x, y, z, p) = \frac{3}{2} \int_0^{+\infty} [(t + x) (t + y) (t + z)]^{-1/2} (t + p)^{-1} dt]

警告

当输入不平衡时，应将此函数视为实验性质。使用另一个独立的实现检查正确性。

参数：

x, y, z, parray_like

实数或复数输入参数。x、y 或 z 是沿负实轴切割的复平面上的数（需进一步约束，参见注释），且最多只能有一个为零。p 必须非零。

outndarray，可选

函数值的可选输出数组

返回：

R标量或 ndarray

积分的值。如果 x、y、z 和 p 都是实数，则返回值为实数。否则，返回值为复数。

如果 p 是实数且为负数，而 x、y 和 z 是实数、非负数，并且最多只有一个为零，则返回柯西主值。[1] [2]

另请参阅

elliprc

退化的对称积分。

elliprd

完全对称的第二类椭圆积分。

elliprf

完全对称的第一类椭圆积分。

elliprg

完全对称的第二类椭圆积分。

注释

代码实现了基于重复定理和直至第七阶的级数展开的 Carlson 算法。[3] 该算法与其早期版本略有不同，因为不再需要在内部循环中调用 elliprc（或 atan/atanh，参见 [4]）。在参数数量差异较大时使用渐近逼近。

当输入参数为复数时，输入值需符合某些充分条件但非必要条件。特别地，x、y 和 z 必须具有非负实部，除非其中两者是非负复共轭数，而另一个是非负实数。[1] 如果输入不满足参考文献 [1] 中描述的充分条件，则将被拒绝，并将输出设置为 NaN。

当x，y或z中的一个等于p时，应优先选择函数elliprd，因为其定义域更少受限制。

新功能，版本 1.8.0。

参考文献

[1] (1,2,3,4,5)

B. C. Carlson，“实数或复数椭圆积分的数值计算”，Numer. Algorithm, vol. 10, no. 1, pp. 13-26, 1995. arxiv.org/abs/math/9409227 doi.org/10.1007/BF02198293

[2]

B. C. Carlson，编，《数学函数数字图书馆》，NIST, 美国商务部，第十九章。dlmf.nist.gov/19.20.iii

[3]

B. C. Carlson, J. FitzSimmons，“具有两个二次因子平方根的椭圆积分标准化定理”，J. Comput. Appl. Math., vol. 118, nos. 1-2, pp. 71-85, 2000. doi.org/10.1016/S0377-0427(00)00282-X

[4]

F. Johansson，“椭圆函数、椭圆积分和模形式的数值评估”，收录于 J. Blumlein, C. Schneider, P. Paule, 编，《量子场论中的椭圆积分、椭圆函数和模形式》，pp. 269-293, 2019（瑞士，Cham: Springer Nature Switzerland）arxiv.org/abs/1806.06725 doi.org/10.1007/978-3-030-04480-0

[5]

B. C. Carlson, J. L. Gustafson，“对称椭圆积分的渐近逼近”，SIAM J. Math. Anls., vol. 25, no. 2, pp. 288-303, 1994. arxiv.org/abs/math/9310223 doi.org/10.1137/S0036141092228477

示例

基本齐次性质：

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

>>> x = 1.2 + 3.4j
>>> y = 5.
>>> z = 6.
>>> p = 7.
>>> scale = 0.3 - 0.4j
>>> elliprj(scale*x, scale*y, scale*z, scale*p)
(0.10834905565679157+0.19694950747103812j) 

>>> elliprj(x, y, z, p)*np.power(scale, -1.5)
(0.10834905565679556+0.19694950747103854j) 

简化为更简单的椭圆积分：

>>> elliprj(x, y, z, z)
(0.08288462362195129-0.028376809745123258j) 

>>> from scipy.special import elliprd
>>> elliprd(x, y, z)
(0.08288462362195136-0.028376809745123296j) 

所有参数相等：

>>> elliprj(x, x, x, x)
(-0.03986825876151896-0.14051741840449586j) 

>>> np.power(x, -1.5)
(-0.03986825876151894-0.14051741840449583j) 

scipy.special.jv

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

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

实数阶和复数参数的第一类贝塞尔函数。

参数：

varray_like

阶数（浮点数）。

zarray_like

参数（浮点数或复数）。

outndarray, 可选

函数值的可选输出数组

返回：

J标量或 ndarray

贝塞尔函数的值，(J_v(z))。

另请参阅

jve

去除了前导指数行为的(J_v)。

spherical_jn

球形贝塞尔函数。

j0

这个函数在阶数为 0 时的更快版本。

j1

这个函数在阶数为 1 时的更快版本。

注意事项

对于正v值，使用 AMOS [1] zbesj例程进行计算，该例程利用了与修改贝塞尔函数(I_v)的联系，

[ \begin{align}\begin{aligned}J_v(z) = \exp(v\pi\imath/2) I_v(-\imath z)\qquad (\Im z > 0)\J_v(z) = \exp(-v\pi\imath/2) I_v(\imath z)\qquad (\Im z < 0)\end{aligned}\end{align} ]

对于负v值，公式为，

[J_{-v}(z) = J_v(z) \cos(\pi v) - Y_v(z) \sin(\pi v)]

使用的是 AMOS 例程zbesy计算的第二类贝塞尔函数(Y_v(z))。注意，对于整数v，第二项恰好为零；为了提高精度，对于v值使*v = floor(v)*的情况，第二项被明确省略。

与球形贝塞尔函数不要混淆（参见spherical_jn）。

参考文献

[1]

Donald E. Amos，“AMOS，用于复数参数和非负阶贝塞尔函数的便携包”，netlib.org/amos/

示例

在一个点评估阶数为 0 的函数。

>>> from scipy.special import jv
>>> jv(0, 1.)
0.7651976865579666 

对不同阶数在一个点评估函数。

>>> jv(0, 1.), jv(1, 1.), jv(1.5, 1.)
(0.7651976865579666, 0.44005058574493355, 0.24029783912342725) 

可以通过为v参数提供列表或 NumPy 数组的方式，在一次调用中进行不同阶数的评估：

>>> jv([0, 1, 1.5], 1.)
array([0.76519769, 0.44005059, 0.24029784]) 

通过为z提供数组，在几个点评估阶数为 0 的函数。

>>> import numpy as np
>>> points = np.array([-2., 0., 3.])
>>> jv(0, points)
array([ 0.22389078,  1\.        , -0.26005195]) 

如果z是一个数组，则如果要在一次调用中计算不同阶数，则阶数参数v必须广播到正确的形状。要计算 1D 数组的阶数 0 和 1：

>>> orders = np.array([[0], [1]])
>>> orders.shape
(2, 1) 

>>> jv(orders, points)
array([[ 0.22389078,  1\.        , -0.26005195],
 [-0.57672481,  0\.        ,  0.33905896]]) 

绘制从-10 到 10 的 0 到 3 阶函数。

>>> import matplotlib.pyplot as plt
>>> fig, ax = plt.subplots()
>>> x = np.linspace(-10., 10., 1000)
>>> for i in range(4):
...     ax.plot(x, jv(i, x), label=f'$J_{i!r}$')
>>> ax.legend()
>>> plt.show() 

scipy.special.jve

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

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

指数缩放的第一类贝塞尔函数，其次序为v。

定义如下：

jve(v, z) = jv(v, z) * exp(-abs(z.imag)) 

参数：

v array_like

次序（浮点数）。

z array_like

参数（浮点数或复数）。

out ndarray，可选项

函数值的可选输出数组

返回：

J 标量或 ndarray

指数缩放的贝塞尔函数的值。

另请参见

jv

第一类未缩放贝塞尔函数

注意事项

对于正v值，通过利用与修改贝塞尔函数(I_v)的联系的 AMOS [1] zbesj例程进行计算，

[ \begin{align}\begin{aligned}J_v(z) = \exp(v\pi\imath/2) I_v(-\imath z)\qquad (\Im z > 0)\J_v(z) = \exp(-v\pi\imath/2) I_v(\imath z)\qquad (\Im z < 0)\end{aligned}\end{align} ]

对于负v值的公式，

[J_{-v}(z) = J_v(z) \cos(\pi v) - Y_v(z) \sin(\pi v)]

使用，其中(Y_v(z))是第二类贝塞尔函数，使用 AMOS 例程zbesy计算。请注意，对于整数v，第二项恰好为零；为提高精度，对于使v = floor(v)成立的v值，明确省略第二项。

对于大参数z，指数缩放的贝塞尔函数非常有用：对于这些函数，未缩放的贝塞尔函数可能轻松地上溢或下溢。

参考文献

[1]

Donald E. Amos，“AMOS，一种用于复参数和非负次序贝塞尔函数的便携式软件包”，netlib.org/amos/

示例

通过在次序v=1和在z=1000j处计算jv和jve 的值，比较它们在大复参数z处的输出。我们看到jv 溢出，但jve 返回一个有限数：

>>> import numpy as np
>>> from scipy.special import jv, jve
>>> v = 1
>>> z = 1000j
>>> jv(v, z), jve(v, z)
((inf+infj), (7.721967686709077e-19+0.012610930256928629j)) 

对于z的实数参数，jve 返回与jv 相同的值。

>>> v, z = 1, 1000
>>> jv(v, z), jve(v, z)
(0.004728311907089523, 0.004728311907089523) 

通过为v提供列表或 NumPy 数组，可以同时评估多个次序的函数：

>>> jve([1, 3, 5], 1j)
array([1.27304208e-17+2.07910415e-01j, -4.99352086e-19-8.15530777e-03j,
 6.11480940e-21+9.98657141e-05j]) 

同样地，通过为z提供列表或 NumPy 数组，可以一次在多个点评估函数：

>>> jve(1, np.array([1j, 2j, 3j]))
array([1.27308412e-17+0.20791042j, 1.31814423e-17+0.21526929j,
 1.20521602e-17+0.19682671j]) 

也可以通过为v和z提供兼容形状的数组进行广播，同时在几个点评估几个次序。在两个不同次序的v和三个点z上计算jve，得到一个 2x3 的数组。

>>> v = np.array([[1], [3]])
>>> z = np.array([1j, 2j, 3j])
>>> v.shape, z.shape
((2, 1), (3,)) 

>>> jve(v, z)
array([[1.27304208e-17+0.20791042j,  1.31810070e-17+0.21526929j,
 1.20517622e-17+0.19682671j],
 [-4.99352086e-19-0.00815531j, -1.76289571e-18-0.02879122j,
 -2.92578784e-18-0.04778332j]]) 

scipy.special.yn

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

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

整数顺序和实参数的第二类贝塞尔函数。

参数：

narray_like

顺序（整数）。

xarray_like

参数（浮点数）。

outndarray，可选

函数结果的可选输出数组

返回结果：

Y标量或 ndarray

贝塞尔函数的值，(Y_n(x))。

另请参阅

yv

适用于实际顺序和实数或复数参数。

y0

更高效的实现此函数以进行顺序 0

y1

更高效的实现此函数以进行顺序 1

注意事项

Cephes 的包装器[1]例程yn。

该函数通过前向递归在n上进行评估，从由 Cephes 程序 y0 和 y1 计算的值开始。如果n = 0或 1，则直接调用y0或y1的例程。

参考文献

[1]

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

示例

在一个点评估顺序 0 的函数。

>>> from scipy.special import yn
>>> yn(0, 1.)
0.08825696421567697 

在不同顺序的一个点上评估函数。

>>> yn(0, 1.), yn(1, 1.), yn(2, 1.)
(0.08825696421567697, -0.7812128213002888, -1.6506826068162546) 

可以通过为v参数提供一个列表或 NumPy 数组在一个调用中进行不同顺序的评估：

>>> yn([0, 1, 2], 1.)
array([ 0.08825696, -0.78121282, -1.65068261]) 

通过为z提供一个数组，在顺序 0 上的几个点评估函数。

>>> import numpy as np
>>> points = np.array([0.5, 3., 8.])
>>> yn(0, points)
array([-0.44451873,  0.37685001,  0.22352149]) 

如果z是一个数组，则顺序参数v必须可广播到正确的形状，如果希望在一个调用中计算不同的顺序 0 和 1 的话。要计算一个 1D 数组的顺序 0 和 1：

>>> orders = np.array([[0], [1]])
>>> orders.shape
(2, 1) 

>>> yn(orders, points)
array([[-0.44451873,  0.37685001,  0.22352149],
 [-1.47147239,  0.32467442, -0.15806046]]) 

绘制从 0 到 10 的顺序 0 到 3 的函数。

>>> import matplotlib.pyplot as plt
>>> fig, ax = plt.subplots()
>>> x = np.linspace(0., 10., 1000)
>>> for i in range(4):
...     ax.plot(x, yn(i, x), label=f'$Y_{i!r}$')
>>> ax.set_ylim(-3, 1)
>>> ax.legend()
>>> plt.show() 

scipy.special.yv

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

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

实数阶和复数参数的第二类贝塞尔函数。

参数：

varray_like

Order (float).

zarray_like

参数（浮点数或复数）。

outndarray，可选

函数结果的可选输出数组

返回：

Y标量或 ndarray

第二类贝塞尔函数的值，(Y_v(x))。

另请参阅

yve

带有主导指数行为剥离的[Y_v]。

y0

此函数阶数 0 的更快实现

y1

此函数阶数 1 的更快实现

注意事项

对于正v值，使用 AMOS [1] zbesy例程进行计算，该例程利用与汉克尔贝塞尔函数(H_v^{(1)})和(H_v^{(2)})的连接，

[Y_v(z) = \frac{1}{2\imath} (H_v^{(1)} - H_v^{(2)}).]

对于负v值的公式，

[Y_{-v}(z) = Y_v(z) \cos(\pi v) + J_v(z) \sin(\pi v)]

使用，其中(J_v(z))是第一类贝塞尔函数，使用 AMOS 例程zbesj计算。注意对于整数v，第二项确实为零；为了提高精度，对于v的整数值，显式省略第二项。

参考资料

[1]

Donald E. Amos，“AMOS，用于复变量贝塞尔函数和非负阶的可移植包”，netlib.org/amos/

示例

在一个点评估阶数 0 的函数。

>>> from scipy.special import yv
>>> yv(0, 1.)
0.088256964215677 

在不同阶数评估函数在一个点的值。

>>> yv(0, 1.), yv(1, 1.), yv(1.5, 1.)
(0.088256964215677, -0.7812128213002889, -1.102495575160179) 

通过为v参数提供列表或 NumPy 数组，可以在一次调用中执行不同阶数的评估：

>>> yv([0, 1, 1.5], 1.)
array([ 0.08825696, -0.78121282, -1.10249558]) 

通过为z提供数组，在阶数 0 时在多个点评估函数。

>>> import numpy as np
>>> points = np.array([0.5, 3., 8.])
>>> yv(0, points)
array([-0.44451873,  0.37685001,  0.22352149]) 

如果z是一个数组，则在一个调用中计算不同阶数时，参数v必须能够广播到正确的形状。为了计算一维数组的阶数 0 和 1：

>>> orders = np.array([[0], [1]])
>>> orders.shape
(2, 1) 

>>> yv(orders, points)
array([[-0.44451873,  0.37685001,  0.22352149],
 [-1.47147239,  0.32467442, -0.15806046]]) 

绘制阶数 0 到 3 的函数，范围从 0 到 10。

>>> import matplotlib.pyplot as plt
>>> fig, ax = plt.subplots()
>>> x = np.linspace(0., 10., 1000)
>>> for i in range(4):
...     ax.plot(x, yv(i, x), label=f'$Y_{i!r}$')
>>> ax.set_ylim(-3, 1)
>>> ax.legend()
>>> plt.show() 

scipy.special.yve

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

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

实部阶数的未缩放贝塞尔函数第二类。

返回实部阶数为v的复参数z的指数缩放贝塞尔函数第二类：

yve(v, z) = yv(v, z) * exp(-abs(z.imag)) 

参数：

varray_like

阶数（浮点数）。

zarray_like

参数（浮点数或复数）。

outndarray，可选

函数结果的可选输出数组

返回：

Y标量或 ndarray

指数缩放贝塞尔函数的值。

另见

yv

实部阶数的未缩放贝塞尔函数第二类。

笔记

对于正v值，使用 AMOS [1] zbesy例程进行计算，该例程利用与汉克尔贝塞尔函数(H_v^{(1)})和(H_v^{(2)})的连接，

[Y_v(z) = \frac{1}{2\imath} (H_v^{(1)} - H_v^{(2)}).]

对于负v值，使用公式，

[Y_{-v}(z) = Y_v(z) \cos(\pi v) + J_v(z) \sin(\pi v)]

使用，其中(J_v(z))是第一类贝塞尔函数，使用 AMOS 例程zbesj计算。注意，对于整数v，第二项确实为零；为了提高精度，对于使v = floor(v)的v值，明确省略第二项。

指数缩放贝塞尔函数对大z很有用：对于这些函数，未缩放的贝塞尔函数可能很容易溢出或下溢。

参考文献

[1]

Donald E. Amos，“AMOS，一种用于复参数和非负阶贝塞尔函数的便携包”，netlib.org/amos/

示例

通过计算在大复数参数z处阶数v=1和z=1000j的值来比较yv和yve的输出。我们看到yv返回 nan，但yve返回有限数值：

>>> import numpy as np
>>> from scipy.special import yv, yve
>>> v = 1
>>> z = 1000j
>>> yv(v, z), yve(v, z)
((nan+nanj), (-0.012610930256928629+7.721967686709076e-19j)) 

对于z的实数参数，yve返回与yv相同，直到浮点误差。

>>> v, z = 1, 1000
>>> yv(v, z), yve(v, z)
(-0.02478433129235178, -0.02478433129235179) 

可以通过提供v的列表或 NumPy 数组同时评估多个阶数的函数：

>>> yve([1, 2, 3], 1j)
array([-0.20791042+0.14096627j,  0.38053618-0.04993878j,
 0.00815531-1.66311097j]) 

同样，通过提供列表或 NumPy 数组给z，可以一次性评估函数在多个点上的值：

>>> yve(1, np.array([1j, 2j, 3j]))
array([-0.20791042+0.14096627j, -0.21526929+0.01205044j,
 -0.19682671+0.00127278j]) 

还可以通过提供广播兼容形状的v和z数组，同时在几个点上计算两个不同阶数v和三个点z的yve得到一个 2x3 数组。

>>> v = np.array([[1], [2]])
>>> z = np.array([3j, 4j, 5j])
>>> v.shape, z.shape
((2, 1), (3,)) 

>>> yve(v, z)
array([[-1.96826713e-01+1.27277544e-03j, -1.78750840e-01+1.45558819e-04j,
 -1.63972267e-01+1.73494110e-05j],
 [1.94960056e-03-1.11782545e-01j,  2.02902325e-04-1.17626501e-01j,
 2.27727687e-05-1.17951906e-01j]]) 

scipy.special.kn

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

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

整数阶 n 的修正贝塞尔函数第二类

返回实数 z 处整数阶 n 的修正贝塞尔函数第二类。

有时也被称为第三类函数、巴塞特函数或者麦克唐纳函数。

参数：

nint 的数组样式

贝塞尔函数的阶数（浮点数会有警告截断）

xfloat 的数组样式

评估贝塞尔函数的参数

outndarray，可选

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

返回：

标量或者 ndarray

修正贝塞尔函数第二类的值，(K_n(x))。

另请参见

kv

相同函数，但接受实数阶和复数参数

kvp

此函数的导数

注意事项

zbesk 的 AMOS [1] 程序包装器。有关所使用的算法的讨论，请参见 [2] 及其引用。

参考文献

[1]

Donald E. Amos, “AMOS, A Portable Package for Bessel Functions of a Complex Argument and Nonnegative Order”, netlib.org/amos/

[2]

Donald E. Amos, “Algorithm 644: A portable package for Bessel functions of a complex argument and nonnegative order”, ACM TOMS Vol. 12 Issue 3, Sept. 1986, p. 265

示例

绘制实数输入的几个阶数的函数：

>>> import numpy as np
>>> from scipy.special import kn
>>> import matplotlib.pyplot as plt
>>> x = np.linspace(0, 5, 1000)
>>> for N in range(6):
...     plt.plot(x, kn(N, x), label='$K_{}(x)$'.format(N))
>>> plt.ylim(0, 10)
>>> plt.legend()
>>> plt.title(r'Modified Bessel function of the second kind $K_n(x)$')
>>> plt.show() 

计算多个阶数的单个值：

>>> kn([4, 5, 6], 1)
array([   44.23241585,   360.9605896 ,  3653.83831186]) 

scipy.special.kv

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

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

实数阶 v 的修改贝塞尔函数的第二类

返回复数阶 v 的修改贝塞尔函数的第二类。

这些有时也称为第三类函数，巴赛特函数或麦克唐纳函数。它们被定义为修改贝塞尔方程的解，其特征为，

[K_v(x) \sim \sqrt{\pi/(2x)} \exp(-x)]

当 (x \to \infty) [3].

参数：

v 浮点数数组

贝塞尔函数的阶数

z 复数数组

评估贝塞尔函数的参数

out ndarray，可选

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

返回：

标量或 ndarray

结果。请注意，输入必须是复数类型才能获得复数输出，例如 kv(3, -2+0j) 而不是 kv(3, -2)。

参见

kve

除去主导指数行为的函数。

kvp

此函数的导数

注意

AMOS 的包装器 [1] 例程 zbesk。关于所使用的算法的讨论，请参见 [2] 及其中的参考文献。

参考文献

[1]

Donald E. Amos，“AMOS，一种复数参数和非负阶贝塞尔函数的便携包”，netlib.org/amos/

[2]

Donald E. Amos，“算法 644：一种复数参数和非负阶贝塞尔函数的便携包”，ACM TOMS Vol. 12 Issue 3，1986 年 9 月，第 265 页

[3]

NIST 数字数学函数库，方程 10.25.E3. dlmf.nist.gov/10.25.E3

示例

绘制实数输入的多个阶数的函数

>>> import numpy as np
>>> from scipy.special import kv
>>> import matplotlib.pyplot as plt
>>> x = np.linspace(0, 5, 1000)
>>> for N in np.linspace(0, 6, 5):
...     plt.plot(x, kv(N, x), label='$K_{{{}}}(x)$'.format(N))
>>> plt.ylim(0, 10)
>>> plt.legend()
>>> plt.title(r'Modified Bessel function of the second kind $K_\nu(x)$')
>>> plt.show() 

对多个阶数的单个值进行计算：

>>> kv([4, 4.5, 5], 1+2j)
array([ 0.1992+2.3892j,  2.3493+3.6j   ,  7.2827+3.8104j]) 

scipy.special.kve

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

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

指数尺度修正的第二类贝塞尔函数。

返回指数尺度的修正第二类（有时称为第三类）贝塞尔函数，对于复数z的真实阶v：

kve(v, z) = kv(v, z) * exp(z) 

参数：

v浮点数的数组

贝塞尔函数的阶数

z复合的数组

评估贝塞尔函数的参数。

out，可选的 ndarray

函数结果的可选输出数组

返回：

标量或 ndarray

指数尺度修正的第二类贝塞尔函数。

另请参阅

kv

没有指数尺度的此函数。

k0e

此函数的顺序 0 的更快版本。

k1e

此函数的顺序 1 的更快版本。

注释

AMOS 的包装器[1]例程zbesk。有关所用算法的讨论，请参见[2]及其引用。

参考文献

[1]

Donald E. Amos，“AMOS，一种用于复参数和非负顺序的贝塞尔函数的便携式包装”，netlib.org/amos/

[2]

Donald E. Amos，“算法 644：一种用于复参数和非负顺序的贝塞尔函数的便携式包装”，ACM TOMS Vol. 12 Issue 3，1986 年 9 月，第 265 页

示例

在以下示例中，kv返回 0，而kve仍然返回一个有用的有限数。

>>> import numpy as np
>>> from scipy.special import kv, kve
>>> import matplotlib.pyplot as plt
>>> kv(3, 1000.), kve(3, 1000.)
(0.0, 0.03980696128440973) 

通过为v参数提供列表或 NumPy 数组作为参数，对不同顺序的一个点评估函数：

>>> kve([0, 1, 1.5], 1.)
array([1.14446308, 1.63615349, 2.50662827]) 

评估函数在多个点处对零阶进行处理，通过为z提供一个数组。

>>> points = np.array([1., 3., 10.])
>>> kve(0, points)
array([1.14446308, 0.6977616 , 0.39163193]) 

通过为v和z提供数组，以不同的顺序评估多个点的函数。这两个数组必须能够广播到正确的形状。为了计算一维点的顺序 0、1 和 2：

>>> kve([[0], [1], [2]], points)
array([[1.14446308, 0.6977616 , 0.39163193],
 [1.63615349, 0.80656348, 0.41076657],
 [4.41677005, 1.23547058, 0.47378525]]) 

绘制阶数从 0 到 3 的函数，从 0 到 5。

>>> fig, ax = plt.subplots()
>>> x = np.linspace(0., 5., 1000)
>>> for i in range(4):
...     ax.plot(x, kve(i, x), label=f'$K_{i!r}(z)\cdot e^z$')
>>> ax.legend()
>>> ax.set_xlabel(r"$z$")
>>> ax.set_ylim(0, 4)
>>> ax.set_xlim(0, 5)
>>> plt.show() 

scipy.special.iv

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

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

实数阶数的修改贝塞尔函数第一类。

参数：

varray_like

阶数。如果z是实型且为负数，则v必须是整数值。

zfloat 或复数的 array_like

参数。

outndarray, optional

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

返回：

标量或 ndarray

修改过的贝塞尔函数的值。

另请参见

ive

带有前导指数行为剥离的此函数。

i0

此函数的阶数 0 的更快版本。

i1

此函数的阶数 1 的更快版本。

注

对于实数z和(v \in [-50, 50])，使用 Temme 方法[1]进行评估。对于更大的阶数，应用均匀渐近展开。

对于复数z和正数v，调用 AMOS[2]的zbesi例程。它对小z使用幂级数，对大*abs(z)*使用渐近展开，使用由 Wronskian 归一化的 Miller 算法和中间量级的 Neumann 级数，并对大阶数的(I_v(z))和(J_v(z))使用均匀渐近展开。当必要时使用反向递归生成序列或减少阶数。

上述计算在右半平面完成，并通过公式延伸到左半平面，

[I_v(z \exp(\pm\imath\pi)) = \exp(\pm\pi v) I_v(z)]

（当z的实部为正时有效）。对于负数v，使用公式

[I_{-v}(z) = I_v(z) + \frac{2}{\pi} \sin(\pi v) K_v(z)]

其中(K_v(z))是第二类修改贝塞尔函数，使用 AMOS 例程zbesk进行评估。

参考

[1]

Temme, Journal of Computational Physics, vol 21, 343 (1976)

[2]

Donald E. Amos，“AMOS, A Portable Package for Bessel Functions of a Complex Argument and Nonnegative Order”，netlib.org/amos/

示例

在一个点评估阶数 0 的函数。

>>> from scipy.special import iv
>>> iv(0, 1.)
1.2660658777520084 

为不同阶数的一个点评估函数。

>>> iv(0, 1.), iv(1, 1.), iv(1.5, 1.)
(1.2660658777520084, 0.565159103992485, 0.2935253263474798) 

可通过提供列表或 NumPy 数组作为v参数的参数，在一次调用中评估不同阶数。

>>> iv([0, 1, 1.5], 1.)
array([1.26606588, 0.5651591 , 0.29352533]) 

通过提供z的数组，在阶数 0 处评估函数。

>>> import numpy as np
>>> points = np.array([-2., 0., 3.])
>>> iv(0, points)
array([2.2795853 , 1\.        , 4.88079259]) 

如果z是一个数组，则如果要在一次调用中计算不同阶数，阶数参数v必须能广播到正确的形状。要计算 1D 数组的阶数 0 和 1：

>>> orders = np.array([[0], [1]])
>>> orders.shape
(2, 1) 

>>> iv(orders, points)
array([[ 2.2795853 ,  1\.        ,  4.88079259],
 [-1.59063685,  0\.        ,  3.95337022]]) 

绘制从-5 到 5 的 0 到 3 阶函数。

>>> import matplotlib.pyplot as plt
>>> fig, ax = plt.subplots()
>>> x = np.linspace(-5., 5., 1000)
>>> for i in range(4):
...     ax.plot(x, iv(i, x), label=f'$I_{i!r}$')
>>> ax.legend()
>>> plt.show() 

scipy.special.ive

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

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

指数尺度修正的第一类修正贝塞尔函数。

定义如下：

ive(v, z) = iv(v, z) * exp(-abs(z.real)) 

对于没有实部的虚数，返回第一类贝塞尔函数的非尺度版本iv。

参数：

v浮点数的数组

阶数。

z浮点数或复数的数组

参数。

out ndarray，可选

函数值的可选输出数组

返回：

标量或 ndarray

指数尺度修正的修正贝塞尔函数的值。

另请参阅

iv

第一类修正贝塞尔函数

i0e

该函数在阶数 0 时的更快实现

i1e

该函数在阶数 1 时的更快实现

注意事项

对于正v，调用 AMOS [1] zbesi例程。它使用小z的幂级数，大*abs(z)*的渐近展开，通过 Wronskian 归一化的 Miller 算法以及中间数量的 Neumann 级数，并且针对大阶数的(I_v(z))和(J_v(z))使用均匀渐近展开。必要时使用后向递归生成序列或减少阶数。

上述计算在右半平面完成，并通过公式延续到左半平面，

[I_v(z \exp(\pm\imath\pi)) = \exp(\pm\pi v) I_v(z)]

（当z的实部为正时）对于负v，公式

[I_{-v}(z) = I_v(z) + \frac{2}{\pi} \sin(\pi v) K_v(z)]

使用zbesk例程评估修正贝塞尔函数第二类K_v(z)。

对于大的参数z，ive是有用的：对于这些参数，iv很容易溢出，而ive由于指数尺度而不会溢出。

参考文献

[1]

Donald E. Amos, “AMOS, A Portable Package for Bessel Functions of a Complex Argument and Nonnegative Order”, netlib.org/amos/

示例

在以下示例中iv返回无穷大，而ive仍然返回有限数。

>>> from scipy.special import iv, ive
>>> import numpy as np
>>> import matplotlib.pyplot as plt
>>> iv(3, 1000.), ive(3, 1000.)
(inf, 0.01256056218254712) 

通过将列表或 NumPy 数组作为v参数的参数，评估不同阶数的一个点上的函数：

>>> ive([0, 1, 1.5], 1.)
array([0.46575961, 0.20791042, 0.10798193]) 

通过提供一个z数组，对阶数 0 的多个点评估函数。

>>> points = np.array([-2., 0., 3.])
>>> ive(0, points)
array([0.30850832, 1\.        , 0.24300035]) 

通过为v和z提供可广播到正确形状的数组，对不同阶数的几个点评估函数。要计算一维点数组的 0、1 和 2 阶：

>>> ive([[0], [1], [2]], points)
array([[ 0.30850832,  1\.        ,  0.24300035],
 [-0.21526929,  0\.        ,  0.19682671],
 [ 0.09323903,  0\.        ,  0.11178255]]) 

绘制从-5 到 5 的 0 到 3 阶函数。

>>> fig, ax = plt.subplots()
>>> x = np.linspace(-5., 5., 1000)
>>> for i in range(4):
...     ax.plot(x, ive(i, x), label=f'$I_{i!r}(z)\cdot e^{{-|z|}}$')
>>> ax.legend()
>>> ax.set_xlabel(r"$z$")
>>> plt.show() 

scipy.special.hankel1

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

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

第一类汉克尔函数

参数：

v数组类似

阶（浮点数）。

z数组类似

参数（浮点数或复数）。

outndarray，可选

函数值的可选输出数组

返回：

标量或 ndarray

第一类汉克尔函数的值。

另见

hankel1e

ndarray 该函数去除了前导指数行为。

注意事项

通过关系进行计算的 AMOS [1] 例程 zbesh 的包装器，

[H^{(1)}_v(z) = \frac{2}{\imath\pi} \exp(-\imath \pi v/2) K_v(z \exp(-\imath\pi/2))]

其中 (K_v) 是第二类修改贝塞尔函数。对于负阶，关系

[H^{(1)}_{-v}(z) = H^{(1)}_v(z) \exp(\imath\pi v)]

用于

参考文献

[1]

Donald E. Amos，《AMOS，一种复数参数和非负阶贝塞尔函数的便携包》，netlib.org/amos/

scipy.special.hankel1e

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

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

第一类指数尺度汉克尔函数

定义为：

hankel1e(v, z) = hankel1(v, z) * exp(-1j * z) 

参数：

v数组类型

阶数（float）。

z数组类型

参数（float 或 complex）。

out ndarray，可选项

函数值的可选输出数组

返回：

标量或 ndarray

指数尺度汉克尔函数的值。

注意事项

AMOS [1]例程zbesh的包装器，使用以下关系进行计算，

[H^{(1)}_v(z) = \frac{2}{\imath\pi} \exp(-\imath \pi v/2) K_v(z \exp(-\imath\pi/2))]

其中(K_v)是第二类修正贝塞尔函数。对于负阶，关系式

[H^{(1)}_{-v}(z) = H^{(1)}_v(z) \exp(\imath\pi v)]

被使用。

参考文献

[1]

Donald E. Amos，“AMOS, A Portable Package for Bessel Functions of a Complex Argument and Nonnegative Order”，netlib.org/amos/

scipy.special.hankel2

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

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

第二类汉克尔函数

参数：

v array_like

阶数（浮点数）。

z array_like

参数（浮点数或复数）。

out ndarray，可选

函数值的可选输出数组

返回：

标量或者 ndarray

第二类汉克尔函数的值。

另请参见

hankel2e

去除了主导指数行为的此函数。

注意

AMOS [1] 程序包 zbesh 的一个封装，使用以下关系进行计算，

[H^{(2)}_v(z) = -\frac{2}{\imath\pi} \exp(\imath \pi v/2) K_v(z \exp(\imath\pi/2))]

其中 (K_v) 是第二类修正贝塞尔函数。对于负阶数，关系

[H^{(2)}_{-v}(z) = H^{(2)}_v(z) \exp(-\imath\pi v)]

被使用。

参考文献

[1]

Donald E. Amos，“AMOS, A Portable Package for Bessel Functions of a Complex Argument and Nonnegative Order”，netlib.org/amos/

scipy.special.hankel2e

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

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

第二类指数缩放的汉克尔函数

定义为：

hankel2e(v, z) = hankel2(v, z) * exp(1j * z) 

参数：

v类似数组

订单（浮点数）。

z类似数组

参数（浮点数或复数）。

out ndarray，可选

函数值的可选输出数组

返回：

标量或 ndarray

第二类指数缩放汉克尔函数的值。

注释

用于通过关系计算的 AMOS [1]例程zbesh的包装器。

[H^{(2)}_v(z) = -\frac{2}{\imath\pi} \exp(\frac{\imath \pi v}{2}) K_v(z \exp(\frac{\imath\pi}{2}))]

其中(K_v)是第二类修正贝塞尔函数。对于负订单，关系式

[H^{(2)}_{-v}(z) = H^{(2)}_v(z) \exp(-\imath\pi v)]

被使用。

参考文献

[1]

Donald E. Amos，“AMOS, A Portable Package for Bessel Functions of a Complex Argument and Nonnegative Order”，netlib.org/amos/

scipy.special.wright_bessel

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

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

Wright 广义贝塞尔函数。

Wright 广义贝塞尔函数是整函数，定义为

[\Phi(a, b; x) = \sum_{k=0}^\infty \frac{x^k}{k! \Gamma(a k + b)}]

参见 [1]。

参数：

a浮点数数组

a >= 0

b浮点数数组

b >= 0

x浮点数数组

x >= 0

out，可选，ndarray

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

返回：

标量或者 ndarray

Wright 广义贝塞尔函数的值

注意事项

由于具有三个参数的函数的复杂性，仅实现非负参数。

参考文献

[1]

数学函数数字图书馆，10.46. dlmf.nist.gov/10.46.E1

示例

>>> from scipy.special import wright_bessel
>>> a, b, x = 1.5, 1.1, 2.5
>>> wright_bessel(a, b-1, x)
4.5314465939443025 

现在，让我们验证这个关系

[\Phi(a, b-1; x) = a x \Phi(a, b+a; x) + (b-1) \Phi(a, b; x)]

>>> a * x * wright_bessel(a, b+a, x) + (b-1) * wright_bessel(a, b, x)
4.5314465939443025 

scipy.special.lmbda

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

scipy.special.lmbda(v, x)

Jahnke-Emden Lambda 函数，即 Lambdav(x)。

此函数定义如[2]所示，

[\Lambda_v(x) = \Gamma(v+1) \frac{J_v(x)}{(x/2)^v},]

其中(\Gamma)为 Gamma 函数，(J_v)为第一类贝塞尔函数。

参数：

vfloat

Lambda 函数的阶数

xfloat

函数及其导数计算的值。

返回值：

vlndarray

Lambda_vi(x)的值，对于 vi=v-int(v)，vi=1+v-int(v)，…，vi=v。

dlndarray

Lambda_vi’(x)的导数，对于 vi=v-int(v)，vi=1+v-int(v)，…，vi=v。

参考文献：

[1]

Zhang, Shanjie and Jin, Jianming. “Computation of Special Functions”, John Wiley and Sons, 1996. people.sc.fsu.edu/~jburkardt/f77_src/special_functions/special_functions.html

[2]

Jahnke, E. and Emde, F. “Tables of Functions with Formulae and Curves” (4th ed.), Dover, 1945

scipy.special.jnjnp_zeros

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

scipy.special.jnjnp_zeros(nt)

计算整数阶贝塞尔函数Jn和Jn'的零点。

结果按零点的大小排序。

参数：

nt 整数

计算的零点数（<=1200）

返回：

zo[l-1] 数组

Jn(x)和Jn'(x)的第 l 个零点的值。长度为nt。

n[l-1] 数组

Jn(x)或Jn'(x)的顺序，与第 l 个零点相关。长度为nt。

m[l-1] 数组

Jn(x)或Jn'(x)的零点的序号，与第 l 个零点相关。长度为nt。

t[l-1] 数组

如果 zo 的第 l 个零点是Jn(x)的零点，则为 0；如果是Jn'(x)的零点，则为 1。长度为nt。

另见

jn_zeros，jnp_zeros

以获取分离的零点数组。

参考文献

[1]

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