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

SciPy 1.12 中文文档（十六）

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

scipy.spatial.ConvexHull

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

class scipy.spatial.ConvexHull(points, incremental=False, qhull_options=None)

N 维凸壳。

自版本 0.12.0 新增。

参数：

points：浮点型数组，形状为 (npoints, ndim)

构造凸壳的点的坐标

incremental：布尔值，可选

允许逐步添加新点。这会占用一些额外资源。

qhull_options：字符串，可选

传递给 Qhull 的其他选项。有关详细信息，请参阅 Qhull 手册。（默认值：对于 ndim > 4 为“Qx”，否则为“”）选项“Qt”始终启用。

引发：

QhullError

当 Qhull 遇到错误条件（如几何退化），且未启用解决选项时引发。

ValueError

如果输入的数组不兼容，则引发此错误。

注意

使用Qhull 库计算凸壳。

参考文献

[Qhull]

www.qhull.org/

示例

随机点集的凸壳：

>>> from scipy.spatial import ConvexHull, convex_hull_plot_2d
>>> import numpy as np
>>> rng = np.random.default_rng()
>>> points = rng.random((30, 2))   # 30 random points in 2-D
>>> hull = ConvexHull(points) 

绘制它：

>>> import matplotlib.pyplot as plt
>>> plt.plot(points[:,0], points[:,1], 'o')
>>> for simplex in hull.simplices:
...     plt.plot(points[simplex, 0], points[simplex, 1], 'k-') 

我们也可以直接使用外壳的顶点，对于二维情况保证顺时针排序：

>>> plt.plot(points[hull.vertices,0], points[hull.vertices,1], 'r--', lw=2)
>>> plt.plot(points[hull.vertices[0],0], points[hull.vertices[0],1], 'ro')
>>> plt.show() 

从一个点可见的面片：

创建一个正方形，并在正方形上方添加一个点。

>>> generators = np.array([[0.2, 0.2],
...                        [0.2, 0.4],
...                        [0.4, 0.4],
...                        [0.4, 0.2],
...                        [0.3, 0.6]]) 

使用 QG 选项调用 ConvexHull。QG4 表示计算不包括点 4 的外壳部分，指示从点 4 可见的面片。

>>> hull = ConvexHull(points=generators,
...                   qhull_options='QG4') 

“good”数组指示从点 4 可见的面片。

>>> print(hull.simplices)
 [[1 0]
 [1 2]
 [3 0]
 [3 2]]
>>> print(hull.good)
 [False  True False False] 

现在绘制它，突出显示可见的面片。

>>> fig = plt.figure()
>>> ax = fig.add_subplot(1,1,1)
>>> for visible_facet in hull.simplices[hull.good]:
...     ax.plot(hull.points[visible_facet, 0],
...             hull.points[visible_facet, 1],
...             color='violet',
...             lw=6)
>>> convex_hull_plot_2d(hull, ax=ax)
 <Figure size 640x480 with 1 Axes> # may vary
>>> plt.show() 

属性：

points：双精度浮点型数组，形状为 (npoints, ndim)

输入点的坐标。

vertices：整型数组，形状为 (nvertices,)

形成凸壳顶点的点的索引。对于二维凸壳，顶点按逆时针顺序排列。对于其他维度，按输入顺序排列。

simplices：整型数组，形状为 (nfacet, ndim)

形成凸壳单纯面的点的索引。

neighbors：整型数组，形状为 (nfacet, ndim)

每个面片的相邻面片的索引。第 k 个相邻面片位于第 k 个顶点的对面。-1 表示没有相邻面片。

equations：双精度浮点型数组，形状为 (nfacet, ndim+1)

形成面的超平面方程 [normal, offset]（参见Qhull 文档了解更多）。

coplanar：整型数组，形状为 (ncoplanar, 3)

共面点的索引及其最近面片和最近顶点索引的对应索引。由于数值精度问题，未包括在三角剖分中的输入点 不 被包括在内。

如果未指定选项“Qc”，则不计算此列表。

good：布尔型数组或 None

一个一维布尔数组，指示哪些面是好的。与计算好的面选项一起使用，例如 QGn 和 QG-n。好的面被定义为从点 n 可见（n）或不可见（-n）的面，其中 n 是‘points’中的第 n 个点。‘good’属性可用作‘simplices’的索引，以返回好的（可见）面：simplices[good]。仅从凸包的外部可见一个面，且既不共面也不退化计为可见性的情况。

如果未指定“QGn”或“QG-n”选项，则返回 None。

New in version 1.3.0.

areafloat

输入维度大于 2 时的凸包表面积。当输入points为二维时，这是凸包的周长。

New in version 0.17.0.

volumefloat

输入维度大于 2 时的凸包体积。当输入points为二维时，这是凸包的面积。

New in version 0.17.0.

方法

add_points(points[, restart])	处理一组额外的新点。
close()	结束增量处理。

scipy.spatial.Voronoi

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.spatial.Voronoi.html#scipy.spatial.Voronoi

class scipy.spatial.Voronoi(points, furthest_site=False, incremental=False, qhull_options=None)

N 维空间中的泰森图。

新版本 0.12.0 中添加。

参数：

points浮点数的 ndarray，形状为 (npoints, ndim)

用于构建泰森多边形的点的坐标

furthest_site布尔值，可选

是否计算最远点网格化的泰森图。默认值：False

incremental布尔值，可选

允许逐步添加新点。这会占用一些额外的资源。

qhull_options字符串，可选

传递给 Qhull 的附加选项。详细信息请参阅 Qhull 手册。（默认值：对于 ndim > 4，“Qbb Qc Qz Qx”，否则为“Qbb Qc Qz”。增量模式省略“Qz”。）

引发：

QhullError

当 Qhull 遇到错误条件时引发，如未启用解决选项时的几何退化。

ValueError

如果给定的输入数组不兼容则引发。

注意事项

使用 Qhull library 计算泰森图。

示例

一组点的泰森图：

>>> import numpy as np
>>> points = np.array([[0, 0], [0, 1], [0, 2], [1, 0], [1, 1], [1, 2],
...                    [2, 0], [2, 1], [2, 2]])
>>> from scipy.spatial import Voronoi, voronoi_plot_2d
>>> vor = Voronoi(points) 

绘制：

>>> import matplotlib.pyplot as plt
>>> fig = voronoi_plot_2d(vor)
>>> plt.show() 

泰森顶点：

>>> vor.vertices
array([[0.5, 0.5],
 [0.5, 1.5],
 [1.5, 0.5],
 [1.5, 1.5]]) 

存在单个有限泰森区域和四个有限泰森脊：

>>> vor.regions
[[], [-1, 0], [-1, 1], [1, -1, 0], [3, -1, 2], [-1, 3], [-1, 2], [0, 1, 3, 2], [2, -1, 0], [3, -1, 1]]
>>> vor.ridge_vertices
[[-1, 0], [-1, 0], [-1, 1], [-1, 1], [0, 1], [-1, 3], [-1, 2], [2, 3], [-1, 3], [-1, 2], [1, 3], [0, 2]] 

脊是在以下输入点之间绘制的线段之间垂直的：

>>> vor.ridge_points
array([[0, 3],
 [0, 1],
 [2, 5],
 [2, 1],
 [1, 4],
 [7, 8],
 [7, 6],
 [7, 4],
 [8, 5],
 [6, 3],
 [4, 5],
 [4, 3]], dtype=int32) 

属性：

points双精度浮点数的 ndarray，形状为 (npoints, ndim)

输入点的坐标。

vertices双精度浮点数的 ndarray，形状为 (nvertices, ndim)

泰森顶点的坐标。

ridge_points整数的 ndarray，形状为 (nridges, 2)

每个泰森脊位于其间的点的索引。

ridge_vertices整数列表的列表，形状为 (nridges, *)

形成每个泰森脊的泰森顶点的索引。

regions整数列表的列表，形状为 (nregions, *)

形成每个泰森区域的泰森顶点的索引。-1 表示泰森图外的顶点。当启用 qhull 选项“Qz” 时，空子列表表示内部添加的无限远处点的泰森区域。

point_region整数数组，形状为 (npoints)

每个输入点的泰森区域的索引。如果未指定 qhull 选项“Qc”，则列表将包含 -1，表示未与泰森区域关联的点。如果启用了 qhull 选项“Qz”，则元素数将比区域数少一个，因为内部添加了一个额外的无限远点以方便计算。

furthest_site

如果这是最远点网格化则为 True，否则为 False。

新版本 1.4.0 中添加。

方法

add_points(points[, restart])	处理一组额外的新点。
close()	完成增量处理。

scipy.spatial.SphericalVoronoi

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.spatial.SphericalVoronoi.html#scipy.spatial.SphericalVoronoi

class scipy.spatial.SphericalVoronoi(points, radius=1, center=None, threshold=1e-06)

球面上的 Voronoi 图。

版本 0.18.0 中的新内容。

参数：

points浮点数数组，形状为（npoints，ndim）

用于构建球面 Voronoi 图的点的坐标。

radius浮点数，可选

球的半径（默认值：1）

center浮点数数组，形状为（ndim，）

球的中心（默认值：原点）

threshold浮点数

用于检测重复点和点与球参数之间不匹配的阈值。（默认值：1e-06）

引发：

ValueError

如果points中有重复项。如果提供的radius与points不一致。

另请参阅

Voronoi

N 维空间中的传统 Voronoi 图。

注释

球面 Voronoi 图算法的步骤如下。计算输入点（生成器）的凸包，等同于它们在球面上的 Delaunay 三角剖分[Caroli]。然后使用凸包的邻居信息来排序每个生成器周围的 Voronoi 区域顶点。后一种方法对浮点数问题的敏感性远低于基于角度的 Voronoi 区域顶点排序方法。

球面 Voronoi 算法性能的实证评估表明二次时间复杂度（对数线性是最佳的，但算法更难实现）。

参考文献

[Caroli]

Caroli 等人。球面上或接近球面的点的稳健且高效的 Delaunay 三角形。研究报告 RR-7004，2009 年。

[VanOosterom]

Van Oosterom 和 Strackee。平面三角形的立体角。IEEE 生物医学工程交易，1983 年，第 125-126 页。

示例

执行一些导入并在立方体上取一些点：

>>> import numpy as np
>>> import matplotlib.pyplot as plt
>>> from scipy.spatial import SphericalVoronoi, geometric_slerp
>>> from mpl_toolkits.mplot3d import proj3d
>>> # set input data
>>> points = np.array([[0, 0, 1], [0, 0, -1], [1, 0, 0],
...                    [0, 1, 0], [0, -1, 0], [-1, 0, 0], ]) 

计算球面 Voronoi 图：

>>> radius = 1
>>> center = np.array([0, 0, 0])
>>> sv = SphericalVoronoi(points, radius, center) 

生成绘图：

