On 4/21/06, David Cournapeau <david@ar.media.kyoto-u.ac.jp
> wrote:
Robert Kern wrote:
> David Cournapeau wrote:
>
This looks exactly like what I am looking for. My problem for my
function is the following (pseudo code):
foo(x, mu, va):
if mu and va scalars:
call scalar_implementation
return result
if mu and va rank 1:
call scalar implementation on each element
if mu rank 1 and va rank 2:
call matrix implementation
To handle the first two cases (scalar, and call scalar on every element), you should be able to use 'numpy.frompyfunc' to create a version of your scalar function that automatically works that way.
def plusone(v):
return v+1
uf = numpy.frompyfunc(plusone,1,1)
>>> uf(1)
2
>>> uf([1,2,3])
array([2, 3, 4], dtype=object)
and assumed all arguments are always rank 2, even if they are "scalar"
(size 1), a bit like in
numpy.linalg, if I understood
correctly (calling numpy.linalg.inv(1) does not work). It looks like
those atleast* methods should do the work.
Actually, my problem is pretty similar to implementing wrapper around
numpy.linalg.inv which works in scalar case and rank 1 (assuming rank 1
means diagonal) cases. Are those atleast* functions expensive ? For
small size arrays, I don't care too much, but in the case of a big array
of rank 1 converted to a rank 2 array, does those function need to copy
the data ?
Looks like atleast_1d doesn't copy the data, so yes, it should be fast.
a = numpy.array([1,2,3,4])
b = numpy.atleast_2d(a)
a
array([1, 2, 3, 4])
b
array([[1, 2, 3, 4]])
a[1]=0
a
array([1, 0, 3, 4])
b
array([[1, 0, 3, 4]])
--