SciPy 1.12 中文文档（四十一）
scipy.special.besselpoly
scipy.special.besselpoly(a, lmb, nu, out=None) = <ufunc 'besselpoly'>
第一类贝塞尔函数的加权积分。
计算
[\int_0¹ x^\lambda J_\nu(2 a x) , dx]
这里的(J_\nu)是贝塞尔函数，(\lambda=lmb), (\nu=nu)。
参数：
a类似数组
贝塞尔函数内的比例因子。
lmb类似数组
x的幂
nu类似数组
贝塞尔函数的阶数。
outndarray，可选
函数结果的可选输出数组。
返回：
标量或者 ndarray
积分的值。
参考资料
[1]
Cephes 数学函数库，www.netlib.org/cephes/
示例
为一个参数集评估函数。
>>> from scipy.special import besselpoly
>>> besselpoly(1, 1, 1)
0.24449718372863877
评估不同比例因子下的函数。
>>> import numpy as np
>>> factors = np.array([0., 3., 6.])
>>> besselpoly(factors, 1, 1)
array([ 0\. , -0.00549029, 0.00140174])
绘制不同幂次、阶数和比例尺度的函数图像。
>>> import matplotlib.pyplot as plt
>>> fig, ax = plt.subplots()
>>> powers = np.linspace(0, 10, 100)
>>> orders = [1, 2, 3]
>>> scales = [1, 2]
>>> all_combinations = [(order, scale) for order in orders
... for scale in scales]
>>> for order, scale in all_combinations:
... ax.plot(powers, besselpoly(scale, powers, order),
... label=rf"$\nu={order}, a={scale}$")
>>> ax.legend()
>>> ax.set_xlabel(r"$\lambda$")
>>> ax.set_ylabel(r"$\int_0¹ x^{\lambda} J_{\nu}(2ax)\,dx$")
>>> plt.show()
scipy.special.jvp
原文链接：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.jvp.html#scipy.special.jvp
scipy.special.jvp(v, z, n=1)
计算一阶类贝塞尔函数的导数。
计算贝塞尔函数 Jv 关于 z 的第 n 阶导数。
参数：
v数组或浮点数
贝塞尔函数的阶数
z复数
要评估导数的参数；可以是实数或复数。
nint，默认为 1
导数的阶数。对于 0 返回贝塞尔函数jv本身。
返回：
标量或 ndarray
贝塞尔函数导数的值。
注释
使用关系 DLFM 10.6.7 计算导数 [2]。
参考文献
[1]
Zhang, Shanjie 和 Jin, Jianming. “Special Functions 的计算”, John Wiley and Sons, 1996, 第五章。people.sc.fsu.edu/~jburkardt/f77_src/special_functions/special_functions.html
[2]
NIST 数学函数数字图书馆。dlmf.nist.gov/10.6.E7
示例
计算阶数为 0 时一阶类贝塞尔函数及其前两阶导数在 1 处的值。
>>> from scipy.special import jvp
>>> jvp(0, 1, 0), jvp(0, 1, 1), jvp(0, 1, 2)
(0.7651976865579666, -0.44005058574493355, -0.3251471008130331)
提供一个数组作为 v 来计算一阶类贝塞尔函数在 1 处的多个阶数的第一阶导数。
>>> jvp([0, 1, 2], 1, 1)
array([-0.44005059, 0.3251471 , 0.21024362])
提供一个数组作为 z 来计算一阶类贝塞尔函数阶数为 0 时在多个点处的第一阶导数。
>>> import numpy as np
>>> points = np.array([0., 1.5, 3.])
>>> jvp(0, points, 1)
array([-0\. , -0.55793651, -0.33905896])
绘制一阶类贝塞尔函数及其前三阶导数。
>>> import matplotlib.pyplot as plt
>>> x = np.linspace(-10, 10, 1000)
>>> fig, ax = plt.subplots()
>>> ax.plot(x, jvp(1, x, 0), label=r"$J_1$")
>>> ax.plot(x, jvp(1, x, 1), label=r"$J_1'$")
>>> ax.plot(x, jvp(1, x, 2), label=r"$J_1''$")
>>> ax.plot(x, jvp(1, x, 3), label=r"$J_1'''$")
>>> plt.legend()
>>> plt.show()
scipy.special.yvp
原文：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.yvp.html#scipy.special.yvp
scipy.special.yvp(v, z, n=1)
计算第二类贝塞尔函数的导数。
计算贝塞尔函数 Yv 对 z 的第 n 阶导数。
参数：
varray_like of float
贝塞尔函数的阶数
zcomplex
评估导数的参数
nint，默认为 1
求导阶数。对于 0 返回 BEssel 函数 yv
返回值：
scalar 或 ndarray
第 n 阶贝塞尔函数的导数。
参见
yv
第二类贝塞尔函数
注释
该导数是使用关系 DLFM 10.6.7 计算的 [2]。
参考文献
[1]
Zhang, Shanjie 和 Jin, Jianming。“特殊函数的计算”，John Wiley and Sons，1996 年，第五章。people.sc.fsu.edu/~jburkardt/f77_src/special_functions/special_functions.html
[2]
NIST 数字图书馆的数学函数。dlmf.nist.gov/10.6.E7
示例
计算阶数为 0 的第二类贝塞尔函数及其在 1 处的前两个导数。
>>> from scipy.special import yvp
>>> yvp(0, 1, 0), yvp(0, 1, 1), yvp(0, 1, 2)
(0.088256964215677, 0.7812128213002889, -0.8694697855159659)
通过为 v 提供数组，在 1 处计算阶数为 0 的第二类贝塞尔函数的一阶导数。
>>> yvp([0, 1, 2], 1, 1)
array([0.78121282, 0.86946979, 2.52015239])
通过为 z 提供数组，计算阶数为 0 的第二类贝塞尔函数的一阶导数在几个点处。
>>> import numpy as np
>>> points = np.array([0.5, 1.5, 3.])
>>> yvp(0, points, 1)
array([ 1.47147239, 0.41230863, -0.32467442])
绘制阶数为 1 的第二类贝塞尔函数及其前三个导数。
>>> import matplotlib.pyplot as plt
>>> x = np.linspace(0, 5, 1000)
>>> x[0] += 1e-15
>>> fig, ax = plt.subplots()
>>> ax.plot(x, yvp(1, x, 0), label=r"$Y_1$")
>>> ax.plot(x, yvp(1, x, 1), label=r"$Y_1'$")
>>> ax.plot(x, yvp(1, x, 2), label=r"$Y_1''$")
>>> ax.plot(x, yvp(1, x, 3), label=r"$Y_1'''$")
>>> ax.set_ylim(-10, 10)
>>> plt.legend()
>>> plt.show()
scipy.special.kvp
原文：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.kvp.html#scipy.special.kvp
scipy.special.kvp(v, z, n=1)
计算实数阶修正贝塞尔函数 Kv(z)的导数
Kv(z)是第二类修正贝塞尔函数。导数是相对于z计算的。
参数：
v浮点数数组
贝塞尔函数的阶数
z复数数组
计算导数的论点
n整数，默认为 1
导数的阶数。对于 0，返回贝塞尔函数kv本身。
返回值：
outndarray
结果
另见
注释
使用关系 DLFM 10.29.5 计算导数[2]。
参考文献
[1]
张善杰和金建明。“特殊函数的计算”，约翰威利和儿子，1996 年，第六章。people.sc.fsu.edu/~jburkardt/f77_src/special_functions/special_functions.html
[2]
NIST 数学函数数字库。dlmf.nist.gov/10.29.E5
示例
在 1 处计算第二类修正贝塞尔函数及其前两个导数的阶数。
>>> from scipy.special import kvp
>>> kvp(0, 1, 0), kvp(0, 1, 1), kvp(0, 1, 2)
(0.42102443824070834, -0.6019072301972346, 1.0229316684379428)
通过为v提供一个数组，在 1 处计算几个阶数的第二类修正贝塞尔函数的一阶导数。
>>> kvp([0, 1, 2], 1, 1)
array([-0.60190723, -1.02293167, -3.85158503])
通过为z提供一个数组，计算几个点的第二类修正贝塞尔函数的一阶导数，其中z是浮点数的数组。
>>> import numpy as np
>>> points = np.array([0.5, 1.5, 3.])
>>> kvp(0, points, 1)
array([-1.65644112, -0.2773878 , -0.04015643])
绘制第二类修正贝塞尔函数及其前三个导数。
>>> import matplotlib.pyplot as plt
>>> x = np.linspace(0, 5, 1000)
>>> fig, ax = plt.subplots()
>>> ax.plot(x, kvp(1, x, 0), label=r"$K_1$")
>>> ax.plot(x, kvp(1, x, 1), label=r"$K_1'$")
>>> ax.plot(x, kvp(1, x, 2), label=r"$K_1''$")
>>> ax.plot(x, kvp(1, x, 3), label=r"$K_1'''$")
>>> ax.set_ylim(-2.5, 2.5)
>>> plt.legend()
>>> plt.show()
scipy.special.ivp
原文：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.ivp.html#scipy.special.ivp
scipy.special.ivp(v, z, n=1)
计算一类修正贝塞尔函数的导数。
计算一类修正贝塞尔函数Iv关于z的第 n 阶导数。
参数：
varray_like 或 float
贝塞尔函数的阶数
zarray_like
用于计算导数的参数；可以是实数或复数。
nint，默认值 1
导数的阶数。对于 0，返回贝塞尔函数iv本身。
返回：
标量或 ndarray
修正贝塞尔函数的第 n 阶导数。
另请参阅
iv
注释
使用关系 DLFM 10.29.5 计算导数[2]。
参考文献
[1]
张善杰和金建明。“特殊函数的计算”，John Wiley and Sons，1996 年，第六章。people.sc.fsu.edu/~jburkardt/f77_src/special_functions/special_functions.html
[2]
NIST 数学函数数字图书馆。dlmf.nist.gov/10.29.E5
示例
计算一类修正贝塞尔函数的一阶导数为 0 阶和其在 1 处的前两个导数。
>>> from scipy.special import ivp
>>> ivp(0, 1, 0), ivp(0, 1, 1), ivp(0, 1, 2)
(1.2660658777520084, 0.565159103992485, 0.7009067737595233)
通过为v提供数组，计算一类修正贝塞尔函数的一阶导数的多个阶在 1 处的值。
>>> ivp([0, 1, 2], 1, 1)
array([0.5651591 , 0.70090677, 0.29366376])
通过为z提供数组，计算一类修正贝塞尔函数的一阶导数为 0 阶在几个点处的值。
>>> import numpy as np
>>> points = np.array([0., 1.5, 3.])
>>> ivp(0, points, 1)
array([0\. , 0.98166643, 3.95337022])
绘制一类修正贝塞尔函数的一阶导数为 1 阶及其前三阶导数。
>>> import matplotlib.pyplot as plt
>>> x = np.linspace(-5, 5, 1000)
>>> fig, ax = plt.subplots()
>>> ax.plot(x, ivp(1, x, 0), label=r"$I_1$")
>>> ax.plot(x, ivp(1, x, 1), label=r"$I_1'$")
>>> ax.plot(x, ivp(1, x, 2), label=r"$I_1''$")
>>> ax.plot(x, ivp(1, x, 3), label=r"$I_1'''$")
>>> plt.legend()
>>> plt.show()
scipy.special.h1vp
原文：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.h1vp.html#scipy.special.h1vp
scipy.special.h1vp(v, z, n=1)
计算对z的汉克尔函数 H1v(z)的导数。
参数：
varray_like
汉克尔函数的阶数
zarray_like
评估导数的参数。可以是实数或复数。
nint，默认为 1
导数的阶数。对于 0 返回汉克尔函数h1v本身。
返回：
标量或 ndarray
汉克尔函数导数的值。
另见
hankel1
注意
使用关系 DLFM 10.6.7 [2] 计算导数。
参考资料
[1]
张, 善杰 和 金, 建明。“特殊函数的计算”，约翰·威利和儿子出版社, 1996 年, 第五章。people.sc.fsu.edu/~jburkardt/f77_src/special_functions/special_functions.html
[2]
NIST 数字数学函数库。dlmf.nist.gov/10.6.E7
示例
计算阶数为 0 的第一类汉克尔函数及其在 1 处的前两个导数。
>>> from scipy.special import h1vp
>>> h1vp(0, 1, 0), h1vp(0, 1, 1), h1vp(0, 1, 2)
((0.7651976865579664+0.088256964215677j),
(-0.44005058574493355+0.7812128213002889j),
(-0.3251471008130329-0.8694697855159659j))
通过提供一个数组v，计算在 1 处多个阶数的第一类汉克尔函数的第一导数。
>>> h1vp([0, 1, 2], 1, 1)
array([-0.44005059+0.78121282j, 0.3251471 +0.86946979j,
0.21024362+2.52015239j])
通过提供一个数组z，计算在多个点处阶数为 0 的第一类汉克尔函数的第一导数。
>>> import numpy as np
>>> points = np.array([0.5, 1.5, 3.])
>>> h1vp(0, points, 1)
array([-0.24226846+1.47147239j, -0.55793651+0.41230863j,
-0.33905896-0.32467442j])
scipy.special.h2vp
原文：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.h2vp.html#scipy.special.h2vp
scipy.special.h2vp(v, z, n=1)
计算 Hankel 函数 H2v(z)关于z的导数。
参数：
varray_like
Hankel 函数的阶数
zarray_like
求导数的自变量。可以是实数或复数。
nint，默认为 1
导数的阶数。对于 0 返回 Hankel 函数h2v本身。
返回：
标量或者 ndarray
Hankel 函数导数的值。
另请参阅
hankel2
注意事项
导数的计算使用 DLFM 10.6.7 关系 [2]。
参考文献
[1]
张善杰和金建明。“特殊函数的计算”，John Wiley and Sons 出版，1996 年，第五章。people.sc.fsu.edu/~jburkardt/f77_src/special_functions/special_functions.html
[2]
NIST 数学函数数字图书馆。dlmf.nist.gov/10.6.E7
示例
计算阶数为 0 的第二类 Hankel 函数在 1 处及其前两个导数。
>>> from scipy.special import h2vp
>>> h2vp(0, 1, 0), h2vp(0, 1, 1), h2vp(0, 1, 2)
((0.7651976865579664-0.088256964215677j),
(-0.44005058574493355-0.7812128213002889j),
(-0.3251471008130329+0.8694697855159659j))
提供v数组，计算一阶导数的第二类 Hankel 函数在 1 处的多个阶数。
>>> h2vp([0, 1, 2], 1, 1)
array([-0.44005059-0.78121282j, 0.3251471 -0.86946979j,
0.21024362-2.52015239j])
提供z数组，计算阶数为 0 的第二类 Hankel 函数在多个点处的一阶导数。
>>> import numpy as np
>>> points = np.array([0.5, 1.5, 3.])
>>> h2vp(0, points, 1)
array([-0.24226846-1.47147239j, -0.55793651-0.41230863j,
-0.33905896+0.32467442j])
scipy.special.spherical_jn
scipy.special.spherical_jn(n, z, derivative=False)
第一类球贝塞尔函数或其导数。
定义为[1],
[j_n(z) = \sqrt{\frac{\pi}{2z}} J_{n + 1/2}(z),]
其中(J_n)是第一类贝塞尔函数。
参数：
nint，类数组
Bessel 函数的顺序（n >= 0）。
z复数或浮点数，类数组
贝塞尔函数的参数。
derivativebool，可选
如果为 True，则返回导数值（而不是函数本身）。
返回：
jnndarray
注意事项
对于大于顺序的实数参数，使用升序递推计算函数[2]。对于小的实数或复数参数，使用与第一类圆柱贝塞尔函数的定义关系。
使用关系计算导数[3]，
[ \begin{align}\begin{aligned}j_n'(z) = j_{n-1}(z) - \frac{n + 1}{z} j_n(z).\j_0'(z) = -j_1(z)\end{aligned}\end{align} ]
自 0.18.0 版本起新增。
参考文献
[1]
[2]
[3]
[AS]
米尔顿·阿布拉莫维茨和艾琳·A·斯特甘（Milton Abramowitz and Irene A. Stegun）主编。数学函数手册，包含公式、图表和数学表格。纽约：多佛出版社，1972 年。
示例
第一类球贝塞尔函数(j_n)接受实数和复数第二参数。它们可以返回复数类型：
>>> from scipy.special import spherical_jn
>>> spherical_jn(0, 3+5j)
(-9.878987731663194-8.021894345786002j)
>>> type(spherical_jn(0, 3+5j))
<class 'numpy.complex128'>
我们可以验证在区间([1, 2])中的(n=3)的导数关系：
>>> import numpy as np
>>> x = np.arange(1.0, 2.0, 0.01)
>>> np.allclose(spherical_jn(3, x, True),
... spherical_jn(2, x) - 4/x * spherical_jn(3, x))
True
几个具有实数参数的(j_n)：
>>> import matplotlib.pyplot as plt
>>> x = np.arange(0.0, 10.0, 0.01)
>>> fig, ax = plt.subplots()
>>> ax.set_ylim(-0.5, 1.5)
>>> ax.set_title(r'Spherical Bessel functions $j_n$')
>>> for n in np.arange(0, 4):
... ax.plot(x, spherical_jn(n, x), label=rf'$j_{n}$')
>>> plt.legend(loc='best')
>>> plt.show()
scipy.special.spherical_yn
scipy.special.spherical_yn(n, z, derivative=False)
第二类球贝塞尔函数或其导数。
定义如[1]，
[y_n(z) = \sqrt{\frac{\pi}{2z}} Y_{n + 1/2}(z),]
其中(Y_n)是第二类贝塞尔函数。
参数：
n整数，类数组
贝塞尔函数的阶数（n >= 0）。
z复数或浮点数，类数组
贝塞尔函数的自变量。
derivative布尔值，可选项
如果为 True，则返回导数值（而不是函数本身）。
返回：
ynndarray
注释
对于实数自变量，使用递增的递推计算函数[2]。对于复数自变量，使用与第二类圆柱贝塞尔函数的定义关系。
使用关系计算导数[3]。
[ \begin{align}\begin{aligned}y_n' = y_{n-1} - \frac{n + 1}{z} y_n.\y_0' = -y_1\end{aligned}\end{align} ]
新功能版本 0.18.0。
参考文献
[1]
[2]
[3]
[AS]
米尔顿·阿布拉莫维奇和艾琳·A·斯特根（Milton Abramowitz and Irene A. Stegun）编辑。数学函数手册：带有公式、图表和数学表格。纽约：多佛尔出版社，1972 年。
例子
第二类球贝塞尔函数(y_n)接受实数和复数作为第二个自变量。它们可以返回复数类型：
>>> from scipy.special import spherical_yn
>>> spherical_yn(0, 3+5j)
(8.022343088587197-9.880052589376795j)
>>> type(spherical_yn(0, 3+5j))
<class 'numpy.complex128'>
我们可以验证关于导数的关系，从(n=3)的注释中，在区间([1, 2])内：
>>> import numpy as np
>>> x = np.arange(1.0, 2.0, 0.01)
>>> np.allclose(spherical_yn(3, x, True),
... spherical_yn(2, x) - 4/x * spherical_yn(3, x))
True
带有实数自变量的前几个(y_n)：
>>> import matplotlib.pyplot as plt
>>> x = np.arange(0.0, 10.0, 0.01)
>>> fig, ax = plt.subplots()
>>> ax.set_ylim(-2.0, 1.0)
>>> ax.set_title(r'Spherical Bessel functions $y_n$')
>>> for n in np.arange(0, 4):
... ax.plot(x, spherical_yn(n, x), label=rf'$y_{n}$')
>>> plt.legend(loc='best')
>>> plt.show()
scipy.special.spherical_in
scipy.special.spherical_in(n, z, derivative=False)
修改后的第一类球面贝塞尔函数或其导数。
定义如下 [1],
[i_n(z) = \sqrt{\frac{\pi}{2z}} I_{n + 1/2}(z),]
其中 (I_n) 是修改后的第一类圆柱贝塞尔函数。
参数:
nint, array_like
贝塞尔函数的阶数 (n >= 0)。
z复数或浮点数，array_like
贝塞尔函数的自变量。
derivative布尔值，可选
如果为 True，则返回导数值（而非函数本身）。
返回:
inndarray
注意事项
使用其与修改后的第一类圆柱贝塞尔函数的定义关系来计算函数。
使用关系计算导数 [2],
[ \begin{align}\begin{aligned}i_n' = i_{n-1} - \frac{n + 1}{z} i_n.\i_1' = i_0\end{aligned}\end{align} ]
自 0.18.0 版本起新增。
参考文献
[1]
[2]
[AS]
Milton Abramowitz 和 Irene A. Stegun 编辑。Handbook of Mathematical Functions with Formulas, Graphs, and Mathematical Tables. 纽约：Dover，1972 年。
示例
修改后的第一类球面贝塞尔函数 (i_n) 接受实数和复数第二个参数。它们可以返回复数类型：
>>> from scipy.special import spherical_in
>>> spherical_in(0, 3+5j)
(-1.1689867793369182-1.2697305267234222j)
>>> type(spherical_in(0, 3+5j))
<class 'numpy.complex128'>
我们可以验证在区间 ([1, 2]) 内 (n=3) 时，从注释中得到的导数关系：
>>> import numpy as np
>>> x = np.arange(1.0, 2.0, 0.01)
>>> np.allclose(spherical_in(3, x, True),
... spherical_in(2, x) - 4/x * spherical_in(3, x))
True
前几个具有实数参数的 (i_n)：
>>> import matplotlib.pyplot as plt
>>> x = np.arange(0.0, 6.0, 0.01)
>>> fig, ax = plt.subplots()
>>> ax.set_ylim(-0.5, 5.0)
>>> ax.set_title(r'Modified spherical Bessel functions $i_n$')
>>> for n in np.arange(0, 4):
... ax.plot(x, spherical_in(n, x), label=rf'$i_{n}$')
>>> plt.legend(loc='best')
>>> plt.show()
scipy.special.spherical_kn
scipy.special.spherical_kn(n, z, derivative=False)
修改的球形贝塞尔函数第二类或其导数。
定义如[1]，
[k_n(z) = \sqrt{\frac{\pi}{2z}} K_{n + 1/2}(z),]
其中 (K_n) 是修改的第二类贝塞尔函数。
参数：
n 整数，数组类型
Bessel 函数的顺序（(n \geq 0)）。
z 复数或浮点数，数组类型
Bessel 函数的参数。
derivative 布尔值，可选
如果为 True，则返回导数值（而不是函数本身）。
返回：
kn ndarray
注释
使用其与修改的圆柱形贝塞尔函数第二类的定义关系计算函数。
利用关系计算导数[2]，
[ \begin{align}\begin{aligned}k_n' = -k_{n-1} - \frac{n + 1}{z} k_n.\k_0' = -k_1\end{aligned}\end{align} ]
0.18.0 版本中的新功能。
参考资料
[1]
[2]
[AS]
Milton Abramowitz 和 Irene A. Stegun，编。 Handbook of Mathematical Functions with Formulas, Graphs, and Mathematical Tables。 New York: Dover, 1972.
示例
修改的球形贝塞尔函数第二类 (k_n) 接受实数和复数第二参数。它们可以返回复数类型：
>>> from scipy.special import spherical_kn
>>> spherical_kn(0, 3+5j)
(0.012985785614001561+0.003354691603137546j)
>>> type(spherical_kn(0, 3+5j))
<class 'numpy.complex128'>
我们可以验证关于导数的关系来自于注释，(n=3)在区间([1, 2])：
>>> import numpy as np
>>> x = np.arange(1.0, 2.0, 0.01)
>>> np.allclose(spherical_kn(3, x, True),
... - 4/x * spherical_kn(3, x) - spherical_kn(2, x))
True
带有实数参数的前几个 (k_n)：
>>> import matplotlib.pyplot as plt
>>> x = np.arange(0.0, 4.0, 0.01)
>>> fig, ax = plt.subplots()
>>> ax.set_ylim(0.0, 5.0)
>>> ax.set_title(r'Modified spherical Bessel functions $k_n$')
>>> for n in np.arange(0, 4):
... ax.plot(x, spherical_kn(n, x), label=rf'$k_{n}$')
>>> plt.legend(loc='best')
>>> plt.show()
scipy.special.riccati_jn
scipy.special.riccati_jn(n, x)
计算第一类里卡提-贝塞尔函数及其导数。
第一类里卡提-贝塞尔函数定义为 (x j_n(x))，其中 (j_n) 是第一类阶数为 (n) 的球贝塞尔函数。
此函数计算所有订单包括 n 的里卡提-贝塞尔函数的值和第一阶导数。
参数：
nint
函数计算的最大阶数
xfloat
在其处评估的参数
返回值:
jnndarray
j0(x) 到 jn(x) 的值
jnpndarray
第一阶导数 j0’(x), …, jn’(x)
注意事项
计算是通过向后递归进行的，使用关系 DLMF 10.51.1 [2].
由张善杰和金建明创建的 Fortran 程序包装器 [1].
参考文献
[1]
Zhang, Shanjie 和 Jin, Jianming. “Computation of Special Functions”, John Wiley and Sons, 1996. people.sc.fsu.edu/~jburkardt/f77_src/special_functions/special_functions.html
[2]
NIST 数字数学函数库。dlmf.nist.gov/10.51.E1
scipy.special.riccati_yn
scipy.special.riccati_yn(n, x)
计算第二类里卡提-贝塞尔函数及其导数。
第二类里卡提-贝塞尔函数定义为 (x y_n(x))，其中 (y_n) 是第二类球贝塞尔函数的阶数为 (n)。
此函数计算所有顺序直到包括 n 的函数值和第一阶导数。
参数：
nint
函数计算的最大阶数
xfloat
要评估的参数
返回：
ynndarray
y0(x), …, yn(x) 的值
ynpndarray
第一阶导数 y0’(x), …, yn’(x)
注意
计算通过升序递归进行，使用关系 DLMF 10.51.1 [2]。
张善杰和金建明创建的 Fortran 程序包装器 [1]。
参考文献
[1]
张善杰和金建明。“特殊函数的计算”，约翰·威利和儿子，1996 年。people.sc.fsu.edu/~jburkardt/f77_src/special_functions/special_functions.html
[2]
美国国家标准技术研究所数学函数数字图书馆。dlmf.nist.gov/10.51.E1
scipy.special.struve
原文链接：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.struve.html#scipy.special.struve
scipy.special.struve(v, x, out=None) = <ufunc 'struve'>
Struve 函数。
返回阶数v在x处的 Struve 函数值。Struve 函数定义如下，
[H_v(x) = (z/2)^{v + 1} \sum_{n=0}^\infty \frac{(-1)^n (z/2)^{2n}}{\Gamma(n + \frac{3}{2}) \Gamma(n + v + \frac{3}{2})},]
其中(\Gamma)是 Gamma 函数。
参数：
v 数组类型
Struve 函数的阶数（浮点数）。
x数组类型
Struve 函数的参数（浮点数；必须为正，除非v是整数）。
out ndarray，可选
函数结果的可选输出数组
返回：
H 标量或者 ndarray
阶数v在x处的 Struve 函数值。
另见
modstruve
修改的 Struve 函数
注意
讨论在[1]中使用的三种方法来评估 Struve 函数：
-
幂级数
-
Bessel 函数的展开（如果( |z| < |v| + 20 ))。
-
渐近大-z 展开（如果(z \geq 0.7v + 12))。
基于和式中最大项估计的舍入误差，并返回与最小误差相关联的结果。
参考资料
[1]
NIST 数字数学函数库 dlmf.nist.gov/11
示例
计算阶数为 1 的 Struve 函数在 2 处的值。
>>> import numpy as np
>>> from scipy.special import struve
>>> import matplotlib.pyplot as plt
>>> struve(1, 2.)
0.6467637282835622
通过为阶参数v提供列表，计算 2 阶的 Struve 函数，阶数为 1、2 和 3。
>>> struve([1, 2, 3], 2.)
array([0.64676373, 0.28031806, 0.08363767])
通过为x提供数组，计算多个点处阶数为 1 的 Struve 函数。
>>> points = np.array([2., 5., 8.])
>>> struve(1, points)
array([0.64676373, 0.80781195, 0.48811605])
通过为v和z提供广播到正确形状的数组，计算多个点处多个阶数的 Struve 函数。
>>> orders = np.array([[1], [2], [3]])
>>> points.shape, orders.shape
((3,), (3, 1))
>>> struve(orders, points)
array([[0.64676373, 0.80781195, 0.48811605],
[0.28031806, 1.56937455, 1.51769363],
[0.08363767, 1.50872065, 2.98697513]])
绘制从-10 到 10 的 0 到 3 阶 Struve 函数。
>>> fig, ax = plt.subplots()
>>> x = np.linspace(-10., 10., 1000)
>>> for i in range(4):
... ax.plot(x, struve(i, x), label=f'$H_{i!r}$')
>>> ax.legend(ncol=2)
>>> ax.set_xlim(-10, 10)
>>> ax.set_title(r"Struve functions $H_{\nu}$")
>>> plt.show()
scipy.special.modstruve
scipy.special.modstruve(v, x, out=None) = <ufunc 'modstruve'>
修改 Struve 函数。
返回顺序 v 处 x 处修改 Struve 函数的值。修改 Struve 函数定义为，
[L_v(x) = -\imath \exp(-\pi\imath v/2) H_v(\imath x),]
其中 (H_v) 是 Struve 函数。
参数：
v array_like
修改 Struve 函数的顺序（float）。
x array_like
Struve 函数的参数（float；必须为正，除非 v 是整数）。
out ndarray，可选
函数结果的可选输出数组
返回：
L scalar 或 ndarray
顺序 v 处 x 处修改 Struve 函数的值。
参见
struve
注意事项
在 [1] 中讨论了三种方法来评估函数：
-
幂级数
-
在 Bessel 函数的展开（如果 (|x| < |v| + 20)）
-
渐近大 x 展开（如果 (x \geq 0.7v + 12)）
根据总和中的最大项估计舍入误差，并返回与最小误差相关的结果。
参考资料
[1]
NIST 数字数学函数库 dlmf.nist.gov/11
示例
计算顺序为 1 的修改 Struve 函数在 2 处的值。
>>> import numpy as np
>>> from scipy.special import modstruve
>>> import matplotlib.pyplot as plt
>>> modstruve(1, 2.)
1.102759787367716
通过提供顺序参数 v 的列表，在 2 处计算顺序为 1、2 和 3 的修改 Struve 函数。
>>> modstruve([1, 2, 3], 2.)
array([1.10275979, 0.41026079, 0.11247294])
通过提供一个 x 的数组，计算几个点的一阶修改 Struve 函数。
>>> points = np.array([2., 5., 8.])
>>> modstruve(1, points)
array([ 1.10275979, 23.72821578, 399.24709139])
通过提供 v 和 z 的数组，在几个点上计算几个顺序的修改 Struve 函数。这些数组必须能够广播到正确的形状。
>>> orders = np.array([[1], [2], [3]])
>>> points.shape, orders.shape
((3,), (3, 1))
>>> modstruve(orders, points)
array([[1.10275979e+00, 2.37282158e+01, 3.99247091e+02],
[4.10260789e-01, 1.65535979e+01, 3.25973609e+02],
[1.12472937e-01, 9.42430454e+00, 2.33544042e+02]])
绘制从 -5 到 5 的顺序为 0 到 3 的修改 Struve 函数。
>>> fig, ax = plt.subplots()
>>> x = np.linspace(-5., 5., 1000)
>>> for i in range(4):
... ax.plot(x, modstruve(i, x), label=f'$L_{i!r}$')
>>> ax.legend(ncol=2)
>>> ax.set_xlim(-5, 5)
>>> ax.set_title(r"Modified Struve functions $L_{\nu}$")
>>> plt.show()
scipy.special.itstruve0
scipy.special.itstruve0(x, out=None) = <ufunc 'itstruve0'>
零阶斯特鲁夫函数的积分。
[I = \int_0^x H_0(t),dt]
参数：
xarray_like
积分上限（浮点数）。
outndarray，可选
函数值的可选输出数组
返回：
I标量或 ndarray
从 0 到x的[H_0]的积分。
另请参见
由此函数积分的函数。
注：
由张善杰和金建明创建的 Fortran 例程的包装器[1]。
参考文献
[1]
Zhang, Shanjie and Jin, Jianming. “Computation of Special Functions”, John Wiley and Sons, 1996. people.sc.fsu.edu/~jburkardt/f_src/special_functions/special_functions.html
示例
在一个点上评估函数。
>>> import numpy as np
>>> from scipy.special import itstruve0
>>> itstruve0(1.)
0.30109042670805547
通过为x提供一个数组，在多个点上评估函数。
>>> points = np.array([1., 2., 3.5])
>>> itstruve0(points)
array([0.30109043, 1.01870116, 1.96804581])
绘制从-20 到 20 的函数。
>>> import matplotlib.pyplot as plt
>>> x = np.linspace(-20., 20., 1000)
>>> istruve0_values = itstruve0(x)
>>> fig, ax = plt.subplots()
>>> ax.plot(x, istruve0_values)
>>> ax.set_xlabel(r'$x$')
>>> ax.set_ylabel(r'$\int_0^{x}H_0(t)\,dt$')
>>> plt.show()
scipy.special.it2struve0
scipy.special.it2struve0(x, out=None) = <ufunc 'it2struve0'>
与 0 阶斯特鲁夫函数相关的积分。
返回积分，
[\int_x^\infty \frac{H_0(t)}{t},dt]
其中(H_0)是 0 阶斯特鲁夫函数。
参数：
xarray_like
积分的下限。
out ndarray，可选
函数值的可选输出数组
返回：
I标量或 ndarray
积分的值。
另请参阅
struve
注意
由张善杰和金建明创建的 Fortran 例程的包装器 [1]。
参考文献
[1]
张善杰和金建明，《特殊函数的计算》，John Wiley and Sons 出版，1996 年。people.sc.fsu.edu/~jburkardt/f_src/special_functions/special_functions.html
示例
在一个点上评估函数。
>>> import numpy as np
>>> from scipy.special import it2struve0
>>> it2struve0(1.)
0.9571973506383524
通过为x提供数组，在多个点上评估函数。
>>> points = np.array([1., 2., 3.5])
>>> it2struve0(points)
array([0.95719735, 0.46909296, 0.10366042])
绘制从-10 到 10 的函数。
>>> import matplotlib.pyplot as plt
>>> x = np.linspace(-10., 10., 1000)
>>> it2struve0_values = it2struve0(x)
>>> fig, ax = plt.subplots()
>>> ax.plot(x, it2struve0_values)
>>> ax.set_xlabel(r'$x$')
>>> ax.set_ylabel(r'$\int_x^{\infty}\frac{H_0(t)}{t}\,dt$')
>>> plt.show()
scipy.special.itmodstruve0
scipy.special.itmodstruve0(x, out=None) = <ufunc 'itmodstruve0'>
阶数为 0 的修改 Struve 函数的积分。
[I = \int_0^x L_0(t),dt]
参数：
xarray_like
积分的上限（浮点数）。
outndarray, 可选
函数值的可选输出数组
返回：
I标量或 ndarray
从 0 到 x 的[L_0]的积分。
参见
modstruve
通过此函数进行积分的修改 Struve 函数
注意事项
由张善杰和金建明创建的 Fortran 例程的包装器[1]。
参考文献
[1]
Zhang, Shanjie 和 Jin, Jianming. “Special Functions 的计算”, John Wiley and Sons, 1996. people.sc.fsu.edu/~jburkardt/f_src/special_functions/special_functions.html
示例
在一个点上评估函数。
>>> import numpy as np
>>> from scipy.special import itmodstruve0
>>> itmodstruve0(1.)
0.3364726286440384
通过为x提供数组，在几个点上评估函数。
>>> points = np.array([1., 2., 3.5])
>>> itmodstruve0(points)
array([0.33647263, 1.588285 , 7.60382578])
绘制从 -10 到 10 的函数。
>>> import matplotlib.pyplot as plt
>>> x = np.linspace(-10., 10., 1000)
>>> itmodstruve0_values = itmodstruve0(x)
>>> fig, ax = plt.subplots()
>>> ax.plot(x, itmodstruve0_values)
>>> ax.set_xlabel(r'$x$')
>>> ax.set_ylabel(r'$\int_0^xL_0(t)\,dt$')
>>> plt.show()
scipy.special.bdtr
原文：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.bdtr.html#scipy.special.bdtr
scipy.special.bdtr(k, n, p, out=None) = <ufunc 'bdtr'>
二项分布累积分布函数。
二项概率密度的前 floor(k) 项的和。
[\mathrm{bdtr}(k, n, p) = \sum_{j=0}^{\lfloor k \rfloor} {{n}\choose{j}} p^j (1-p)^{n-j}]
参数：
k array_like
成功数量（双精度），四舍五入到最接近的整数。
n array_like
事件数量（整数）。
p array_like
单次事件成功的概率（浮点数）。
out ndarray，可选
函数值的可选输出数组。
返回：
y 标量或 ndarray。
n 个独立事件中 floor(k) 或更少成功的概率，成功概率为 p。
注意
项没有直接求和；而是根据以下公式使用正则化不完全贝塔函数，
[\mathrm{bdtr}(k, n, p) = I_{1 - p}(n - \lfloor k \rfloor, \lfloor k \rfloor + 1).]
Cephes 的包装器 [1] 例程 bdtr。
参考文献
[1]
Cephes 数学函数库，www.netlib.org/cephes/
scipy.special.bdtrc
原文：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.bdtrc.html#scipy.special.bdtrc
scipy.special.bdtrc(k, n, p, out=None) = <ufunc 'bdtrc'>
二项分布的生存函数。
floor(k) + 1 到 n 的二项概率密度的项之和，
[\mathrm{bdtrc}(k, n, p) = \sum_{j=\lfloor k \rfloor +1}^n {{n}\choose{j}} p^j (1-p)^{n-j}]
参数：
k array_like
成功次数（double），向下舍入到最近的整数。
n array_like
事件数量（int）
p array_like
单个事件成功的概率。
out ndarray，可选
函数值的可选输出数组
返回：
y 标量或 ndarray
在成功概率为 p 的 n 个独立事件中，floor(k) + 1 或更多次成功的概率。
另请参见
bdtr
betainc
注释
这些项不直接求和；而是根据以下公式使用正则化不完全贝塔函数，
[\mathrm{bdtrc}(k, n, p) = I_{p}(\lfloor k \rfloor + 1, n - \lfloor k \rfloor).]
Cephes [1] 程序的包装器 bdtrc。
参考文献
[1]
Cephes 数学函数库，www.netlib.org/cephes/
scipy.special.bdtri
原文：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.bdtri.html#scipy.special.bdtri
scipy.special.bdtri(k, n, y, out=None) = <ufunc 'bdtri'>
关于 p 的bdtr的逆函数。
找到事件概率 p，使得二项概率密度的 0 到 k 项之和等于给定的累积概率 y。
参数：
k数组样式
成功次数（浮点数），向下舍入到最接近的整数。
n数组样式
事件数（浮点数）
y数组样式
累积概率（n 次事件中至多 k 次成功的概率）。
out ndarray，可选
作为函数值的可选输出数组。
返回：
p标量或者数组样式
事件概率，使得 bdtr(lfloor k rfloor, n, p) = y。
另请参见
注释
使用逆贝塔积分函数和关系进行计算，：
1 - p = betaincinv(n - k, k + 1, y).
Cephes 的包装器[1]例程bdtri。
参考文献
[1]
Cephes 数学函数库，www.netlib.org/cephes/
scipy.special.bdtr
原文链接：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.bdtr.html#scipy.special.bdtr
scipy.special.bdtr(k, n, p, out=None) = <ufunc 'bdtr'>
二项分布累积分布函数。
二项概率密度的项 0 到*floor(k)*的总和。
[\mathrm{bdtr}(k, n, p) = \sum_{j=0}^{\lfloor k \rfloor} {{n}\choose{j}} p^j (1-p)^{n-j}]
参数：
k 数组样式
成功次数（双），四舍五入到最接近的整数。
n 数组样式
事件数量（整数）。
p数组样式
单次事件成功的概率（浮点数）。
out ndarray，可选
该函数值的可选输出数组
返回：
y 标量或 ndarray
概率floor(k)或更少成功在n独立事件中，成功概率为p。
注释
项并不直接求和；而是根据公式使用正则化不完全贝塔函数，
[\mathrm{bdtr}(k, n, p) = I_{1 - p}(n - \lfloor k \rfloor, \lfloor k \rfloor + 1).]
Cephes 的包装器[1]例程 bdtr.
参考文献
[1]
Cephes 数学函数库，www.netlib.org/cephes/
scipy.special.bdtrik
原文链接：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.bdtrik.html#scipy.special.bdtrik
scipy.special.bdtrik(y, n, p, out=None) = <ufunc 'bdtrik'>
bdtr 关于 k 的反函数。
找到成功次数 k，使得二项概率密度函数对 n 个事件、成功概率 p 的前 k 项之和等于给定的累积概率 y。
参数：
y array_like
累积概率（在 n 次事件中成功 k 次或更少的概率）。
n array_like
事件数（浮点数）。
p array_like
成功概率（浮点数）。
out ndarray，可选
可选的输出数组的函数值
返回：
k 标量或者 ndarray
成功次数 k 满足 bdtr(k, n, p) = y。
参见
bdtr 的反函数。
注意事项
公式 26.5.24 of [1] 用于将二项分布简化为累积不完全贝塔分布。
计算 k 包括搜索能够产生期望的 y 值的数值。搜索依赖于 y 随 k 的单调性。
封装了 CDFLIB [2] Fortran 程序 cdfbin。
参考文献
[1]
Milton Abramowitz 和 Irene A. Stegun 编辑。Handbook of Mathematical Functions with Formulas, Graphs, and Mathematical Tables. New York: Dover, 1972.
[2]
Barry Brown, James Lovato, 和 Kathy Russell, CDFLIB: Library of Fortran Routines for Cumulative Distribution Functions, Inverses, and Other Parameters.
scipy.special.bdtr
原文：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.bdtr.html#scipy.special.bdtr
scipy.special.bdtr(k, n, p, out=None) = <ufunc 'bdtr'>
二项分布累积分布函数。
0 到 floor(k) 项的二项概率密度之和。
[\mathrm{bdtr}(k, n, p) = \sum_{j=0}^{\lfloor k \rfloor} {{n}\choose{j}} p^j (1-p)^{n-j}]
参数：
karray_like
成功次数（double），向下取整到最接近的整数。
narray_like
事件数（int）。
parray_like
单次事件成功的概率（float）。
outndarray，可选
函数值的可选输出数组
返回：
y标量或 ndarray
floor(k) 或更少成功的概率，n 个独立事件中的成功概率。
注意事项
这些术语不直接求和；而是根据以下公式使用了正则化的不完全贝塔函数，
[\mathrm{bdtr}(k, n, p) = I_{1 - p}(n - \lfloor k \rfloor, \lfloor k \rfloor + 1).]
Cephes 的封装函数 [1] bdtr。
参考文献
[1]
Cephes 数学函数库，www.netlib.org/cephes/
scipy.special.bdtrin
原文链接：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.bdtrin.html#scipy.special.bdtrin
scipy.special.bdtrin(k, y, p, out=None) = <ufunc 'bdtrin'>
关于 n 的 bdtr 的逆函数。
查找事件数量 n，使得二项概率密度函数中第 0 到 k 项的和对应于给定的累积概率 y。
参数：
karray_like
成功次数（浮点数）。
yarray_like
累积概率（在 n 次事件中成功次数不超过 k 的概率）。
parray_like
成功概率（浮点数）。
outndarray，可选
函数值的可选输出数组
返回：
n标量或者 ndarray
事件数量 n，使得 bdtr(k, n, p) = y。
参见
bdtr
注意事项
公式 26.5.24 of [1] 用于将二项分布简化为累积不完全贝塔分布。
计算 n 包括寻找一个值，该值产生所需的 y 值。搜索依赖于 y 随 n 的单调性。
CDFLIB 的包装器 [2] Fortran 例程 cdfbin。
参考文献
[1]
Milton Abramowitz 和 Irene A. Stegun 编，数学函数手册，带有公式、图表和数学表。纽约：Dover，1972。
[2]
Barry Brown，James Lovato 和 Kathy Russell，CDFLIB：Fortran 库例程，用于累积分布函数、逆函数和其他参数。
scipy.special.bdtr
原文链接：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.bdtr.html#scipy.special.bdtr
scipy.special.bdtr(k, n, p, out=None) = <ufunc 'bdtr'>
二项分布累积分布函数。
二项概率密度从 0 到 k 范围内的术语的总和。
[\mathrm{bdtr}(k, n, p) = \sum_{j=0}^{\lfloor k \rfloor} {{n}\choose{j}} p^j (1-p)^{n-j}]
参数：
karray_like
成功次数（双精度），四舍五入到最接近的整数。
narray_like
事件数量（整数）。
parray_like
单个事件中成功的概率（浮点数）。
outndarray，可选
函数值的可选输出数组
返回：
y标量或 ndarray
k 或更少独立事件中成功的概率，有 n 个事件。
注释
不直接求和术语；而是根据以下公式使用正则化不完全贝塔函数，
[\mathrm{bdtr}(k, n, p) = I_{1 - p}(n - \lfloor k \rfloor, \lfloor k \rfloor + 1).]
Cephes 的包装器 [1] 过程 bdtr。
参考文献
[1]
Cephes 数学函数库，www.netlib.org/cephes/
