对于给定的随机数组
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而分量保持不变，然后在pri_ara分量保持不变时递增sec_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)
最后一行不起作用，因为数组中每个x的np.arange长度不同，并且 numpy 要求轴具有相同的形状。
一种解决方案是将每行填充为具有相同长度，但这会使事情复杂化，因为当我将pri_ara和sec_ara组合在一起时，我将不得不删除填充。
如果有更直接的方法，真的很喜欢它！
TL;最后的灾难恢复
我将首先使用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
TL;博士
这是一个完全矢量化的解决方案：
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
这并不好，但它有效：
import numpy as np
pri_ara = np.array([0.51, 0.19, 0.72, 0.21])
sec_ara = np.array([0.14, 0.44, 0.48, 0.81])
def pop_func(arr, step):
diff = np.diff(arr)
diff_steps = (diff / step).astype(int)
diff_abs = np.abs(diff_steps) + 1
diff_sign = np.sign(diff_steps)
res = np.hstack([arr[i] + step*diff_sign[i]*np.arange(diff_abs[i])
for i in range(len(arr) - 1)])
res = np.hstack([res, arr[-1:]])
return res, diff_abs
def twistpop_func(arr1, arr2, step):
n = len(arr1)
arr1_pop, d1 = pop_func(arr=arr1, step=step)
arr2_pop, d2 = pop_func(arr=arr2, step=step)
org_idx1 = np.zeros(n, dtype=int)
org_idx1[1:] = np.cumsum(d1)
org_idx1[2:] += np.cumsum(d2[1:])
org_idx2 = np.zeros(n, dtype=int)
org_idx2[1:] = np.cumsum(d2)
org_idx2[1:] += np.cumsum(d1)
for i in range(n-1):
arr1_pop = np.insert(arr1_pop, np.full(d2[i], org_idx1[i+1]), arr1[i+1])
arr2_pop = np.insert(arr2_pop, np.full(d1[i], org_idx2[i]), arr2[i])
return np.stack((arr1_pop, arr2_pop), axis=1)
res = twistpop_func(arr1=pri_ara, arr2=sec_ara, step=0.1)