>>> # sort vertices (optional, helpful for plotting)
>>> sv.sort_vertices_of_regions()
>>> t_vals = np.linspace(0, 1, 2000)
>>> fig = plt.figure()
>>> ax = fig.add_subplot(111, projection='3d')
>>> # plot the unit sphere for reference (optional)
>>> u = np.linspace(0, 2 * np.pi, 100)
>>> v = np.linspace(0, np.pi, 100)
>>> x = np.outer(np.cos(u), np.sin(v))
>>> y = np.outer(np.sin(u), np.sin(v))
>>> z = np.outer(np.ones(np.size(u)), np.cos(v))
>>> ax.plot_surface(x, y, z, color='y', alpha=0.1)
>>> # plot generator points
>>> ax.scatter(points[:, 0], points[:, 1], points[:, 2], c='b')
>>> # plot Voronoi vertices
>>> ax.scatter(sv.vertices[:, 0], sv.vertices[:, 1], sv.vertices[:, 2],
...                    c='g')
>>> # indicate Voronoi regions (as Euclidean polygons)
>>> for region in sv.regions:
...    n = len(region)
...    for i in range(n):
...        start = sv.vertices[region][i]
...        end = sv.vertices[region][(i + 1) % n]
...        result = geometric_slerp(start, end, t_vals)
...        ax.plot(result[..., 0],
...                result[..., 1],
...                result[..., 2],
...                c='k')
>>> ax.azim = 10
>>> ax.elev = 40
>>> _ = ax.set_xticks([])
>>> _ = ax.set_yticks([])
>>> _ = ax.set_zticks([])
>>> fig.set_size_inches(4, 4)
>>> plt.show() 

属性：

points双精度数组，形状为（npoints，ndim）

从ndim维度中的点生成 Voronoi 图。

radius双精度

球的半径

center双精度数组，形状为（ndim，）

球的中心

vertices双精度数组，形状为（nvertices，ndim）

对应于点的 Voronoi 顶点

regions整数列表的列表，形状为（npoints，_ ）

第 n 个条目是由属于点中第 n 个点的顶点的索引组成的列表

方法

calculate_areas()	计算 Voronoi 区域的面积。

scipy.spatial.HalfspaceIntersection

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.spatial.HalfspaceIntersection.html#scipy.spatial.HalfspaceIntersection

class scipy.spatial.HalfspaceIntersection(halfspaces, interior_point, incremental=False, qhull_options=None)

N 维中的半空间交集。

0.19.0 版本中的新功能。

参数：

halfspacesndarray of floats, shape (nineq, ndim+1)

以形式[A; b]表示的堆叠不等式 Ax + b <= 0

interior_pointndarray of floats, shape (ndim,)

明显位于由半空间定义的区域内部的点。也称为可行点，可以通过线性规划获得。

incrementalbool, 可选

允许逐步添加新的半空间。这会占用额外的资源。

qhull_optionsstr, 可选

传递给 Qhull 的额外选项。有关详细信息，请参阅 Qhull 手册。（默认：对于 ndim > 4，“Qx”，否则为“”。选项“H”始终启用。）

引发：

QhullError

在 Qhull 遇到错误条件时引发，例如几何退化，当未启用解析选项时。

ValueError

如果输入一个不兼容的数组，则引发错误。

注释

使用Qhull 库计算交集。这重新生成了 Qhull 的“qhalf”功能。

参考资料

[Qhull]

www.qhull.org/

[1]

S. Boyd, L. Vandenberghe，《凸优化》可在stanford.edu/~boyd/cvxbook/获取

示例

形成某些多边形的平面半空间交集

>>> from scipy.spatial import HalfspaceIntersection
>>> import numpy as np
>>> halfspaces = np.array([[-1, 0., 0.],
...                        [0., -1., 0.],
...                        [2., 1., -4.],
...                        [-0.5, 1., -2.]])
>>> feasible_point = np.array([0.5, 0.5])
>>> hs = HalfspaceIntersection(halfspaces, feasible_point) 

将半空间作为填充区域和交点绘制：

>>> import matplotlib.pyplot as plt
>>> fig = plt.figure()
>>> ax = fig.add_subplot(1, 1, 1, aspect='equal')
>>> xlim, ylim = (-1, 3), (-1, 3)
>>> ax.set_xlim(xlim)
>>> ax.set_ylim(ylim)
>>> x = np.linspace(-1, 3, 100)
>>> symbols = ['-', '+', 'x', '*']
>>> signs = [0, 0, -1, -1]
>>> fmt = {"color": None, "edgecolor": "b", "alpha": 0.5}
>>> for h, sym, sign in zip(halfspaces, symbols, signs):
...     hlist = h.tolist()
...     fmt["hatch"] = sym
...     if h[1]== 0:
...         ax.axvline(-h[2]/h[0], label='{}x+{}y+{}=0'.format(*hlist))
...         xi = np.linspace(xlim[sign], -h[2]/h[0], 100)
...         ax.fill_between(xi, ylim[0], ylim[1], **fmt)
...     else:
...         ax.plot(x, (-h[2]-h[0]*x)/h[1], label='{}x+{}y+{}=0'.format(*hlist))
...         ax.fill_between(x, (-h[2]-h[0]*x)/h[1], ylim[sign], **fmt)
>>> x, y = zip(*hs.intersections)
>>> ax.plot(x, y, 'o', markersize=8) 

默认情况下，qhull 不提供计算内点的方法。可以使用线性规划轻松计算。考虑形式为(Ax + b \leq 0)的半空间，解决线性规划：

[ \begin{align}\begin{aligned}max : y\s.t. Ax + y ||A_i|| \leq -b\end{aligned}\end{align} ]

其中(A_i)是 A 的行，即每个平面的法线。

将得到一个位于凸多面体内部最深处的点 x。准确地说，它是一个半径为 y 的最大超球体的中心，其内嵌在多面体内部。这一点被称为多面体的切比雪夫中心（见[1] 4.3.1, pp148-149）。Qhull 输出的方程总是标准化的。

>>> from scipy.optimize import linprog
>>> from matplotlib.patches import Circle
>>> norm_vector = np.reshape(np.linalg.norm(halfspaces[:, :-1], axis=1),
...     (halfspaces.shape[0], 1))
>>> c = np.zeros((halfspaces.shape[1],))
>>> c[-1] = -1
>>> A = np.hstack((halfspaces[:, :-1], norm_vector))
>>> b = - halfspaces[:, -1:]
>>> res = linprog(c, A_ub=A, b_ub=b, bounds=(None, None))
>>> x = res.x[:-1]
>>> y = res.x[-1]
>>> circle = Circle(x, radius=y, alpha=0.3)
>>> ax.add_patch(circle)
>>> plt.legend(bbox_to_anchor=(1.6, 1.0))
>>> plt.show() 

属性:

halfspacesndarray of double, shape (nineq, ndim+1)

输入半空间。

interior_point :ndarray of floats, shape (ndim,)

输入内点。

intersectionsndarray of double, shape (ninter, ndim)

所有半空间的交集。

dual_pointsndarray of double, shape (nineq, ndim)

输入半空间的对偶点。

dual_facetslist of lists of ints

形成对偶凸壳（不一定是简单）面的点索引。

dual_verticesndarray of ints, shape (nvertices,)

形成对偶凸包顶点的半空间索引。对于二维凸包，顶点按逆时针顺序排列。对于其他维度，按输入顺序排列。

dual_equations双精度浮点数数组，形状为 (nfacet, ndim+1)

形成对偶面的超平面方程的[法向量, 偏移量]（详见Qhull 文档）。

dual_areafloat

对偶凸包的面积

dual_volumefloat

对偶凸包的体积

Methods

add_halfspaces(halfspaces[, restart])	处理一组额外的新半空间。
close()	完成增量处理。

scipy.spatial.delaunay_plot_2d

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

scipy.spatial.delaunay_plot_2d(tri, ax=None)

在二维中绘制给定的 Delaunay 三角剖分

参数：

triscipy.spatial.Delaunay 实例

要绘制的三角剖分

axmatplotlib.axes.Axes 实例，可选

绘图所用的坐标轴

返回：

figmatplotlib.figure.Figure 实例

绘图的图表

另请参见

Delaunay

matplotlib.pyplot.triplot

笔记

需要 Matplotlib。

示例

>>> import numpy as np
>>> import matplotlib.pyplot as plt
>>> from scipy.spatial import Delaunay, delaunay_plot_2d 

一组随机点的 Delaunay 三角剖分：

>>> rng = np.random.default_rng()
>>> points = rng.random((30, 2))
>>> tri = Delaunay(points) 

将其绘制出来：

>>> _ = delaunay_plot_2d(tri)
>>> plt.show() 

scipy.spatial.convex_hull_plot_2d

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

scipy.spatial.convex_hull_plot_2d(hull, ax=None)

在二维中绘制给定的凸包图形

参数：

hull 是 scipy.spatial.ConvexHull 的实例

要绘制的凸包

ax 是 matplotlib.axes.Axes 的实例，可选

绘制的坐标轴

返回：

fig 是 matplotlib.figure.Figure 的实例

绘图的图形

请参阅

ConvexHull

注意事项

需要 Matplotlib。

示例

>>> import numpy as np
>>> import matplotlib.pyplot as plt
>>> from scipy.spatial import ConvexHull, convex_hull_plot_2d 

随机点集的凸包：

>>> rng = np.random.default_rng()
>>> points = rng.random((30, 2))
>>> hull = ConvexHull(points) 

绘制图形：

>>> _ = convex_hull_plot_2d(hull)
>>> plt.show() 

scipy.spatial.voronoi_plot_2d

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.spatial.voronoi_plot_2d.html#scipy.spatial.voronoi_plot_2d

scipy.spatial.voronoi_plot_2d(vor, ax=None, **kw)

绘制给定的 2-D Voronoi 图

参数：

vorscipy.spatial.Voronoi 实例

绘图的图表

axmatplotlib.axes.Axes 实例，可选

绘图的轴

show_points布尔值，可选

将 Voronoi 点添加到图表。

show_vertices布尔值，可选

将 Voronoi 顶点添加到图表。

line_colors字符串，可选

指定多边形边界的线颜色

line_width浮点数，可选

指定多边形边界的线宽

line_alpha浮点数，可选

指定多边形边界的线透明度

point_size浮点数，可选

指定点的大小

返回：

figmatplotlib.figure.Figure 实例

图表的图例

参见

Voronoi

注意

需要 Matplotlib。

示例

>>> import numpy as np
>>> import matplotlib.pyplot as plt
>>> from scipy.spatial import Voronoi, voronoi_plot_2d 

为示例创建一组点：

>>> rng = np.random.default_rng()
>>> points = rng.random((10,2)) 

为这些点生成 Voronoi 图：

>>> vor = Voronoi(points) 

使用voronoi_plot_2d绘制图表：

>>> fig = voronoi_plot_2d(vor) 

使用voronoi_plot_2d再次绘制图表，并自定义一些设置：

>>> fig = voronoi_plot_2d(vor, show_vertices=False, line_colors='orange',
...                       line_width=2, line_alpha=0.6, point_size=2)
>>> plt.show() 

