Есть ли какая-нибудь непонятная функция, которая может сделать маленькие с точки зрения диагональных матриц столбцов с большим количеством элементов в строках?

Question

Мне нужно создать массив Num2N. Это должно быть похоже на стопку диагональных матриц с нулями и единицами в строках

[1100 [111000 0011 000111 1100 111000 0011] 000111 111000 000111]

Я пытался создать массивы единиц и нулей и объединить их. Но вместо матрицы получил еще один большой массив

N=4
ones = np.ones(N)
zeros = np.zeros(N)
odd_row = np.concatenate([ones,zeros])
even_row = np.concatenate([zeros,ones])
two_row = np.concatenate((odd_row, even_row), axis=0)
a = np.empty(0)
total = a
for i in range (0, N//2):
    total = np.concatenate((total, two_row), axis=0)
total = total.reshape(N, 2*N)

Answer 1

Вот один метод, использующий трансляцию:

n = 5

sum(np.ogrid[:n*n:n,-n:n])//n&1

или (больше печатать, но быстрее)

np.arange(n)[:,None]+np.arange(-n,n)//n)&1

или (другая стратегия набирает текст, но быстрее)

def f_pp():
    out = np.zeros((n,2*n),int)
    flat = out.ravel()               
    flat[3*n:-n].reshape(-1,2*n)[::2] = 1 
    flat[:n] = 1
    if not n&1:
        flat.ravel()[-n:] = 1
    return out


# array([[1, 1, 1, 1, 1, 0, 0, 0, 0, 0],
#        [0, 0, 0, 0, 0, 1, 1, 1, 1, 1],
#        [1, 1, 1, 1, 1, 0, 0, 0, 0, 0],
#        [0, 0, 0, 0, 0, 1, 1, 1, 1, 1],
#        [1, 1, 1, 1, 1, 0, 0, 0, 0, 0]])

ogrid создает

c,r = np.ogrid[:n*n:n,-n:n]

столбец

array([[ 0],
       [ 5],
       [10],
       [15],
       [20]])

и ряд

array([[-5, -4, -3, -2, -1,  0,  1,  2,  3, 4]])

Они выбраны так, что их легко можно преобразовать в двоичные шаблоны:

c//n&1

array([[0],
       [1],
       [0],
       [1],
       [0]])

r//n&1

array([[1, 1, 1, 1, 1, 0, 0, 0, 0, 0]])

, которые затем суммируются с использованием широковещания и сохраняются данные.

Answer 2

Вы можете сделать это с помощью диапазона, который вы конвертируете в 1 и 0, прежде чем изменить его форму

N = 3
r = np.arange(N*N*2)//N
r = np.reshape(1 - r%2 ^ r//2%2,(N,2*N))

[[1, 1, 1, 0, 0, 0],
 [0, 0, 0, 1, 1, 1],
 [1, 1, 1, 0, 0, 0]]

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

Значения получены из диапазона с использованием следующих числовых свойств:

• Если рассматривать левый и правый блоки как «номера столбцов», номера столбцов блоков будутi // N% 2
• Каждый номер строки будет i // (2 * N)
• четные и нечетные номера строк обозначаются i // (2 * N)% 2
• Чтобы чередовать 1 и 0, мы используем исключительное значение или ^ между четно-нечетными значениями (0 или 1) строк и значениями столбцов блока (также 0 или 1)
• Длясначала получаем блок 1s, мы вычитаем результат из 1, который инвертирует 1s и 0s
• Наконец, мы преобразуем массив в матрицу

Визуально, (для N = 3) этоВот как будут выглядеть промежуточные значения:

r (range)  [0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,15,16,17]

r//N       [0, 0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4, 5, 5, 5]
r//N//2    [0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2]

r//N%2     [0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1]
r//N//2%2  [0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0]

^          [0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1]
1 - .      [1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0]

reshape    [1, 1, 1, 0, 0, 0][0, 0, 0, 1, 1, 1][1, 1, 1, 0, 0, 0]

Вы также можете обработать строкуШаблоны s и столбцов раздельно и объединяют их в матрицу (вместо того, чтобы использовать изменение формы):

 r = np.arange(1,N+1)[:,None]%2 ^ np.arange(N*2)//N

Это делает шаблоны 1 и 0 немного более прямыми.

Более «механический»способ сделать это состоит в том, чтобы подготовить матрицу из двух строк с четными и нечетными строками, а затем использовать чередующиеся индексы 0 и 1 для формирования фактических строк матрицы:

zo   = np.arange(2*N)//N    # [0,0,0,1,1,1]
ozzo = np.array([1-zo,zo])  # [[1,1,1,0,0,0][0,0,0,1,1,1]] odd/even rows
r = ozzo[np.arange(N)%2]    # ozzo[0,1,0,1,0,1] actual row selection