объединение массивов с неодинаковыми размерами, сохраняющих фиксированное позиционирование индекса

Question

Допустим, у меня есть данные для 3 пар переменных, A, B и C (в моем реальном приложении число переменных составляет от 1000 до 3000, но может быть даже выше).

Позвольте также сказать, что есть фрагменты данных, которые поступают в массивах.

Например:

Массив X:

np.array([[  0.,   2.,   3.],
        [ -2.,   0.,   4.],
        [ -3.,  -4.,   0.]])

Где:

X[0,0] = corresponds to data for variables A and A
X[0,1] = corresponds to data for variables A and B
X[0,2] = corresponds to data for variables A and C
X[1,0] = corresponds to data for variables B and A
X[1,1] = corresponds to data for variables B and B
X[1,2] = corresponds to data for variables B and C
X[2,0] = corresponds to data for variables C and A
X[2,1] = corresponds to data for variables C and B
X[2,2] = corresponds to data for variables C and C

Массив Y:

np.array([[2,12],
[-12, 2]])

Y[0,0] = corresponds to data for variables A and C
Y[0,1] = corresponds to data for variables A and B
Y[1,0] = corresponds to data for variables B and A
Y[1,1] = corresponds to data for variables C and A

Массив Z:

np.array([[ 99,  77],
       [-77, -99]])

Z[0,0] = corresponds to data for variables A and C
Z[0,1] = corresponds to data for variables B and C
Z[1,0] = corresponds to data for variables C and B
Z[1,1] = corresponds to data for variables C and A

Я хочу объединить вышеупомянутые массивы, сохраняя фиксированную позицию переменной, следующим образом:

END_RESULT_ARRAY index 0 corresponds to variable A
END_RESULT_ARRAY index 1 corresponds to variable B
END_RESULT_ARRAY index 2 corresponds to variable C

В принципе в юниверсе есть N переменных, но они могут меняться каждый месяц (новые могут быть введены, а существующие могут выпасть, а затем вернуться или никогда не вернуться). Внутри N переменных в юниверсе я вычисляю пары перестановок, и положение каждой переменной фиксировано, т. Е. Индекс 0 соответствует переменной A, индекс = 1 соответствует переменной B (как описано выше).

С учетом вышеуказанного требованияконец END_RESULT_ARRAY должен выглядеть следующим образом:

array([[[  0.,   2.,   3.],
        [ -2.,   0.,   4.],
        [ -3.,  -4.,   0.]],

       [[ nan,  12.,   2.],
        [-12.,  nan,  nan],
        [  2.,  nan,  nan]],

       [[ nan,  nan,  99.],
        [ nan,  nan,  77.],
        [-99., -77.,  nan]]])

Имейте в виду, что приведенное выше является иллюстрацией.

В моем реальном приложении у меня есть около 125 массивов, и каждый генерируется новыймесяц. Каждый месячный массив может иметь разные размеры и может содержать данные только для части переменных, определенных в моей вселенной. Кроме того, поскольку новые массивы создаются каждый месяц, невозможно узнать, какой у них будет размер или какие переменные будут иметь данные (или какие будут отсутствовать).

Итак, вплоть до самого последнего месячного массива мы можем определить максимальный размер на основе доступных исторических данных. Каждый месяц мы будем пересматривать максимальный размер всех массивов, когда появится новый массив. Как только у нас будет максимальный размер, мы сможем заново соединить / объединить все массивы, ЕСЛИ ЭТО ЧТО-ТО, ЧТО ДЕЙСТВИТЕЛЬНО в numpy. Это будет текущая операция, выполняемая каждый месяц.

Я хочу, чтобы общий механизм мог соединять эти массивы вместе, соблюдая требования, которые я описываю относительно позиции индекса для фиксированных переменных.

Я действительно хочу использовать H5PY массивы, так как мой набор данных будет расти в геометрической прогрессии в недалеком будущем. Однако я бы хотел, чтобы это работало с numpy в качестве первого шага.

Answer 1

На основании комментария, сделанного @ user3483203. Следующим шагом является объединение массивов.

a = np.array([[  0.,   2.,   3.],
        [ -2.,   0.,   4.],
        [ -3.,  -4.,   0.]])

b = np.array([[0,12], [-12, 0]])


out = np.full_like(a, np.nan); i, j = b.shape;  out[:i, :j] = b

res = np.array([a, out])
print (res)

Answer 2

Это отвечает на первоначальный вопрос, который с тех пор был изменен:

Допустим, у меня есть следующие массивы:

np.array([[  0.,   2.,   3.],
        [ -2.,   0.,   4.],
        [ -3.,  -4.,   0.]])


np.array([[0,12],
[-12, 0]])

Я хочу объединить вышеупомянутые 2 массива так, чтобыконечный результат выглядит следующим образом:

array([[[0, 2, 3], 
[-2, 0, 4],
[-3,-4, 0]],

[[0,12, np.nan],
[-12, 0, np.nan],
[np.nan, np.nan, np.nan]]])

---

Узнайте, на сколько каждый массив превышает максимальный размер в каждом измерении, затем используйте np.pad для заполнения в конце каждого измерения,затем наконец np.stack, чтобы сложить их вместе:

import numpy as np
a = np.arange(12).reshape(4,3).astype(np.float)
b = np.arange(4).reshape(1,4).astype(np.float)

arrs = (a,b)
dims = len(arrs[0].shape)

maxshape = tuple( max(( x.shape[i] for x in arrs)) for i in range(dims))

paddedarrs = ( np.pad(x, tuple((0, maxshape[i]-x.shape[i]) for i in range(dims)), 'constant', constant_values=(np.   nan,)) for x in (a,b))

c = np.stack(paddedarrs,0)

print (a)
print(b,"\n======================")
print(c)

[[ 0.  1.  2.]
 [ 3.  4.  5.]
 [ 6.  7.  8.]
 [ 9. 10. 11.]]
[[0. 1. 2. 3.]]
======================
[[[ 0.  1.  2. nan]
  [ 3.  4.  5. nan]
  [ 6.  7.  8. nan]
  [ 9. 10. 11. nan]]

 [[ 0.  1.  2.  3.]
  [nan nan nan nan]
  [nan nan nan nan]
  [nan nan nan nan]]]