scipy.spatial.tsearch

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

scipy.spatial.tsearch(tri, xi)

查找包含给定点的单纯形。此函数与 Delaunay.find_simplex 做相同的事情。

参数：

triDelaunayInfo

Delaunay 三角剖分

xindarray of double，形状为 (…, ndim)

指向的点：

返回：

indarray of int，与 xi 相同的形状

每个点包含的单纯形的索引。在三角剖分之外的点将获得值 -1。

另请参阅：

Delaunay.find_simplex

注意事项：

新版本 0.9 中新增。

示例：

>>> import numpy as np
>>> import matplotlib.pyplot as plt
>>> from scipy.spatial import Delaunay, delaunay_plot_2d, tsearch
>>> rng = np.random.default_rng() 

一组随机点的 Delaunay 三角剖分：

>>> pts = rng.random((20, 2))
>>> tri = Delaunay(pts)
>>> _ = delaunay_plot_2d(tri) 

查找包含给定点集的单纯形：

>>> loc = rng.uniform(0.2, 0.8, (5, 2))
>>> s = tsearch(tri, loc)
>>> plt.triplot(pts[:, 0], pts[:, 1], tri.simplices[s], 'b-', mask=s==-1)
>>> plt.scatter(loc[:, 0], loc[:, 1], c='r', marker='x')
>>> plt.show() 

scipy.spatial.distance_matrix

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

scipy.spatial.distance_matrix(x, y, p=2, threshold=1000000)

计算距离矩阵。

返回所有成对距离的矩阵。

参数：

x(M, K) array_like

K 维空间中的 M 个向量的矩阵。

y(N, K) array_like

N 维空间中的 N 个向量的矩阵。

p浮点数，1 <= p <= 无穷大

使用的 Minkowski p-范数。

threshold正整数

如果M * N * K > threshold，算法将使用 Python 循环而不是大临时数组。

返回：

result(M, N) ndarray

包含每个向量x到每个向量y的距离的矩阵。

示例

>>> from scipy.spatial import distance_matrix
>>> distance_matrix([[0,0],[0,1]], [[1,0],[1,1]])
array([[ 1\.        ,  1.41421356],
 [ 1.41421356,  1\.        ]]) 

scipy.spatial.minkowski_distance

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

scipy.spatial.minkowski_distance(x, y, p=2)

计算两个数组之间的 L**p 距离。

x和y的最后一个维度必须具有相同的长度。任何其他维度必须支持广播。

参数：

x(…, K) array_like

输入数组。

y(…, K) array_like

输入数组。

pfloat，1 <= p <= 无穷大

指定使用的 Minkowski p-范数。

返回：

distndarray

输入数组之间的距离。

示例

>>> from scipy.spatial import minkowski_distance
>>> minkowski_distance([[0, 0], [0, 0]], [[1, 1], [0, 1]])
array([ 1.41421356,  1\.        ]) 

scipy.spatial.minkowski_distance_p

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.spatial.minkowski_distance_p.html#scipy.spatial.minkowski_distance_p

scipy.spatial.minkowski_distance_p(x, y, p=2)

计算两个数组之间 L**p 距离的 p 次方。

为了效率，此函数计算 Lp 距离，但不提取 p 次根。如果 p 是 1 或无穷大，则等于实际的 Lp 距离。

x 和 y 的最后维度必须具有相同的长度。任何其他维度必须适合广播。

参数：

x(…, K) array_like

输入数组。

y(…, K) array_like

输入数组。

pfloat, 1 <= p <= 无穷大

使用哪种闵可夫斯基 p-范数。

返回：

distndarray

输入数组之间距离的 p 次方。

示例

>>> from scipy.spatial import minkowski_distance_p
>>> minkowski_distance_p([[0, 0], [0, 0]], [[1, 1], [0, 1]])
array([2, 1]) 

scipy.spatial.procrustes

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.spatial.procrustes.html#scipy.spatial.procrustes

scipy.spatial.procrustes(data1, data2)

对比斯分析，用于两个数据集的相似性测试。

每个输入矩阵都是点或向量的集合（矩阵的行）。空间的维数是每个矩阵的列数。给定两个大小相同的矩阵，对比斯会标准化两者，以使：

• (tr(AA^{T}) = 1)。

• 两组点都围绕原点居中。

对比斯（[1], [2]）然后将最佳变换应用于第二个矩阵（包括缩放/扩展、旋转和反射），以最小化(M^{{2}=\sum(data1-data2)})，或者两个输入数据集之间点差的平方和。

此函数未设计用于处理具有不同数据点数（行）的数据集。如果两个数据集的维数不同（列数不同），只需向较小的那个添加零列即可。

参数：

data1array_like

矩阵，n行表示k（列）空间中的点data1是参考数据，在标准化后，来自data2的数据将被转换以适应data1中的模式（必须具有>1 个唯一点）。

data2array_like

要适应k空间中的n行数据到data1。必须与data1具有相同的形状(numrows, numcols)（必须具有>1 个唯一点）。

返回：

mtx1array_like

data1的标准化版本。

mtx2array_like

最适合data1的data2的方向。居中，但不一定(tr(AA^{T}) = 1)。

差异度float

如上所定义的(M^{2})。

异常：

ValueError

如果输入数组不是二维的。如果输入数组的形状不同。如果输入数组有零列或零行。

另请参阅

scipy.linalg.orthogonal_procrustes

scipy.spatial.distance.directed_hausdorff

另一个用于两个数据集的相似性测试

注记

• 差异度不应依赖于输入矩阵的顺序，但输出矩阵会，因为只有第一个输出矩阵保证按照(tr(AA^{T}) = 1)进行缩放。

• 复制的数据点通常可以，复制数据点会增加对比斯转换的影响。

• 差异度随着每个输入矩阵中的点数缩放。

参考资料

[1]

Krzanowski, W. J.（2000）。“多元分析原理”。

[2]

Gower, J. C.（1975）。“广义对比斯分析”。

示例

>>> import numpy as np
>>> from scipy.spatial import procrustes 

矩阵b在这里是a的旋转、平移、缩放和镜像版本：

>>> a = np.array([[1, 3], [1, 2], [1, 1], [2, 1]], 'd')
>>> b = np.array([[4, -2], [4, -4], [4, -6], [2, -6]], 'd')
>>> mtx1, mtx2, disparity = procrustes(a, b)
>>> round(disparity)
0.0 

scipy.spatial.geometric_slerp

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.spatial.geometric_slerp.html#scipy.spatial.geometric_slerp

scipy.spatial.geometric_slerp(start, end, t, tol=1e-07)

几何球形线性插值。

插值沿任意维度空间中的单位半径大圆弧进行。

参数：

start(n_dimensions, ) 数组样式

在 1-D 数组样式对象中，单个 n 维输入坐标。n 必须大于 1。

end(n_dimensions, ) 数组样式

在 1-D 数组样式对象中，单个 n 维输入坐标。n 必须大于 1。

tfloat 或 (n_points,) 1D 数组样式

表示插值参数的双精度浮点数或 1D 数组样式，其值在包含的区间 [0, 1] 内。一种常见方法是使用 np.linspace(0, 1, n_pts) 生成数组以获取线性间隔点。允许升序、降序和打乱顺序。

tolfloat

用于确定起始和结束坐标是否为反极的绝对容差。

返回：

result(t.size, D)

包含插值球形路径的双精度数组，当使用 0 和 1 的 t 时，包括起点和终点。插值值应与 t 数组中提供的相同排序顺序对应。如果 t 是浮点数，则结果可能是一维的。

引发：

ValueError

如果 start 和 end 是反极，不在单位 n-球上，或者存在各种退化条件。

另请参见

scipy.spatial.transform.Slerp

与四元数一起工作的 3-D Slerp

注释

实现基于数学公式提供的，来源于对 4-D 几何学的研究，由 Ken Shoemake 的原始四元数 Slerp 发表中的一个脚注中认可的算法。

新功能版本 1.5.0。

参考文献

[1]

en.wikipedia.org/wiki/Slerp#Geometric_Slerp

[2]

Ken Shoemake（1985）Animating rotation with quaternion curves. ACM SIGGRAPH Computer Graphics，19（3）：245-254。

示例

在跨越 90 度的圆周上插值四个线性间隔的值：

>>> import numpy as np
>>> from scipy.spatial import geometric_slerp
>>> import matplotlib.pyplot as plt
>>> fig = plt.figure()
>>> ax = fig.add_subplot(111)
>>> start = np.array([1, 0])
>>> end = np.array([0, 1])
>>> t_vals = np.linspace(0, 1, 4)
>>> result = geometric_slerp(start,
...                          end,
...                          t_vals) 

插值结果应在单位圆上的 30 度间隔可识别：

>>> ax.scatter(result[...,0], result[...,1], c='k')
>>> circle = plt.Circle((0, 0), 1, color='grey')
>>> ax.add_artist(circle)
>>> ax.set_aspect('equal')
>>> plt.show() 

尝试在圆的反极之间插值是模棱两可的，因为存在两条可能的路径；在球体上存在无限可能的测地线路径。尽管如此，一个模棱两可的路径会连同警告返回：

>>> opposite_pole = np.array([-1, 0])
>>> with np.testing.suppress_warnings() as sup:
...     sup.filter(UserWarning)
...     geometric_slerp(start,
...                     opposite_pole,
...                     t_vals)
array([[ 1.00000000e+00,  0.00000000e+00],
 [ 5.00000000e-01,  8.66025404e-01],
 [-5.00000000e-01,  8.66025404e-01],
 [-1.00000000e+00,  1.22464680e-16]]) 

将原始示例扩展到球体并在 3D 中绘制插值点：

>>> from mpl_toolkits.mplot3d import proj3d
>>> fig = plt.figure()
>>> ax = fig.add_subplot(111, projection='3d') 

绘制单位球作为参考（可选）：

>>> u = np.linspace(0, 2 * np.pi, 100)
>>> v = np.linspace(0, np.pi, 100)
>>> x = np.outer(np.cos(u), np.sin(v))
>>> y = np.outer(np.sin(u), np.sin(v))
>>> z = np.outer(np.ones(np.size(u)), np.cos(v))
>>> ax.plot_surface(x, y, z, color='y', alpha=0.1) 

在球面上插值更多点可能会使曲线看起来更加平滑，这对球面上的离散积分计算也很有用：

>>> start = np.array([1, 0, 0])
>>> end = np.array([0, 0, 1])
>>> t_vals = np.linspace(0, 1, 200)
>>> result = geometric_slerp(start,
...                          end,
...                          t_vals)
>>> ax.plot(result[...,0],
...         result[...,1],
...         result[...,2],
...         c='k')
>>> plt.show() 

scipy.spatial.QhullError

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.spatial.QhullError.html#scipy.spatial.QhullError

exception scipy.spatial.QhullError

with_traceback()

Exception.with_traceback(tb) – set self.traceback to tb and return self.

特殊函数（scipy.special）

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

