Algorithms as objects?

Chris Rebert clp2 at rebertia.com
Fri Aug 28 01:14:35 CEST 2009


On Thu, Aug 27, 2009 at 4:05 PM,
Kreso<kkumNOTTHISer at thatsearchenginesguglsemail.com> wrote:
>
> I am writing an application that essentially calculates set of numbers,
> say N1, N2, ..., where they can be calculated by several different
> algorithms. (One should be able to choose the algorithm at run time.)
> In each algorithm one starts from a set of functions, say f1, f2, ...,
> which are then transformed into some other functions g1(f1, f2, ..),
> g2(f1, f2, ...), ... , then maybe transformed once more and result is
> obtained by evaluating final functions.
>  I can naturally think about this as a collection of transformation
> blocks, which have functions as input and output, and which can be
> put together to get the final results. However, I am not sure
> how to program this, especially since one cannot subclass function
> type. To be clear let me give simplified example of what is needed:
>
> f(x) has unknown shape, so one would like to try, say
>
> f1(x) = ax - b x**2   or    f2(x) = a sin(b*x),
>
> where a and b are variable parameters.
>
> Then, one would like to create, with known k(x,y), function g(x)
> in one of two ways:
>
> g1(x) = k(x, x)*f(x)  or   g2(x) = integrate(k(x, y) * f(y), y=0..1),
>
> and finally evaluate N=g(1) as result. In this simple example
> there are 4 different algorithms  for f(x) -> g(x) -> N, and one
> should be able to simply choose between them, e.g. by calling
> N(g1, f2, (a,b)).
>
> In practice algorithm is not necessary so linear,  but is
> generally tree-lika:
>
> (a,b) -> f1(x) --->g1(x)---+
>                           |--> h(x) --> N
> (c,d) ---+--> g2(x)--------+
>         |
>  f2(x) --+
>
>
> It would be nice to have some class of function-objects,
> that f1(x), .., g1(x), ... could be members/instances of so that common
> operations on these functions could be possible (checking
> that they satisfy some necessary properties, plotting them, ...),
> and then second "class" of transformations/methods operating on
> these objects.
> I seem to be confused by the fact that I would like to somehow treat
> algorithms as objects (so that one can experiment with different
> algorithm systems) but I don't have clear picture how to do it.
> I am just brainstorming for ideas. Any advice is welcome.

It sounds like you're describing the Strategy Pattern
(http://en.wikipedia.org/wiki/Strategy_pattern).

To have objects callable like functions, just implement the  __call__
special method in your class(es):
http://docs.python.org/reference/datamodel.html#object.__call__

Cheers,
Chris
--
http://blog.rebertia.com



More information about the Python-list mailing list