# [SciPy-user] vectorizing methods?

Dede ded.espaze@laposte....
Tue Jul 24 03:51:06 CDT 2007

```Sorry to reply a little late, I have else that solution:

def vectorize(bar_function):
def modified_bar_function(self, x):
return bar_function(self, x) + self.a
modified_bar_function.__doc__ = "Be carrefull, I am not who you think"
return modified_bar_function

class VectorizeBar(type):
def __init__(cls, name, bases, dct):
setattr(cls, "bar", vectorize(dct["bar"]))

class Bar:
__metaclass__ = VectorizeBar

def bar(self, x):
return x

a = 2.

It brings some magic but it's rather funny in some cases.

Cheers,

Dede

On Sun, 15 Jul 2007 11:32:44 +0200
Gael Varoquaux <gael.varoquaux@normalesup.org> wrote:

> On Sat, Jul 14, 2007 at 04:31:59PM -0700, Greg Novak wrote:
> > Is there a preferred way to vectorize methods, rather than
> > functions? The obvious thing doesn't work:
>
> > class foo:
> >     def bar(self, x): pass
> >     bar = vectorize(bar)
>
> This cannot work, as you are applying "vectorize" before the class is
> built, so the function is still unbound. The binding process, which
> happens during the building of the class, will not like what you have
> done to the function to vectorize it, mainly the fact that it is no
> longer a plain function.
>
>
> > class foo:
> >     __vectorMethods = ('bar', )
>
> >     def __init__(self, n):
> >         for name in self.__vectorMethods:
> >             setattr(self, name, vectorize(getattr(self, name)))
>
> >     def bar(self, x): pass
>
> There you are vectorizing after the construction of the instance, so
> the method is already bound.
>
> > which works fine but it doesn't seem like it should be necessary to
> > do it in the initialization of every instance.
>
> Well, if your methods don't really refer to the object (they don't use
> self at all in the body of the function), you could do something like:
>
> class Foo(object):
>     @staticmethod
>     @vectorize
>     def bar(x):
>         return x
>
>
> In the static method there is no reference to the object. The problem
> is that when the class is binding the method (making a call in which
> the first argument is already assigned to the instance) it is really
> modifying it. If you could apply vectorize to only part of the
> argument, and get a curry of the original function you could than
> transform bar(self, *args) in baz(self, *args), where *args can be
> vectors, and this might work.
>
> Is can see two ways out of this:
>
>    1) Do some heavy magic with a metaclass and modify the binding
> process (I am talking about things I don't know, so it may not be
>       feasible).
>
>  2.a) Use a static method that you vectorize, and pass it the
> instance as the first argument using a convention bound method:
>
> 	class Foo(object):
> 	    @staticmethod
> 	    @vectorize
> 	    def bar(self, x):
> 		return self.a + x
>
> 	    def baz(self, x):
> 		return self.bar(self, x)
>
> 	    a = 1
>
>  2.b) IMHO it would be even cleaner to only pass interesting vectors
> to the vectorize staticmethod, as it has been vectorized relatively to
>       "self", but self cannot be a vector:
>
> 	class Foo(object):
> 	    @staticmethod
> 	    @vectorize
> 	    def bar(a, x):
> 		return a + x
>
> 	    def baz(self, x):
> 		return self.bar(self.a, x)
>
> 	    a = 1
>
>       Basically this is similar to using a standard function instead
> of a method, but lets face it, the notions of bound method and
>       vectorized function seem mutually incompatible as they both
> want to modify a function.
>
> It might be possible to implement a decorator similar to staticmethod
> that does the proces presented in 2.a) but hiddes it from the user,
> but to do this, you would need to understand how staticmethod works,
> and I suspect there is some cooperation of the class building
> mechanisme (so we are back to 1), I think).
>
> I hope 2.a) or 2.b) suit you, elsewhere maybe some one has a better
> idea ?
>
> Cheers,
>
> Gaël
> _______________________________________________
> SciPy-user mailing list
> SciPy-user@scipy.org
> http://projects.scipy.org/mailman/listinfo/scipy-user
```