下面几乎所有函数都接受 NumPy 数组作为输入参数，也可以接受单个数字。这意味着它们遵循广播和自动数组循环规则。从技术上讲，它们是 NumPy 通用函数。那些不接受 NumPy 数组的函数在部分描述中标有警告。

另请参阅

scipy.special.cython_special – 特殊函数的类型化 Cython 版本

错误处理

当发生错误时，通过返回 NaN 或其他适当的值来处理错误。某些特殊函数例程在发生错误时可以发出警告或引发异常。默认情况下，此功能已禁用；要查询和控制当前错误处理状态，提供了以下函数。

geterr()	获取当前处理特殊函数错误的方式。
seterr(**kwargs)	设置特殊函数错误处理方式。
errstate(**kwargs)	特殊函数错误处理的上下文管理器。
SpecialFunctionWarning	可能由特殊函数发出的警告。
SpecialFunctionError	特殊函数可能引发的异常。

可用函数

Airy 函数

airy(z[, out])	Airy 函数及其导数。
airye(z[, out])	指数缩放的 Airy 函数及其导数。
ai_zeros(nt)	计算 Airy 函数 Ai 及其导数的 nt 个零点和值。
bi_zeros(nt)	计算 Airy 函数 Bi 及其导数的 nt 个零点和值。
itairy(x[, out])	Airy 函数的积分

椭圆函数和积分

ellipj(u, m[, out])	雅可比椭圆函数
ellipk(m[, out])	第一类完全椭圆积分
ellipkm1(p[, out])	当 m = 1 时的第一类完全椭圆积分
ellipkinc(phi, m[, out])	第一类不完全椭圆积分
ellipe(m[, out])	第二类完全椭圆积分
ellipeinc(phi, m[, out])	第二类不完全椭圆积分
elliprc(x, y[, out])	对称退化椭圆积分
elliprd(x, y, z[, out])	第二类对称椭圆积分
elliprf(x, y, z[, out])	完全对称第一类椭圆积分
elliprg(x, y, z[, out])	完全对称第二类椭圆积分
elliprj(x, y, z, p[, out])	第三类对称椭圆积分

Bessel functions

jv(v, z[, out])	复数参数的第一类贝塞尔函数
jve(v, z[, out])	指数缩放的第一类贝塞尔函数
yn(n, x[, out])	整数阶实参数第二类贝塞尔函数
yv(v, z[, out])	复数参数的第二类贝塞尔函数
yve(v, z[, out])	指数缩放的第二类贝塞尔函数
kn(n, x[, out])	整数阶修正贝塞尔函数第二类
kv(v, z[, out])	第二类修正贝塞尔函数
kve(v, z[, out])	指数缩放的第二类修正贝塞尔函数
iv(v, z[, out])	实数阶修正贝塞尔函数第一类
ive(v, z[, out])	指数缩放的第一类修正贝塞尔函数
hankel1(v, z[, out])	第一类汉克尔函数
hankel1e(v, z[, out])	指数缩放的第一类汉克尔函数
hankel2(v, z[, out])	第二类汉克尔函数
hankel2e(v, z[, out])	指数缩放的第二类汉克尔函数
wright_bessel(a, b, x[, out])	莱特广义贝塞尔函数

不接受 NumPy 数组的以下函数（不是通用函数）：

lmbda(v, x)	雅恩克-艾姆登 Lambda 函数，Lambdav(x)

贝塞尔函数的零点

不接受 NumPy 数组的以下函数（不是通用函数）：

