python - 如何以恒定步长填充数组元素之间的间距，并将两个这样的数组与主要和次要优先级组合起来？

Question

对于给定的随机数组

a = np.random.rand(3)
>>> a
array([0.51, 0.19, 0.72])

我想用常量 step = 0.1 填充元素之间的区域，这样我就有了结果数组

>>> pop_func(a)
array([0.51, 0.41, 0.31, 0.21, 0.19, 0.29, 0.39, 0.49, 0.59, 0.69, 0.72])

现在我有两个这样的数组(它们是 2dim 数组的主要和次要组件)； pri_ara 和 sec_ara，ara = np.array([pri_ara, sec_ara]).T。

我想在每个轴上执行相同的 pop_func 但有一个扭曲。 ara 将被填充，这样在 ara 的索引下，pri_ara 首先递增到下一个元素，而 sec_ara 组件保持不变，然后是 sec_ara 增量，而 pri_ara 组件保持不变，.这很难用语言表达，但作为一个明确的例子，step = 0.1:

pri_ara = array([0.51, 0.19, 0.32])
sec_ara = array([0.14, 0.44, 0.48])
ara = np.array([pri_ara, sec_ara]).T

>>> twistpop_func(ara)
np.array([[0.51, 0.14], 
          [0.41, 0.14], 
          [0.31, 0.14], 
          [0.21, 0.14], 
          [0.19, 0.14], 
          [0.19, 0.24], 
          [0.19, 0.34], 
          [0.19, 0.44], 
          [0.29, 0.44], 
          [0.32, 0.44], 
          [0.32, 0.48]])

---

我尝试做的是在每个组件数组的每个元素中创建一个 np.arange，即

pri_ara = pri_ara[..., None]
a, b = pri_ara[:-1], pri_ara[1:]
absign = np.nan_to_num((a - b)/np.abs(a - b), nan=1) # nan_to_num necessary to remove nan entries where element of a and b are equal
                                                     # set nan -> 1, so arange will not create any elements inbetween
pri_ara = np.concatenate(
    (a, b, absign * step * np.ones_like(a)), 
    axis = -1
)
pri_ara = np.apply_along_axis(lambda x: np.arange(*x), axis=-1, arr=pri_ara)

最后一行不起作用，因为 np.arange 的长度对于数组中的每个 x 都不同，并且 numpy 要求轴具有相同的形状。

一个解决方案是将每一行填充为相同的长度，但这会使事情变得复杂，因为当我将 pri_ara 和 sec_ara 组合在一起时，我将不得不删除填充。

如果有更直接的方法，我会非常喜欢!

Answer 1

TL;最后的 DR

我会首先使用 np.repeat 制作一个大小合适的输出缓冲区，然后用循环填充上升/下降部分。

让我们看看您的运行规模，并制定重复策略以填充它们。给定数据集 ara

0.51 0.14
0.19 0.44
0.32 0.48

你想得到

0.51 0.14
0.41 0.14  4 = abs(0.19 - 0.51) // step + 1
0.31 0.14
0.21 0.14
---- ----
0.19 0.14
0.19 0.24  3 = abs(0.44 - 0.14) // step + 1
0.19 0.34
---- ----
0.19 0.44  2 = abs(0.32 - 0.19) // step + 1
0.29 0.44
---- ----
0.32 0.44  1 = abs(0.48 - 0.44) // step + 1
---- ----
0.32 0.48  last section is always size 1

使用上面显示的大小信息，这显然是基于 np.diff(ara, axis=0)，我们可以首先构造一个如下所示的数组:

0.51 0.14
0.51 0.14
0.51 0.14
0.51 0.14
0.19 0.14
0.19 0.14
0.19 0.14
0.19 0.44
0.19 0.44
0.32 0.44
0.32 0.48

诀窍是将所有元素重复所需的次数:

signs = np.diff(ara, axis=0, append=ara[-1, None]).ravel()[:-1]
d = (np.abs(signs) // step).astype(int) + 1
repeats = np.tile(d, 2)
values = np.repeat(ara.ravel(order='F'), 2)[1:-1]

buffer = np.repeat(values, repeats).reshape(-1, 2, order='F')

剩下的部分是填写升序/降序数字的范围。这可以通过 for 循环轻松完成:

ends = np.cumsum(d)
starts = np.zeros_like(end)
starts[1:] = ends[:-1]
for col, start, end in zip(itertools.cycle((0, 1)), starts, ends):
    s = buffer[start, col]
    e = buffer[end, col]
    buffer[start:end, col] = np.arange(s, e, np.copysign(step, e - s))

但这“一点也不好玩”，因为它使用了一个for 循环。所以让我们做一个真正的矢量化解决方案。首先，我们需要一个累积和数组，我们可以使用它来添加到每个升序/降序部分。如果我们只是执行 np.arange(buffer.shape[0]) * step，在每个部分边界重置，并获得正确的符号，我们可以简单地将其添加到缓冲区以获得输出。想象一下以下操作:

( 0 -  0) * step * sign(0.19 - 0.51)
( 1 -  0) * step * sign(0.19 - 0.51)
( 2 -  0) * step * sign(0.19 - 0.51)
( 3 -  0) * step * sign(0.19 - 0.51)
 --   --
( 4 -  4) * step * sign(0.44 - 0.14)
( 5 -  4) * step * sign(0.44 - 0.14)
( 6 -  4) * step * sign(0.44 - 0.14)
 --   --
( 7 -  7) * step * sign(0.32 - 0.19)
( 8 -  7) * step * sign(0.32 - 0.19)
 --   --
( 9 -  9) * step * sign(0.48 - 0.44)
 --   --
(10 - 10) * step * "Doesn't matter"

第一列是递增范围。第二列是每个部分的偏移量，看起来像部分长度的累加和。这些符号已经是我们计算出来的东西。

整个操作如下所示:

numbers = np.arange(buffer.shape[0])
offsets = np.zeros(d.size)
offsets[1:] = np.cumsum(d[:-1])
offsets = np.repeat(offsets, d)
signs = np.repeat(signs, d)

ramps = (numbers - offsets) * np.copysign(step, signs)

在将其添加到输出缓冲区之前，我们必须将此数组分成两列，按部分交替。您可以通过将 ramps 复制到两列并将不需要的元素设置为零来做到这一点:

ramps = np.stack((ramps, ramps), axis=1)
mask = np.zeros((d.size, 2))
mask[::2, 0] = mask[1::2, 1] = 1
mask = np.repeat(mask, d, axis=0)

buffer += ramps * mask

长话短说

这是一个完全矢量化的解决方案:

def twistpop_func(ara):
    signs = np.diff(ara, axis=0, append=ara[-1, None]).ravel()[:-1]

    d = (np.abs(signs) // step).astype(int) + 1

    repeats = np.tile(d, 2)

    values = np.repeat(ara.ravel(order='F'), 2)[1:-1]

    buffer = np.repeat(values, repeats).reshape(-1, 2, order='F')

    numbers = np.arange(buffer.shape[0])

    offsets = np.zeros(d.size)
    offsets[1:] = np.cumsum(d[:-1])
    offsets = np.repeat(offsets, d)

    signs = np.repeat(signs, d)

    ramps = (numbers - offsets) * np.copysign(step, signs)
    ramps = np.stack((ramps, ramps), axis=1)

    mask = np.zeros((d.size, 2))
    mask[::2, 0] = mask[1::2, 1] = 1
    mask = np.repeat(mask, d, axis=0)

    buffer += ramps * mask
    return buffer