tableau de diffusion Numpy

Question

je le tableau suivant dans NumPy:

A = array([1, 2, 3]) 

Comment puis-je obtenir les matrices suivantes (sans boucle explicite)?

B = [ 1 1 1 
     2 2 2 
     3 3 3 ] 

C = [ 1 2 3 
     1 2 3 
     1 2 3 ] 

Merci!

Answer 1

Edit2: L'OP demande dans les commentaires comment calculer

n(i, j) = l(i, i) + l(j, j) - 2 * l(i, j) 

je peux penser à deux manières. J'aime cette façon parce qu'il généralise facilement:

import numpy as np 

l=np.arange(9).reshape(3,3) 
print(l) 
# [[0 1 2] 
# [3 4 5] 
# [6 7 8]] 

L'idée est d'utiliser np.ogrid. Ceci définit une liste de deux réseaux, l'un numpy de forme (3,1) et une forme de (1,3):

grid=np.ogrid[0:3,0:3] 
print(grid) 
# [array([[0], 
#  [1], 
#  [2]]), array([[0, 1, 2]])] 

grid[0] peuvent être utilisés comme un indicateur de l'indice i, et grid[1] peut être utilisé comme un proxy pour l'indice j.

donc partout dans l'expression l(i, i) + l(j, j) - 2 * l(i, j), vous remplacez simplement i ->grid[0] et j ->grid[1], et la diffusion numpy se charge du reste:

n=l[grid[0],grid[0]] + l[grid[1],grid[1]] + 2*l 
print(n) 
# [[ 0 6 12] 
# [10 16 22] 
# [20 26 32]] 

Cependant, dans ce cas particulier, depuis l(i,i) et l(j,j) ne sont que les éléments de diagonale l, vous pouvez le faire à la place:

d=np.diag(l) 
print(d) 
# [0 4 8] 

d[np.newaxis,:] pompes la forme de d à (1,3) et d[:,np.newaxis] pompes jusqu'à la forme de d à (3,1).

La diffusion numérique envoie vers le haut d[np.newaxis,:] et d[:,np.newaxis] pour formater (3,3), en copiant les valeurs appropriées.

n=d[np.newaxis,:] + d[:,np.newaxis] + 2*l 
print(n) 
# [[ 0 6 12] 
# [10 16 22] 
# [20 26 32]] 

---

Edit1: En général, vous n'avez pas besoin de former B ou C. Le but de la diffusion Numpy est de vous permettre d'utiliser A à la place de B ou C. Si vous nous montrez comment vous prévoyez d'utiliser B ou C, nous pourrions vous montrer comment faire la même chose avec A et la diffusion numérique.

---

(réponse originale):

In [11]: B=A.repeat(3).reshape(3,3) 

In [12]: B 
Out[12]: 
array([[1, 1, 1], 
     [2, 2, 2], 
     [3, 3, 3]]) 

In [13]: C=B.T 

In [14]: C 
Out[14]: 
array([[1, 2, 3], 
     [1, 2, 3], 
     [1, 2, 3]]) 

ou

In [25]: C=np.tile(A,(3,1)) 

In [26]: C 
Out[26]: 
array([[1, 2, 3], 
     [1, 2, 3], 
     [1, 2, 3]]) 

In [27]: B=C.T 

In [28]: B 
Out[28]: 
array([[1, 1, 1], 
     [2, 2, 2], 
     [3, 3, 3]]) 

du département des Tricheries:

In [57]: np.lib.stride_tricks.as_strided(A,shape=(3,3),strides=(4,0)) 
Out[57]: 
array([[1, 1, 1], 
     [2, 2, 2], 
     [3, 3, 3]]) 

In [58]: np.lib.stride_tricks.as_strided(A,shape=(3,3),strides=(0,4)) 
Out[58]: 
array([[1, 2, 3], 
     [1, 2, 3], 
     [1, 2, 3]]) 

Mais notez que ce sont vues de A, pas de copies (comme l'ont été les solutions ci-dessus). Changement B, modifie A:

In [59]: B=np.lib.stride_tricks.as_strided(A,shape=(3,3),strides=(4,0)) 

In [60]: B[0,0]=100 

In [61]: A 
Out[61]: array([100, 2, 3]) 

---

Answer 2

fil très vieux, mais juste au cas où quelqu'un se soucie ...

C,B = np.meshgrid(A,A)