python - 连接两个网格及其结果数组的 numpy 方法

Question

考虑两个 n 维的、可能重叠的 numpy meshgrids，比如

m1 = (x1, y1, z1, ...)
m2 = (x2, y2, z2, ...)

在 m1 和 m2 中没有重复的坐标元组。每个 meshgrid 都有一个结果数组，它可能来自不同的函数:

r1 = f1(m1)
r2 = f2(m2)

f1(m) != f2(m)。现在我想加入这两个 meshgrids 及其结果数组，例如m=m1&m2 和 r=r1&r2(其中 & 表示某种联合)，使得 m< 中的坐标元组 仍然排序并且 r 中的值仍然对应于原始坐标元组。新创建的坐标元组应该是可识别的(例如具有特殊值)。

为了详细说明我所追求的，我有两个例子，它们用简单的 for 和 if 语句来做我想做的事情。这是一个一维示例:

x1 = [1, 5, 7]
r1 = [i**2 for i in x1]

x2 = [2, 4, 6]
r2 = [i*3 for i in x2]

x,r = list(zip(*sorted([(i,j) for i,j in zip(x1+x2,r1+r2)],key=lambda x: x[0])))

给出

x = (1, 2, 4, 5, 6, 7)
r = (1, 6, 12, 25, 18, 49)

对于 2D，它开始变得相当复杂:

import numpy as np
a1 = [1, 5, 7]
b1 = [2, 5, 6]

x1,y1 = np.meshgrid(a1,b1)
r1 = x1*y1

a2 = [2, 4, 6]
b2 = [1, 3, 8]

x2, y2 = np.meshgrid(a2,b2)
r2 = 2*x2

a = [1, 2, 4, 5, 6, 7]
b = [1, 2, 3, 5, 6, 8]

x,y = np.meshgrid(a,b)

r = np.ones(x.shape)*-1

for i in range(x.shape[0]):
    for j in range(x.shape[1]):
        if   x[i,j] in a1 and y[i,j] in b1:
            r[i,j] = r1[a1.index(x[i,j]),b1.index(y[i,j])]

        elif x[i,j] in a2 and y[i,j] in b2:
            r[i,j] = r2[a2.index(x[i,j]),b2.index(y[i,j])]

这给出了期望的结果，新坐标对的值为 -1:

x=
[[1 2 4 5 6 7]
 [1 2 4 5 6 7]
 [1 2 4 5 6 7]
 [1 2 4 5 6 7]
 [1 2 4 5 6 7]
 [1 2 4 5 6 7]]
y=
[[1 1 1 1 1 1]
 [2 2 2 2 2 2]
 [3 3 3 3 3 3]
 [5 5 5 5 5 5]
 [6 6 6 6 6 6]
 [8 8 8 8 8 8]]
r=
[[ -1.   4.   4.  -1.   4.  -1.]
 [  2.  -1.  -1.   5.  -1.   6.]
 [ -1.   8.   8.  -1.   8.  -1.]
 [ 10.  -1.  -1.  25.  -1.  30.]
 [ 14.  -1.  -1.  35.  -1.  42.]
 [ -1.  12.  12.  -1.  12.  -1.]]

但是随着维度和数组大小的增加，这也会很快变慢。所以这里终于出现了问题:如何仅使用 numpy 函数来完成此操作。如果不可能，在 python 中实现它的最快方法是什么。如果无论如何相关，我更喜欢使用 Python 3。请注意，我在示例中使用的函数并不是我使用的实际函数。

Answer 1

我们可以使用一些掩码来替换 B 中的 A 部分，从而为我们提供 1D 掩码。然后，我们可以将这些掩码与 np.ix_ 一起使用扩展到所需的维数。

因此，对于 2D 的情况，应该是这样的——

# Initialize o/p array
r_out = np.full([len(a), len(b)],-1)           

# Assign for the IF part
mask_a1 = np.in1d(a,a1)
mask_b1 = np.in1d(b,b1)
r_out[np.ix_(mask_b1, mask_a1)] = r1.T

# Assign for the ELIF part
mask_a2 = np.in1d(a,a2)
mask_b2 = np.in1d(b,b2)
r_out[np.ix_(mask_b2, mask_a2)] = r2.T

a 可以像这样创建 -

a = np.concatenate((a1,a2))
a.sort()

同样，对于b。

此外，我们可以使用索引而不是掩码来与 np.ix_ 一起使用。同样，我们可以使用 np.searchsorted。因此，我们可以使用 np.searchsorted(a,a1) 获取相应的索引，而不是掩码 np.in1d(a,a1) 等等面具。这应该快得多。

---

对于 3D 的情况，我假设我们会有另一个数组，比如 c。因此，初始化部分将涉及使用 len(c)。将有一个对应于 c 的掩码/索引数组，因此在 np.ix_ 中多了一项。并且会有 r1 和 r2 的转置。