jnjnp_zeros(nt)	计算整数阶贝塞尔函数 Jn 和 Jn' 的零点
jnyn_zeros(n, nt)	计算贝塞尔函数 Jn(x)，Jn'(x)，Yn(x) 和 Yn'(x) 的 nt 个零点
jn_zeros(n, nt)	计算整数阶贝塞尔函数 Jn 的零点
jnp_zeros(n, nt)	计算整数阶贝塞尔函数导数 Jn' 的零点
yn_zeros(n, nt)	计算整数阶贝塞尔函数 Yn(x) 的零点
ynp_zeros(n, nt)	计算整数阶贝塞尔函数导数 Yn'(x) 的零点
y0_zeros(nt[, complex])	计算 Bessel 函数 Y0(z) 及其导数在每个零点处的 nt 个零点
y1_zeros（nt[, complex]）	计算贝塞尔函数 (Y1(z)) 的 nt 个零点，以及每个零点的导数。
y1p_zeros（nt[, complex]）	计算贝塞尔导数 (Y1'(z)) 的 nt 个零点，以及每个零点的值。

常见贝塞尔函数的快速版本

j0（x[, out]）	第一类贝塞尔函数，阶数为 0。
j1（x[, out]）	第一类贝塞尔函数，阶数为 1。
y0（x[, out]）	第二类贝塞尔函数，阶数为 0。
y1（x[, out]）	第二类贝塞尔函数，阶数为 1。
i0（x[, out]）	阶数为 0 的修改的贝塞尔函数。
i0e（x[, out]）	阶数为 0 的指数尺度修改的贝塞尔函数。
i1（x[, out]）	阶数为 1 的修改的贝塞尔函数。
i1e（x[, out]）	阶数为 1 的指数尺度修改的贝塞尔函数。
k0（x[, out]）	修改的第二类贝塞尔函数，阶数为 0，(K_0)。
k0e（x[, out]）	阶数为 0 的指数尺度修改的贝塞尔函数 K。
k1（x[, out]）	修改的第二类贝塞尔函数，阶数为 1，(K_1(x))。
k1e（x[, out]）	阶数为 1 的指数尺度修改的贝塞尔函数 K。

贝塞尔函数的积分

itj0y0（x[, out]）	阶数为 0 的第一类贝塞尔函数的积分。
it2j0y0（x[, out]）	与第一类阶数为 0 的贝塞尔函数相关的积分。
iti0k0（x[, out]）	修改的阶数为 0 的贝塞尔函数的积分。
it2i0k0（x[, out]）	与修改的阶数为 0 的贝塞尔函数相关的积分。
besselpoly(a, lmb, nu[, out])	第一类贝塞尔函数的加权积分。

贝塞尔函数的导数

jvp(v, z[, n])	计算第一类贝塞尔函数的导数。
yvp(v, z[, n])	计算第二类贝塞尔函数的导数。
kvp(v, z[, n])	计算修正贝塞尔函数 Kv(z) 的实数阶导数
ivp(v, z[, n])	计算第一类修正贝塞尔函数的导数。
h1vp(v, z[, n])	计算汉克尔函数 H1v(z) 关于 z 的导数。
h2vp(v, z[, n])	计算汉克尔函数 H2v(z) 关于 z 的导数。

球贝塞尔函数

spherical_jn(n, z[, derivative])	球贝塞尔函数第一类或其导数。
spherical_yn(n, z[, derivative])	球贝塞尔函数第二类或其导数。
spherical_in(n, z[, derivative])	修改的第一类球贝塞尔函数或其导数。
spherical_kn(n, z[, derivative])	修改的第二类球贝塞尔函数或其导数。

里卡第-贝塞尔函数

以下函数不接受 NumPy 数组（它们不是通用函数）：

riccati_jn(n, x)	计算第一类里卡第-贝塞尔函数及其导数。
riccati_yn(n, x)	计算第二类里卡第-贝塞尔函数及其导数。

斯特鲁夫函数

struve(v, x[, out])	斯特鲁夫函数。
modstruve(v, x[, out])	修改斯特鲁夫函数。
itstruve0(x[, out])	零阶斯特鲁夫函数的积分。
it2struve0(x[, out])	与零阶斯特鲁夫函数相关的积分。
itmodstruve0(x[, out])	零阶修正斯特鲁夫函数的积分。

原始统计函数

另见

scipy.stats：这些函数的友好版本。

二项分布

bdtr(k, n, p[, out])	二项分布累积分布函数。
bdtrc(k, n, p[, out])	二项分布生存函数。
bdtri(k, n, y[, out])	相对于 p 的逆函数，与 bdtr 相关。
bdtrik(y, n, p[, out])	相对于 k 的逆函数，与 bdtr 相关。
bdtrin(k, y, p[, out])	相对于 n 的逆函数，与 bdtr 相关。

Beta 分布

btdtr(a, b, x[, out])	Beta 分布的累积分布函数。
btdtri(a, b, p[, out])	Beta 分布的第 p 个分位数。
btdtria(p, b, x[, out])	相对于 a 的逆函数，与 btdtr 相关。
btdtrib(a, p, x[, out])	相对于 b 的逆函数，与 btdtr 相关。

F 分布

fdtr(dfn, dfd, x[, out])	F 分布累积分布函数。
fdtrc(dfn, dfd, x[, out])	F 分布生存函数。
fdtri(dfn, dfd, p[, out])	F 分布的第 p 个分位数。
fdtridfd(dfn, p, x[, out])	fdtr 的逆函数，关于 dfd 的。

Gamma 分布

gdtr(a, b, x[, out])	Gamma 分布累积分布函数。
gdtrc(a, b, x[, out])	Gamma 分布生存函数。
gdtria(p, b, x[, out])	gdtr 的逆函数，关于 a 的。
gdtrib(a, p, x[, out])	gdtr 的逆函数，关于 b 的。
gdtrix(a, b, p[, out])	gdtr 的逆函数，关于 x 的。

负二项分布

nbdtr(k, n, p[, out])	负二项分布累积分布函数。
nbdtrc(k, n, p[, out])	负二项分布生存函数。
nbdtri(k, n, y[, out])	对于参数 p，返回满足 y = nbdtr(k, n, p) 的逆函数，负二项分布累积分布函数。
nbdtrik(y, n, p[, out])	负二项分布百分位函数。
nbdtrin(k, y, p[, out])	nbdtr 的逆函数，关于 n 的。

非中心 F 分布

ncfdtr(dfn, dfd, nc, f[, out])	非中心 F 分布的累积分布函数。
ncfdtridfd(dfn, p, nc, f[, out])	计算非中心 F 分布的自由度（分母部分）。
ncfdtridfn(p, dfd, nc, f[, out])	计算非中心 F 分布的自由度（分子部分）。
ncfdtri(dfn, dfd, nc, p[, out])	非中心F分布的累积分布函数的反函数。
ncfdtrinc(dfn, dfd, p, f[, out])	计算非中心F分布的非中心参数。

非中心t分布

nctdtr(df, nc, t[, out])	非中心t分布的累积分布函数。
nctdtridf(p, nc, t[, out])	计算非中心t分布的自由度。
nctdtrit(df, nc, p[, out])	非中心t分布的累积分布函数的反函数。
nctdtrinc(df, p, t[, out])	计算非中心t分布的非中心参数。

正态分布

nrdtrimn(p, x, std[, out])	给定其他参数计算正态分布的均值。
nrdtrisd(p, x, mn[, out])	给定其他参数计算正态分布的标准差。
ndtr(x[, out])	标准正态分布的累积分布函数。
log_ndtr(x[, out])	高斯累积分布函数的对数。
ndtri(y[, out])	ndtr的逆函数，对应于 x。
ndtri_exp(y[, out])	log_ndtr的逆函数，对应于 x。

泊松分布

pdtr(k, m[, out])	泊松分布的累积分布函数。
pdtrc(k, m[, out])	泊松分布的生存函数。
pdtri(k, y[, out])	pdtr的逆函数，对应于 m。
pdtrik(p, m[, out])	pdtr 的反函数，对应 m。

学生 t 分布

stdtr(df, t[, out])	学生 t 分布累积分布函数
stdtridf(p, t[, out])	stdtr 的反函数，对应 df
stdtrit(df, p[, out])	学生 t 分布的第 p 个分位数。

卡方分布

chdtr(v, x[, out])	卡方分布累积分布函数。
chdtrc(v, x[, out])	卡方生存函数。
chdtri(v, p[, out])	chdtrc 的反函数，对应 x。
chdtriv(p, x[, out])	chdtr 的反函数，对应 v。

非中心卡方分布

chndtr(x, df, nc[, out])	非中心卡方累积分布函数
chndtridf(x, p, nc[, out])	chndtr 的反函数，对应 df
chndtrinc(x, df, p[, out])	chndtr 的反函数，对应 nc。
chndtrix(p, df, nc[, out])	chndtr 的反函数，对应 x

Kolmogorov 分布

smirnov(n, d[, out])	Kolmogorov-Smirnov 补充累积分布函数
smirnovi(n, p[, out])	smirnov 的反函数
kolmogorov(y[, out])	Kolmogorov 分布的补余累积分布（生存函数）。
kolmogi(p[, out])	Kolmogorov 分布的逆生存函数。

Box-Cox 变换

boxcox(x, lmbda[, out])	计算 Box-Cox 变换。
boxcox1p(x, lmbda[, out])	计算 1 + x 的 Box-Cox 变换。
inv_boxcox(y, lmbda[, out])	计算 Box-Cox 变换的逆。
inv_boxcox1p(y, lmbda[, out])	计算 Box-Cox 变换的逆。

Sigmoid 函数

logit(x[, out])	ndarrays 的 Logit 函数。
expit(x[, out])	Expit 函数（又名 logistic 函数）。
log_expit(x[, out])	Logistic sigmoid 函数的对数。

Miscellaneous

tklmbda(x, lmbda[, out])	Tukey lambda 分布的累积分布函数。
owens_t(h, a[, out])	Owen's T 函数。

信息理论函数

entr(x[, out])	计算熵的逐元素函数。
rel_entr(x, y[, out])	计算相对熵的逐元素函数。
kl_div(x, y[, out])	计算 Kullback-Leibler 散度的逐元素函数。
huber(delta, r[, out])	Huber 损失函数。
pseudo_huber(delta, r[, out])	伪-Huber 损失函数。

Gamma 和相关函数

gamma(z[, out])	gamma 函数。
gammaln(x[, out])	gamma 函数的绝对值的对数。
loggamma(z[, out])	伽马函数的主分支对数。
gammasgn(x[, out])	伽马函数的符号。
gammainc(a, x[, out])	正则化下不完全伽马函数。
gammaincinv(a, y[, out])	正则化下不完全伽马函数的反函数。
gammaincc(a, x[, out])	正则化上不完全伽马函数。
gammainccinv(a, y[, out])	正则化上不完全伽马函数的反函数。
beta(a, b[, out])	贝塔函数。
betaln(a, b[, out])	贝塔函数绝对值的自然对数。
betainc(a, b, x[, out])	正则化不完全贝塔函数。
betaincc(a, b, x[, out])	正则化不完全贝塔函数的补函数。
betaincinv(a, b, y[, out])	正则化不完全贝塔函数的反函数。
betainccinv(a, b, y[, out])	补充正则化不完全贝塔函数的反函数。
psi(z[, out])	Digamma 函数。
rgamma(z[, out])	伽马函数的倒数。
polygamma(n, x)	Polygamma 函数。
multigammaln(a, d)	返回多变量伽马函数的对数，有时也称为广义伽马函数。
digamma(z[, out])	Digamma 函数。
poch(z, m[, out])	Pochhammer 符号。

误差函数和 Fresnel 积分

erf(z[, out])	返回复数参数的误差函数。
erfc(x[, out])	互补误差函数，1 - erf(x)。
erfcx(x[, out])	缩放的互补误差函数，exp(x**2) * erfc(x)。
erfi(z[, out])	虚数误差函数，-i erf(i z)。
erfinv(y[, out])	误差函数的反函数。
erfcinv(y[, out])	互补误差函数的反函数。
wofz(z[, out])	Faddeeva 函数。
dawsn(x[, out])	Dawson 积分。
fresnel(z[, out])	Fresnel 积分。
fresnel_zeros(nt)	计算正弦和余弦 Fresnel 积分 S(z)和 C(z)的 nt 个复数零点。
modfresnelp(x[, out])	修改的 Fresnel 正积分。
modfresnelm(x[, out])	修改的 Fresnel 负积分。
voigt_profile(x, sigma, gamma[, out])	Voigt 轮廓。

以下函数不接受 NumPy 数组（它们不是通用函数）：

erf_zeros(nt)	计算第一象限中按绝对值排序的前 nt 个零点。
fresnelc_zeros(nt)	计算余弦 Fresnel 积分 C(z)的 nt 个复数零点。
fresnels_zeros(nt)	计算正弦 Fresnel 积分 S(z)的 nt 个复数零点。

Legendre 函数

lpmv(m, v, x[, out])	整数阶及实数次数的关联 Legendre 函数。
sph_harm(m, n, theta, phi[, out])	计算球谐函数。

以下函数不接受 NumPy 数组（它们不是通用函数）：

clpmn(m, n, z[, type])	复数参数的第一类相关勒让德函数。
lpn(n, z)	第一类 Legendre 函数。
lqn(n, z)	第二类 Legendre 函数。
lpmn(m, n, z)	第一类相关勒让德函数序列。
lqmn(m, n, z)	第二类相关勒让德函数序列。

椭球谐波

ellip_harm(h2, k2, n, p, s[, signm, signn])	椭球谐波函数 E^p_n(l)
ellip_harm_2(h2, k2, n, p, s)	椭球谐波函数 F^p_n(l)
ellip_normal(h2, k2, n, p)	椭球谐波归一化常数 gamma^p_n

正交多项式

下列函数评估正交多项式的值：

assoc_laguerre(x, n[, k])	计算阶数为 n 和次数为 k 的广义（相关）拉盖尔多项式。
eval_legendre(n, x[, out])	在某一点评估勒让德多项式。
eval_chebyt(n, x[, out])	在某一点评估第一类切比雪夫多项式。
eval_chebyu(n, x[, out])	在某一点评估第二类切比雪夫多项式。
eval_chebyc(n, x[, out])	在[-2, 2]区间上的某一点评估第一类切比雪夫多项式。
eval_chebys(n, x[, out])	在[-2, 2]区间上的某一点评估第二类切比雪夫多项式。
eval_jacobi(n, alpha, beta, x[, out])	在某一点评估雅各比多项式。
eval_laguerre(n, x[, out])	在某一点评估拉盖尔多项式。
eval_genlaguerre(n, alpha, x[, out])	在某一点评估广义拉盖尔多项式。
eval_hermite(n, x[, out])	在某一点评估物理学家的厄米多项式。
eval_hermitenorm(n, x[, out])	在某一点评估概率学家的（归一化的）厄米多项式。
eval_gegenbauer(n, alpha, x[, out])	在某一点评估格根鲍尔多项式。
eval_sh_legendre(n, x[, out])	在某一点评估偏移勒让德多项式。
eval_sh_chebyt(n, x[, out])	在某一点评估偏移第一类切比雪多项式。
eval_sh_chebyu(n, x[, out])	在某一点评估偏移第二类切比雨多项式。
eval_sh_jacobi(n, p, q, x[, out])	在某一点评估偏移雅可比多项式。

下列函数计算正交多项式的根和求积权重：

roots_legendre(n[, mu])	高斯-勒让德求积。
roots_chebyt(n[, mu])	高斯切比提（第一类）求积。
roots_chebyu(n[, mu])	高斯切比雨（第二类）求积。
roots_chebyc(n[, mu])	高斯切比西（第一类）求积。
roots_chebys(n[, mu])	高斯切比雪（第二类）求积。
roots_jacobi(n, alpha, beta[, mu])	高斯-雅可比求积。
roots_laguerre(n[, mu])	高斯-拉盖尔求积法。
roots_genlaguerre(n, alpha[, mu])	高斯-广义拉盖尔求积法。
roots_hermite(n[, mu])	高斯-埃尔米特（物理学家）求积法。
roots_hermitenorm(n[, mu])	高斯-埃尔米特（统计学家）求积法。
roots_gegenbauer(n, alpha[, mu])	高斯-格格伯正交多项式求积法。
roots_sh_legendre(n[, mu])	高斯-勒让德（平移）求积法。
roots_sh_chebyt(n[, mu])	高斯-切比雪夫（第一类，平移）求积法。
roots_sh_chebyu(n[, mu])	高斯-切比雪夫（第二类，平移）求积法。
roots_sh_jacobi(n, p1, q1[, mu])	高斯-雅各比（平移）求积法。

以下函数依次返回orthopoly1d对象中的多项式系数，其功能类似于numpy.poly1d。orthopoly1d类还具有weights属性，返回适当形式的高斯求积的根、权重和总权重的n x 3数组。请注意，进行算术运算时，orthopoly1d对象会转换为poly1d，且会丢失原始正交多项式的信息。

legendre(n[, monic])	勒让德多项式。
chebyt(n[, monic])	第一类切比雪夫多项式。
chebyu(n[, monic])	第二类切比雪夫多项式。
chebyc(n[, monic])	([-2, 2]) 区间第一类切比雪夫多项式。
chebys(n[, monic])	([-2, 2]) 区间第二类切比雪夫多项式。
jacobi(n, alpha, beta[, monic])	雅各比多项式。
laguerre(n[, monic])	拉盖尔多项式。
genlaguerre(n, alpha[, monic])	广义（相关）拉盖尔多项式。
hermite(n[, monic])	物理学家的厄米多项式。
hermitenorm(n[, monic])	规范化的（概率学家的）厄米多项式。
gegenbauer(n, alpha[, monic])	盖格宾博尔（超球形）多项式。
sh_legendre(n[, monic])	移位勒让德多项式。
sh_chebyt(n[, monic])	第一类移位切比雪夫多项式。
sh_chebyu(n[, monic])	第二类移位切比雪夫多项式。
sh_jacobi(n, p, q[, monic])	移位雅各比多项式。

警告

计算高阶多项式（约为 order > 20）使用多项式系数是数值不稳定的。应使用 eval_* 函数来评估多项式值。

超几何函数

hyp2f1(a, b, c, z[, out])	高斯超几何函数 2F1(a, b; c; z)
hyp1f1(a, b, x[, out])	紊乱超几何函数 1F1。
hyperu(a, b, x[, out])	紊乱超几何函数 U
hyp0f1(v, z[, out])	紊乱超几何极限函数 0F1。

抛物柱函数

pbdv(v, x[, out])	抛物柱函数 D
pbvv(v, x[, out])	抛物型缸函数 V
pbwa(a, x[, out])	抛物型缸函数 W

下列函数不接受 NumPy 数组（它们不是通用函数）：

pbdv_seq(v, x)	抛物型缸函数 Dv(x) 及其导数
pbvv_seq(v, x)	抛物型缸函数 Vv(x) 及其导数
pbdn_seq(n, z)	抛物型缸函数 Dn(z) 及其导数

马修及相关函数

mathieu_a(m, q[, out])	偶数马修函数的特征值
mathieu_b(m, q[, out])	奇数马修函数的特征值

下列函数不接受 NumPy 数组（它们不是通用函数）：

mathieu_even_coef(m, q)	偶数马修和修正马修函数的傅里叶系数
mathieu_odd_coef(m, q)	偶数马修和修正马修函数的傅里叶系数

下列函数返回函数及其一阶导数：

mathieu_cem(m, q, x[, out])	偶数马修函数及其导数
mathieu_sem(m, q, x[, out])	奇数马修函数及其导数
mathieu_modcem1(m, q, x[, out])	第一类偶数修正马修函数及其导数
mathieu_modcem2(m, q, x[, out])	第二类偶数修正马修函数及其导数
mathieu_modsem1(m, q, x[, out])	第一类奇数修正马修函数及其导数
mathieu_modsem2(m, q, x[, out])	奇异修正的马修函数第二类及其导数

椭圆体波函数

pro_ang1(m, n, c, x[, out])	椭圆体第一类角函数及其导数
pro_rad1(m, n, c, x[, out])	椭圆体第一类径向函数及其导数
pro_rad2(m, n, c, x[, out])	椭圆体第二类径向函数及其导数
obl_ang1(m, n, c, x[, out])	椭圆体第一类角函数及其导数
obl_rad1(m, n, c, x[, out])	椭圆体第一类径向函数及其导数
obl_rad2(m, n, c, x[, out])	椭圆体第二类径向函数及其导数。
pro_cv(m, n, c[, out])	椭圆体函数的特征值
obl_cv(m, n, c[, out])	椭圆体函数的特征值
pro_cv_seq(m, n, c)	椭圆体波函数的特征值序列。
obl_cv_seq(m, n, c)	椭圆体波函数的特征值序列。

以下函数需要预先计算特征值：

pro_ang1_cv(m, n, c, cv, x[, out])	预计算特征值的椭圆体角函数 pro_ang1
pro_rad1_cv(m, n, c, cv, x[, out])	预计算特征值的椭圆体径向函数 pro_rad1
pro_rad2_cv(m, n, c, cv, x[, out])	预计算特征值的椭圆体径向函数 pro_rad2
obl_ang1_cv(m, n, c, cv, x[, out])	预计算特征值的椭球体角函数 obl_ang1_cv。
obl_rad1_cv(m, n, c, cv, x[, out])	预计算特征值的椭球体径向函数 obl_rad1_cv。
obl_rad2_cv(m, n, c, cv, x[, out])	预计算特征值的椭球体径向函数 obl_rad2_cv。

Kelvin 函数

kelvin(x[, out])	复数形式的 Kelvin 函数
kelvin_zeros(nt)	计算所有 Kelvin 函数的 nt 个零点。
ber(x[, out])	Kelvin 函数 ber。
bei(x[, out])	Kelvin 函数 bei。
berp(x[, out])	Kelvin 函数 ber 的导数。
beip(x[, out])	Kelvin 函数 bei 的导数。
ker(x[, out])	Kelvin 函数 ker。
kei(x[, out])	Kelvin 函数 kei。
kerp(x[, out])	Kelvin 函数 ker 的导数。
keip(x[, out])	Kelvin 函数 kei 的导数。

以下函数不接受 NumPy 数组（它们不是通用函数）：

ber_zeros(nt)	计算 Kelvin 函数 ber 的 nt 个零点。
bei_zeros(nt)	计算 Kelvin 函数 bei 的 nt 个零点。
berp_zeros(nt)	计算 Kelvin 函数 ber 的导数的 nt 个零点。
beip_zeros(nt)	计算 Kelvin 函数 bei 的导数的 nt 个零点。
ker_zeros(nt)	计算 Kelvin 函数 ker 的 nt 个零点。
kei_zeros(nt)	计算 Kelvin 函数 kei 的 nt 个零点。
kerp_zeros(nt)	计算 Kelvin 函数 ker 的导数的 nt 个零点。
keip_zeros(nt)	计算 Kelvin 函数 kei 的导数的 nt 个零点。

组合数学

comb(N, k, *[, exact, repetition, legacy])	从 N 个物体中取 k 个的组合数。
perm(N, k[, exact])	N 个物体中取 k 个的排列数，即 N 的 k 排列。
stirling2(N, K, *[, exact])	生成第二类 Stirling 数。

Lambert W 函数及相关函数

lambertw(z[, k, tol])	Lambert W 函数。
wrightomega(z[, out])	Wright Omega 函数。

其他特殊函数

agm(a, b[, out])	计算算术-几何平均数 a 和 b 的算术-几何平均数。
bernoulli(n)	伯努利数 B0..Bn（包括）。
binom(x, y[, out])	作为两个实数变量函数的二项式系数。
diric(x, n)	周期正弦函数，也称为狄利克雷函数。
euler(n)	欧拉数 E(0), E(1), ..., E(n)。
expn(n, x[, out])	广义指数积分 En。
exp1(z[, out])	指数积分 E1。
expi(x[, out])	指数积分 Ei。
factorial(n[, exact])	数字或数字数组的阶乘。
factorial2(n[, exact])	双阶乘。
factorialk(n, k[, exact])	n 的 k 次多重阶乘，n(!!...!)。
shichi(x[, out])	双曲正弦和余弦积分。
sici(x[, out])	正弦和余弦积分。
softmax(x[, axis])	计算 softmax 函数。
log_softmax(x[, axis])	计算 softmax 函数的对数。
spence(z[, out])	斯宾斯函数，也称为二阶狄利克雷函数。
zeta(x[, q, out])	黎曼或 Hurwitz zeta 函数。
zetac(x[, out])	黎曼函数减 1。

便捷函数

cbrt(x[, out])	x的逐元立方根。
exp10(x[, out])	逐元素计算10**x。
exp2(x[, out])	逐元素计算2**x。
radian(d, m, s[, out])	将度数转换为弧度。
cosdg(x[, out])	以度为单位给出角度x的余弦。
sindg(x[, out])	以度为单位给出角度x的正弦。
tandg(x[, out])	以度为单位给出角度x的正切。
cotdg(x[, out])	以度为单位给出角度x的余切。
log1p(x[, out])	计算 log(1 + x)，当x接近零时使用。
expm1(x[, out])	计算exp(x) - 1。
cosm1(x[, out])	当x接近零时，计算 cos(x) - 1。
powm1(x, y[, out])	计算x**y - 1。
round(x[, out])	四舍五入到最近的整数。
xlogy(x, y[, out])	计算 x*log(y)，若 x = 0 则结果为 0。
xlog1py(x, y[, out])	计算 x*log1p(y)，若 x = 0 则结果为 0。
logsumexp(a[, axis, b, keepdims, return_sign])	计算输入元素的指数函数和的对数。
exprel(x[, out])	相对误差指数函数，(exp(x) - 1)/x。
sinc(x)	返回归一化的 sinc 函数。

scipy.special.geterr

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

scipy.special.geterr()

获取当前特殊函数错误处理的方式。

返回：

err字典

一个包含键“singular”、“underflow”、“overflow”、“slow”、“loss”、“no_result”、“domain”、“arg”和“other”的字典，它们的值是字符串“ignore”、“warn”和“raise”。这些键表示可能的特殊函数错误，而值定义了如何处理这些错误。

另请参阅

seterr

设置特殊函数错误的处理方式

errstate

特殊函数错误处理的上下文管理器

numpy.geterr

浮点错误的类似 numpy 函数

注意事项

完整文档有关特殊函数错误类型及处理选项，请参见seterr。

示例

默认情况下所有错误均被忽略。

>>> import scipy.special as sc
>>> for key, value in sorted(sc.geterr().items()):
...     print("{}: {}".format(key, value))
...
arg: ignore
domain: ignore
loss: ignore
no_result: ignore
other: ignore
overflow: ignore
singular: ignore
slow: ignore
underflow: ignore 

scipy.special.seterr

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

scipy.special.seterr(**kwargs)

设置如何处理特殊功能错误。

参数：

all, 可选

一次设置所有类型的特殊功能错误的处理。选项包括：

• 当错误发生时‘ignore’不采取任何操作

• ‘warn’ 当错误发生时打印SpecialFunctionWarning(通过 Pythonwarnings模块)

• ‘raise’ 当错误发生时引发SpecialFunctionError。

默认值是不改变当前行为。如果指定了额外类别的特殊功能错误的行为，则首先应用all，然后是额外的类别。

singular, 可选

对奇异点的处理。

underflow, 可选

下溢的处理。

overflow, 可选

对溢出的处理。

slow, 可选

收敛速度慢的处理。

loss, 可选

精度损失的处理。

no_result, 可选

未找到结果的处理。

domain, 可选

函数参数的无效参数的处理。

arg, 可选

函数参数的无效参数的处理。

other, 可选

未知错误的处理。

返回：

olderrdict

包含旧设置的字典。

另请参阅

geterr

获取当前处理特殊功能错误的方式

errstate

特殊功能错误处理的上下文管理器

numpy.seterr

浮点错误的类似 numpy 函数

例子

>>> import scipy.special as sc
>>> from pytest import raises
>>> sc.gammaln(0)
inf
>>> olderr = sc.seterr(singular='raise')
>>> with raises(sc.SpecialFunctionError):
...     sc.gammaln(0)
...
>>> _ = sc.seterr(**olderr) 

我们还可以除一外，为每个类别都引发错误。

>>> olderr = sc.seterr(all='raise', singular='ignore')
>>> sc.gammaln(0)
inf
>>> with raises(sc.SpecialFunctionError):
...     sc.spence(-1)
...
>>> _ = sc.seterr(**olderr) 

scipy.special.errstate

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

class scipy.special.errstate(**kwargs)

用于特殊函数错误处理的上下文管理器。

在上下文中使用 errstate 实例作为上下文管理器允许该上下文中的语句以已知的错误处理行为执行。进入上下文时，错误处理通过 seterr 设置，退出时恢复为之前的状态。

参数：

kwargs

关键字参数。有效关键字是可能的特殊函数错误。每个关键字应具有字符串值，定义了特定类型错误的处理方式。值必须是'ignore'、'warn'或'other'。详见 seterr。

另请参见

geterr

获取当前处理特殊函数错误的方法

seterr

设置特殊函数错误的处理方式

numpy.errstate

浮点数误差的类似 numpy 函数

示例

>>> import scipy.special as sc
>>> from pytest import raises
>>> sc.gammaln(0)
inf
>>> with sc.errstate(singular='raise'):
...     with raises(sc.SpecialFunctionError):
...         sc.gammaln(0)
...
>>> sc.gammaln(0)
inf 

我们还可以除了一个之外的每个类别都提升。

>>> with sc.errstate(all='raise', singular='ignore'):
...     sc.gammaln(0)
...     with raises(sc.SpecialFunctionError):
...         sc.spence(-1)
...
inf 

scipy.special.SpecialFunctionWarning

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

exception scipy.special.SpecialFunctionWarning

特殊函数可能发出的警告。

with_traceback()

Exception.with_traceback(tb) – 设置 self.traceback 为 tb 并返回 self。

scipy.special.SpecialFunctionError

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

exception scipy.special.SpecialFunctionError

特殊函数可能引发的异常。

with_traceback()

Exception.with_traceback(tb) – 将 self.traceback 设置为 tb 并返回 self。

scipy.special.airy

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

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

Airy 函数及其导数。

参数：

zarray_like

实数或复数参数。

outtuple of ndarray, optional

函数值的可选输出数组

返回：

Ai, Aip, Bi, Bip4-tuple of scalar or ndarray

Airy 函数 Ai 和 Bi，以及它们的导数 Aip 和 Bip。

另请参见

airye

指数缩放的 Airy 函数。

注意

Airy 函数 Ai 和 Bi 是方程的两个独立解

[y''(x) = x y(x).]

对于实数 z 在 [-10, 10] 范围内，通过调用 Cephes [1] 的 airy 程序进行计算，该程序在小 z 的情况下使用幂级数求和，在大 z 的情况下使用有理最小极值逼近法。

在此范围之外，AMOS [2] 的 zairy 和 zbiry 程序被使用。它们使用幂级数计算 (|z| < 1)，并使用修正贝塞尔函数与更大的 z 的关系计算（其中 (t \equiv 2 z^{3/2}/3)）：

[ \begin{align}\begin{aligned}Ai(z) = \frac{1}{\pi \sqrt{3}} K_{1/3}(t)\Ai'(z) = -\frac{z}{\pi \sqrt{3}} K_{2/3}(t)\Bi(z) = \sqrt{\frac{z}{3}} \left(I_{-1/3}(t) + I_{1/3}(t) \right)\Bi'(z) = \frac{z}{\sqrt{3}} \left(I_{-2/3}(t) + I_{2/3}(t)\right)\end{aligned}\end{align} ]

参考文献

[1]

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

[2]

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

示例

在区间 [-15, 5] 上计算 Airy 函数。

>>> import numpy as np
>>> from scipy import special
>>> x = np.linspace(-15, 5, 201)
>>> ai, aip, bi, bip = special.airy(x) 

绘制 Ai(x) 和 Bi(x)。

>>> import matplotlib.pyplot as plt
>>> plt.plot(x, ai, 'r', label='Ai(x)')
>>> plt.plot(x, bi, 'b--', label='Bi(x)')
>>> plt.ylim(-0.5, 1.0)
>>> plt.grid()
>>> plt.legend(loc='upper left')
>>> plt.show() 

scipy.special.airye

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

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

指数尺度的艾里函数及其导数。

缩放：

eAi  = Ai  * exp(2.0/3.0*z*sqrt(z))
eAip = Aip * exp(2.0/3.0*z*sqrt(z))
eBi  = Bi  * exp(-abs(2.0/3.0*(z*sqrt(z)).real))
eBip = Bip * exp(-abs(2.0/3.0*(z*sqrt(z)).real)) 

参数：

z array_like

实数或复数参数。

输出 ndarray 的元组，可选

函数值的可选输出数组

返回：

eAi, eAip, eBi, eBip4 个标量或 ndarray 的元组

指数尺度的艾里函数 eAi 和 eBi，及其导数 eAip 和 eBip

另请参见

airy

注意事项

AMOS [1] 程序包 zairy 和 zbiry 的包装器。

参考文献

[1]

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

例子

我们可以计算指数尺度的艾里函数及其导数：

>>> import numpy as np
>>> from scipy.special import airye
>>> import matplotlib.pyplot as plt
>>> z = np.linspace(0, 50, 500)
>>> eAi, eAip, eBi, eBip = airye(z)
>>> f, ax = plt.subplots(2, 1, sharex=True)
>>> for ind, data in enumerate([[eAi, eAip, ["eAi", "eAip"]],
...                             [eBi, eBip, ["eBi", "eBip"]]]):
...     ax[ind].plot(z, data[0], "-r", z, data[1], "-b")
...     ax[ind].legend(data[2])
...     ax[ind].grid(True)
>>> plt.show() 

我们可以通过通常的非尺度化艾里函数来计算这些：

>>> from scipy.special import airy
>>> Ai, Aip, Bi, Bip = airy(z)
>>> np.allclose(eAi, Ai * np.exp(2.0 / 3.0 * z * np.sqrt(z)))
True
>>> np.allclose(eAip, Aip * np.exp(2.0 / 3.0 * z * np.sqrt(z)))
True
>>> np.allclose(eBi, Bi * np.exp(-abs(np.real(2.0 / 3.0 * z * np.sqrt(z)))))
True
>>> np.allclose(eBip, Bip * np.exp(-abs(np.real(2.0 / 3.0 * z * np.sqrt(z)))))
True 

比较非尺度化和指数尺度化的函数，通常的非尺度化函数在大值时会迅速下溢，而指数尺度化函数则不会。

>>> airy(200)
(0.0, 0.0, nan, nan)
>>> airye(200)
(0.07501041684381093, -1.0609012305109042, 0.15003188417418148, 2.1215836725571093) 

scipy.special.ai_zeros

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

scipy.special.ai_zeros(nt)

计算 Airy 函数 Ai 及其导数的 nt 个零点和值。

计算 Airy 函数 Ai(x)的首个 nt 个零点 a，Airy 函数导数 Ai’(x)的首个 nt 个零点 ap，对应的值 Ai(a’)和 Ai’(a)。

参数：

ntint

要计算的零点数

返回：

andarray

Ai(x)的首个 nt 个零点

apndarray

Ai’(x)的首个 nt 个零点

aindarray

求解 Ai’(x)的首个 nt 个零点的 Ai(x)的值

aipndarray

求解首个 nt 个 Ai’(x)的零点的值

参考文献

[1]

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

示例

>>> from scipy import special
>>> a, ap, ai, aip = special.ai_zeros(3)
>>> a
array([-2.33810741, -4.08794944, -5.52055983])
>>> ap
array([-1.01879297, -3.24819758, -4.82009921])
>>> ai
array([ 0.53565666, -0.41901548,  0.38040647])
>>> aip
array([ 0.70121082, -0.80311137,  0.86520403]) 

scipy.special.bi_zeros

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

scipy.special.bi_zeros(nt)

计算 Airy 函数 Bi 及其导数的nt个零点和值

计算第一批nt个 Airy 函数 Bi(x)的零点 b；Airy 函数导数 Bi’(x)的第一批nt个零点 b’；对应的值 Bi(b’)；以及对应的值 Bi’(b)。

参数：

ntint

要计算的零点数

返回：

bndarray

Bi(x)的第一批nt个零点

bpndarray

Bi’(x)的第一批nt个零点

bindarray

Bi(x)的值在第一批nt个 Bi’(x)的零点处评估

bipndarray

Bi’(x)的值在第一批nt个 Bi(x)的零点处评估

参考文献

[1]

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

示例

>>> from scipy import special
>>> b, bp, bi, bip = special.bi_zeros(3)
>>> b
array([-1.17371322, -3.2710933 , -4.83073784])
>>> bp
array([-2.29443968, -4.07315509, -5.51239573])
>>> bi
array([-0.45494438,  0.39652284, -0.36796916])
>>> bip
array([ 0.60195789, -0.76031014,  0.83699101]) 

scipy.special.itairy

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

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

Airy 函数的积分

计算从 0 到 x 的 Airy 函数的积分。

参数：

x类似数组

积分的上限（浮点数）。

输出一组 ndarray 的元组，可选

函数值的可选输出数组

返回：

适当标量或 ndarray

对于 Ai(t) 从 0 到 x 的积分。

下标量或 ndarray

对于 Bi(t) 从 0 到 x 的积分。

上标量或 ndarray

对于 Ai(-t) 从 0 到 x 的积分。

下标量或 ndarray

对于 Bi(-t) 从 0 到 x 的积分。

注意

由张善杰和金建明创建的 Fortran 例程包装器 [1]。

参考资料

[1]

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

示例

在 x=1. 处计算函数。

>>> import numpy as np
>>> from scipy.special import itairy
>>> import matplotlib.pyplot as plt
>>> apt, bpt, ant, bnt = itairy(1.)
>>> apt, bpt, ant, bnt
(0.23631734191710949,
 0.8727691167380077,
 0.46567398346706845,
 0.3730050096342943) 

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

>>> x = np.array([1., 1.5, 2.5, 5])
>>> apt, bpt, ant, bnt = itairy(x)
>>> apt, bpt, ant, bnt
(array([0.23631734, 0.28678675, 0.324638  , 0.33328759]),
 array([  0.87276912,   1.62470809,   5.20906691, 321.47831857]),
 array([0.46567398, 0.72232876, 0.93187776, 0.7178822 ]),
 array([ 0.37300501,  0.35038814, -0.02812939,  0.15873094])) 

将函数从 -10 到 10 绘制出来。

>>> x = np.linspace(-10, 10, 500)
>>> apt, bpt, ant, bnt = itairy(x)
>>> fig, ax = plt.subplots(figsize=(6, 5))
>>> ax.plot(x, apt, label="$\int_0^x\, Ai(t)\, dt$")
>>> ax.plot(x, bpt, ls="dashed", label="$\int_0^x\, Bi(t)\, dt$")
>>> ax.plot(x, ant, ls="dashdot", label="$\int_0^x\, Ai(-t)\, dt$")
>>> ax.plot(x, bnt, ls="dotted", label="$\int_0^x\, Bi(-t)\, dt$")
>>> ax.set_ylim(-2, 1.5)
>>> ax.legend(loc="lower right")
>>> plt.show() 

scipy.special.ellipj

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

scipy.special.ellipj(u, m, out=None) = <ufunc 'ellipj'>

雅各比椭圆函数

计算参数m在 0 到 1 之间以及实数参数u的雅各比椭圆函数。

参数：

marray_like

参数。

uarray_like

参数。

outndarray 元组，可选

函数值的可选输出数组

返回：

sn, cn, dn, ph标量或 ndarray 的 4 元组

返回的函数：

sn(u|m), cn(u|m), dn(u|m) 

ph的值使得如果u = ellipkinc(ph, m)，那么sn(u|m) = sin(ph)和cn(u|m) = cos(ph)。

参见

ellipk

第一类完全椭圆积分

ellipkinc

第一类不完全椭圆积分

注意

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

这些函数是周期性的，在实轴上的四分之一周期等于完全椭圆积分ellipk(m)。

与不完全椭圆积分的关系：如果u = ellipkinc(phi,m)，那么sn(u|m) = sin(phi)，cn(u|m) = cos(phi)。phi称为u的振幅。

计算通过算术-几何均值算法完成，除非m接近 0 或 1e-9。在m接近 1 时，近似仅适用于phi < pi/2的情况。

参考文献

[1]

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

scipy.special.ellipk

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

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

第一类完全椭圆积分。

此函数定义为

[K(m) = \int_0^{\pi/2} [1 - m \sin(t)²]^{-1/2} dt]

参数：

marray_like

椭圆积分的参数。

outndarray，可选

函数值的可选输出数组

返回：

K标量或 ndarray

椭圆积分的值。

另请参阅

ellipkm1

m = 1 周围的完全椭圆积分第一类

ellipkinc

第一类不完全椭圆积分

ellipe

第二类完全椭圆积分

ellipeinc

第二类不完全椭圆积分

elliprf

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

注释

对于 m = 1 附近更高的精度，请使用ellipkm1，这个函数调用它。

以(m)的参数化遵循第 17.2 节中的那个[1]。也使用了相互补参数(1 - m)、模角(\sin²(\alpha) = m)或模(k² = m)，因此请注意选择正确的参数。

Legendre K 积分与 Carlson 对称 R_F 函数相关[2]：

[K(m) = R_F(0, 1-k², 1) .]

参考文献

[1]

Milton Abramowitz 和 Irene A. Stegun，eds. 数学函数手册与公式、图表和数学表格。纽约：多佛尔，1972 年。

[2]

NIST 数学函数数字图书馆。dlmf.nist.gov/，2020-09-15 发布的版本 1.0.28。参见第 19.25 节(i) dlmf.nist.gov/19.25#i

scipy.special.ellipkm1

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

scipy.special.ellipkm1(p, out=None) = <ufunc 'ellipkm1'>

完全椭圆积分的第一类，围绕 m = 1

该函数被定义为

[K(p) = \int_0^{\pi/2} [1 - m \sin(t)²]^{-1/2} dt]

其中 m = 1 - p。

参数：

p 数组样式

将椭圆积分的参数定义为 m = 1 - p。

out ndarray，可选

函数值的可选输出数组

返回：

K 标量或 ndarray

椭圆积分的值。

另请参阅

ellipk

完全椭圆积分的第一类

ellipkinc

不完全椭圆积分的第一类

ellipe

完全椭圆积分的第二类

ellipeinc

不完全椭圆积分的第二类

elliprf

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

注解

Cephes [1] 常规 ellpk 的包装。

对于 p <= 1，计算使用近似值，

[K(p) \approx P(p) - \log(p) Q(p),]

其中 (P) 和 (Q) 是十阶多项式。内部使用参数 p 而不是 m，以便将 m = 1 处的对数奇点移至原点；这样可以保持最大精度。对于 p > 1，使用等式

[K(p) = K(1/p)/\sqrt(p)]

被使用。

参考文献

[1]

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

scipy.special.ellipkinc

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

scipy.special.ellipkinc(phi, m, out=None) = <ufunc 'ellipkinc'>

第二类不完全椭圆积分

此函数定义如下

[K(\phi, m) = \int_0^{\phi} [1 - m \sin(t)²]^{-1/2} dt]

此函数也称为 (F(\phi, m))。

参数：

phiarray_like

椭圆积分的幅度

marray_like

椭圆积分的参数

outndarray, 可选

函数值的可选输出数组

返回：

K标量或 ndarray

椭圆积分的值

另请参见

ellipkm1

第一类完全椭圆积分，接近 m = 1

ellipk

第一类完全椭圆积分

ellipe

第二类完全椭圆积分

ellipeinc

第一类不完全椭圆积分

elliprf

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

注释

Cephes 的包装器 [1] 常规 ellik 程序。使用算术-几何平均算法进行计算。

用 (m) 参数化的方法遵循第 17.2 节中的方法 [2]。还使用其他以互补参数 (1 - m)、模角 (\sin²(\alpha) = m) 或模数 (k² = m) 的参数化方法，因此在选择正确的参数时要小心。

传说中的 K 不完全积分（或 F 积分）与 Carlson 的对称 R_F 函数相关 [3]。设 (c = \csc²\phi),

[F(\phi, m) = R_F(c-1, c-k², c) .]

参考文献

[1]

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

[2]

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

[3]

NIST 数学函数数字图书馆，2020-09-15 版本 1.0.28。参见第 19.25(i) 节 dlmf.nist.gov/19.25#i

scipy.special.ellipe

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

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

第二类完全椭圆积分

此函数定义为

[E(m) = \int_0^{\pi/2} [1 - m \sin(t)²]^{1/2} dt]

参数：

m类似数组

定义椭圆积分的参数。

out ndarray，可选

用于功能值的可选输出数组

返回：

E标量或 ndarray

椭圆积分的值。

参见

ellipkm1

第一类完全椭圆积分，在m = 1 附近

ellipk

第一类完全椭圆积分

ellipkinc

第一类不完全椭圆积分

ellipeinc

第二类不完全椭圆积分

elliprd

对称的第二类椭圆积分。

elliprg

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

注意事项

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

对于m > 0，计算使用近似，

[E(m) \approx P(1-m) - (1-m) \log(1-m) Q(1-m),]

其中(P)和(Q)是十阶多项式。对于m < 0，关系

[E(m) = E(m/(m - 1)) \sqrt(1-m)]

被用于。

关于(m)的参数化遵循[2]中的 17.2 节。也使用基于补充参数(1 - m)、模角(\sin²(\alpha) = m)或模(k² = m)的其他参数化方式，因此请注意选择正确的参数。

Legendre E 积分在多个方面与 Carlson 对称的 R_D 或 R_G 函数相关[3]。例如，

[E(m) = 2 R_G(0, 1-k², 1) .]

参考文献

[1]

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

[2]

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

[3]

NIST 数学函数数字图书馆。dlmf.nist.gov/，2020-09-15 版的发布 1.0.28。参见第 19.25 节(i) dlmf.nist.gov/19.25#i

示例

此函数用于找到半长轴为a和半短轴为b的椭圆的周长。

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

>>> a = 3.5
>>> b = 2.1
>>> e_sq = 1.0 - b**2/a**2  # eccentricity squared 

然后通过以下方式找到周长：

>>> C = 4*a*special.ellipe(e_sq)  # circumference formula
>>> C
17.868899204378693 

当a和b相同时（即离心率为 0），这将减少为圆的周长。

>>> 4*a*special.ellipe(0.0)  # formula for ellipse with a = b
21.991148575128552
>>> 2*np.pi*a  # formula for circle of radius a
21.991148575128552 

scipy.special.ellipeinc

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

scipy.special.ellipeinc(phi, m, out=None) = <ufunc 'ellipeinc'>

不完全椭圆积分的第二类

此函数定义如下：

[E(\phi, m) = \int_0^{\phi} [1 - m \sin(t)²]^{1/2} dt]

参数：

phiarray_like

椭圆积分的振幅。

marray_like

椭圆积分的参数。

outndarray，可选

函数值的可选输出数组

返回：

E标量或 ndarray

椭圆积分的值。

另见

ellipkm1

完全椭圆积分的第一类，在m=1 附近

ellipk

完全椭圆积分的第一类

ellipkinc

不完全椭圆积分的第一类

ellipe

完全的第二类椭圆积分

elliprd

对称的第二类椭圆积分。

elliprf

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

elliprg

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

注释

Cephes [1] 程序 ellie 的封装。

计算使用算术-几何均值算法。

关于(m)的参数化遵循第 17.2 节的[2]。也使用其他关于补充参数(1 - m)、模角(\sin²(\alpha) = m)或模数(k² = m)的参数化方式，因此要小心选择正确的参数。

传说中的不完全第一类 E 椭圆积分可以用多种方式与 Carlson 的对称积分 R_D、R_F 和 R_G 的组合相关联[3]。例如，对于(c = \csc²\phi)，

[E(\phi, m) = R_F(c-1, c-k², c) - \frac{1}{3} k² R_D(c-1, c-k², c) .]

参考文献

[1]

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

[2]

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

[3]

NIST 数学函数数字图书馆。dlmf.nist.gov/, 2020-09-15 发布的版本 1.0.28。参见 Sec. 19.25(i) dlmf.nist.gov/19.25#i

scipy.special.elliprc

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

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

退化对称椭圆积分。

函数 RC 定义为 [1]

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

参数：

x, y 数组型

实数或复数输入参数。x 可以是复平面上的任意数。y 必须非零。

out 数组型，可选

函数值的可选输出数组

返回：

R 标量或数组

积分的值。如果 y 是实数且为负，则返回柯西主值。如果 x 和 y 都是实数，则返回实数值。否则，返回复数值。

另请参阅

elliprf

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

elliprd

对称椭圆第二类积分。

elliprg

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

elliprj

对称椭圆第三类积分。

注释

RC 是对称积分 RF 的一个特殊情况：elliprc(x, y) == elliprf(x, y, y)。它是一个基本函数而非椭圆积分。

代码基于 duplication theorems 和到第 7 阶的级数展开实现了 Carlson 算法。[2]

新版本 1.8.0 中引入。

参考文献

[1]

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

[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 elliprc 

>>> x = 1.2 + 3.4j
>>> y = 5.
>>> scale = 0.3 + 0.4j
>>> elliprc(scale*x, scale*y)
(0.5484493976710874-0.4169557678995833j) 

>>> elliprc(x, y)/np.sqrt(scale)
(0.5484493976710874-0.41695576789958333j) 

当两个参数重合时，积分特别简单：

>>> x = 1.2 + 3.4j
>>> elliprc(x, x)
(0.4299173120614631-0.3041729818745595j) 

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

另一个简单情况：第一个参数为零：

>>> y = 1.2 + 3.4j
>>> elliprc(0, y)
(0.6753125346116815-0.47779380263880866j) 

>>> np.pi/2/np.sqrt(y)
(0.6753125346116815-0.4777938026388088j) 

当 x 和 y 都是正数时，我们可以用更多基本函数表达 (R_C(x,y))。对于情况 (0 \le x < y)，

>>> x = 3.2
>>> y = 6.
>>> elliprc(x, y)
0.44942991498453444 

>>> np.arctan(np.sqrt((y-x)/x))/np.sqrt(y-x)
0.44942991498453433 

对于情况 (0 \le y < x)，

>>> x = 6.
>>> y = 3.2
>>> elliprc(x,y)
0.4989837501576147 

>>> np.log((np.sqrt(x)+np.sqrt(x-y))/np.sqrt(y))/np.sqrt(x-y)
0.49898375015761476 

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})的连接，

[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})的连接，

[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/