Operazioni elementari della matrice

Question

Ho due matrici di input xey della stessa forma. Ho bisogno di eseguire ciascuno dei loro elementi con indici corrispondenti attraverso una funzione, quindi memorizzare il risultato in quegli indici in un terzo array z. Qual è il modo più poderoso per realizzare questo? In questo momento ho quattro quattro anelli: sono sicuro che c'è un modo più semplice.

x = [[2, 2, 2], 
    [2, 2, 2], 
    [2, 2, 2]] 

y = [[3, 3, 3], 
    [3, 3, 3], 
    [3, 3, 1]] 

def elementwise_function(element_1,element_2): 
    return (element_1 + element_2) 

z = [[5, 5, 5], 
    [5, 5, 5], 
    [5, 5, 3]] 

Mi sto confondendo poiché la mia funzione funzionerà solo su singole coppie di dati. Non posso semplicemente passare gli array xey alla funzione.

Answer 1

Un "modo più semplice" è creare una funzione di rilevamento di NumPy utilizzando numpy.vectorize. Un "ufunc" è la terminologia NumPy per una funzione elementwise (vedere la documentazione here). Usando numpy.vectorize puoi usare la tua funzione elemento per elemento per creare il tuo ufunc, che funziona allo stesso modo degli altri uPunc di NumPy (come aggiunta standard, ecc.): L'ufunc accetterà gli array e applicherà la tua funzione a ogni coppia di elementi, farà broadcasting di forma di array proprio come le funzioni standard di NumPy, ecc. Il documentation page ha alcuni esempi di utilizzo che potrebbero essere utili.

Answer 2

(sto cercando di indovinare il vostro parlare semplice python list, non numpy.array)

ricorsione sempre rendere la nostra vita più facile:

def operate_on_Narray(A, B, function): 
    try: 
     return [operate_on_Narray(a, b, function) for a, b in zip(A, B)] 
    except TypeError as e: 
     # Not iterable 
     return function(A, B) 

Usage:

>>> x = [[2, 2, 2], 
...  [2, 2, 2], 
...  [2, 2, 2]] 
>>> 
>>> y = [[3, 3, 3], 
...  [3, 3, 3], 
...  [3, 3, 1]] 
>>> operate_on_Narray(x, y, lambda a, b: a+b) 
[[5, 5, 5], [5, 5, 5], [5, 5, 3]] 

lavorerà in qualsiasi altro tipo di matrice dimensionale:

>>> operate_on_Narray([1, 2, 3], [4, 5, 6], lambda a, b: a*b) 
[4, 10, 18] 

Answer 3

La seguente trascrizione da una sessione di interprete python 2.7.3 illustra l'uso della funzione incorporata map per applicare un'operazione elementwise agli elementi della matrice 2D. (Nota: operator.add equivalente alla elementwise_function specificato in questione, e anche equivalente alla espressione lambda nel secondo uso di applier.)

>>> import operator 
>>> def applier(a, b, op): 
...  return map(lambda ro: map(op, ro[0], ro[1]), zip(a,b)) 
... 
>>> applier(x, y, operator.add) 
[[5, 5, 2], [5, 4, 5], [6, 5, 5]] 
>>> x; y 
[[2, 2, 1], [2, 2, 2], [3, 2, 2]] 
[[3, 3, 1], [3, 2, 3], [3, 3, 3]] 
>>> applier(x, y, lambda p,q: p+q) 
[[5, 5, 2], [5, 4, 5], [6, 5, 5]] 
>>> applier(x, y, lambda p,q: p-q) 
[[-1, -1, 0], [-1, 0, -1], [0, -1, -1]] 
>>> applier(x, y, lambda p,q: p*q) 
[[6, 6, 1], [6, 4, 6], [9, 6, 6]]