Нумерованная матрица нулевой панели

Ответ 1

numpy.pad с режимом constant делает то, что вам нужно, где мы можем передать кортеж в качестве второго аргумента, чтобы указать, сколько нулей для заполнения на каждом размере, (2, 3), например, будет содержать 2сильные > нули с левой стороны и 3 нули с правой стороны:

Учитывая A как:

A = np.array([1,2,3,4,5])

np.pad(A, (2, 3), 'constant')
# array([0, 0, 1, 2, 3, 4, 5, 0, 0, 0])

Также возможно проложить двумерные массивы numpy, передав кортеж кортежей в качестве ширины заполнения, который принимает формат ((top, bottom), (left, right)):

A = np.array([[1,2],[3,4]])

np.pad(A, ((1,2),(2,1)), 'constant')

#array([[0, 0, 0, 0, 0],           # 1 zero padded to the top
#       [0, 0, 1, 2, 0],           # 2 zeros padded to the bottom
#       [0, 0, 3, 4, 0],           # 2 zeros padded to the left
#       [0, 0, 0, 0, 0],           # 1 zero padded to the right
#       [0, 0, 0, 0, 0]])

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

B = np.pad(A, (0, 1024 - len(A)%1024), 'constant')
B
# array([1, 2, 3, ..., 0, 0, 0])
len(B)
# 1024

Для более крупного A:

A = np.ones(3000)
B = np.pad(A, (0, 1024 - len(A)%1024), 'constant')
B
# array([ 1.,  1.,  1., ...,  0.,  0.,  0.])

len(B)
# 3072

Ответ 2

Это должно работать:

def pad(A, length):
    arr = np.zeros(length)
    arr[:len(A)] = A
    return arr

Вы можете получить немного лучшую производительность, если вы инициализируете пустой массив (np.empty(length)), а затем заполняете A и zeros отдельно, но я сомневаюсь, что ускорения будут стоить дополнительной сложности кода в в большинстве случаев.

Чтобы получить значение для прокрутки до, я думаю, вы, вероятно, просто используете что-то вроде divmod:

n, remainder = divmod(len(A), 1024)
n += bool(remainder)

В принципе, это просто определяет, сколько раз 1024 делит длину вашего массива (и какова остальная часть этого подразделения). Если нет остатка, вам просто нужны элементы n * 1024. Если есть остаток, то вы хотите (n + 1) * 1024.

все вместе:

def pad1024(A):
    n, remainder = divmod(len(A), 1024)
    n += bool(remainder)
    arr = np.zeros(n * 1024)
    arr[:len(A)] = A
    return arr        

Ответ 3

Для справок в будущем:

def padarray(A, size):
    t = size - len(A)
    return np.pad(A, pad_width=(0, t), mode='constant')

padarray([1,2,3], 8)     # [1 2 3 0 0 0 0 0]

Ответ 4

Вы также можете использовать numpy.pad:

>>> A = np.array([1,2,3,4,5])
>>> npad = 8 - len(A)
>>> np.pad(A, pad_width=npad, mode='constant', constant_values=0)[npad:]
array([1, 2, 3, 4, 5, 0, 0, 0])

И в функции:

def pad(A, npads):
    _npads = npads - len(A)
    return np.pad(A, pad_width=_npads, mode='constant', constant_values=0)[_npads:]

Ответ 5

Там np.pad:

A = np.array([1, 2, 3, 4, 5])
A = np.pad(A, (0, length), mode='constant')

Что касается вашего варианта использования, необходимое количество нулей для площадки можно рассчитать как length = len(A) + 1024 - 1024 % len(A).