Except some people don't read the article and already assume numpy is "very" optimized that they might gloss over that line without reading much into it. That line also doesn't say that you might get a 10x speed-up while using numba. I remember when I first came across numba I searched HN for references and didn't find many stories or comments praising it so I skipped over it initially so having HN comments might be useful for future HN'ers.

The equivalent of Nutika for numerical code is pythran. Which compiles to highly optimized c++ code. I have been getting the best speedup with the least changes when using it compared to numba or cython (haven't tested taichi yet).

s/Nutika/Nuitka

https://en.m.wikipedia.org/wiki/Nuitka

Seems like pytorch does: https://stackoverflow.com/questions/63169760/how-can-i-use-n...

Jax already has its own tracing compiler which produces optimized code.

I think GP is referring to the heat equation. "species" is the concentration of the "stuff" that you're describing mathematically. Call that u(x), where is a spatial coordinate and u is a real valued function.

Then the diffusive part says

du(x, t)/dt = \nabla_x u(x, t).

The \nabla term is the laplacian: a multivariate form of the second derivative.

The equation says that a short time from now, u(x, t) will change in proportion to the average value of u, calculated over a small ball surrounding the point x, minus the value of u at the point x itself.

If there's less "stuff" in the points that neighbour x than at x itself, the function will decrease over time. Similarly if there's more stuff at the neighbours of x, u(x, t) will increase. This is the basis of diffusive behaviour.

(Edit: I think the equation in the article is wrong, unless I've misunderstood something: they have a delta (first derivative) when they should have a nabla (laplacian))

What do you mean disappointing? I have consistently been getting the best results with pythran. That said it is strongly focused on numerical code, so your milage might vary for other code. You also should add compiler optimisation flags to get the best performance.

Regarding Nutika AFAIK its goal is not a speed up and performance gains are pretty modest in most cases.

Yes, I mean Pythran ( https://github.com/serge-sans-paille/pythran ). Thank you.

Was Nuitka better? Pythran is quite simple to install and use in Jupyter.

Historically this was a legitimate performance micro-optimization in Python:

    def f(i):
         ...

    def g():
        _f = f
        for i in range(100000):
            _f(i)

because looking up a local variable was faster than looking up a global. I'm not sure if that's still true in newer versions.

Isn’t that expected behaviour, as you’re only looking up “a” once when you do it outside the loop, while doing it every time when inside the loop?

Because any reference in the whole hierarchy could change during the looping (e.g. one could say “multiple.levels = {}” at some point), the interpreter really would need to check it every time unless it can somehow “prove” that these changes will never happen / haven’t happened.

Just keeping a reference to “a” is semantically very different, and I’d consider that a normal optimisation.