Как эффективно построить симметричную матрицу?

Question

Я хочу построить симметричную матрицу с помощью.

r=np.arange(0,11)
k=np.zeros((11,11))

for i in r:
    k[i]=np.arange(i,i-11,-1)

Как избавиться от цикла for для более эффективного построения матрицы?

Answer 1

Вы можете создать свой массив в один слой.

np.fromfunction(lambda r,c: r-c, (11,11))

Результат:

array([[  0.,  -1.,  -2.,  -3.,  -4.,  -5.,  -6.,  -7.,  -8.,  -9., -10.],
       [  1.,   0.,  -1.,  -2.,  -3.,  -4.,  -5.,  -6.,  -7.,  -8.,  -9.],
       [  2.,   1.,   0.,  -1.,  -2.,  -3.,  -4.,  -5.,  -6.,  -7.,  -8.],
       [  3.,   2.,   1.,   0.,  -1.,  -2.,  -3.,  -4.,  -5.,  -6.,  -7.],
       [  4.,   3.,   2.,   1.,   0.,  -1.,  -2.,  -3.,  -4.,  -5.,  -6.],
       [  5.,   4.,   3.,   2.,   1.,   0.,  -1.,  -2.,  -3.,  -4.,  -5.],
       [  6.,   5.,   4.,   3.,   2.,   1.,   0.,  -1.,  -2.,  -3.,  -4.],
       [  7.,   6.,   5.,   4.,   3.,   2.,   1.,   0.,  -1.,  -2.,  -3.],
       [  8.,   7.,   6.,   5.,   4.,   3.,   2.,   1.,   0.,  -1.,  -2.],
       [  9.,   8.,   7.,   6.,   5.,   4.,   3.,   2.,   1.,   0.,  -1.],
       [ 10.,   9.,   8.,   7.,   6.,   5.,   4.,   3.,   2.,   1.,   0.]])

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

Answer 2

Вы можете сделать это следующим образом:

k = np.arange(0, 11)[:, np.newaxis] + np.arange(0, -11, -1)
print(k)

Выход:

[[  0  -1  -2  -3  -4  -5  -6  -7  -8  -9 -10]
 [  1   0  -1  -2  -3  -4  -5  -6  -7  -8  -9]
 [  2   1   0  -1  -2  -3  -4  -5  -6  -7  -8]
 [  3   2   1   0  -1  -2  -3  -4  -5  -6  -7]
 [  4   3   2   1   0  -1  -2  -3  -4  -5  -6]
 [  5   4   3   2   1   0  -1  -2  -3  -4  -5]
 [  6   5   4   3   2   1   0  -1  -2  -3  -4]
 [  7   6   5   4   3   2   1   0  -1  -2  -3]
 [  8   7   6   5   4   3   2   1   0  -1  -2]
 [  9   8   7   6   5   4   3   2   1   0  -1]
 [ 10   9   8   7   6   5   4   3   2   1   0]]

Обратите внимание, что эта матрица не симметрична, а антисимметрична .

Еще один более сложный способ получить тот же результат, но с меньшим объемом памяти, - создать массив с номерами от 10 до -10 и «пролистать» его в каждой строке:

import numpy as np

def make_matrix(n):
    r = np.arange(n, -(n + 1), -1)
    s, = r.strides
    m = np.ndarray(shape=(n + 1, n + 1),
                   dtype=r.dtype,
                   buffer=r.data,
                   offset=s * n,
                   strides=(-s, s),
                   order='C')
    # Avoid writing since it is not a contiguous array
    m.flags.writeable = False
    return m

print(make_matrix(10))
# Same output

Это толькозанимает память первого массива вместо квадратичного размера непрерывной матрицы.

РЕДАКТИРОВАТЬ:

Если вы хотите создать симметричную матрицу, вы можете принять абсолютное значение:

k = np.abs(np.arange(0, 11)[:, np.newaxis] + np.arange(0, -11, -1))

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

import numpy as np

def make_matrix(n):
    a = np.arange(n + 1)
    r = np.concatenate([a[::-1], a[1:]])
    s, = r.strides
    m = np.ndarray(shape=(n + 1, n + 1),
                   dtype=r.dtype,
                   buffer=r.data,
                   offset=s * n,
                   strides=(-s, s),
                   order='C')
    m.flags.writeable = False
    return m

print(make_matrix(10))

Вывод:

[[ 0  1  2  3  4  5  6  7  8  9 10]
 [ 1  0  1  2  3  4  5  6  7  8  9]
 [ 2  1  0  1  2  3  4  5  6  7  8]
 [ 3  2  1  0  1  2  3  4  5  6  7]
 [ 4  3  2  1  0  1  2  3  4  5  6]
 [ 5  4  3  2  1  0  1  2  3  4  5]
 [ 6  5  4  3  2  1  0  1  2  3  4]
 [ 7  6  5  4  3  2  1  0  1  2  3]
 [ 8  7  6  5  4  3  2  1  0  1  2]
 [ 9  8  7  6  5  4  3  2  1  0  1]
 [10  9  8  7  6  5  4  3  2  1  0]]

О производительности, здесь у вас есть несколько тестовв этом случае смежные и несмежные:

import numpy as np

def make_matrix_cont(n):
    return np.abs(np.arange(0, n + 1)[:, np.newaxis] + np.arange(0, -(n + 1), -1))

def make_matrix_noncont(n):
    a = np.arange(n + 1)
    r = np.concatenate([a[::-1], a[1:]])
    s, = r.strides
    m = np.ndarray(shape=(n + 1, n + 1), dtype=r.dtype, buffer=r.data, offset=s * n, strides=(-s, s), order='C')
    m.flags.writeable = False
    return m

n = 1000
k_cont = make_matrix_cont(n)
k_noncont = make_matrix_noncont(n)
print(np.all(k_cont == k_noncont))
# True

%timeit make_matrix_cont(n)
# 3.48 ms ± 42.7 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
%timeit make_matrix_noncont(n)
# 5.2 µs ± 11.1 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

%timeit k_cont.sum()
# 317 µs ± 4.1 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
%timeit k_noncont.sum()
# 370 µs ± 1.59 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

%timeit k_cont @ k_cont
# 313 ms ± 3.9 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
%timeit k_noncont @ k_noncont
# 417 ms ± 1.44 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

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