Как заполнить интервалы между элементами массива с постоянным шагом и объединить два таких массива с первичным и вторичным приоритетами?

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

Это не приятно, но работает:

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)

Answer 2

TL; DR в конце

Я бы начал с создания выходного буфера правильного размера, используя np.repeat, затем заполнив восходящий / нисходящие порции с al oop.

Давайте посмотрим на размер прогонов, которые у вас есть, и разработаем стратегию повторения, чтобы заполнить их. Учитывая набор данных 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 l oop:

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 l oop. Итак, давайте сделаем действительно векторизованное решение. Для начала нам нужен массив кумулятивных сумм, который мы можем использовать для добавления в каждый восходящий / нисходящий раздел. Если мы просто сделаем 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; DR

Вот полностью векторизованный решение:

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