Question

I have a 1d array of values

i = np.arange(0,7,1)

and a function

# Returns a column matrix
def fn(i):
    return np.matrix([[i*2,i*3]]).T


fnv = np.vectorize(fn) 

then writing

fnv(i)

gives me an error

  File "<stdin>", line 1, in <module>
  File "c:\Python33\lib\site-packages\numpy\lib\function_base.py", 
        line 1872, in __call__
    return self._vectorize_call(func=func, args=vargs)
  File "c:\Python33\lib\site-packages\numpy\lib\function_base.py", 
        line 1942, in _vectorize_call
        copy=False, subok=True, dtype=otypes[0])
  ValueError: setting an array element with a sequence.

The result I am looking for is a matrix with two rows and as many columns as in the input array. What is the best notation in numpy to achieve this?

For example i would equal

[1,2,3,4,5,6]

and the output would equal

[[2,4,6,8,10,12],
 [3,6,9,12,15,18]]

Answer 1

EDIT
You should try to avoid using vectorize, because it gives the illusion of numpy efficiency, but inside it’s all python loops.

If you really have to deal with user supplied functions that take ints and return a matrix of shape (2, 1) then there probably isn’t much you can do. But that seems like a really weird use case. If you can replace that with a list of functions that take an int and return an int, and that use ufuncs when needed, i.e. np.sin instead of math.sin, you can do the following

def vectorize2(funcs) :
    def fnv(arr) :
        return np.vstack([f(arr) for f in funcs])
    return fnv

f2 = vectorize2((lambda x : 2 * x, lambda x : 3 * x))

>>> f2(np.arange(10))
array([[ 0,  2,  4,  6,  8, 10, 12, 14, 16, 18],
       [ 0,  3,  6,  9, 12, 15, 18, 21, 24, 27]])

Just for your reference, I have timed this vectorization against your proposed one:

f = vectorize(fn)


>>> timeit.timeit('f(np.arange(10))', 'from __main__ import np, f', number=1000)
0.28073329263679625
>>> timeit.timeit('f2(np.arange(10))', 'from __main__ import np, f2', number=1000)
0.023139129945661807


>>> timeit.timeit('f(np.arange(10000))', 'from __main__ import np, f', number=10)
2.3620706288432984
>>> timeit.timeit('f2(np.arange(10000))', 'from __main__ import np, f2', number=10)
0.002757072593169596

So there is an order of magnitude in speed even for small arrays, that grows to a x1000 speed up, available almost for free, for larger arrays.

ORIGINAL ANSWER

Don’t use vectorize unless there is no way around it, it’s slow. See the following examples

>>> a = np.array(range(7))
>>> a
array([0, 1, 2, 3, 4, 5, 6])
>>> np.vstack((a, a+1))
array([[0, 1, 2, 3, 4, 5, 6],
       [1, 2, 3, 4, 5, 6, 7]])
>>> np.vstack((a, a**2))
array([[ 0,  1,  2,  3,  4,  5,  6],
       [ 0,  1,  4,  9, 16, 25, 36]])

Whatever your function is, if it can be constructed with numpy’s ufuncs, you can do something like np.vstack((a, f(a))) and get what you want