Bądź specjalną matrycę o przekątnej w NumPy

Question

Próbuję dokonać numpy tablicę, która wygląda tak:

[a b c  ] 
[ a b c  ] 
[ a b c ] 
[  a b c ] 

Więc ten obejmuje aktualizację głównej przekątnej i dwóch przekątnych powyżej niej.

Jaki byłby skuteczny sposób robienia tego?

Answer 1

Możesz użyć np.indices, aby uzyskać indeksy swojej tablicy, a następnie przypisać wartości tam, gdzie chcesz.

i,j to odpowiednio indeksy linii i kolumn.

a[i==j] = 1. 
a[i==j-1] = 2. 
a[i==j-2] = 3. 

spowoduje:

array([[ 1., 2., 3., 0., 0., 0., 0., 0., 0., 0.], 
     [ 0., 1., 2., 3., 0., 0., 0., 0., 0., 0.], 
     [ 0., 0., 1., 2., 3., 0., 0., 0., 0., 0.], 
     [ 0., 0., 0., 1., 2., 3., 0., 0., 0., 0.], 
     [ 0., 0., 0., 0., 1., 2., 3., 0., 0., 0.]]) 

Answer 2

import numpy as np 

def using_tile_and_stride(): 
    arr = np.tile(np.array([10,20,30,0,0,0], dtype='float'), (4,1)) 
    row_stride, col_stride = arr.strides 
    arr.strides = row_stride-col_stride, col_stride 
    return arr 

In [108]: using_tile_and_stride() 
Out[108]: 
array([[ 10., 20., 30., 0., 0., 0.], 
     [ 0., 10., 20., 30., 0., 0.], 
     [ 0., 0., 10., 20., 30., 0.], 
     [ 0., 0., 0., 10., 20., 30.]]) 

inne, wolniejsze alternatywy obejmują:

import numpy as np 

import numpy.lib.stride_tricks as stride 

def using_put(): 
    arr = np.zeros((4,6), dtype='float') 
    a, b, c = 10, 20, 30 
    nrows, ncols = arr.shape 
    ind = (np.arange(3) + np.arange(0,(ncols+1)*nrows,ncols+1)[:,np.newaxis]).ravel() 
    arr.put(ind, [a, b, c]) 
    return arr 

def using_strides(): 
    return np.flipud(stride.as_strided(
     np.array([0, 0, 0, 10, 20, 30, 0, 0, 0], dtype='float'), 
     shape=(4, 6), strides = (8, 8))) 

---

Jeśli używasz using_tile_and_stride pamiętać, że tablica jest odpowiednia tylko dla tylko do odczytu. W przeciwnym razie, jeśli były, aby spróbować zmodyfikować tablicę, może być zaskoczony, gdy wiele miejsca array zmienić jednocześnie:

In [32]: arr = using_tile_and_stride() 

In [33]: arr[0, -1] = 100 

In [34]: arr 
Out[34]: 
array([[ 10., 20., 30., 0., 100.], 
     [ 100., 10., 20., 30., 0.], 
     [ 0., 0., 10., 20., 30.], 
     [ 30., 0., 0., 10., 20.]]) 

Można to obejść przez powrót np.ascontiguousarray(arr) zamiast tylko arr, ale potem using_tile_and_stride byłby wolniejszy niż using_put. Więc jeśli chcesz zmodyfikować tablicę, lepszym wyborem będzie using_put.

Answer 3

Skorzystając z mojej odpowiedzi na to pytanie: changing the values of the diagonal of a matrix in numpy, można wykonać pewne skomplikowane cięcie, aby uzyskać widok każdej przekątnej, a następnie wykonać zadanie. W tym przypadku byłoby to po prostu:

import numpy as np 
A = np.zeros((4,6)) 
# main diagonal 
A.flat[:A.shape[1]**2:A.shape[1]+1] = a 
# first superdiagonal 
A.flat[1:max(0,A.shape[1]-1)*A.shape[1]:A.shape[1]+1] = b 
# second superdiagonal 
A.flat[2:max(0,A.shape[1]-2)*A.shape[1]:A.shape[1]+1] = c 

Answer 4

Jest przykładem Toeplitz matrix - można skonstruować go za pomocą scipy.linalg.toeplitz:

import numpy as np 
from scipy.linalg import toeplitz 

first_row = np.array([1, 2, 3, 0, 0, 0]) 
first_col = np.array([1, 0, 0, 0]) 

print(toeplitz(first_col, first_row)) 
# [[1 2 3 0 0 0] 
# [0 1 2 3 0 0] 
# [0 0 1 2 3 0] 
# [0 0 0 1 2 3]]