[Numpy-discussion] Efficient operator overloading

Xavier Gnata gnata@obs.univ-lyon1...
Wed Apr 18 15:13:52 CDT 2007


Timothy Hochberg wrote:
>
>
> On 4/18/07, *Sturla Molden* <sturla@molden.no 
> <mailto:sturla@molden.no>> wrote:
>
>
>     On 4/18/2007 7:33 AM, Anne Archibald wrote:
>
>     >copying. And the scope of improvement would be very limited; an
>     expression like A*B+C*D would be much more efficient, probably, if the
>     whole expression were evaluated at once for each element (due to
>     memory locality and temporary allocation). But it is impossible for
>     numpy, sitting inside python as it does, to do that.
>
>
>
>     Most numerical array/matrix libraries dependent on operator
>     overloading
>     generates temporaries. That is why Fortran is usually perceived as
>     superior to C++ for scientific programming. The Fortran compiler knows
>     about arrays and can avoid allocating three temporary arrays to
>     evaluate
>     and expression like
>
>     y = a * b + c * d
>     [SNIP]
>
>
>
>     I'd really like to see a Python extension library do this one day. It
>     would be very cool and (almost) as efficient as plain Fortran - though
>     not quite, we would still get some small temporary objects
>     created. But
>     that is a sacrifice I am willing to pay to use Python. We would gain
>     some efficacy over Fortran by postponing indefinitely evaluation of
>     computations that are not needed, when this is not known at compile
>     time.
>
>
>     Any comments?
>
>
> I periodically wonder if something like this could be built on top of 
> numexpr without too much pain. Simply build up the expression on 
> operations and then evaluate when data is requested. You'd need some 
> sort of Jekyl & Hyde matrix that spent the first part of it's life 
> unevaluated and then converted itself to something very much like an 
> array when it evaluated itself. If might end up being tricky to make 
> sure that everything got transparently evaluated at the right time 
> though.
>
> I've never had time to try it though.
>
>  
>
>     Sturla Molden
>     Ph.D.
>
Hi,

Correct me if I'm wrong but it is not possible to code something working 
like boost++ in python.
It is due to the fact we cannot overload the = operator in python. As a 
result you cannot implement the way boost++ works : + * - / operators 
build a tree and all the loops are done in the = operator code.

I do not say that it is impossible to code an efficient way to deal with 
operators and matrix in python but only that it looks not possible to 
match the boost++ way of thinking.

Comments?

Xavier


-- 
############################################
Xavier Gnata
CRAL - Observatoire de Lyon
9, avenue Charles André
69561 Saint Genis Laval cedex
Phone: +33 4 78 86 85 28
Fax: +33 4 78 86 83 86
E-mail: gnata@obs.univ-lyon1.fr
############################################ 



More information about the Numpy-discussion mailing list