scipy.sparse.isspmatrix_bsr
scipy.sparse.isspmatrix_bsr(x)
x 是否是 bsr_matrix 类型？
参数：
x
检查是否为 bsr 矩阵的对象
返回：
布尔（bool）
如果 x 是 bsr 矩阵，则返回 True，否则返回 False
示例
>>> from scipy.sparse import bsr_array, bsr_matrix, csr_matrix, isspmatrix_bsr
>>> isspmatrix_bsr(bsr_matrix([[5]]))
True
>>> isspmatrix_bsr(bsr_array([[5]]))
False
>>> isspmatrix_bsr(csr_matrix([[5]]))
False
scipy.sparse.isspmatrix_lil
scipy.sparse.isspmatrix_lil(x)
x 是否为 lil_matrix 类型？
参数：
x
用于检查是否为 lil 矩阵的对象
返回：
布尔值
如果 x 是 lil 矩阵，则为 True；否则为 False
示例
>>> from scipy.sparse import lil_array, lil_matrix, coo_matrix, isspmatrix_lil
>>> isspmatrix_lil(lil_matrix([[5]]))
True
>>> isspmatrix_lil(lil_array([[5]]))
False
>>> isspmatrix_lil(coo_matrix([[5]]))
False
scipy.sparse.isspmatrix_dok
scipy.sparse.isspmatrix_dok(x)
是否为dok_array类型的x？
参数：
x
要检查是否为 dok 矩阵的对象
返回：
布尔值
如果x是 dok 矩阵，则为 True，否则为 False
示例
>>> from scipy.sparse import dok_array, dok_matrix, coo_matrix, isspmatrix_dok
>>> isspmatrix_dok(dok_matrix([[5]]))
True
>>> isspmatrix_dok(dok_array([[5]]))
False
>>> isspmatrix_dok(coo_matrix([[5]]))
False
scipy.sparse.isspmatrix_coo
scipy.sparse.isspmatrix_coo(x)
x 是否为 coo_matrix 类型？
参数：
x
要检查是否为 coo 矩阵的对象
返回值：
布尔值
如果 x 是 coo 矩阵则返回 True，否则返回 False
示例
>>> from scipy.sparse import coo_array, coo_matrix, csr_matrix, isspmatrix_coo
>>> isspmatrix_coo(coo_matrix([[5]]))
True
>>> isspmatrix_coo(coo_array([[5]]))
False
>>> isspmatrix_coo(csr_matrix([[5]]))
False
scipy.sparse.isspmatrix_dia
scipy.sparse.isspmatrix_dia(x)
x 是 dia_matrix 类型吗？
参数：
x
检查对象是否为 dia 矩阵
返回：
布尔值
如果 x 是 dia 矩阵则为 True，否则为 False
示例
>>> from scipy.sparse import dia_array, dia_matrix, coo_matrix, isspmatrix_dia
>>> isspmatrix_dia(dia_matrix([[5]]))
True
>>> isspmatrix_dia(dia_array([[5]]))
False
>>> isspmatrix_dia(coo_matrix([[5]]))
False
压缩稀疏图例程（scipy.sparse.csgraph）
原文：
docs.scipy.org/doc/scipy-1.12.0/reference/sparse.csgraph.html#module-scipy.sparse.csgraph
基于稀疏矩阵表示的快速图算法。
内容
connected_components(csgraph[, directed, …]) | 分析稀疏图的连通分量 |
|---|---|
laplacian(csgraph[, normed, return_diag, …]) | 返回有向图的拉普拉斯矩阵。 |
shortest_path(csgraph[, method, directed, …]) | 在正向有向或无向图上执行最短路径图搜索。 |
dijkstra(csgraph[, directed, indices, …]) | 使用斐波那契堆的迪杰斯特拉算法 |
floyd_warshall(csgraph[, directed, …]) | 使用弗洛伊德-沃舍尔算法计算最短路径长度 |
bellman_ford(csgraph[, directed, indices, …]) | 使用贝尔曼-福特算法计算最短路径长度。 |
johnson(csgraph[, directed, indices, …]) | 使用约翰逊算法计算最短路径长度。 |
breadth_first_order(csgraph, i_start[, …]) | 返回以指定节点开始的广度优先排序。 |
depth_first_order(csgraph, i_start[, …]) | 返回以指定节点开始的深度优先排序。 |
breadth_first_tree(csgraph, i_start[, directed]) | 返回广度优先搜索生成的树。 |
depth_first_tree(csgraph, i_start[, directed]) | 返回深度优先搜索生成的树。 |
minimum_spanning_tree(csgraph[, overwrite]) | 返回无向图的最小生成树。 |
reverse_cuthill_mckee(graph[, symmetric_mode]) | 返回一个排列数组，按照 Reverse-Cuthill McKee 顺序排列稀疏 CSR 或 CSC 矩阵。 |
maximum_flow(csgraph, source, sink) | 在图中的两个顶点之间最大化流量。 |
maximum_bipartite_matching(graph[, perm_type]) | 返回一个二分图的匹配，其基数至少与图的任何给定匹配的基数相同。 |
min_weight_full_bipartite_matching(…[, …]) | 返回二分图的最小权重完全匹配。 |
structural_rank(graph) | 计算给定稀疏模式图（矩阵）的结构秩。 |
NegativeCycleError([message]) | |
construct_dist_matrix(graph, predecessors[, …]) | 从前任矩阵构建距离矩阵。 |
csgraph_from_dense(graph[, null_value, …]) | 从密集矩阵构建 CSR 格式稀疏图。 |
csgraph_from_masked(graph) | 从掩码数组构建 CSR 格式图。 |
csgraph_masked_from_dense(graph[, …]) | 从密集矩阵构建掩码数组图表示。 |
csgraph_to_dense(csgraph[, null_value]) | 将稀疏图表示转换为密集表示 |
csgraph_to_masked(csgraph) | 将稀疏图表示转换为掩码数组表示 |
reconstruct_path(csgraph, predecessors[, …]) | 从图和前任列表构造树。 |
图表示
该模块使用以矩阵格式存储的图。具有 N 个节点的图可以由(N x N)邻接矩阵 G 表示。如果从节点 i 到节点 j 存在连接，则 G[i, j] = w，其中 w 是连接的权重。对于未连接的节点 i 和 j，其值取决于表示方式：
-
对于密集数组表示，非边由 G[i, j] = 0, 无穷大或 NaN 表示。
-
对于密集掩码表示（类型为 np.ma.MaskedArray），非边由掩码值表示。当需要具有零权重边的图时，这将非常有用。
-
对于稀疏数组表示，非边由矩阵中的非条目表示。这种稀疏表示还允许具有零权重的边。
作为一个具体的例子，想象一下，您希望表示以下无向图：
G
(0)
/ \
1 2
/ \
(2) (1)
此图具有三个节点，其中节点 0 和 1 由权重为 2 的边连接，并且节点 0 和 2 由权重为 1 的边连接。我们可以构建如下的密集、掩码和稀疏表示，记住无向图由对称矩阵表示：
>>> import numpy as np
>>> G_dense = np.array([[0, 2, 1],
... [2, 0, 0],
... [1, 0, 0]])
>>> G_masked = np.ma.masked_values(G_dense, 0)
>>> from scipy.sparse import csr_matrix
>>> G_sparse = csr_matrix(G_dense)
当零边具有重要意义时，这变得更加困难。例如，考虑稍微修改上述图的情况：
G2
(0)
/ \
0 2
/ \
(2) (1)
这与上述图相同，除了节点 0 和 2 由零权重边连接。在这种情况下，上述的密集表示会导致歧义：如果零是一个有意义的值，那么如何表示非边？在这种情况下，必须使用掩码或稀疏表示来消除歧义：
>>> import numpy as np
>>> G2_data = np.array([[np.inf, 2, 0 ],
... [2, np.inf, np.inf],
... [0, np.inf, np.inf]])
>>> G2_masked = np.ma.masked_invalid(G2_data)
>>> from scipy.sparse.csgraph import csgraph_from_dense
>>> # G2_sparse = csr_matrix(G2_data) would give the wrong result
>>> G2_sparse = csgraph_from_dense(G2_data, null_value=np.inf)
>>> G2_sparse.data
array([ 2., 0., 2., 0.])
我们使用了来自csgraph子模块的实用程序例程，以便将密集表示转换为可以被子模块中的算法理解的稀疏表示。通过查看数据数组，我们可以看到零值在图中是明确编码的。
有向 vs. 无向
矩阵可以表示有向或无向图。这在 csgraph 模块中通过布尔关键字指定。默认情况下假定图是有向的。在有向图中，从节点 i 到节点 j 的遍历可以通过边 G[i, j] 完成，但不能通过边 G[j, i] 完成。考虑下面的稠密图：
>>> import numpy as np
>>> G_dense = np.array([[0, 1, 0],
... [2, 0, 3],
... [0, 4, 0]])
当 directed=True 时，我们得到如下图：
---1--> ---3-->
(0) (1) (2)
<--2--- <--4---
在非定向图中，从节点 i 到节点 j 的遍历可以通过 G[i, j] 或 G[j, i] 之一完成。如果两条边都不为空，并且它们的权重不相等，则选择较小的那条。
因此，对于相同的图，当 directed=False 时，我们得到如下图：
(0)--1--(1)--3--(2)
需要注意的是，对称矩阵将表示无向图，无论‘directed’关键字设置为 True 还是 False。在这种情况下，通常使用 directed=True 可以更高效地进行计算。
本模块中的例程接受作为输入的 scipy.sparse 表示（csr、csc 或 lil 格式）、带有掩码的表示或通过零、无穷大和 NaN 条目表示的密集表示的表示非边缘。
稀疏线性代数（scipy.sparse.linalg）
原文：
docs.scipy.org/doc/scipy-1.12.0/reference/sparse.linalg.html#module-scipy.sparse.linalg
抽象线性操作符
LinearOperator(*args, **kwargs) | 执行矩阵向量乘积的通用接口。 |
|---|---|
aslinearoperator(A) | 将 A 返回为 LinearOperator。 |
矩阵操作
inv(A) | 计算稀疏矩阵的逆。 |
|---|---|
expm(A) | 使用 Pade 逼近计算矩阵指数。 |
expm_multiply(A, B[, start, stop, num, …]) | 计算矩阵 A 的指数在 B 上的作用。 |
matrix_power(A, power) | 将方阵 A 提升到整数次幂power。 |
矩阵范数
norm(x[, ord, axis]) | 稀疏矩阵的范数。 |
|---|---|
onenormest(A[, t, itmax, compute_v, compute_w]) | 计算稀疏矩阵 1-范数的下界。 |
解线性问题
线性方程系统的直接方法：
spsolve(A, b[, permc_spec, use_umfpack]) | 解稀疏线性系统 Ax=b，其中 b 可以是向量或矩阵。 |
|---|---|
spsolve_triangular(A, b[, lower, …]) | 解方程A x = b，假设 A 是一个三角矩阵。 |
factorized(A) | 返回一个用于求解预因子化稀疏线性系统 A 的函数。 |
MatrixRankWarning | |
use_solver(**kwargs) | 选择要使用的默认稀疏直接求解器。 |
线性方程组的迭代方法：
bicg(A, b[, x0, tol, maxiter, M, callback, …]) | 使用 BI 共轭梯度迭代法解 Ax = b。 |
|---|---|
bicgstab(A, b, *[, x0, tol, maxiter, M, …]) | 使用稳定化的 BI 共轭梯度迭代法解 Ax = b。 |
cg(A, b[, x0, tol, maxiter, M, callback, …]) | 使用共轭梯度迭代法解 Ax = b。 |
cgs(A, b[, x0, tol, maxiter, M, callback, …]) | 使用共轭梯度平方迭代法解 Ax = b。 |
gmres(A, b[, x0, tol, restart, maxiter, M, …]) | 使用广义最小残差迭代法解决 Ax = b。 |
lgmres(A, b[, x0, tol, maxiter, M, …]) | 使用 LGMRES 算法解方程。 |
minres(A, b[, x0, shift, tol, maxiter, M, …]) | 使用最小残差迭代法解决方程 Ax = b |
qmr(A, b[, x0, tol, maxiter, M1, M2, …]) | 使用准最小残差迭代法解 Ax = b。 |
gcrotmk(A, b[, x0, tol, maxiter, M, …]) | 使用灵活的 GCROT(m,k) 算法解方程。 |
tfqmr(A, b[, x0, tol, maxiter, M, callback, …]) | 使用无转置的准最小残差迭代法解 Ax = b。 |
最小二乘问题的迭代方法：
lsqr(A, b[, damp, atol, btol, conlim, …]) | 求解大型稀疏线性方程组的最小二乘解。 |
|---|---|
lsmr(A, b[, damp, atol, btol, conlim, …]) | 用于最小二乘问题的迭代求解器。 |
矩阵分解
特征值问题：
eigs(A[, k, M, sigma, which, v0, ncv, …]) | 寻找方阵 A 的 k 个特征值和特征向量。 |
|---|---|
eigsh(A[, k, M, sigma, which, v0, ncv, …]) | 求解实对称方阵或复共轭 Hermitian 方阵 A 的 k 个特征值和特征向量。 |
lobpcg(A, X[, B, M, Y, tol, maxiter, …]) | 局部最优块预处理共轭梯度法（LOBPCG）。 |
特征值问题：
svds(A[, k, ncv, tol, which, v0, maxiter, …]) | 稀疏矩阵的部分奇异值分解。 |
|---|
svds 函数支持以下求解器：
-
svds(solver=’arpack’)
-
svds(solver=’lobpcg’)
-
svds(solver=’propack’)
完全或不完全 LU 分解
splu(A[, permc_spec, diag_pivot_thresh, …]) | 计算稀疏方阵的 LU 分解。 |
|---|---|
spilu(A[, drop_tol, fill_factor, drop_rule, …]) | 计算稀疏方阵的不完全 LU 分解。 |
SuperLU() | 稀疏矩阵的 LU 分解。 |
稀疏结构的稀疏数组
LaplacianNd(*args, **kwargs) | N 维网格的 Laplacian 及其特征值/特征向量。 |
|---|
异常情况
ArpackNoConvergence(msg, eigenvalues, …) | ARPACK 迭代未收敛 |
|---|---|
ArpackError(info[, infodict]) | ARPACK 错误 |
scipy.sparse.SparseEfficiencyWarning
exception scipy.sparse.SparseEfficiencyWarning
with_traceback()
Exception.with_traceback(tb) – 设置 self.traceback 为 tb 并返回 self。
scipy.sparse.SparseWarning
exception scipy.sparse.SparseWarning
with_traceback()
Exception.with_traceback(tb) – 设置 self.traceback 为 tb 并返回 self。
空间算法和数据结构（scipy.spatial）
空间变换
这些内容包含在scipy.spatial.transform子模块中。
最近邻查询
KDTree(data[, leafsize, compact_nodes, …]) | 用于快速最近邻查找的 kd 树 |
|---|---|
cKDTree(data[, leafsize, compact_nodes, …]) | 用于快速最近邻查找的 kd 树 |
Rectangle(maxes, mins) | 超矩形类。 |
距离度量
距离度量包含在scipy.spatial.distance子模块中。
Delaunay 三角剖分，凸包和 Voronoi 图
Delaunay(points[, furthest_site, …]) | N 维空间中的 Delaunay 剖分 |
|---|---|
ConvexHull(points[, incremental, qhull_options]) | N 维空间中的凸包 |
Voronoi(points[, furthest_site, …]) | N 维空间中的 Voronoi 图 |
SphericalVoronoi(points[, radius, center, …]) | 球面上的 Voronoi 图 |
HalfspaceIntersection(halfspaces, interior_point) | N 维空间中的半空间交 |
绘图辅助函数
delaunay_plot_2d(tri[, ax]) | 绘制给定的二维 Delaunay 三角剖分 |
|---|---|
convex_hull_plot_2d(hull[, ax]) | 绘制给定的二维凸包图 |
voronoi_plot_2d(vor[, ax]) | 绘制给定的二维 Voronoi 图 |
另请参见
教程
单纯形表示
Delaunay 剖分中出现的单纯形（三角形，四面体等），凸壳的面和 Voronoi 岭（N-1-D 单纯形）在以下方案中表示：
tess = Delaunay(points)
hull = ConvexHull(points)
voro = Voronoi(points)
# coordinates of the jth vertex of the ith simplex
tess.points[tess.simplices[i, j], :] # tessellation element
hull.points[hull.simplices[i, j], :] # convex hull facet
voro.vertices[voro.ridge_vertices[i, j], :] # ridge between Voronoi cells
对于 Delaunay 三角剖分和凸包，简单形式的邻域结构满足条件：tess.neighbors[i,j] 是第 i 个简单形式中第 j 个顶点对应的相邻简单形式。如果没有相邻简单形式，则为 -1。
凸包面也定义了一个超平面方程：
(hull.equations[i,:-1] * coord).sum() + hull.equations[i,-1] == 0
对于 Delaunay 三角剖分，类似的超平面方程对应于相应的 N+1 维抛物面上的凸包面。
Delaunay 三角剖分对象提供了一个方法，用于定位包含给定点的简单形式，以及重心坐标计算。
函数
tsearch(tri, xi) | 找到包含给定点的简单形式。 |
|---|---|
distance_matrix(x, y[, p, threshold]) | 计算距离矩阵。 |
minkowski_distance(x, y[, p]) | 计算两个数组之间的 L**p 距离。 |
minkowski_distance_p(x, y[, p]) | 计算两个数组之间 L**p 距离的 p 次方。 |
procrustes(data1, data2) | Procrustes 分析，用于比较两个数据集的相似性。 |
geometric_slerp(start, end, t[, tol]) | 几何球面线性插值。 |
在 scipy.spatial 中使用的警告 / 错误信息
QhullError |
|---|
scipy.spatial.KDTree
原文：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.spatial.KDTree.html#scipy.spatial.KDTree
class scipy.spatial.KDTree(data, leafsize=10, compact_nodes=True, copy_data=False, balanced_tree=True, boxsize=None)
用于快速最近邻查找的 kd 树。
该类提供了对一组 k 维点的索引，可用于快速查找任意点的最近邻居。
参数：
data 数组样式，形状（n，m）
要索引的 n 个 m 维数据点。除非需要生成双精度连续数组，否则不会复制此数组，因此修改此数据将导致错误的结果。如果使用 copy_data=True 构建 kd 树，则也会复制数据。
leafsize 正整数，可选
算法在切换到暴力法的点数。默认值：10。
compact_nodes 布尔值，可选
如果为 True，则构建 kd 树以缩小超矩形到实际数据范围。这通常会得到一个更紧凑的树，对退化输入数据更具鲁棒性，并以更快的查询速度换取更长的构建时间。默认值：True。
copy_data 布尔值，可选
如果为 True，则数据始终会复制以保护 kd 树免受数据损坏。默认值：False。
balanced_tree 布尔值，可选
如果为 True，则使用中位数来分割超矩形，而不是中点。这通常会得到一个更紧凑的树和更快的查询速度，但以更长的构建时间为代价。默认值：True。
boxsize 数组样式或标量，可选
将 m 维环面拓扑应用于 KDTree。该拓扑由(x_i + n_i L_i)生成，其中(n_i)为整数，(L_i)为第 i 维的盒尺寸。输入数据将被包裹到(0, L_i))中。如果任何数据超出此边界，则会引发 ValueError。
注意：
使用的算法在 Maneewongvatana 和 Mount 1999 年的文章中有描述。总体思想是 kd 树是一个二叉树，每个节点代表一个轴对齐的超矩形。每个节点指定一个轴并根据它们沿该轴的坐标是否大于或小于特定值来分割点集。
在构建过程中，轴和分割点是由“滑动中点”规则选择的，这确保单元不会全部变得又长又细。
可查询给定点的 r 个最近邻居（可选仅返回距离点的最大距离内的那些）。还可以查询 r 个近似最近邻居，效率显著提高。
对于大维度（20 已经很大），不要指望比暴力法运行得更快。高维度最近邻查询是计算机科学中一个重要的未解决问题。
属性：
data ndarray，形状（n，m）
要索引的维度 m 的 n 数据点。除非需要生成连续的 double 数组，否则不会复制此数组。如果使用copy_data=True构建 kd 树，则数据也会被复制。
leafsizepositive int
算法转换为暴力方法的点数。
mint
单个数据点的维度。
nint
数据点的数量。
maxesndarray, shape (m,)
数据点 n 维度中每个维度的最大值。
minsndarray, shape (m,)
数据点 n 维度中每个维度的最小值。
sizeint
树中节点的数量。
方法
[count_neighbors(other, r[, p, weights, …]) | 计算可以形成的附近点对数。 |
|---|---|
query(x[, k, eps, p, distance_upper_bound, …]) | 查询 kd 树以获取最近邻居。 |
query_ball_point(x, r[, p, eps, workers, …]) | 查找距离点 x 距离小于 r 的所有点。 |
query_ball_tree(other, r[, p, eps]) | 查找self和other之间距离最多为 r 的所有点对。 |
query_pairs(r[, p, eps, output_type]) | 查找self中距离最多为 r 的所有点对。 |
sparse_distance_matrix(other, max_distance) | 计算稀疏距离矩阵。 |
| innernode | |
| leafnode | |
| node |
scipy.spatial.cKDTree
原文链接：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.spatial.cKDTree.html#scipy.spatial.cKDTree
class scipy.spatial.cKDTree(data, leafsize=16, compact_nodes=True, copy_data=False, balanced_tree=True, boxsize=None)
用于快速最近邻查找的 kd 树
此类提供对一组 k 维点的索引，可用于快速查找任意点的最近邻居。
注意
cKDTree在功能上与KDTree相同。在 SciPy v1.6.0 之前，cKDTree性能更好，功能略有不同，但现在这两个名称仅用于向后兼容。如果不考虑与 SciPy < 1.6 的兼容性问题，请优先使用KDTree。
参数:
data类似数组，形状为(n,m)
要索引的 n 个 m 维数据点。除非必须生成连续的双精度数组，否则不会复制此数组，因此修改这些数据将导致伪数据结果。如果使用 copy_data=True 构建 kd 树，则也会复制数据。
leafsize正整数，可选
算法切换到暴力方法的点数。默认值：16。
compact_nodes布尔值，可选
如果为 True，则构建 kd 树以缩小超矩形至实际数据范围。这通常会得到更紧凑的树，能够处理退化输入数据并在查询时提供更快的速度，但会增加构建时间。默认值：True。
copy_data布尔值，可选
如果为 True，则始终复制数据以保护 kd 树免受数据损坏。默认值：False。
balanced_tree布尔值，可选
如果为 True，则使用中位数来分割超矩形，而不是使用中点。这通常会给出更紧凑的树和更快的查询速度，但会增加构建时间。默认值：True。
boxsize类似数组或标量，可选
对 KDTree 应用 m 维环形拓扑结构。拓扑结构由(x_i + n_i L_i)生成，其中(n_i)为整数，(L_i)为第 i 维的箱尺寸。输入数据将被包装到([0, L_i))。如果任何数据超出此边界，则会引发 ValueError。
注意事项
所使用的算法描述在 Maneewongvatana 和 Mount 1999 年的论文中。其主要思想是 kd 树是一棵二叉树，每个节点代表一个轴对齐的超矩形。每个节点指定一个轴，并根据它们沿该轴的坐标是否大于或小于特定值来分割点集。
在构建过程中，通过“滑动中位数”规则选择轴和分割点，以确保单元格不会全部变得又长又薄。
可以查询树以获取任意给定点的最接近的 r 个邻居（可选仅返回距离该点某些最大距离内的邻居）。还可以查询，效率大大提高，获取 r 个近似最近邻居。
对于大维度（20 已经很大），不要指望此方法比暴力搜索运行更快。高维度最近邻查询是计算机科学中一个重要的开放问题。
属性：
datandarray，形状为 (n,m)
要索引的 n 个维度为 m 的数据点。除非需要生成连续的 double 数组，否则不会复制此数组。如果使用 copy_data=True 构建 kd 树，则还会复制数据。
leafsize正整数
算法切换到暴力搜索的点数。
mint
单个数据点的维数。
nint
数据点的数量。
maxesndarray，形状为 (m,)
n 个数据点每个维度的最大值。
minsndarray，形状为 (m,)
n 个数据点中每个维度的最小值。
tree对象，类 cKDTreeNode
此属性提供了 cKDTree 对象中根节点的 Python 视图。kd 树的完整 Python 视图在首次访问时动态创建。此属性允许您在 Python 中创建自己的查询函数。
sizeint
树中的节点数。
方法
count_neighbors(self, other, r[, p, …]) | 计算可以形成的附近对数。 |
|---|---|
query(self, x[, k, eps, p, …]) | 查询 kd 树的最近邻居 |
query_ball_point(self, x, r[, p, eps, …]) | 查找距离点 x 距离小于 r 的所有点。 |
query_ball_tree(self, other, r[, p, eps]) | 找到 self 和 other 之间距离最多为 r 的所有点对。 |
query_pairs(self, r[, p, eps, output_type]) | 找到距离 self 中任意一对点距离最多为 r 的所有点对。 |
sparse_distance_matrix(self, other, max_distance) | 计算稀疏距离矩阵 |
scipy.spatial.Rectangle
class scipy.spatial.Rectangle(maxes, mins)
超矩形类。
表示区间的笛卡尔积。
方法
max_distance_point(x[, p]) | 返回输入点与超矩形中点之间的最大距离。 |
|---|---|
max_distance_rectangle(other[, p]) | 计算两个超矩形之间点的最大距离。 |
min_distance_point(x[, p]) | 返回输入点与超矩形中点之间的最小距离。 |
min_distance_rectangle(other[, p]) | 计算两个超矩形之间点的最小距离。 |
split(d, split) | 通过分割生成两个超矩形。 |
volume() | 总体积。 |
scipy.spatial.Delaunay
class scipy.spatial.Delaunay(points, furthest_site=False, incremental=False, qhull_options=None)
N 维中的 Delaunay 镶嵌。
从版本 0.9 开始新增。
参数：
points浮点数数组，形状为（npoints，ndim）
要三角化的点的坐标
furthest_site布尔值，可选
是否计算最远点 Delaunay 三角剖分。默认值：False
从版本 0.12.0 开始新增。
incremental布尔值，可选
允许逐步添加新点。这会占用额外的资源。
qhull_options字符串，可选
传递给 Qhull 的其他选项。有关详细信息，请参阅 Qhull 手册。选项“Qt”始终启用。默认值：“Qbb Qc Qz Qx Q12”（对于 ndim > 4）和“Qbb Qc Qz Q12”（否则）。递增模式省略“Qz”。
从版本 0.12.0 开始新增。
引发：
QhullError
当 Qhull 遇到错误条件（例如在未启用解决选项的几何退化时）时引发。
ValueError
如果输入给出的数组不兼容，则引发。
注意
使用 Qhull 库计算的镶嵌 Qhull library。
注意
除非您传入 Qhull 选项“QJ”，否则 Qhull 不保证每个输入点都会出现在 Delaunay 三角剖分的顶点中。省略的点在coplanar属性中列出。
示例
一组点的三角剖分：
>>> import numpy as np
>>> points = np.array([[0, 0], [0, 1.1], [1, 0], [1, 1]])
>>> from scipy.spatial import Delaunay
>>> tri = Delaunay(points)
我们可以绘制它：
>>> import matplotlib.pyplot as plt
>>> plt.triplot(points[:,0], points[:,1], tri.simplices)
>>> plt.plot(points[:,0], points[:,1], 'o')
>>> plt.show()
形成三角剖分的两个三角形的点的索引和坐标：
>>> tri.simplices
array([[2, 3, 0], # may vary
[3, 1, 0]], dtype=int32)
请注意，根据舍入误差的处理方式，简单形可能与上述不同的顺序排列。
>>> points[tri.simplices]
array([[[ 1\. , 0\. ], # may vary
[ 1\. , 1\. ],
[ 0\. , 0\. ]],
[[ 1\. , 1\. ],
[ 0\. , 1.1],
[ 0\. , 0\. ]]])
三角形 0 是三角形 1 的唯一相邻单元，并且它位于三角形 1 的顶点 1 的对面：
>>> tri.neighbors[1]
array([-1, 0, -1], dtype=int32)
>>> points[tri.simplices[1,1]]
array([ 0\. , 1.1])
我们可以找出哪些三角形点在：
>>> p = np.array([(0.1, 0.2), (1.5, 0.5), (0.5, 1.05)])
>>> tri.find_simplex(p)
array([ 1, -1, 1], dtype=int32)
数组中返回的整数是相应点所在单纯形的索引。如果返回-1，则表示该点不在任何单纯形中。请注意，以下示例中的快捷方式仅适用于有效点，因为无效点返回-1，而-1 本身是列表中最后一个单纯形的有效索引。
>>> p_valids = np.array([(0.1, 0.2), (0.5, 1.05)])
>>> tri.simplices[tri.find_simplex(p_valids)]
array([[3, 1, 0], # may vary
[3, 1, 0]], dtype=int32)
我们还可以为这些点在三角形 1 中计算重心坐标：
>>> b = tri.transform[1,:2].dot(np.transpose(p - tri.transform[1,2]))
>>> np.c_[np.transpose(b), 1 - b.sum(axis=0)]
array([[ 0.1 , 0.09090909, 0.80909091],
[ 1.5 , -0.90909091, 0.40909091],
[ 0.5 , 0.5 , 0\. ]])
第一个点的坐标全为正，这意味着它确实在三角形内部。第三个点在边缘上，因此其第三个坐标为空。
属性：
points双精度数组，形状为（npoints，ndim）
输入点的坐标。
simplices整数数组，形状为（nsimplex，ndim+1）
在三角形剖分中形成单纯形的点的索引。对于 2-D，点是逆时针方向排列的。
neighbors整数数组，形状为（nsimplex，ndim+1）
每个单纯形的相邻单纯形的索引。第 k 个相邻单纯形位于第 k 个顶点的对面。对于边界上的单纯形，-1 表示没有相邻单纯形。
equations双精度数组，形状为（nsimplex，ndim+2）
[normal, offset]构成抛物面上平面方程的超平面（详见Qhull 文档）。
paraboloid_scale, paraboloid_shiftfloat
用于额外抛物面维度的缩放和移位（详见Qhull 文档）。
transform双精度数组，形状为 (nsimplex, ndim+1, ndim)
从x到重心坐标c的仿射变换。
vertex_to_simplex整数的 ndarray，形状为 (npoints,)
从顶点到其所属单纯形的查找数组。
convex_hull整数的 ndarray，形状为 (nfaces, ndim)
构成点集凸包的面的顶点。
coplanar整数的 ndarray，形状为 (ncoplanar, 3)
共面点的索引及其最近平面和最近顶点的相应索引。由于数值精度问题，共面点是未包含在三角剖分中的输入点。
如果未指定选项“Qc”，则不计算此列表。
新版本 0.12.0 中引入。
vertex_neighbor_vertices包含两个 int 类型的 ndarray 元组；(indptr, indices)
顶点的相邻顶点。
furthest_site
如果这是一个最远点三角剖分，则为 True；如果不是，则为 False。
新版本 1.4.0 中引入。
方法
add_points(points[, restart]) | 处理一组额外的新点。 |
|---|---|
close() | 完成增量处理。 |
find_simplex(self, xi[, bruteforce, tol]) | 查找包含给定点的单纯形。 |
lift_points(self, x) | 将点映射到 Qhull 抛物面上。 |
plane_distance(self, xi) | 计算到所有单纯形点 xi 的超平面距离。 |
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]
示例
随机点集的凸壳：
>>> 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
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
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]
[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
scipy.spatial.delaunay_plot_2d(tri, ax=None)
在二维中绘制给定的 Delaunay 三角剖分
参数：
triscipy.spatial.Delaunay 实例
要绘制的三角剖分
axmatplotlib.axes.Axes 实例，可选
绘图所用的坐标轴
返回：
figmatplotlib.figure.Figure 实例
绘图的图表
另请参见
Delaunay
笔记
需要 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
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
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 实例
图表的图例
参见
注意
需要 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。
另请参阅：
注意事项：
新版本 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
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
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
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
scipy.spatial.procrustes(data1, data2)
对比斯分析，用于两个数据集的相似性测试。
每个输入矩阵都是点或向量的集合（矩阵的行）。空间的维数是每个矩阵的列数。给定两个大小相同的矩阵，对比斯会标准化两者，以使：
-
(tr(AA^{T}) = 1)。
-
两组点都围绕原点居中。
对比斯（[1], [2]）然后将最佳变换应用于第二个矩阵（包括缩放/扩展、旋转和反射），以最小化(M{2}=\sum(data1-data2){2})，或者两个输入数据集之间点差的平方和。
此函数未设计用于处理具有不同数据点数（行）的数据集。如果两个数据集的维数不同（列数不同），只需向较小的那个添加零列即可。
参数：
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
rray_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
scipy.spatial.procrustes(data1, data2)
对比斯分析，用于两个数据集的相似性测试。
每个输入矩阵都是点或向量的集合（矩阵的行）。空间的维数是每个矩阵的列数。给定两个大小相同的矩阵，对比斯会标准化两者，以使：
-
(tr(AA^{T}) = 1)。
-
两组点都围绕原点居中。
对比斯（[1], [2]）然后将最佳变换应用于第二个矩阵（包括缩放/扩展、旋转和反射），以最小化(M{2}=\sum(data1-data2){2})，或者两个输入数据集之间点差的平方和。
此函数未设计用于处理具有不同数据点数（行）的数据集。如果两个数据集的维数不同（列数不同），只需向较小的那个添加零列即可。
参数：
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
扫一扫
1954
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
