SciPy-1-12-中文文档-二十-
SciPy 1.12 中文文档（二十）
scipy.special.eval_sh_chebyu
scipy.special.eval_sh_chebyu(n, x, out=None) = <ufunc 'eval_sh_chebyu'>
在某一点评估第二类移位切比雪夫多项式。
这些多项式定义为
[U_n^*(x) = U_n(2x - 1)]
其中(U_n)是第一类切比雪夫多项式。详见[AS]中的 22.5.15。
参数：
n类似数组
多项式的次数。如果不是整数，则通过与eval_chebyu的关系确定结果。
x类似数组
评估移位切比雪夫多项式的点
out数组，可选
函数值的可选输出数组
返回：
U标量或类似数组
移位切比雪夫多项式的值
另请参阅
roots_sh_chebyu
第二类移位切比雪夫多项式的根和积分权重
sh_chebyu
移位切比雪夫多项式对象
eval_chebyu
评估第二类切比雪夫多项式
参考文献
[AS]
米尔顿·阿布拉莫维奇和艾琳·A·斯特根，编。《数学函数手册：公式、图表和数学表》。纽约：多佛尔，1972 年。
scipy.special.eval_sh_jacobi
scipy.special.eval_sh_jacobi(n, p, q, x, out=None) = <ufunc 'eval_sh_jacobi'>
在某一点评估偏移雅各比多项式。
由...定义
[G_n^{(p, q)}(x) = \binom{2n + p - 1}{n}^{-1} P_n^{(p - q, q - 1)}(2x - 1),]
其中(P_n^{(\cdot, \cdot)})是第 n 个雅各比多项式。有关详细信息，请参见[AS]的 22.5.2 节。
参数：
n整数
多项式的次数。如果不是整数，则通过与binom和eval_jacobi的关系确定结果。
p浮点数
参数
q浮点数
参数
outndarray，可选
函数值的可选输出数组
返回：
G标量或 ndarray
偏移雅各比多项式的值。
另请参见
roots_sh_jacobi
偏移雅各比多项式的根和积分权重
sh_jacobi
偏移雅各比多项式对象
eval_jacobi
评估雅各比多项式
参考文献
[AS]
米尔顿·阿布拉莫维茨和艾琳·A·斯特根，编。《数学函数手册：公式、图表和数学表格》。纽约：多佛尔出版社，1972 年。
scipy.special.roots_legendre
scipy.special.roots_legendre(n, mu=False)
高斯-勒让德积分。
计算高斯-勒让德积分的样本点和权重[GL]。样本点是第 n 次 Legendre 多项式(P_n(x))的根。这些样本点和权重能够正确地在区间([-1, 1])上用权函数(w(x) = 1)积分次数小于等于(2n - 1)的多项式。有关更多详细信息，请参见[AS]中的 2.2.10。
参数：
nint
积分阶数
mubool, optional
如果为 True，则返回权重的总和，可选。
返回结果：
xndarray
样本点
wndarray
权重
mufloat
权重的总和。
另请参阅
scipy.integrate.quadrature
scipy.integrate.fixed_quad
numpy.polynomial.legendre.leggauss
参考文献
[AS]
Milton Abramowitz 和 Irene A. Stegun，主编。数学函数手册，公式，图表和数学表格。纽约：多佛尔出版社，1972 年。
[GL] (1,2)
高斯-勒让德积分，维基百科，en.wikipedia.org/wiki/Gauss%E2%80%93Legendre_quadrature
示例
>>> import numpy as np
>>> from scipy.special import roots_legendre, eval_legendre
>>> roots, weights = roots_legendre(9)
roots保存根，而weights保存高斯-勒让德积分的权重。
>>> roots
array([-0.96816024, -0.83603111, -0.61337143, -0.32425342, 0\. ,
0.32425342, 0.61337143, 0.83603111, 0.96816024])
>>> weights
array([0.08127439, 0.18064816, 0.2606107 , 0.31234708, 0.33023936,
0.31234708, 0.2606107 , 0.18064816, 0.08127439])
验证我们通过评估roots处的第 9 次 Legendre 多项式来获得根。所有值都近似为零：
>>> eval_legendre(9, roots)
array([-8.88178420e-16, -2.22044605e-16, 1.11022302e-16, 1.11022302e-16,
0.00000000e+00, -5.55111512e-17, -1.94289029e-16, 1.38777878e-16,
-8.32667268e-17])
在这里，我们将展示如何使用上述值来估算使用高斯-勒让德积分从 1 到 2 的积分的方法 f(t) = t + 1/t [GL]。首先定义函数和积分限制。
>>> def f(t):
... return t + 1/t
...
>>> a = 1
>>> b = 2
我们将使用integral(f(t), t=a, t=b)来表示从 t=a 到 t=b 的函数 f 的定积分。roots中的样本点来自区间[-1, 1]，因此我们将通过简单的变量更改重新编写积分：
x = 2/(b - a) * t - (a + b)/(b - a)
带逆：
t = (b - a)/2 * x + (a + 2)/2
然后：
integral(f(t), a, b) =
(b - a)/2 * integral(f((b-a)/2*x + (a+b)/2), x=-1, x=1)
我们可以用roots_legendre返回的值来近似后一个积分。
将上述计算得到的根从[-1, 1]映射到[a, b]。
>>> t = (b - a)/2 * roots + (a + b)/2
将积分近似为函数值的加权和。
>>> (b - a)/2 * f(t).dot(weights)
2.1931471805599276
将其与精确结果进行比较，即 3/2 + log(2)：
>>> 1.5 + np.log(2)
2.1931471805599454
scipy.special.roots_chebyt
scipy.special.roots_chebyt(n, mu=False)
Gauss-Chebyshev（第一类）积分法。
用于计算 Gauss-Chebyshev 积分法的样本点和权重。样本点是第一类 n 次切比雪夫多项式 (T_n(x)) 的根。这些样本点和权重可以正确地在区间 ([-1, 1]) 上以权重函数 (w(x) = 1/\sqrt{1 - x²}) 积分度为 (2n - 1) 或更低的多项式。详见 [AS] 中的 22.2.4。
参数：
nint
积分阶数
mubool，可选
如果为 True，则返回权重的总和，可选。
返回：
xndarray
样本点
wndarray
权重
mufloat
权重的总和
参见
numpy.polynomial.chebyshev.chebgauss
参考文献
[AS]
Milton Abramowitz 和 Irene A. Stegun 编，Handbook of Mathematical Functions with Formulas, Graphs, and Mathematical Tables。纽约：Dover，1972。
scipy.special.roots_chebyu
scipy.special.roots_chebyu(n, mu=False)
Gauss-Chebyshev（第二类）积分。
计算 Gauss-Chebyshev 积分的样本点和权重。这些样本点是第二类第(n)次 Chebyshev 多项式 (U_n(x)) 的根。这些样本点和权重可以正确地在区间 ([-1, 1]) 上对权函数 (w(x) = \sqrt{1 - x²}) 下的不超过 (2n - 1) 阶的多项式进行积分。详细信息请参见[AS]的第 22.2.5 节。
参数:
n整数
积分阶数
mu布尔值，可选项
如果为 True，返回权重之和，可选项。
返回值：
xndarray
样本点
wndarray
权重
mu浮点数
权重之和
参见
scipy.integrate.quadrature
scipy.integrate.fixed_quad
参考文献
[AS]
Milton Abramowitz 和 Irene A. Stegun 编著。Handbook of Mathematical Functions with Formulas, Graphs, and Mathematical Tables. New York: Dover, 1972.
scipy.special.roots_chebyc
scipy.special.roots_chebyc(n, mu=False)
Gauss-Chebyshev（第一类）求积法。
计算 Gauss-Chebyshev 求积的样本点和权重。样本点是第一类第 (n) 阶切比雪夫多项式 (C_n(x)) 的根。这些样本点和权重能正确地积分不超过 (2n - 1) 阶的多项式，区间为 ([-2, 2])，权函数为 (w(x) = 1 / \sqrt{1 - (x/2)²})。更多详情请见《AS》中的第 22.2.6 节（#r7d5a5e4f4911-as）。
参数：
n int
求积次序
mu bool，可选
如果为 True，返回权重的总和，可选。
返回：
x ndarray
样本点
w ndarray
权重
mu float
权重的总和
另请参见
scipy.integrate.quadrature
scipy.integrate.fixed_quad
参考文献
[AS]
Milton Abramowitz 和 Irene A. Stegun 编著。《数学函数手册：公式、图表和数学表》。纽约：多佛出版社，1972 年。
scipy.special.roots_chebys
scipy.special.roots_chebys(n, mu=False)
高斯切比雪夫（第二类）积分。
计算高斯切比雪夫积分的样本点和权重。样本点是第二类第 (n) 度切比雪夫多项式 (S_n(x)) 的根。这些样本点和权重可以正确地在区间 ([-2, 2]) 上积分 (2n - 1) 次及以下的多项式，权重函数为 (w(x) = \sqrt{1 - (x/2)²})。详见 [AS] 的 22.2.7 节。
参数：
nint
积分阶数
mubool，可选
如果为 True，则返回权重的总和，可选。
返回：
xndarray
样本点
wndarray
权重
mufloat
权重总和
另请参阅
scipy.integrate.quadrature
scipy.integrate.fixed_quad
参考文献
[AS]
Milton Abramowitz 和 Irene A. Stegun 编辑的《数学函数、公式、图表及数学表格手册》。纽约：Dover 出版社，1972 年。
scipy.special.roots_jacobi
scipy.special.roots_jacobi(n, alpha, beta, mu=False)
高斯-雅各比积分。
计算高斯-雅各比积分的样本点和权重。样本点为第 n 阶雅各比多项式的根 (P^{\alpha, \beta}_n(x))。这些样本点和权重可以正确地积分次数不超过 (2n - 1) 的多项式，权重函数为 (w(x) = (1 - x)^{\alpha} (1 + x)^{\beta})。详见 [AS] 中的 22.2.1 节。
参数：
nint
积分阶数
alphafloat
alpha 必须 > -1
betafloat
beta 必须 > -1
mubool，可选
如果为 True，则返回权重之和，可选。
返回：
xndarray
样本点
wndarray
权重
mufloat
权重之和
另请参阅
参考文献
[AS]
Milton Abramowitz 和 Irene A. Stegun 编著。《Handbook of Mathematical Functions with Formulas, Graphs, and Mathematical Tables》。纽约：Dover，1972 年。
scipy.special.roots_laguerre
scipy.special.roots_laguerre(n, mu=False)
高斯-拉盖尔积分。
计算高斯-拉盖尔积分的样本点和权重。样本点是第 n 阶拉盖尔多项式 (L_n(x)) 的根。这些样本点和权重可以正确地在权重函数 (w(x) = e^{-x}) 下积分度数小于等于 (2n - 1) 的多项式，积分区间为 ([0, \infty])。详情请参阅《AS》(#r837212c90989-as) 中的 22.2.13。
参数：
nint
积分阶数
mubool，可选
如果为 True，则返回权重的总和，可选。
返回：
xndarray
样本点
wndarray
权重
mufloat
权重的总和
另请参阅
scipy.integrate.quadrature
scipy.integrate.fixed_quad
numpy.polynomial.laguerre.laggauss
参考文献
[AS]
Milton Abramowitz 和 Irene A. Stegun 编，Handbook of Mathematical Functions with Formulas, Graphs, and Mathematical Tables. New York: Dover, 1972.
scipy.special.roots_genlaguerre
scipy.special.roots_genlaguerre(n, alpha, mu=False)
高斯广义拉盖尔积分。
计算高斯广义拉盖尔积分的样本点和权重。样本点是第 n 次广义拉盖尔多项式的根，(L^{\alpha}_n(x))。这些样本点和权重能正确地对小于或等于次数(2n - 1)的多项式在区间([0, \infty])上的积分，权重函数为(w(x) = x^{\alpha} e^{-x})。详情请见[AS]的 22.3.9 节。
参数：
n整数
积分阶数
alpha浮点数
alpha 必须 > -1
mu布尔值，可选
如果为真，则返回权重之和，可选。
返回：
x数组
样本点
w数组
权重
mu浮点数
权重之和
另请参阅
scipy.integrate.quadrature
scipy.integrate.fixed_quad
参考文献
[AS]
米尔顿·阿布拉莫维奇和艾琳·A·斯特根 编著。《数学函数手册：公式、图表和数学表》。纽约：多佛出版社，1972 年。
scipy.special.roots_hermite
scipy.special.roots_hermite(n, mu=False)
Gauss-Hermite（物理学家的）求积。
计算高斯-厄米特求积的样本点和权重。样本点是第 n 次厄米特多项式(H_n(x))的根。这些样本点和权重可以正确地在权函数为(w(x) = e^{-x²})的情况下对小于等于(2n - 1)次多项式在区间([-\infty, \infty])上积分。详情请参见[AS]中的 22.2.14 节。
参数:
n整数
求积阶数
mu布尔型, 可选
如果为真，可选地返回权重的总和。
返回值:
x数组
样本点
w数组
权重
mu浮点型
权重的总和
另请参见
scipy.integrate.quadrature
scipy.integrate.fixed_quad
numpy.polynomial.hermite.hermgauss（在 NumPy v2.0.dev0 中）
roots_hermitenorm
注意事项
对于小的 n（最多 150），使用 Golub-Welsch 算法的修改版本。节点由特征值问题计算，并通过牛顿迭代的一步进行改进。权重由众所周知的解析公式计算。
对于大于 150 的 n，应用一种最佳渐近算法，以数值稳定的方式计算节点和权重。该算法具有线性运行时间，使得对非常大的 n（数千或更多）的计算成为可能。
参考文献
[townsend.trogdon.olver-2014]
Townsend, A. 和 Trogdon, T. 和 Olver, S. (2014) 整个实数线上高斯求积节点和权重的快速计算. arXiv:1410.5286.
[townsend.trogdon.olver-2015]
Townsend, A. 和 Trogdon, T. 和 Olver, S. (2015) 整个实数线上高斯求积节点和权重的快速计算. IMA 数值分析杂志 DOI:10.1093/imanum/drv002.
[AS]
Milton Abramowitz 和 Irene A. Stegun 编辑. Handbook of Mathematical Functions with Formulas, Graphs, and Mathematical Tables. 纽约: Dover, 1972.
scipy.special.roots_hermitenorm
scipy.special.roots_hermitenorm(n, mu=False)
高斯-埃尔米特（统计学家）积分。
计算高斯-埃尔米特积分的样本点和权重。样本点是第 n 次埃尔米特多项式的根，(He_n(x))。这些样本点和权重可以正确地对小于等于(2n - 1)次多项式在区间([-\infty, \infty])上进行积分，权重函数为(w(x) = e^{-x²/2})。更多细节请参见[AS]中的 22.2.15。
参数：
nint
积分阶数
mubool，可选
如果为 True，则返回权重之和，可选。
返回：
xndarray
样本点
wndarray
权重
mufloat
权重之和
另请参阅
scipy.integrate.quadrature
scipy.integrate.fixed_quad
numpy.polynomial.hermite_e.hermegauss
注意事项
对于小的 n 值，最多到 150，使用了 Golub-Welsch 算法的修改版本。节点是从特征值问题中计算出来的，并通过牛顿迭代的一步进行改进。权重是根据众所周知的解析公式计算出来的。
对于大于 150 的 n 值，使用了一种优化的渐近算法，以数值稳定的方式计算节点和权重。该算法具有线性运行时间，使得对于非常大的 n 值（几千或更多）的计算成为可能。
参考资料
[AS]
Milton Abramowitz 和 Irene A. Stegun，编。《带有公式、图表和数学表的数学函数手册》。纽约：多佛出版社，1972 年。
scipy.special.roots_gegenbauer
scipy.special.roots_gegenbauer(n, alpha, mu=False)
Gauss-Gegenbauer 积分。
计算 Gauss-Gegenbauer 积分的样本点和权重。样本点是第 n 阶 Gegenbauer 多项式 (C^{\alpha}_n(x)) 的根。这些样本点和权重可以正确地在区间 ([-1, 1]) 上，使用权重函数 (w(x) = (1 - x²)^{\alpha - 1/2})，积分阶数为 (2n - 1) 或更低。更多详细信息请参见《数学函数手册》第 22.2.3 节 [AS]。
参数：
nint
积分阶数
alphafloat
alpha 必须 > -0.5
mubool，可选
如果为 True，则返回权重的总和，可选。
返回：
xndarray
样本点
wndarray
权重
mufloat
权重的总和
另请参阅
scipy.integrate.quadrature
scipy.integrate.fixed_quad
参考文献
[AS]
Milton Abramowitz 和 Irene A. Stegun 编著。《数学函数手册》。纽约：多佛出版社，1972 年。
scipy.special.roots_sh_legendre
scipy.special.roots_sh_legendre(n, mu=False)
Gauss-Legendre（移位）积分。
计算 Gauss-Legendre 积分的采样点和权重。采样点是第 n 次移位 Legendre 多项式 (P^*_n(x)) 的根。这些采样点和权重能够正确地在区间 ([0, 1]) 上以权重函数 (w(x) = 1.0) 积分度数不超过 (2n - 1) 的多项式。详情请参见 [AS] 中的 2.2.11。
参数：
n整数类型
积分阶数
mu布尔类型，可选
如果为 True，则返回权重的总和，可选。
返回：
x 数组类型
采样点
w 数组类型
权重
mu浮点数类型
权重总和
另请参见
scipy.integrate.quadrature
scipy.integrate.fixed_quad
参考文献
[AS]
密尔顿·阿布拉莫维茨（Milton Abramowitz）和艾琳·A·斯特根（Irene A. Stegun）编著。《数学函数手册：公式、图表和数学表格》。纽约：多佛出版社，1972 年。
scipy.special.roots_sh_chebyt
scipy.special.roots_sh_chebyt(n, mu=False)
高斯切比雪夫（第一类，偏移）积分。
计算高斯切比雪夫积分的样本点和权重。样本点是第一类偏移切比雪夫多项式 (T_n(x)) 的根，其阶数为 (n)。这些样本点和权重能够正确地在区间 ([0, 1]) 上以权重函数 (w(x) = 1/\sqrt{x - x²}) 积分不超过阶数为 (2n - 1) 的多项式。详细内容请参见[AS]中的第 22.2.8 节。
参数：
nint
积分阶数
mubool，可选
如果为 True，返回权重之和，可选。
返回值：
xndarray
样本点
wndarray
权重
mufloat
权重之和
另请参见
scipy.integrate.quadrature
scipy.integrate.fixed_quad
参考文献
[AS]
Milton Abramowitz 和 Irene A. Stegun 编辑。数学函数手册，公式，图表和数学表。纽约：多佛尔出版社，1972 年。
scipy.special.roots_sh_chebyu
scipy.special.roots_sh_chebyu(n, mu=False)
Gauss-Chebyshev（第二类，位移）积分。
计算 Gauss-Chebyshev 积分的样本点和权重。样本点是第 n 阶位移切比雪夫多项式 (U_n(x)) 的根。这些样本点和权重可以正确地积分不超过 (2n - 1) 阶的多项式，权函数为 (w(x) = \sqrt{x - x²})，在区间 ([0, 1]) 内。详见 [AS] 第 22.2.9 节。
Parameters:
nint
积分阶数
mubool, optional
如果为真，返回权重的总和，可选。
Returns:
xndarray
样本点
wndarray
权重
mufloat
权重的总和
See also
scipy.integrate.quadrature
scipy.integrate.fixed_quad
References
[AS]
Milton Abramowitz 和 Irene A. Stegun 编。Handbook of Mathematical Functions with Formulas, Graphs, and Mathematical Tables。New York: Dover, 1972。
scipy.special.roots_sh_jacobi
scipy.special.roots_sh_jacobi(n, p1, q1, mu=False)
高斯-雅各比（移位）积分法。
计算高斯-雅各比（移位）积分法的样本点和权重。样本点是第 n 阶移位雅各比多项式 (G^{p,q}_n(x)) 的根。这些样本点和权重能正确地对 (2n - 1) 阶或以下的多项式在区间 ([0, 1]) 上进行积分，权重函数为 (w(x) = (1 - x)^{p-q} x^{q-1})。详见《AS》第 22.2.2 节的详细说明。
参数：
nint
积分阶数
p1float
（p1 - q1）必须 > -1
q1float
q1 必须 > 0
mubool，可选
如果为 True，返回权重的和，可选。
返回：
xndarray
样本点
wndarray
权重
mufloat
权重的和
另请参阅
scipy.integrate.quadrature
scipy.integrate.fixed_quad
参考文献
[AS]
Milton Abramowitz 和 Irene A. Stegun 编辑。《数学函数手册：公式、图表和数学表》。纽约：Dover，1972 年。
scipy.special.legendre
scipy.special.legendre(n, monic=False)
勒让德多项式。
定义为解决方案
[\frac{d}{dx}\left[(1 - x²)\frac{d}{dx}P_n(x)\right] + n(n + 1)P_n(x) = 0;]
(P_n(x)) 是一个 (n) 次多项式。
参数：
n int
多项式的度。
monic bool，可选
如果 True，将领导系数缩放为 1。默认为 False。
返回：
P orthopoly1d
勒让德多项式。
注意
多项式 (P_n) 在 ([-1, 1]) 上是正交的，权函数为 1。
示例
生成第三阶勒让德多项式 1/2*(5x³ + 0x² - 3x + 0):
>>> from scipy.special import legendre
>>> legendre(3)
poly1d([ 2.5, 0\. , -1.5, 0\. ])
scipy.special.chebyt
原文链接：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.chebyt.html#scipy.special.chebyt
scipy.special.chebyt(n, monic=False)
第一类切比雪夫多项式。
定义为解
[(1 - x²)\frac{d²}{dx²}T_n - x\frac{d}{dx}T_n + n²T_n = 0;]
(T_n) 是一个 (n) 次多项式。
参数：
nint
多项式的次数。
monicbool, 可选
如果 True，将领先系数缩放为 1。默认为 False。
返回：
Torthopoly1d
第一类切比雪夫多项式。
另请参阅
chebyu
第二类切比雪夫多项式。
注释
多项式 (T_n) 在 ([-1, 1]) 上与权重函数 ((1 - x²)^{-1/2}) 正交。
参考文献
[AS]
Milton Abramowitz 和 Irene A. Stegun 编著。Handbook of Mathematical Functions with Formulas, Graphs, and Mathematical Tables. 纽约：Dover，1972。
示例
第一类切比雪夫多项式的阶数 (n) 可以通过特定的 (n \times n) 矩阵的行列式得到。例如，我们可以检查从以下 (3 \times 3) 矩阵的行列式得到的点恰好在 (T_3) 上：
>>> import numpy as np
>>> import matplotlib.pyplot as plt
>>> from scipy.linalg import det
>>> from scipy.special import chebyt
>>> x = np.arange(-1.0, 1.0, 0.01)
>>> fig, ax = plt.subplots()
>>> ax.set_ylim(-2.0, 2.0)
>>> ax.set_title(r'Chebyshev polynomial $T_3$')
>>> ax.plot(x, chebyt(3)(x), label=rf'$T_3$')
>>> for p in np.arange(-1.0, 1.0, 0.1):
... ax.plot(p,
... det(np.array([[p, 1, 0], [1, 2*p, 1], [0, 1, 2*p]])),
... 'rx')
>>> plt.legend(loc='best')
>>> plt.show()
它们也与雅各比多项式 (P_n^{(-0.5, -0.5)}) 有关系：
[P_n^{(-0.5, -0.5)}(x) = \frac{1}{4^n} \binom{2n}{n} T_n(x)]
让我们验证当 (n = 3) 时：
>>> from scipy.special import binom
>>> from scipy.special import jacobi
>>> x = np.arange(-1.0, 1.0, 0.01)
>>> np.allclose(jacobi(3, -0.5, -0.5)(x),
... 1/64 * binom(6, 3) * chebyt(3)(x))
True
我们可以绘制一些值的切比雪夫多项式 (T_n)：
>>> x = np.arange(-1.5, 1.5, 0.01)
>>> fig, ax = plt.subplots()
>>> ax.set_ylim(-4.0, 4.0)
>>> ax.set_title(r'Chebyshev polynomials $T_n$')
>>> for n in np.arange(2,5):
... ax.plot(x, chebyt(n)(x), label=rf'$T_n={n}$')
>>> plt.legend(loc='best')
>>> plt.show()
scipy.special.chebyu
原文：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.chebyu.html#scipy.special.chebyu
scipy.special.chebyu(n, monic=False)
第二类 Chebyshev 多项式。
定义为以下方程的解
[(1 - x²)\frac{d²}{dx²}U_n - 3x\frac{d}{dx}U_n + n(n + 2)U_n = 0;]
(U_n)是一个阶数为(n)的多项式。
参数：
nint
多项式的阶数。
monicbool，可选
如果True，将主导系数标度为 1。默认为False。
返回：
Uorthopoly1d
第二类 Chebyshev 多项式。
另见
chebyt
第一类 Chebyshev 多项式。
注意
多项式(U_n)在([-1, 1])上与权重函数((1 - x²)^{1/2})正交。
参考文献
[AS]
Milton Abramowitz 和 Irene A. Stegun 编著。《数学函数、公式、图表和数学表》手册。纽约：多佛尔，1972 年。
示例
第二类 Chebyshev 多项式的阶数为(n)，可以通过特定的(n \times n)矩阵的行列式来获得。例如，我们可以检查从以下(3 \times 3)矩阵行列式获得的点恰好位于(U_3)上：
>>> import numpy as np
>>> import matplotlib.pyplot as plt
>>> from scipy.linalg import det
>>> from scipy.special import chebyu
>>> x = np.arange(-1.0, 1.0, 0.01)
>>> fig, ax = plt.subplots()
>>> ax.set_ylim(-2.0, 2.0)
>>> ax.set_title(r'Chebyshev polynomial $U_3$')
>>> ax.plot(x, chebyu(3)(x), label=rf'$U_3$')
>>> for p in np.arange(-1.0, 1.0, 0.1):
... ax.plot(p,
... det(np.array([[2*p, 1, 0], [1, 2*p, 1], [0, 1, 2*p]])),
... 'rx')
>>> plt.legend(loc='best')
>>> plt.show()
它们满足递推关系：
[U_{2n-1}(x) = 2 T_n(x)U_{n-1}(x)]
其中(T_n)是第一类 Chebyshev 多项式。让我们验证一下(n = 2)的情况：
>>> from scipy.special import chebyt
>>> x = np.arange(-1.0, 1.0, 0.01)
>>> np.allclose(chebyu(3)(x), 2 * chebyt(2)(x) * chebyu(1)(x))
True
我们可以绘制一些值得注意的 Chebyshev 多项式(U_n)：
>>> x = np.arange(-1.0, 1.0, 0.01)
>>> fig, ax = plt.subplots()
>>> ax.set_ylim(-1.5, 1.5)
>>> ax.set_title(r'Chebyshev polynomials $U_n$')
>>> for n in np.arange(1,5):
... ax.plot(x, chebyu(n)(x), label=rf'$U_n={n}$')
>>> plt.legend(loc='best')
>>> plt.show()
scipy.special.chebyc
原文：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.chebyc.html#scipy.special.chebyc
scipy.special.chebyc(n, monic=False)
在([-2, 2])上的第一类切比雪夫多项式。
定义为 (C_n(x) = 2T_n(x/2))，其中 (T_n) 是第 n 个第一类切比雪夫多项式。
参数：
nint
多项式的次数。
monic布尔值，可选
如果 True，将首项系数缩放为 1。默认为 False。
返回：
Corthopoly1d
在([-2, 2])上的第一类切比雪夫多项式。
参见
chebyt
第一类切比雪夫多项式。
笔记
多项式 (C_n(x)) 在([-2, 2])上按权函数 (1/\sqrt{1 - (x/2)²}) 正交。
参考文献
[1]
Abramowitz 和 Stegun，《数学函数手册》第二十二章。National Bureau of Standards，1972。
scipy.special.chebys
原文链接：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.chebys.html#scipy.special.chebys
scipy.special.chebys(n, monic=False)
第二类切比雪夫多项式在 ([-2, 2]) 上。
定义为 (S_n(x) = U_n(x/2))，其中 (U_n) 是第二类切比雪夫多项式。
参数：
nint
多项式的次数。
monicbool，可选
如果为 True，将首项系数缩放为 1。默认为 False。
返回：
Sorthopoly1d
第二类切比雪夫多项式在 ([-2, 2]) 上。
参见
第二类切比雪夫多项式
注释
多项式 (S_n(x)) 在 ([-2, 2]) 上与权函数 (\sqrt{1 - (x/2)}²) 正交。
参考文献
[1]
Abramowitz 和 Stegun，《数学函数手册》第二十二章。国家标准局，1972 年。
scipy.special.jacobi
原文：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.jacobi.html#scipy.special.jacobi
scipy.special.jacobi(n, alpha, beta, monic=False)
雅各比多项式。
定义为解决方案
[(1 - x²)\frac{d²}{dx²}P_n^{(\alpha, \beta)} + (\beta - \alpha - (\alpha + \beta + 2)x) \frac{d}{dx}P_n^{(\alpha, \beta)} + n(n + \alpha + \beta + 1)P_n^{(\alpha, \beta)} = 0]
对于 (\alpha, \beta > -1)；(P_n^{(\alpha, \beta)}) 是一个次数为 (n) 的多项式。
参数：
nint
多项式的次数。
alphafloat
参数，必须大于 -1。
betafloat
参数，必须大于 -1。
monicbool, optional
如果 True，将领导系数缩放为 1。默认为 False。
返回：
Porthopoly1d
雅各比多项式。
注意事项
对于固定的 (\alpha, \beta)，多项式 (P_n^{(\alpha, \beta)}) 在 ([-1, 1]) 上以权函数 ((1 - x)^\alpha(1 + x)^\beta) 正交。
参考文献
[AS]
Milton Abramowitz 和 Irene A. Stegun 编辑。Handbook of Mathematical Functions with Formulas, Graphs, and Mathematical Tables. New York: Dover, 1972.
示例
雅各比多项式满足递推关系：
[P_n^{(\alpha, \beta-1)}(x) - P_n^{(\alpha-1, \beta)}(x) = P_{n-1}^{(\alpha, \beta)}(x)]
例如，可以验证 (\alpha = \beta = 2) 且 (n = 1) 在区间 ([-1, 1]) 上：
>>> import numpy as np
>>> from scipy.special import jacobi
>>> x = np.arange(-1.0, 1.0, 0.01)
>>> np.allclose(jacobi(0, 2, 2)(x),
... jacobi(1, 2, 1)(x) - jacobi(1, 1, 2)(x))
True
不同 (\alpha) 值下雅各比多项式 (P_5^{(\alpha, -0.5)}) 的绘图：
>>> import matplotlib.pyplot as plt
>>> x = np.arange(-1.0, 1.0, 0.01)
>>> fig, ax = plt.subplots()
>>> ax.set_ylim(-2.0, 2.0)
>>> ax.set_title(r'Jacobi polynomials $P_5^{(\alpha, -0.5)}$')
>>> for alpha in np.arange(0, 4, 1):
... ax.plot(x, jacobi(5, alpha, -0.5)(x), label=rf'$\alpha={alpha}$')
>>> plt.legend(loc='best')
>>> plt.show()
scipy.special.laguerre
scipy.special.laguerre(n, monic=False)
拉盖尔多项式。
定义为以下方程的解：
[x\frac{d²}{dx²}L_n + (1 - x)\frac{d}{dx}L_n + nL_n = 0;]
(L_n) 是一个次数为 (n) 的多项式。
参数：
nint
多项式的次数。
monicbool，可选
如果 True，将主导系数缩放为 1。默认为 False。
返回：
Lorthopoly1d
拉盖尔多项式。
参见
广义（关联）拉盖尔多项式。
注释
多项式 (L_n) 在 ([0, \infty)) 上以权重函数 (e^{-x}) 正交。
参考文献
[AS]
Milton Abramowitz 和 Irene A. Stegun 编辑。Handbook of Mathematical Functions with Formulas, Graphs, and Mathematical Tables. 纽约：Dover, 1972。
示例
拉盖尔多项式 (L_n) 是广义拉盖尔多项式 (L_n^{(\alpha)}) 的特例，其中 (\alpha = 0)。让我们在区间 ([-1, 1]) 上验证它：
>>> import numpy as np
>>> from scipy.special import genlaguerre
>>> from scipy.special import laguerre
>>> x = np.arange(-1.0, 1.0, 0.01)
>>> np.allclose(genlaguerre(3, 0)(x), laguerre(3)(x))
True
多项式 (L_n) 还满足递推关系：
[(n + 1)L_{n+1}(x) = (2n +1 -x)L_n(x) - nL_{n-1}(x)]
对于 (n = 3)，在 ([0, 1]) 上可以轻松验证：
>>> x = np.arange(0.0, 1.0, 0.01)
>>> np.allclose(4 * laguerre(4)(x),
... (7 - x) * laguerre(3)(x) - 3 * laguerre(2)(x))
True
这是前几个拉盖尔多项式 (L_n) 的图示：
>>> import matplotlib.pyplot as plt
>>> x = np.arange(-1.0, 5.0, 0.01)
>>> fig, ax = plt.subplots()
>>> ax.set_ylim(-5.0, 5.0)
>>> ax.set_title(r'Laguerre polynomials $L_n$')
>>> for n in np.arange(0, 5):
... ax.plot(x, laguerre(n)(x), label=rf'$L_{n}$')
>>> plt.legend(loc='best')
>>> plt.show()
scipy.special.genlaguerre
scipy.special.genlaguerre(n, alpha, monic=False)
广义（关联）拉盖尔多项式。
定义为以下方程的解
[x\frac{d²}{dx²}L_n^{(\alpha)} + (\alpha + 1 - x)\frac{d}{dx}L_n^{(\alpha)} + nL_n^{(\alpha)} = 0,]
其中 (\alpha > -1)；(L_n^{(\alpha)}) 是一个阶数为 (n) 的多项式。
参数：
nint
多项式的阶数。
alphafloat
参数，必须大于 -1。
monicbool, 可选
如果 True，则将首项系数缩放为 1。默认为 False。
返回：
Lorthopoly1d
广义拉盖尔多项式。
另请参阅
拉盖尔多项式。
松矛超几何函数
注释
对于固定的 (\alpha)，多项式 (L_n^{(\alpha)}) 在 ([0, \infty)) 上具有权重函数 (e{-x}x\alpha) 的正交性。
拉盖尔多项式是 (\alpha = 0) 的特殊情况。
References
[AS]
米尔顿·阿布拉莫维茨和艾琳·A·斯蒂根 编。《数学函数、公式、图表和数学表》。纽约：多佛，1972 年。
示例
广义拉盖尔多项式与松矛超几何函数 ({}_1F_1) 密切相关：
[L_n^{(\alpha)} = \binom{n + \alpha}{n} {}_1F_1(-n, \alpha +1, x)]
例如，对于 (n = \alpha = 3)，可以在区间 ([-1, 1]) 内验证：
>>> import numpy as np
>>> from scipy.special import binom
>>> from scipy.special import genlaguerre
>>> from scipy.special import hyp1f1
>>> x = np.arange(-1.0, 1.0, 0.01)
>>> np.allclose(genlaguerre(3, 3)(x), binom(6, 3) * hyp1f1(-3, 4, x))
True
这是广义拉盖尔多项式 (L_3^{(\alpha)}) 的一些值的绘图：
>>> import matplotlib.pyplot as plt
>>> x = np.arange(-4.0, 12.0, 0.01)
>>> fig, ax = plt.subplots()
>>> ax.set_ylim(-5.0, 10.0)
>>> ax.set_title(r'Generalized Laguerre polynomials $L_3^{\alpha}$')
>>> for alpha in np.arange(0, 5):
... ax.plot(x, genlaguerre(3, alpha)(x), label=rf'$L_3^{(alpha)}$')
>>> plt.legend(loc='best')
>>> plt.show()
scipy.special.hermite
原文链接：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.hermite.html#scipy.special.hermite
scipy.special.hermite(n, monic=False)
物理学家的厄米多项式。
定义为
[H_n(x) = (-1)ne\frac{dn}{dxn}e^{-x²};]
(H_n) 是一个次数为 (n) 的多项式。
参数：
nint
多项式的次数。
monicbool，可选
如果 True，将主导系数缩放为 1。默认为 False。
返回：
Horthopoly1d
厄米多项式。
注释
多项式 (H_n) 在 ((-\infty, \infty)) 上按权函数 (e^{-x²}) 正交。
示例
>>> from scipy import special
>>> import matplotlib.pyplot as plt
>>> import numpy as np
>>> p_monic = special.hermite(3, monic=True)
>>> p_monic
poly1d([ 1\. , 0\. , -1.5, 0\. ])
>>> p_monic(1)
-0.49999999999999983
>>> x = np.linspace(-3, 3, 400)
>>> y = p_monic(x)
>>> plt.plot(x, y)
>>> plt.title("Monic Hermite polynomial of degree 3")
>>> plt.xlabel("x")
>>> plt.ylabel("H_3(x)")
>>> plt.show()
scipy.special.hermitenorm
scipy.special.hermitenorm(n, monic=False)
正交化（概率学家）厄米多项式。
定义为
[He_n(x) = (-1)ne\frac{dn}{dxn}e^{-x²/2};]
(He_n) 是一个次数为 (n) 的多项式。
参数：
n 整型
多项式的次数。
monic 布尔型，可选
如果 True，则将主导系数缩放为 1. 默认值为 False。
返回：
He orthopoly1d
厄米多项式。
注意事项
多项式 (He_n) 在 ((-\infty, \infty)) 范围内与权函数 (e^{-x²/2}) 正交。
scipy.special.gegenbauer
scipy.special.gegenbauer(n, alpha, monic=False)
超球面 (ultraspherical) 多项式。
定义为
[(1 - x²)\frac{d²}{dx²}C_n^{(\alpha)} - (2\alpha + 1)x\frac{d}{dx}C_n^{(\alpha)} + n(n + 2\alpha)C_n^{(\alpha)} = 0]
对于(\alpha > -1/2)；(C_n^{(\alpha)}) 是一个(n)次多项式。
参数：
n整数
多项式的次数。
alpha浮点数
参数，必须大于-0.5。
monic布尔值，可选
如果为True，将主导系数缩放为 1。默认为False。
返回：
Corthopoly1d
超球面多项式。
注意
多项式(C_n^{(\alpha)}) 在([-1,1])上以权函数((1 - x²)^{(\alpha - 1/2)})正交。
例子
>>> import numpy as np
>>> from scipy import special
>>> import matplotlib.pyplot as plt
我们可以使用gegenbauer函数初始化一个变量p作为一个超球面多项式，并在点x = 1处评估。
>>> p = special.gegenbauer(3, 0.5, monic=False)
>>> p
poly1d([ 2.5, 0\. , -1.5, 0\. ])
>>> p(1)
1.0
要在区间((-3, 3))中的各点(x)评估p，只需将数组x传递给p如下：
>>> x = np.linspace(-3, 3, 400)
>>> y = p(x)
我们可以使用matplotlib.pyplot来可视化x, y。
>>> fig, ax = plt.subplots()
>>> ax.plot(x, y)
>>> ax.set_title("Gegenbauer (ultraspherical) polynomial of degree 3")
>>> ax.set_xlabel("x")
>>> ax.set_ylabel("G_3(x)")
>>> plt.show()
scipy.special.sh_legendre
scipy.special.sh_legendre(n, monic=False)
移位 Legendre 多项式。
定义为 (P^*_n(x) = P_n(2x - 1))，其中 (P_n) 是第 n 个 Legendre 多项式。
参数：
nint
多项式的次数。
monic布尔值，可选
如果True，将主导系数缩放为 1。默认为False。
返回：
P orthopoly1d
移位 Legendre 多项式。
注意事项
多项式 (P^*_n) 在区间 ([0, 1]) 上以权重函数 1 正交。
scipy.special.sh_chebyt
scipy.special.sh_chebyt(n, monic=False)
第一类移位 Chebyshev 多项式。
定义为(T^*_n(x) = T_n(2x - 1))，其中(T_n)为第一类 Chebyshev 多项式的第 n 项。
参数：
nint
多项式的次数。
monicbool，可选
如果True，将主导系数缩放为 1。默认为False。
返回：
Torthopoly1d
第一类移位 Chebyshev 多项式。
注意事项
多项式(T^*_n)在区间([0, 1])上以权函数((x - x²)^{-1/2})为正交。
scipy.special.sh_chebyu
scipy.special.sh_chebyu(n, monic=False)
第二类平移切比雪夫多项式。
定义为 (U^*_n(x) = U_n(2x - 1))，其中 (U_n) 是第二类切比雪夫多项式的第 n 个。
参数：
nint
多项式的次数。
monicbool，可选
如果为 True，则将领导系数标准化为 1。默认为 False。
返回值：
Uorthopoly1d
第二类平移切比雪夫多项式。
注意事项
多项式 (U^*_n) 在区间 ([0, 1]) 上是按权函数 ((x - x²)^{1/2}) 正交的。
scipy.special.sh_jacobi
scipy.special.sh_jacobi(n, p, q, monic=False)
移位雅各比多项式。
由...定义
[G_n^{(p, q)}(x) = \binom{2n + p - 1}{n}{-1}P_n(2x - 1),]
其中(P_n^{(\cdot, \cdot)})是第 n 个雅各比多项式。
参数：
n整数
多项式的次数。
p浮点数
参数，必须满足(p > q - 1)。
q浮点数
参数，必须大于 0。
monic布尔型，可选的
如果True，则将主导系数缩放为 1。默认为False。
返回：
Gorthopoly1d
移位雅各比多项式。
笔记
对于固定的(p, q)，多项式(G_n^{(p, q)})在区间([0, 1])上按照权函数((1 - x)^{p - q}x^{q - 1})正交。
scipy.special.hyp2f1
原文：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.hyp2f1.html#scipy.special.hyp2f1
scipy.special.hyp2f1(a, b, c, z, out=None) = <ufunc 'hyp2f1'>
高斯超几何函数 2F1(a, b; c; z)
参数：
a, b, carray_like
参数，应为实值。
zarray_like
参数，实数或复数。
outndarray, optional
函数值的可选输出数组
返回：
hyp2f1标量或 ndarray
高斯超几何函数的值。
另见
hyp0f1
一阶超几何函数。
hyp1f1
库默的（共轭超几何）函数。
注意
这个函数在 (|z| < 1) 时定义为
[\mathrm{hyp2f1}(a, b, c, z) = \sum_{n=0}^\infty \frac{(a)_n (b)_n}{(c)_n}\frac{z^n}{n!},]
并通过解析延拓定义在复平面的其余部分 [1]。这里的 ((\cdot)_n) 是 Pochhammer 符号；参见 poch。当 (n) 是整数时，结果是一个 (n) 次多项式。
复数 z 的实现描述在 [2] 中，除了 z 在以下区域：
[0.9 <= \left|z\right| < 1.1, \left|1 - z\right| >= 0.9, \mathrm{real}(z) >= 0]
其中的实现遵循 [4]。
参考文献
[1]
NIST 数学函数数字图书馆 dlmf.nist.gov/15.2
[2]
- Zhang 和 J.M. Jin，“特殊函数的计算”，Wiley 1996
[3]
Cephes 数学函数库，www.netlib.org/cephes/
[4]
J.L. Lopez 和 N.M. Temme，“高斯超几何函数的新级数展开”，Adv Comput Math 39, 349-365 (2013). doi.org/10.1007/s10444-012-9283-y
示例
>>> import numpy as np
>>> import scipy.special as sc
当 c 是负整数时，它有极点。
>>> sc.hyp2f1(1, 1, -2, 1)
inf
当 a 或 b 是负整数时，它是一个多项式。
>>> a, b, c = -1, 1, 1.5
>>> z = np.linspace(0, 1, 5)
>>> sc.hyp2f1(a, b, c, z)
array([1\. , 0.83333333, 0.66666667, 0.5 , 0.33333333])
>>> 1 + a * b * z / c
array([1\. , 0.83333333, 0.66666667, 0.5 , 0.33333333])
它在 a 和 b 中是对称的。
>>> a = np.linspace(0, 1, 5)
>>> b = np.linspace(0, 1, 5)
>>> sc.hyp2f1(a, b, 1, 0.5)
array([1\. , 1.03997334, 1.1803406 , 1.47074441, 2\. ])
>>> sc.hyp2f1(b, a, 1, 0.5)
array([1\. , 1.03997334, 1.1803406 , 1.47074441, 2\. ])
它包含许多其他函数作为特殊情况。
>>> z = 0.5
>>> sc.hyp2f1(1, 1, 2, z)
1.3862943611198901
>>> -np.log(1 - z) / z
1.3862943611198906
>>> sc.hyp2f1(0.5, 1, 1.5, z**2)
1.098612288668109
>>> np.log((1 + z) / (1 - z)) / (2 * z)
1.0986122886681098
>>> sc.hyp2f1(0.5, 1, 1.5, -z**2)
0.9272952180016117
>>> np.arctan(z) / z
0.9272952180016122
scipy.special.hyp1f1
原文链接：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.hyp1f1.html#scipy.special.hyp1f1
scipy.special.hyp1f1(a, b, x, out=None) = <ufunc 'hyp1f1'>
第一类的超几何函数 1F1。
该级数定义了超几何函数
[{}1F_1(a; b; x) = \sum^\infty \frac{(a)_k}{(b)_k k!} x^k.]
更多详细信息请参见[dlmf]。这里的((\cdot)_k)是 Pochhammer 符号；参见poch。
参数：
a, barray_like
实参数
xarray_like
实数或复数参数
outndarray，可选
函数结果的可选输出数组
返回：
标量或 ndarray
超几何函数的值
另请参阅
另一个超几何函数
收敛的超几何极限函数
高斯超几何函数
参考文献
[dlmf]
NIST 数字数学函数库dlmf.nist.gov/13.2#E2
例子
>>> import numpy as np
>>> import scipy.special as sc
当 x 为零时，它等于一：
>>> sc.hyp1f1(0.5, 0.5, 0)
1.0
当 b 是非正整数时，它是奇异的。
>>> sc.hyp1f1(0.5, -1, 0)
inf
当 a 是非正整数时，它是一个多项式。
>>> a, b, x = -1, 0.5, np.array([1.0, 2.0, 3.0, 4.0])
>>> sc.hyp1f1(a, b, x)
array([-1., -3., -5., -7.])
>>> 1 + (a / b) * x
array([-1., -3., -5., -7.])
当 a = b 时，它缩小为指数函数。
>>> sc.hyp1f1(2, 2, [1, 2, 3, 4])
array([ 2.71828183, 7.3890561 , 20.08553692, 54.59815003])
>>> np.exp([1, 2, 3, 4])
array([ 2.71828183, 7.3890561 , 20.08553692, 54.59815003])
scipy.special.hyperu
原文：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.hyperu.html#scipy.special.hyperu
scipy.special.hyperu(a, b, x, out=None) = <ufunc 'hyperu'>
U 分歧超几何函数
它被定义为方程的解
[x \frac{d²w}{dx²} + (b - x) \frac{dw}{dx} - aw = 0]
满足属性的
[U(a, b, x) \sim x^{-a}]
当(x \to \infty)时。详情请参阅NIST 数字数学函数库。
参数：
a, b数组型
实值参数
x数组型
实值参数
out ndarray, 可选
函数值的可选输出数组
返回：
标量或 ndarray
U的值
参考
[dlmf]
NIST 数字数学函数库 dlmf.nist.gov/13.2#E6
示例
>>> import numpy as np
>>> import scipy.special as sc
它在负x轴上有一个分支切割。
>>> x = np.linspace(-0.1, -10, 5)
>>> sc.hyperu(1, 1, x)
array([nan, nan, nan, nan, nan])
当x趋向于无穷大时，它逼近于零。
>>> x = np.array([1, 10, 100])
>>> sc.hyperu(1, 1, x)
array([0.59634736, 0.09156333, 0.00990194])
它满足库默(Kummer)变换。
>>> a, b, x = 2, 1, 1
>>> sc.hyperu(a, b, x)
0.1926947246463881
>>> x**(1 - b) * sc.hyperu(a - b + 1, 2 - b, x)
0.1926947246463881
scipy.special.hyp0f1
原文链接：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.hyp0f1.html#scipy.special.hyp0f1
scipy.special.hyp0f1(v, z, out=None) = <ufunc 'hyp0f1'>
拉盖尔超几何极限函数 0F1。
参数：
v类似数组
实数值参数
z类似数组
实数或复数值的参数
out数组, 可选项
用于存放函数结果的可选输出数组
返回：
标量或者数组
拉盖尔超几何极限函数
注意事项
此函数定义为：
[0F_1(v, z) = \sum{\infty}\frac{zk}{(v)_k k!}.]
它也是 (_1F_1(q; v; z/q)) 当 (q \to \infty) 时的极限，并且满足微分方程 (f''(z) + vf'(z) = f(z))。详见 [1] 获取更多信息。
参考文献
[1]
Wolfram MathWorld, “拉盖尔超几何极限函数”, mathworld.wolfram.com/ConfluentHypergeometricLimitFunction.html
例子
>>> import numpy as np
>>> import scipy.special as sc
当z为零时它为一。
>>> sc.hyp0f1(1, 0)
1.0
当q趋近无穷时，它是拉盖尔超几何函数的极限。
>>> q = np.array([1, 10, 100, 1000])
>>> v = 1
>>> z = 1
>>> sc.hyp1f1(q, v, z / q)
array([2.71828183, 2.31481985, 2.28303778, 2.27992985])
>>> sc.hyp0f1(v, z)
2.2795853023360673
它与贝塞尔函数相关。
>>> n = 1
>>> x = np.linspace(0, 1, 5)
>>> sc.jv(n, x)
array([0\. , 0.12402598, 0.24226846, 0.3492436 , 0.44005059])
>>> (0.5 * x)**n / sc.factorial(n) * sc.hyp0f1(n + 1, -0.25 * x**2)
array([0\. , 0.12402598, 0.24226846, 0.3492436 , 0.44005059])
scipy.special.pbdv
原文链接：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.pbdv.html#scipy.special.pbdv
scipy.special.pbdv(v, x, out=None) = <ufunc 'pbdv'>
抛物线柱函数 D
返回值 (d, dp)：抛物线柱函数 Dv(x) 的值为 d，其导数 Dv’(x) 的值为 dp。
参数：
v：array_like
实参数
x：array_like
实数参数
out：ndarray，可选
函数结果的可选输出数组
返回：
d：标量或者 ndarray
函数的值
dp：标量或者 ndarray
对于 x 的导数值
scipy.special.pbvv
原文：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.pbvv.html#scipy.special.pbvv
scipy.special.pbvv(v, x, out=None) = <ufunc 'pbvv'>
抛物柱函数 V
返回参数 v 的抛物柱函数 Vv(x) 和其导数 Vv’(x)。
参数：
v类似数组
实数参数
x类似数组
实数参数
out ndarray，可选
用于存放函数结果的可选输出数组
返回：
v标量或者 ndarray
函数值
vp 标量或者 ndarray
对 x 的导数
scipy.special.pbwa
原文：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.pbwa.html#scipy.special.pbwa
scipy.special.pbwa(a, x, out=None) = <ufunc 'pbwa'>
抛物柱函数 W。
该函数是微分方程的一个特解
[y'' + \left(\frac{1}{4}x² - a\right)y = 0,]
完整定义请参见第 12.14 节中的[1]。
参数：
aarray_like
实参数
xarray_like
实参数
outndarray，可选
可选的输出数组，用于存放函数结果
返回：
w标量或 ndarray
函数的值
wp标量或 ndarray
x 处导数的值
注释
该函数是由张和金的 Fortran 例程封装而成的[2]。该实现仅在|a|, |x| < 5范围内准确，超出此范围将返回 NaN。
引用
[1]
数学函数的数字图书馆, 14.30. dlmf.nist.gov/14.30
[2]
张, 善杰 和 金, 建明. “特殊函数的计算”, 约翰·威利与儿子出版社, 1996. people.sc.fsu.edu/~jburkardt/f_src/special_functions/special_functions.html
scipy.special.pbdv_seq
scipy.special.pbdv_seq(v, x)
抛物型缸函数 Dv(x) 及其导数。
参数：
vfloat
抛物型缸函数的阶数
xfloat
在函数及其导数上评估的数值
返回：
dvndarray
D_vi(x) 的值, 其中 vi=v-int(v), vi=1+v-int(v), …, vi=v.
dpndarray
导数 D_vi’(x), 其中 vi=v-int(v), vi=1+v-int(v), …, vi=v.
参考文献
[1]
张, 善杰 和 金, 建明. “特殊函数的计算”, 约翰·威利和儿子, 1996, 第十三章. people.sc.fsu.edu/~jburkardt/f77_src/special_functions/special_functions.html
scipy.special.pbvv_seq
scipy.special.pbvv_seq(v, x)
抛物线缸函数 Vv(x) 及其导数。
参数：
v浮点数
抛物线缸函数的阶数
x浮点数
在其上评估函数和导数的值
返回：
dv ndarray
V_vi(x) 的值，其中 vi=v-int(v)，vi=1+v-int(v)，…，vi=v。
dp ndarray
导数 V_vi’(x)，其中 vi=v-int(v)，vi=1+v-int(v)，…，vi=v。
参考文献
[1]
张姗杰和金建明。“特殊函数的计算”，约翰·威利与儿子，1996 年，第十三章。people.sc.fsu.edu/~jburkardt/f77_src/special_functions/special_functions.html
scipy.special.pbdn_seq
scipy.special.pbdn_seq(n, z)
抛物柱函数 Dn(z) 及其导数。
参数：
nint
抛物柱函数的阶数
zcomplex
函数和其导数计算所用的值
返回值：
dvndarray
D_i(z) 的值，其中 i=0, …, i=n。
dpndarray
D_i’(z) 的导数，其中 i=0, …, i=n。
参考资料
[1]
张善杰和金建明的《特殊函数的计算》，John Wiley and Sons, 1996 年，第十三章。people.sc.fsu.edu/~jburkardt/f77_src/special_functions/special_functions.html
scipy.special.mathieu_a
scipy.special.mathieu_a(m, q, out=None) = <ufunc 'mathieu_a'>
偶数马修函数的特征值
参数：
marray_like
函数的阶数
qarray_like
函数的参数
outndarray，可选
可选的输出数组，用于函数结果
返回：
标量或者 ndarray
马修方程偶数解 ce_m(z, q) 的特征值。
另见
mathieu_b, mathieu_cem, mathieu_sem
scipy.special.mathieu_b
scipy.special.mathieu_b(m, q, out=None) = <ufunc 'mathieu_b'>
奇数马修函数的特征值
参数：
m：array_like
函数的阶数
q：array_like
函数的参数
out：ndarray，可选
可选的输出数组，用于函数结果
返回：
标量或者 ndarray
数学方程中奇数解se_m(z, q)的特征值。
另请参阅
mathieu_a，mathieu_cem，mathieu_sem
scipy.special.mathieu_even_coef
scipy.special.mathieu_even_coef(m, q)
偶数 Mathieu 和修正 Mathieu 函数的傅立叶系数。
Mathieu 微分方程的偶数解的傅立叶级数形式为
[\mathrm{ce}{2n}(z, q) = \sum^{\infty} A_{(2n)}^{(2k)} \cos 2kz][\mathrm{ce}{2n+1}(z, q) = \sum^{\infty} A_{(2n+1)}^{(2k+1)} \cos (2k+1)z]
此函数返回偶数输入 m=2n 的系数 (A_{(2n)}^{(2k)})，以及奇数输入 m=2n+1 的系数 (A_{(2n+1)}^{(2k+1)})。
参数：
m整数
数学函数的阶数。必须是非负的。
q浮点数 (>=0)
数学函数的参数。必须是非负的。
返回：
Ak ndarray
对应于偶数或奇数 m 的偶数或奇数傅立叶系数。
参考文献
[1]
张善杰和金建明著。“特殊函数的计算”，John Wiley and Sons 出版，1996 年。people.sc.fsu.edu/~jburkardt/f77_src/special_functions/special_functions.html
[2]
NIST 数学函数数字图书馆 dlmf.nist.gov/28.4#i
scipy.special.mathieu_odd_coef
scipy.special.mathieu_odd_coef(m, q)
偶数 Mathieu 和修改后的 Mathieu 函数的傅里叶系数。
Mathieu 微分方程的奇数解的傅里叶级数形式如下：
[\mathrm{se}{2n+1}(z, q) = \sum^{\infty} B_{(2n+1)}^{(2k+1)} \sin (2k+1)z][\mathrm{se}{2n+2}(z, q) = \sum^{\infty} B_{(2n+2)}^{(2k+2)} \sin (2k+2)z]
此函数返回偶数输入 m=2n+2 的系数 (B_{(2n+2)}^{(2k+2)})，以及奇数输入 m=2n+1 的系数 (B_{(2n+1)}^{(2k+1)})。
参数：
mint
Mathieu 函数的阶数。必须是非负数。
qfloat (>=0)
Mathieu 函数的参数。必须是非负数。
返回：
Bkndarray
偶数或奇数 m 对应的傅里叶系数。
参考文献
[1]
Zhang, Shanjie 和 Jin, Jianming. “特殊函数的计算”, John Wiley and Sons, 1996. people.sc.fsu.edu/~jburkardt/f77_src/special_functions/special_functions.html
scipy.special.mathieu_cem
scipy.special.mathieu_cem(m, q, x, out=None) = <ufunc 'mathieu_cem'>
Even Mathieu 函数及其导数
返回阶数为 m，参数为 q 的偶数 Mathieu 函数 ce_m(x, q) 在 x 处（以度数给出）的值。同时返回相对于 x 的导数。
参数：
m：array_like
函数的阶数
q：array_like
函数的参数
x：array_like
函数的参数，以度为单位给出，而非弧度
out：ndarray 或元组，可选
可选的输出数组用于函数结果
返回：
y：标量或者 ndarray
函数的值
yp：标量或者 ndarray
对 x 的导数值
另请参见：
mathieu_a、mathieu_b、mathieu_sem
scipy.special.mathieu_sem
scipy.special.mathieu_sem(m, q, x, out=None) = <ufunc 'mathieu_sem'>
奇数马修函数及其导数
返回阶为 m 和参数 q 的奇数马修函数，评估在 x 上（以度给出）。还返回相对于 x 的导数 se_m(x, q)。
参数：
m array_like
函数的顺序
q array_like
函数的参数
x array_like
函数的自变量，以度给出，不是弧度。
out 的元组 ndarray，可选
函数结果的可选输出数组
返回：
y 标量或 ndarray
函数的值
yp 标量或 ndarray
导数相对于 x 的值
另请参阅
mathieu_a, mathieu_b, mathieu_cem
scipy.special.mathieu_modcem1
scipy.special.mathieu_modcem1(m, q, x, out=None) = <ufunc 'mathieu_modcem1'>
一阶改良马修函数及其导数
计算一阶改良马修函数的偶函数Mc1m(x, q)及其在x处的导数，其中m为阶数，q为参数。
参数：
marray_like
函数的阶数
qarray_like
函数的参数
xarray_like
函数的自变量，以度数给出，非弧度
out元组的 ndarray，可选
函数结果的可选输出数组
返回：
yscalar or ndarray
函数值
ypscalar or ndarray
导数值 vs x
另见
mathieu_modsem1
scipy.special.mathieu_modcem2
scipy.special.mathieu_modcem2(m, q, x, out=None) = <ufunc 'mathieu_modcem2'>
第二类偶修正 Mathieu 函数及其导数
评估第二类偶修正 Mathieu 函数 Mc2m(x, q) 及其在 x（以度给出）处的导数，对于阶数 m 和参数 q。
参数：
m：array_like
函数的阶数
q：array_like
函数的参数
x：array_like
函数的参数，以度给出，非弧度
out：ndarray 的元组，可选
函数结果的可选输出数组
返回值：
y：标量或 ndarray
函数值
yp：标量或 ndarray
对 x 的导数值
另见
mathieu_modsem2
scipy.special.mathieu_modsem1
scipy.special.mathieu_modsem1(m, q, x, out=None) = <ufunc 'mathieu_modsem1'>
一阶奇数修正马修函数及其导数
评估一阶奇数修正马修函数，Ms1m(x, q)，及其在x（以度给出）处的导数，对于阶数m和参数q。
参数：
m类似数组
函数的阶数
q类似数组
函数参数
x类似数组
函数参数，以度给出，非弧度
outndarray 的元组，可选
函数结果的可选输出数组
返回：
y标量或类似数组
函数值
yp标量或类似数组
函数导数值对 x
参见
mathieu_modcem1
scipy.special.mathieu_modsem2
scipy.special.mathieu_modsem2(m, q, x, out=None) = <ufunc 'mathieu_modsem2'>
第二类奇异修正 Mathieu 函数及其导数
对于给定的阶数m和参数q，在x（以度为单位给出）处评估第二类奇异修正 Mathieu 函数 Ms2m(x, q)及其导数。
参数：
m类似数组
函数的阶数
q类似数组
函数的参数
x类似数组
函数的自变量，以度为单位，而非弧度
out的元组，类似数组，可选
函数结果的可选输出数组
返回：
y标量或者数组
函数的值
yp标量或者数组
导数值与x的比较
另请参见
mathieu_modcem2
scipy.special.pro_ang1
scipy.special.pro_ang1(m, n, c, x, out=None) = <ufunc 'pro_ang1'>
第一类长椭球函数及其导数
计算第一类长椭球函数及其在 x 方向上的导数（对于模式参数 m>=0 和 n>=m，椭球参数 c 以及 |x| < 1.0）。
参数：
m：array_like
非负模式参数 m
n：array_like
模式参数 n (>= m)
c：array_like
椭球参数
x：array_like
实数参数（|x| < 1.0）
out：ndarray，可选
可选的输出数组用于存储函数结果
返回：
s：标量或者 ndarray
函数的返回值
sp：标量或者 ndarray
对于 x 的导数值
scipy.special.pro_rad1
scipy.special.pro_rad1(m, n, c, x, out=None) = <ufunc 'pro_rad1'>
长形椭球径向函数及其导数的第一类
计算椭球参数为c，模参数 m>=0 和 n>=m，且|x| < 1.0时的长形椭球径向函数及其导数（相对于x）。
参数：
m数组样式
非负模参数 m
n数组样式
模参数 n（>= m）
c数组样式
椭球参数
x数组样式
实参数 (|x| < 1.0)
outndarray，可选
用于函数结果的可选输出数组
返回：
s标量或 ndarray
函数的值
sp标量或 ndarray
相对于 x 的导数的值
scipy.special.pro_rad2
scipy.special.pro_rad2(m, n, c, x, out=None) = <ufunc 'pro_rad2'>
第二类椭圆球面径向函数及其导数
计算第二类椭圆球面径向函数及其导数（关于 x），对于模参数 m>=0 和 n>=m，椭圆球面参数 c 和 |x| < 1.0。
参数：
m 数组或类似对象
非负模参数 m
n 数组或类似对象
模参数 n (>= m)
c 数组或类似对象
椭圆球面参数
cv 数组或类似对象
特征值
x 数组或类似对象
实参数 (|x| < 1.0)
out ndarray，可选
可选输出数组，用于函数结果
返回：
s 标量或 ndarray
函数的值
sp 标量或 ndarray
导数的值 vs x
scipy.special.obl_ang1
scipy.special.obl_ang1(m, n, c, x, out=None) = <ufunc 'obl_ang1'>
第一类椭球体角函数及其导数
计算第一类椭球体角函数及其关于 x 的导数（对于模参数 m>=0 和 n>=m，椭球体参数 c 和 |x| < 1.0）。
参数：
m 类似数组
模参数 m（非负）
n 类似数组
模参数 n（>= m）
c 类似数组
球形参数
x 类似数组
参数 x（|x| < 1.0）
out ndarray，可选
函数结果的可选输出数组
返回值：
s 标量或 ndarray
函数的值
sp 标量或 ndarray
对于 x 的导数值
另请参阅
obl_ang1_cv
scipy.special.obl_rad1
scipy.special.obl_rad1(m, n, c, x, out=None) = <ufunc 'obl_rad1'>
椭圆体第一类径向函数及其导数
计算模参数 m>=0 和 n>=m，椭圆体参数 c 和 |x| < 1.0 下的椭圆体第一类径向函数及其导数（关于 x）
参数：
m 数组类型
模参数 m（非负）
n 数组类型
模参数 n（>= m）
c 数组类型
椭圆体参数
x 数组类型
参数 x（|x| < 1.0）
out 数组，可选
可选输出数组用于函数结果
返回：
s 标量或者数组类型
函数值
sp 标量或者数组类型
关于 x 的导数值
另请参见
obl_rad1_cv
scipy.special.obl_rad2
scipy.special.obl_rad2(m, n, c, x, out=None) = <ufunc 'obl_rad2'>
第二类椭圆球面径向函数及其导数。
计算第二类椭圆球面径向函数及其对 x 的导数，对于模式参数 m>=0 和 n>=m，椭圆参数 c 和 |x| < 1.0。
参数:
m 数组类型
参数 m（非负）
n 数组类型
参数 n（>= m）
c 数组类型
椭圆参数
x 数组类型
参数 x（|x| < 1.0）
out ndarray，可选
函数结果的可选输出数组
返回值:
s标量或者 ndarray
函数的值
sp 标量或者 ndarray
导数 vs x 的值
参见
obl_rad2_cv
scipy.special.pro_cv
原文：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.pro_cv.html#scipy.special.pro_cv
scipy.special.pro_cv(m, n, c, out=None) = <ufunc 'pro_cv'>
椭圆体函数特征值
计算椭圆体波函数特征值，顺序为 m，n（n≥m），椭圆体参数 c。
参数：
m array_like
非负参数模式 m
n array_like
参数模式 n（≥ m）
c array_like
球形参数
out ndarray，可选
函数结果的可选输出数组
返回：
cv 标量或 ndarray
特征值
scipy.special.obl_cv
原文：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.obl_cv.html#scipy.special.obl_cv
scipy.special.obl_cv(m, n, c, out=None) = <ufunc 'obl_cv'>
椭球体函数特征值
计算椭球体波函数的特征值，阶数为m、n（n>=m），椭球体参数为c。
参数：
marray_like
模式参数 m（非负）
narray_like
模式参数 n（>= m）
carray_like
椭球体参数
outndarray，可选
函数结果的可选输出数组
返回值：
cv标量或 ndarray
特征值
scipy.special.pro_cv_seq
scipy.special.pro_cv_seq(m, n, c)
椭圆体波函数特征值。
计算模式 m 和 n’=m..n 的椭圆体波函数的一系列特征值，以及椭圆体参数 c。
参考文献
[1]
张善杰、金建明著，“特殊函数的计算”，John Wiley and Sons，1996。people.sc.fsu.edu/~jburkardt/f77_src/special_functions/special_functions.html
scipy.special.obl_cv_seq
scipy.special.obl_cv_seq(m, n, c)
椭圆体波函数的特征值。
计算椭圆体波函数的特征值序列，对于模式 m 和 n’=m..n 以及椭圆体参数 c。
参考文献
[1]
张善杰、金建明，“特殊函数的计算”，John Wiley and Sons 出版，1996 年。people.sc.fsu.edu/~jburkardt/f77_src/special_functions/special_functions.html
scipy.special.pro_ang1_cv
scipy.special.pro_ang1_cv(m, n, c, cv, x, out=None) = <ufunc 'pro_ang1_cv'>
长圆体角函数 pro_ang1 用于预计算的特征值
计算长圆体第一类角函数及其导数（相对于 x）的值，对于模参数 m>=0 和 n>=m，球面参数 c 和 |x| < 1.0。需要预先计算的特征值。
参数：
m类似数组
非负模参数 m
n类似数组
模参数 n (>= m)
c类似数组
球面参数
cv类似数组
特征值
x类似数组
实参数 (|x| < 1.0)
outndarray，可选
用于函数结果的可选输出数组
返回：
s标量或 ndarray
函数的值
sp标量或 ndarray
对 x 的导数值
scipy.special.pro_rad1_cv
scipy.special.pro_rad1_cv(m, n, c, cv, x, out=None) = <ufunc 'pro_rad1_cv'>
长椭球径向函数 pro_rad1 的特征值预计算值
计算第一类长椭球径向函数及其在 x 上的导数（对于模式参数 m≥0 和 n≥m，椭球参数 c 和 |x| < 1.0）。需要预先计算特征值。
参数：
m array_like
非负模式参数 m
n array_like
模式参数 n（≥ m）
c array_like
椭球参数
cv array_like
特征值
x array_like
实数参数（|x| < 1.0）
out ndarray，可选
函数结果的可选输出数组
返回值：
s 标量或者 ndarray
函数值
sp 标量或者 ndarray
对 x 的导数值
scipy.special.pro_rad2_cv
scipy.special.pro_rad2_cv(m, n, c, cv, x, out=None) = <ufunc 'pro_rad2_cv'>
预计算特征值的第二类椭圆旋转体径向函数 pro_rad2
计算第二类椭圆旋转体径向函数及其在模式参数 m>=0 和 n>=m、椭圆参数c以及|x| < 1.0（相对于x）的导数。需要预先计算的特征值。
参数：
m类似数组
非负模式参数 m
n类似数组
模式参数 n（>= m）
c类似数组
椭圆参数
cv类似数组
特征值
x类似数组
实参数（|x| < 1.0）
outndarray，可选
函数结果的可选输出数组
返回值：
s标量或 ndarray
函数值
sp标量或 ndarray
对于 x 的导数值
scipy.special.obl_ang1_cv
scipy.special.obl_ang1_cv(m, n, c, cv, x, out=None) = <ufunc 'obl_ang1_cv'>
钝形球面角函数 obl_ang1 对预先计算的特征值的角度
计算钝形球面角函数的第一类及其导数（关于 x），对于模式参数 m>=0 和 n>=m，球体参数 c 和 |x| < 1.0。需要预先计算的特征值。
参数：
m类似数组
模式参数 m (非负)
n类似数组
模式参数 n (>= m)
c类似数组
球体参数
cv类似数组
特征值
x类似数组
参数 x (|x| < 1.0)
out数组，可选
可选的输出数组，用于函数结果
返回：
s标量或者数组
函数值
sp标量或者数组
导数值 vs x
参见
obl_ang1
scipy.special.obl_rad1_cv
scipy.special.obl_rad1_cv(m, n, c, cv, x, out=None) = <ufunc 'obl_rad1_cv'>
预先计算的特征值的椭球体径向函数 obl_rad1
计算第一类椭球体径向函数及其关于x的导数（对于模式参数 m>=0 和 n>=m，椭球参数c和|x| < 1.0）。需要预先计算的特征值。
参数:
marray_like
模式参数 m（非负）
narray_like
模式参数 n (>= m)
carray_like
椭球体参数
cvarray_like
特征值
xarray_like
参数 x (|x| < 1.0)
outndarray，可选
可选的输出数组用于函数结果
返回：
s标量或 ndarray
函数值
sp标量或 ndarray
导数值 vs x
另请参阅
obl_rad1
scipy.special.obl_rad2_cv
scipy.special.obl_rad2_cv(m, n, c, cv, x, out=None) = <ufunc 'obl_rad2_cv'>
预计算特征值的椭球体径向函数 obl_rad2。
计算椭球体径向函数的第二类及其导数（相对于 x），适用于模式参数 m>=0 和 n>=m，椭球体参数 c 和 |x| < 1.0。需要预先计算好的特征值。
参数：
m array_like
模式参数 m (非负)
n array_like
模式参数 n (>= m)
c array_like
椭球体参数
cv array_like
特征值
x array_like
参数 x (|x| < 1.0)
out ndarray, 可选
可选的输出数组用于函数结果。
返回值：
s 标量或者 ndarray
函数值
sp 标量或者 ndarray
导数值 vs x
参见
obl_rad2
scipy.special.kelvin
原文链接：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.kelvin.html#scipy.special.kelvin
scipy.special.kelvin(x, out=None) = <ufunc 'kelvin'>
开尔文函数作为复数
参数：
xarray_like
参数
out ndarray 元组，可选
函数值的可选输出数组
返回值：
Be, Ke, Bep, Kep4-元组，标量或 ndarray
元组（Be, Ke, Bep, Kep）包含复数，表示在x处评估的实部和虚部开尔文函数及其导数。例如，kelvin(x)[0].real = ber x 和 kelvin(x)[0].imag = bei x，ker 和 kei 类似。
scipy.special.kelvin_zeros
scipy.special.kelvin_zeros(nt)
计算所有 Kelvin 函数的 nt 个零点。
返回长度为 nt 的数组元组，包含(ber, bei, ker, kei, ber’, bei’, ker’, kei’)的零点数组。
参考文献
[1]
张善杰、金建明。“特殊函数的计算”，John Wiley and Sons 出版，1996 年。people.sc.fsu.edu/~jburkardt/f77_src/special_functions/special_functions.html
scipy.special.ber
原文：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.ber.html#scipy.special.ber
scipy.special.ber(x, out=None) = <ufunc 'ber'>
凯尔文函数 ber。
定义如下
[\mathrm{ber}(x) = \Re[J_0(x e^{3 \pi i / 4})]]
其中 (J_0) 是零阶第一类贝塞尔函数（见 jv）。详见 [dlmf] 获取更多详情。
参数：
xarray_like
实数参数。
outndarray，可选
函数结果的可选输出数组。
返回：
标量或者 ndarray
凯尔文函数的值。
另请参见
bei
对应的实部
berp
bei 的导数
jv
第一类贝塞尔函数
参考
[dlmf]
NIST, 数字数学函数库, dlmf.nist.gov/10.61
示例
它可以用贝塞尔函数表示。
>>> import numpy as np
>>> import scipy.special as sc
>>> x = np.array([1.0, 2.0, 3.0, 4.0])
>>> sc.jv(0, x * np.exp(3 * np.pi * 1j / 4)).real
array([ 0.98438178, 0.75173418, -0.22138025, -2.56341656])
>>> sc.ber(x)
array([ 0.98438178, 0.75173418, -0.22138025, -2.56341656])
scipy.special.bei
原文：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.bei.html#scipy.special.bei
scipy.special.bei(x, out=None) = <ufunc 'bei'>
函数 bei 的开尔文函数。
定义如下
[\mathrm{bei}(x) = \Im[J_0(x e^{3 \pi i / 4})]]
其中 (J_0) 是第一类零阶贝塞尔函数（参见 jv）。详细信息请参见 [dlmf]。
参数：
xarray_like
实参数。
outndarray，可选
可选的输出数组用于函数的结果。
返回：
标量或者 ndarray
开尔文函数的值。
另请参阅
对应的实部
bei 的导数
第一类贝塞尔函数
参考文献
[dlmf]
NIST, 数学函数数字图书馆, dlmf.nist.gov/10.61
示例
可以用贝塞尔函数表达。
>>> import numpy as np
>>> import scipy.special as sc
>>> x = np.array([1.0, 2.0, 3.0, 4.0])
>>> sc.jv(0, x * np.exp(3 * np.pi * 1j / 4)).imag
array([0.24956604, 0.97229163, 1.93758679, 2.29269032])
>>> sc.bei(x)
array([0.24956604, 0.97229163, 1.93758679, 2.29269032])
scipy.special.berp
原文：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.berp.html#scipy.special.berp
scipy.special.berp(x, out=None) = <ufunc 'berp'>
ber 函数的导数。
参数：
xarray_like
实数参数。
outndarray，可选
函数结果的可选输出数组。
返回值：
标量或者 ndarray
ber 的导数值。
参见
ber
参考文献
[dlmf]
NIST, 数学函数数字图书馆, dlmf.nist.gov/10#PT5
scipy.special.beip
原文链接：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.beip.html#scipy.special.beip
scipy.special.beip(x, out=None) = <ufunc 'beip'>
Kelvin 函数 bei 的导数。
参数：
xarray_like
实数参数。
outndarray，可选
可选的输出数组，用于函数的结果。
返回值：
标量或者 ndarray
bei 的导数的值。
参见
参考资料
[dlmf]
美国国家标准与技术研究院，数学函数数字图书馆，dlmf.nist.gov/10#PT5
scipy.special.ker
原文链接：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.ker.html#scipy.special.ker
scipy.special.ker(x, out=None) = <ufunc 'ker'>
凯尔文函数 ker。
定义如下
[\mathrm{ker}(x) = \Re[K_0(x e^{\pi i / 4})]]
其中 (K_0) 是第二类修正贝塞尔函数（参见kv）。更多详细信息请见[dlmf]。
参数：
xarray_like
实数参数。
outndarray, 可选
函数结果的可选输出数组。
返回值：
标量或者 ndarray
凯尔文函数的值。
另请参阅
kei
相应的虚部
kerp
凯尔函数的导数
kv
第二类修正贝塞尔函数
参考文献
[dlmf]
NIST, 数学函数数字图书馆，dlmf.nist.gov/10.61
示例
可用第二类修正贝塞尔函数表示。
>>> import numpy as np
>>> import scipy.special as sc
>>> x = np.array([1.0, 2.0, 3.0, 4.0])
>>> sc.kv(0, x * np.exp(np.pi * 1j / 4)).real
array([ 0.28670621, -0.04166451, -0.06702923, -0.03617885])
>>> sc.ker(x)
array([ 0.28670621, -0.04166451, -0.06702923, -0.03617885])
scipy.special.kei
原文链接：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.kei.html#scipy.special.kei
scipy.special.kei(x, out=None) = <ufunc 'kei'>
开尔文函数 kei。
定义为
[\mathrm{kei}(x) = \Im[K_0(x e^{\pi i / 4})]]
其中 (K_0) 是第二类修正贝塞尔函数（参见 kv）。有关更多详细信息，请参见[dlmf]。
参数：
xarray_like
实部参数。
outndarray，可选
函数结果的可选输出数组。
返回：
标量或 ndarray
开尔文函数的值。
另见
相应的实部
kei 的导数
第二类修正贝塞尔函数
参考文献
[dlmf]
NIST，数学函数数字图书馆，dlmf.nist.gov/10.61
示例
它可以用第二类修正贝塞尔函数表示。
>>> import numpy as np
>>> import scipy.special as sc
>>> x = np.array([1.0, 2.0, 3.0, 4.0])
>>> sc.kv(0, x * np.exp(np.pi * 1j / 4)).imag
array([-0.49499464, -0.20240007, -0.05112188, 0.0021984 ])
>>> sc.kei(x)
array([-0.49499464, -0.20240007, -0.05112188, 0.0021984 ])
scipy.special.kerp
原文：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.kerp.html#scipy.special.kerp
scipy.special.kerp(x, out=None) = <ufunc 'kerp'>
ker 函数的导数。
参数:
x数组样
实数参数。
out数组, 可选
函数结果的可选输出数组。
返回值:
标量或数组
ker的导数值。
另请参见
ker
参考文献
[dlmf]
美国国家标准技术研究所，数学函数数字图书馆，dlmf.nist.gov/10#PT5
scipy.special.keip
原文：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.keip.html#scipy.special.keip
scipy.special.keip(x, out=None) = <ufunc 'keip'>
Kelvin 函数 kei 的导数。
参数：
x 类似数组
实数参数。
out ndarray，可选
函数结果的可选输出数组。
返回：
标量或者 ndarray
kei 的导数的值。
另见
参考
[dlmf]
NIST，数字数学函数数字库，dlmf.nist.gov/10#PT5
scipy.special.ber_zeros
scipy.special.ber_zeros(nt)
计算 Kelvin 函数 ber 的 nt 个零点。
参数：
ntint
计算的零点数量。必须为正数。
返回值：
ndarray
首 nt 个 Kelvin 函数的零点。
另见
ber
参考文献
[1]
Zhang, Shanjie 和 Jin, Jianming。“特殊函数的计算”，John Wiley and Sons，1996 年。people.sc.fsu.edu/~jburkardt/f77_src/special_functions/special_functions.html
scipy.special.bei_zeros
scipy.special.bei_zeros(nt)
计算 Kelvin 函数bei的 nt 个零点。
参数：
nt int
需要计算的零点数量。必须是正数。
返回：
ndarray
第一 nt 个 Kelvin 函数的零点。
另请参阅
bei
参考文献：
[1]
Zhang, Shanjie 和 Jin, Jianming. “特殊函数的计算”, John Wiley and Sons, 1996. people.sc.fsu.edu/~jburkardt/f77_src/special_functions/special_functions.html
scipy.special.berp_zeros
scipy.special.berp_zeros(nt)
计算 Kelvin 函数 ber 的导数的nt个零点。
参数：
ntint
需要计算的零点数。必须为正数。
返回：
ndarray
第nt个 Kelvin 函数导数的零点。
另见
ber, berp
参考文献
[1]
张, 善杰 和 金, 建明. “特殊函数的计算”, 约翰·威利和儿子, 1996. people.sc.fsu.edu/~jburkardt/f77_src/special_functions/special_functions.html
scipy.special.beip_zeros
scipy.special.beip_zeros(nt)
计算 Kelvin 函数 bei 的导数的 nt 个零点。
参数：
ntint
需要计算的零点数量。必须是正数。
返回：
ndarray
Kelvin 函数导数的前 nt 个零点。
另见
参考文献
[1]
张善杰和金建明。“特殊函数的计算”，John Wiley and Sons，1996。people.sc.fsu.edu/~jburkardt/f77_src/special_functions/special_functions.html
scipy.special.ker_zeros
scipy.special.ker_zeros(nt)
计算 Kelvin 函数 ker 的 nt 个零点。
参数：
ntint
要计算的零点数。必须是正数。
返回结果：
ndarray
Kelvin 函数的前 nt 个零点。
另请参见
ker
参考文献
[1]
Zhang, Shanjie 和 Jin, Jianming. “计算特殊函数”, John Wiley and Sons, 1996. people.sc.fsu.edu/~jburkardt/f77_src/special_functions/special_functions.html
scipy.special.kei_zeros
scipy.special.kei_zeros(nt)
计算开尔文函数 kei 的 nt 个零点。
参数：
ntint
要计算的零点数目。必须是正数。
返回：
ndarray
第一个 nt 个开尔文函数的零点。
参见
kei
参考文献
[1]
Zhang, Shanjie 和 Jin, Jianming. “特殊函数的计算”, John Wiley and Sons, 1996. people.sc.fsu.edu/~jburkardt/f77_src/special_functions/special_functions.html
scipy.special.kerp_zeros
scipy.special.kerp_zeros(nt)
计算 Kelvin 函数 ker 的导数的 nt 个零点。
参数：
ntint
需要计算的零点数量。必须是正数。
返回值：
ndarray
Kelvin 函数导数的前 nt 个零点。
另请参阅
ker, kerp
References
[1]
张栅杰和金建明的著作《特殊函数计算》，John Wiley and Sons, 1996. people.sc.fsu.edu/~jburkardt/f77_src/special_functions/special_functions.html
scipy.special.keip_zeros
scipy.special.keip_zeros(nt)
计算凯尔文函数 kei 导数的 nt 个零点。
参数：
ntint
需要计算的零点数。必须是正数。
返回值：
ndarray
第一个 nt 个凯尔文函数导数的零点。
另见
参考资料
[1]
张善杰，金建明。《特殊函数的计算》，John Wiley and Sons，1996 年。people.sc.fsu.edu/~jburkardt/f77_src/special_functions/special_functions.html
scipy.special.comb
原文：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.comb.html#scipy.special.comb
scipy.special.comb(N, k, *, exact=False, repetition=False, legacy=<object object>)
每次取 N 个事物中 k 个的组合数。
这通常表示为“N 选 k”。
参数：
N整数，ndarray
事物的数量。
k整数，ndarray
取元素的数量。
exact布尔值，可选
对于整数，如果exact为 False，则使用浮点精度，否则结果将精确计算。对于非整数，如果exact为 True，则忽略。
repetition布尔值，可选
如果repetition为 True，则计算带重复的组合数。
legacy布尔值，可选
如果legacy为 True 且exact为 True，则非整数参数被转换为整数；如果legacy为 False，则非整数参数的结果不受exact值影响。
自版本 1.9.0 起已弃用：使用legacy已被弃用，并将在 Scipy 1.14.0 中移除。如果要保留旧版行为，请直接转换输入，例如comb(int(your_N), int(your_k), exact=True)。
返回：
val整数，浮点数，ndarray
组合总数。
参见
binom
二项式系数作为两个实变量的函数。
注意
-
仅在 exact=False 情况下接受数组参数。
-
如果 N < 0 或 k < 0，则返回 0。
-
如果 k > N 且 repetition=False，则返回 0。
示例
>>> import numpy as np
>>> from scipy.special import comb
>>> k = np.array([3, 4])
>>> n = np.array([10, 10])
>>> comb(n, k, exact=False)
array([ 120., 210.])
>>> comb(10, 3, exact=True)
120
>>> comb(10, 3, exact=True, repetition=True)
220
scipy.special.perm
原文链接：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.perm.html#scipy.special.perm
scipy.special.perm(N, k, exact=False)
N 个物品中取 k 个的排列，即 k-permutations of N。
也称为“部分排列”。
参数：
N整数，数组
事物的数量。
k整数，数组
取出元素的数量。
exact布尔值，可选
如果 exact 为 False，则使用浮点数精度计算，否则使用精确的长整数计算。
返回：
val整数，数组
N 个物品中取 k 个的排列数。
注释
-
仅对 exact=False 情况接受数组参数。
-
如果 k > N，N < 0，或者 k < 0，则返回 0。
示例
>>> import numpy as np
>>> from scipy.special import perm
>>> k = np.array([3, 4])
>>> n = np.array([10, 10])
>>> perm(n, k)
array([ 720., 5040.])
>>> perm(10, 3, exact=True)
720
scipy.special.stirling2
scipy.special.stirling2(N, K, *, exact=False)
生成第二类斯特林数。
第二类斯特林数计算如下：将 N 个元素的集合分成 K 个非空子集的方式数量。
此函数返回的值是使用动态规划计算的，可以避免在解决方案的子问题中进行冗余计算。对于类似数组的输入，此实现还避免了在不同斯特林数计算中进行冗余计算。
有时这些数字被表示为
[{N \brace{K}}]
详细信息请参见[1]。通常口语表达为“N 子集 K”。
参数：
Nint，ndarray
东西数量。
Kint，ndarray
采取非空子集的数量。
exactbool，可选
使用动态规划（DP）与浮点数处理较小的数组，并使用 Temme 的二阶近似处理更大的N和K输入，可以在速度和精度之间进行权衡。详细描述请参见[2]。对于n > 50，使用 Temme 近似。DP 的最大相对误差为4.510^-16（n <= 50），Temme 近似的最大相对误差为510^-5（51 <= n < 70）和910^-6（70 <= n < 101）。请注意，随着n*的增加，这些最大相对误差会进一步减小。
返回：
valint，float，ndarray
分区数。
参见
comb
N 件东西中取 k 件的组合数。
注意事项
-
如果 N < 0 或者 K < 0，则返回 0。
-
如果 K > N，则返回 0。
输出类型始终为int或对象的 ndarray。输入必须包含 numpy 或 python 整数，否则会引发 TypeError。
参考文献
R. L. Graham, D. E. Knuth and O. Patashnik, “Concrete Mathematics: A Foundation for Computer Science,” Addison-Wesley Publishing Company, Boston, 1989. 第六章，第 258 页。
[2]
Temme, Nico M. “Stirling numbers 的渐近估计.” 应用数学研究 89.3 (1993): 233-243。
示例
>>> import numpy as np
>>> from scipy.special import stirling2
>>> k = np.array([3, -1, 3])
>>> n = np.array([10, 10, 9])
>>> stirling2(n, k)
array([9330, 0, 3025], dtype=object)
scipy.special.lambertw
scipy.special.lambertw(z, k=0, tol=1e-8)
莱姆伯特 W 函数。
莱姆伯特 W 函数W(z)被定义为w * exp(w)的反函数。换句话说，W(z)的值是这样的，即z = W(z) * exp(W(z))对于任意复数z成立。
莱姆伯特 W 函数是一个具有无限多个分支的多值函数。每个分支给出方程z = w exp(w)的一个单独解。在这里，分支由整数k索引。
参数：
zarray_like
输入参数。
kint，可选
分支索引。
tolfloat，可选
评估容限。
返回：
warray
w将与z具有相同的形状。
另请参阅
wrightomega
莱特Ω函数
注解
所有分支都由lambertw支持：
-
lambertw(z)给出主要解（分支 0） -
lambertw(z, k)在k分支上给出解决方案
莱姆伯特 W 函数有两个部分实数分支：主分支（k = 0）对于实数z > -1/e是实数的，而k = -1分支对于-1/e < z < 0是实数的。除k = 0外的所有分支在z = 0处有对数奇点。
可能问题
评估在接近分支点-1/e时可能变得不精确。在某些极端情况下，lambertw目前可能无法收敛，或者可能进入错误的分支。
算法
使用 Halley 迭代来反转w * exp(w)，使用一阶渐近逼近（O(log(w))或O(w)）作为初始估计。
分支的定义、实现和选择基于[2]。
参考文献
[1]
zh.wikipedia.org/wiki/%E8%8E%B1%E5%A7%86%E8%B4%9D%E5%B0%94%E5%87%BD%E6%95%B0
[2]
Corless 等人，“关于莱姆伯特 W 函数”，Adv. Comp. Math. 5（1996）329-359。cs.uwaterloo.ca/research/tr/1993/03/W.pdf
示例
莱姆伯特 W 函数是w exp(w)的反函数：
>>> import numpy as np
>>> from scipy.special import lambertw
>>> w = lambertw(1)
>>> w
(0.56714329040978384+0j)
>>> w * np.exp(w)
(1.0+0j)
任何分支均给出有效的反函数：
>>> w = lambertw(1, k=3)
>>> w
(-2.8535817554090377+17.113535539412148j)
>>> w*np.exp(w)
(1.0000000000000002+1.609823385706477e-15j)
方程求解应用
莱姆伯特 W 函数可用于解决各种类型的方程。这里我们给出两个例子。
首先，该函数可用于解决形如
(x = a + b e^{c x})
对于(x)。我们假设(c)不为零。经过一点代数，方程可写为
(z e^z = -b c e^{a c})
其中(z = c (a - x))。然后可以使用 Lambert W 函数表达(z)。
(z = W(-b c e^{a c}))
给出
(x = a - W(-b c e^{a c})/c)
例如，
>>> a = 3
>>> b = 2
>>> c = -0.5
解(x = a + b e^{c x})的方程是：
>>> x = a - lambertw(-b*c*np.exp(a*c))/c
>>> x
(3.3707498368978794+0j)
验证它是否解决了方程：
>>> a + b*np.exp(c*x)
(3.37074983689788+0j)
Lambert W 函数也可用于找出无限功率塔 (z{z{z^{\ldots}}}) 的值：
>>> def tower(z, n):
... if n == 0:
... return z
... return z ** tower(z, n-1)
...
>>> tower(0.5, 100)
0.641185744504986
>>> -lambertw(-np.log(0.5)) / np.log(0.5)
(0.64118574450498589+0j)
scipy.special.wrightomega
scipy.special.wrightomega(z, out=None) = <ufunc 'wrightomega'>
Wright Omega 函数。
定义为解满足
[\omega + \log(\omega) = z]
其中 (\log) 是复对数的主分支。
参数：
z数组类似
评估 Wright Omega 函数的点
out ndarray，可选
函数值的可选输出数组
返回值：
omega标量或者 ndarray
Wright Omega 函数的值
参见
lambertw
Lambert W 函数
注释
0.19.0 版本中新增。
函数也可定义为
[\omega(z) = W_{K(z)}(e^z)]
其中 (K(z) = \lceil (\Im(z) - \pi)/(2\pi) \rceil) 是解缠数，(W) 是 Lambert W 函数。
这里的实现取自[1]。
参考文献
[1]
Lawrence, Corless, and Jeffrey, “Algorithm 917: Complex Double-Precision Evaluation of the Wright (\omega) Function.” ACM Transactions on Mathematical Software, 2012. DOI:10.1145/2168773.2168779.
示例
>>> import numpy as np
>>> from scipy.special import wrightomega, lambertw
>>> wrightomega([-2, -1, 0, 1, 2])
array([0.12002824, 0.27846454, 0.56714329, 1\. , 1.5571456 ])
复数输入：
>>> wrightomega(3 + 5j)
(1.5804428632097158+3.8213626783287937j)
验证 wrightomega(z) 满足 w + log(w) = z：
>>> w = -5 + 4j
>>> wrightomega(w + np.log(w))
(-5+4j)
验证与 lambertw 的联系：
>>> z = 0.5 + 3j
>>> wrightomega(z)
(0.0966015889280649+1.4937828458191993j)
>>> lambertw(np.exp(z))
(0.09660158892806493+1.4937828458191993j)
>>> z = 0.5 + 4j
>>> wrightomega(z)
(-0.3362123489037213+2.282986001579032j)
>>> lambertw(np.exp(z), k=1)
(-0.33621234890372115+2.282986001579032j)
scipy.special.agm
原文：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.agm.html#scipy.special.agm
scipy.special.agm(a, b, out=None) = <ufunc 'agm'>
计算a和b的算术-几何平均值。
从 a_0 = a 和 b_0 = b 开始，并迭代计算：
a_{n+1} = (a_n + b_n)/2
b_{n+1} = sqrt(a_n*b_n)
随着 n 的增加，a_n 和 b_n 趋于相同的极限；它们的共同极限是 agm(a, b)。
参数：
a, barray_like
仅适用于实数值。如果值均为负数，则结果为负数。如果一个值为负，另一个值为正，则返回nan。
outndarray，可选
函数值的可选输出数组
返回：
标量或 ndarray
a和b的算术-几何平均值。
示例
>>> import numpy as np
>>> from scipy.special import agm
>>> a, b = 24.0, 6.0
>>> agm(a, b)
13.458171481725614
将该结果与迭代比较：
>>> while a != b:
... a, b = (a + b)/2, np.sqrt(a*b)
... print("a = %19.16f b=%19.16f" % (a, b))
...
a = 15.0000000000000000 b=12.0000000000000000
a = 13.5000000000000000 b=13.4164078649987388
a = 13.4582039324993694 b=13.4581390309909850
a = 13.4581714817451772 b=13.4581714817060547
a = 13.4581714817256159 b=13.4581714817256159
当给定类似数组的参数时，将应用广播机制：
>>> a = np.array([[1.5], [3], [6]]) # a has shape (3, 1).
>>> b = np.array([6, 12, 24, 48]) # b has shape (4,).
>>> agm(a, b)
array([[ 3.36454287, 5.42363427, 9.05798751, 15.53650756],
[ 4.37037309, 6.72908574, 10.84726853, 18.11597502],
[ 6\. , 8.74074619, 13.45817148, 21.69453707]])
scipy.special.bernoulli
scipy.special.bernoulli(n)
伯努利数 B0..Bn（包括）。
参数：
nint
指示要生成伯努利级数中的项数。
返回：
ndarray
伯努利数 [B(0), B(1), ..., B(n)]。
参考文献
[1]
张善杰和金建明，“特殊函数的计算”，约翰·威利和儿子，1996 年。people.sc.fsu.edu/~jburkardt/f77_src/special_functions/special_functions.html
[2]
“伯努利数”，维基百科，en.wikipedia.org/wiki/Bernoulli_number
示例
>>> import numpy as np
>>> from scipy.special import bernoulli, zeta
>>> bernoulli(4)
array([ 1\. , -0.5 , 0.16666667, 0\. , -0.03333333])
维基百科文章（[2]）指出了伯努利数与黎曼 zeta 函数的关系，B_n^+ = -n * zeta(1 - n) 对于 n > 0：
>>> n = np.arange(1, 5)
>>> -n * zeta(1 - n)
array([ 0.5 , 0.16666667, -0\. , -0.03333333])
注意，在维基百科文章中使用的符号中，bernoulli 计算的是 B_n^-（即采用 B_1 = -1/2 的约定）。上述给出的关系式是用于 B_n^+ 的，因此 0.5 的符号与 bernoulli(4) 的输出不匹配。
scipy.special.binom
原文：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.special.binom.html#scipy.special.binom
scipy.special.binom(x, y, out=None) = <ufunc 'binom'>
将二项式系数视为两个实变量的函数。
对于实数参数，二项式系数定义如下：
[\binom{x}{y} = \frac{\Gamma(x + 1)}{\Gamma(y + 1)\Gamma(x - y + 1)} = \frac{1}{(x + 1)\mathrm{B}(x - y + 1, y + 1)}]
其中(\Gamma)是 Gamma 函数（gamma），(\mathrm{B})是 Beta 函数（beta）[1]。
参数：
x, y：array_like
(\binom{x}{y})的实数参数。
out：ndarray，可选
函数值的可选输出数组
返回：
标量或 ndarray
二项式系数的值。
另见：
N 件事物中取 k 件的组合数。
注意事项：
Gamma 函数在非正整数处有极点，并且在实数线上的极点方向决定其趋向于正无穷大或负无穷大。当将(\binom{x}{y})视为两个实变量的函数时，当x为负整数时是未定义的。binom在x为负整数时返回nan。即使当x为负整数且y为整数时，也与通常定义(\binom{n}{k})的约定相反，当其被视为两个整数变量的函数时。
参考文献：
en.wikipedia.org/wiki/Binomial_coefficient
示例：
以下示例说明了binom与函数comb的差异。
>>> from scipy.special import binom, comb
当exact=False且x和y均为正数时，comb在内部调用binom。
>>> x, y = 3, 2
>>> (binom(x, y), comb(x, y), comb(x, y, exact=True))
(3.0, 3.0, 3)
对于较大的值，comb中的exact=True与binom不再一致。
>>> x, y = 43, 23
>>> (binom(x, y), comb(x, y), comb(x, y, exact=True))
(960566918219.9999, 960566918219.9999, 960566918220)
当x为负整数时，binom返回nan，但对于负参数仍然有定义。当x或y为负数或x小于y时，comb返回 0。
>>> x, y = -3, 2
>>> (binom(x, y), comb(x, y), comb(x, y, exact=True))
(nan, 0.0, 0)
>>> x, y = -3.1, 2.2
>>> (binom(x, y), comb(x, y), comb(x, y, exact=True))
(18.714147876804432, 0.0, 0)
>>> x, y = 2.2, 3.1
>>> (binom(x, y), comb(x, y), comb(x, y, exact=True))
(0.037399983365134115, 0.0, 0)
