Array elementwise operations

Question

I have two input arrays x and y of the same shape. I need to run each of their elements with matching indices through a function, then store the result at those indices in a third array z. What is the most pythonic way to accomplish this? Right now I have four four loops - I'm sure there is an easier way.

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]]

I am getting confused since my function will only work on individual data pairs. I can't simply pass the x and y arrays to the function.

Is there any hope that you can do the operation on the matrix level? For example, `z = x + y` works in your example above. Perhaps you could show us what your function is and we can help you get it working on matrices? — mathematical.coffee, Nov 25 '12 at 23:38

score 27 · Accepted Answer · edited Mar 05 '20 at 11:29

One "easier way" is to create a NumPy-aware function using numpy.vectorize. A "ufunc" is NumPy terminology for an elementwise function (see documentation here). Using numpy.vectorize lets you use your element-by-element function to create your own ufunc, which works the same way as other NumPy ufuncs (like standard addition, etc.): the ufunc will accept arrays and it will apply your function to each pair of elements, it will do array shape broadcasting just like standard NumPy functions, etc. The documentation page has some usage examples that might be helpful.

In [1]: import numpy as np
   ...: def myfunc(a, b):
   ...:     "Return 1 if a>b, otherwise return 0"
   ...:     if a > b:
   ...:         return 1
   ...:     else:
   ...:         return 0
   ...: vfunc = np.vectorize(myfunc)
   ...: 

In [2]: vfunc([1, 2, 3, 4], [4, 3, 2, 1])
   ...: 
Out[2]: array([0, 0, 1, 1])
In [3]: vfunc([1, 2, 3, 4], 2)
   ...: 
Out[3]: array([0, 0, 1, 1])

score 4 · Answer 2 · answered Nov 25 '12 at 23:48

(I'm guessing your talking about simple python list, not numpy.array)

Recursion always making our life easier:

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]]

It will work in any other kind of dimensional array:

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

James Waldby - jwpat7 · Answer 3 · 2019-06-12T20:29:30.573

The following transcript from a python 2.7.3 interpreter session illustrates use of builtin function map to apply an elementwise operation to 2D-matrix elements. (Note: operator.add is equivalent to the elementwise_function specified in question, and also equivalent to the lambda expression in the second use of 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]]

Note, the above has x, y as follows:

x=[[2, 2, 1], [2, 2, 2], [3, 2, 2]]
y=[[3, 3, 1], [3, 2, 3], [3, 3, 3]]

As mentioned before, the transcript above is from a python 2.7.3 interpreter session. If this code is run in python 3, it will instead return map objects. One can use a function like the following to see the numbers:

def itemize(m):
    return [itemize(e) for e in m] if hasattr(m, '__iter__') else m

With that function in place, the statement

itemize(applier(x, y, operator.add))

returns

[[5, 5, 2], [5, 4, 5], [6, 5, 5]]

@onurcanbektas, that's a consequence of python 3 vs 2. See edit for more info and of course upvote the edit! — James Waldby - jwpat7, Jun 12 '19 at 20:30

Array elementwise operations

3 Answers3