确定二维网格中具有周期性条件的相邻单元。

Question

假设我们有如下的二维网络，我们用整数标记其单元格索引。

20  21  22  23  24
15  16  17  18  19
10  11  12  13  14
5   6   7   8   9
0   1   2   3   4

我想要的是一个函数，它接收一个单元格索引（cell）和沿轴的单元格数量（本例中n=5）作为输入，并返回一个包含9个邻居（包括单元格本身）的数组，同时考虑到全局框的周期性。

我向你展示我的尝试，它 "几乎 "奏效。

def celdas_vecinas(cell,n):

    return np.mod(cell + np.array([0, -n-1, -n, -n+1, -1, 1, n-1, n, n+1], dtype=np.int64), n**2)

我输入了np. mod来反映周期性条件。关键是这个函数只对某些值表现良好。

>>> celdas_vecinas(1,5) 
array([ 1, 20, 21, 22,  0,  2,  5,  6,  7]) # right!

>>> celdas_vecinas(21,5)
array([21, 15, 16, 17, 20, 22,  0,  1,  2]) # right!

但如果我在角落里输入其中一个单元格的索引，就会发生以下情况。

>>> celdas_vecinas(0,5)
array([ 0, 19, 20, 21, 24,  1,  4,  5,  6]) # should be 9 instead of 19

比如cell=5的时候也会失败

有人知道如何实现这个函数吗？当单元格索引不触及任何边框时，实现起来很容易，但我不知道如何加入周期性的效果，虽然我猜想这一定与np.mod函数有关。

Answer 1

行的周期性和列的周期性不一样。我想你应该先把每边的2个单元格弄好，然后上下移动。我已经试过了，似乎是可行的 。

def celdas_vecinas(cell, n) :
    last_row = n * (cell // n)
    left_cell = last_row + ( cell - last_row - 1 ) % n
    right_cell = last_row + ( cell - last_row + 1 ) % n
    line = np.array( [ left_cell, cell, right_cell ] )
    return np.mod( [ line + n, line, line - n ], n**2)

(我删除了我之前的答案，因为我在indeces中搞砸了)

Answer 2

Numpy实现 得以 numpy.argwhere 检索值indeces，创建网格的索引，用 numpy.ix_，最后应用 numpy.narray.ravel 方法来平铺数组：。

import numpy as np

n = 5
grid = np.arange(n**2).reshape(n,n)[::-1]

def celdas_vecinas_np(grid, v, n):

    x, y = np.argwhere(grid == v)[0]
    idx = np.arange(x-1, x+2) %n
    idy = np.arange(y-1, y+2) %n

    return grid[np.ix_(idx, idy)].ravel()

celdas_vecinas_np(grid, 24, n)
array([ 3,  4,  0, 23, 24, 20, 18, 19, 15])

另一方面，对于一个 Numba的实施 我们不能用 numpy.argwhere但我们可以使用 numpy.where 来获取索引。一旦我们这样做了，就只需要在正确的范围内循环，即。

from numba import njit

@njit
def celdas_vecinas_numba(grid, v, n):

    x, y = np.where(grid == v)
    x, y = x[0], y[0]

    result = []
    for ix in range(x-1, x+2):
        for iy in range(y-1, y+2):
            result.append(grid[ix%n, iy%n])

    return result

celdas_vecinas_numba(grid, 24, n)
[3, 4, 0, 23, 24, 20, 18, 19, 15]

绩效比较 在这样的小网格下，numba在我的本地机器上运行速度已经快了20倍。

%timeit celdas_vecinas_np(grid, 24, 5)
38 µs ± 1.62 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)

%timeit celdas_vecinas_numba(grid, 24, n)
1.81 µs ± 93.5 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

Answer 3

用这个试试:

grid = [[20,  21,  22,  23,  24],[15,  16,  17,  18,  19],[10,  11,  12,  13,  14],[5,   6,   7,   8,   9],[0,   1,   2,   3,   4]]
def celdas_vecinas(cell,n):
    Row = [-1, -1, -1, 0, 0, 0, 1, 1, 1]
    Col = [-1, 0, 1, -1, 0, 1, -1, 0, 1]
    x = y = 0
    for i in range(n):
        z = 0;
        for j in range(n):
            if grid[i][j] == cell:
                x = i
                y = j
                z = 1
                break
        if z:
            break

    ans = []
    for i in range(9):
        xx = (n + x + Row[i]) % n
        yy = (n + y + Col[i]) % n
        ans.append(grid[xx][yy])
    return ans;
print(celdas_vecinas(1,5))
print(celdas_vecinas(21,5))
print(celdas_vecinas(5,5))

Answer 4

根据Comevussor的回答，我最终写了这段代码：

@nb.njit(nb.i8[:](nb.i8, nb.i8), fastmath=True)
def celdas_vecinas(cell,n):

    Nt = n**2 # total number of cells

    x = cell % n; y = cell // n # x,y cell coordinates
    izq =      (x - 1) % n + y * n
    der =      (x + 1) % n + y * n
    arri =     (x % n + (y+1) * n) % Nt
    aba =      (x % n + (y-1) * n) % Nt
    aba_izq =  (izq - n) % Nt
    aba_der =  (der - n) % Nt
    arri_izq = (izq + n) % Nt
    arri_der = (der + n) % Nt

    return np.array([cell, aba_izq, aba, aba_der, izq, der, arri_izq, arri, arri_der])

它的工作性能如下：

>>> %timeit celdas_vecinas(0,5)
567 ns ± 13.8 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)