Is MATLAB faster than Python?

Question

I want to compute magnetic fields of some conductors using the Biot–Savart law and I want to use a 1000x1000x1000 matrix. Before I use MATLAB, but now I want to use Python. Is Python slower than MATLAB ? How can I make Python faster?

EDIT: Maybe the best way is to compute the big array with C/C++ and then transfering them to Python. I want to visualise then with VPython.

EDIT2: Which is better in my case: C or C++?

Solution 1

You might find some useful results at the bottom of this link

http://wiki.scipy.org/PerformancePython

From the introduction,

A comparison of weave with NumPy, Pyrex, Psyco, Fortran (77 and 90) and C++ for solving Laplace's equation.

It also compares MATLAB and seems to show similar speeds to when using Python and NumPy.

Of course this is only a specific example, your application might be allow better or worse performance. There is no harm in running the same test on both and comparing.

You can also compile NumPy with optimized libraries such as ATLAS which provides some BLAS/LAPACK routines. These should be of comparable speed to MATLAB.

I'm not sure if the NumPy downloads are already built against it, but I think ATLAS will tune libraries to your system if you compile NumPy,

http://www.scipy.org/Installing_SciPy/Windows

The link has more details on what is required under the Windows platform.

EDIT:

If you want to find out what performs better, C or C++, it might be worth asking a new question. Although from the link above C++ has best performance. Other solutions are quite close too i.e. Pyrex, Python/Fortran (using f2py) and inline C++.

The only matrix algebra under C++ I have ever done was using MTL and implementing an Extended Kalman Filter. I guess, though, in essence it depends on the libraries you are using LAPACK/BLAS and how well optimised it is.

This link has a list of object-oriented numerical packages for many languages.

http://www.oonumerics.org/oon/

Solution 2

NumPy and MATLAB both use an underlying BLAS implementation for standard linear algebra operations. For some time both used ATLAS, but nowadays MATLAB apparently also comes with other implementations like Intel's Math Kernel Library (MKL). Which one is faster by how much depends on the system and how the BLAS implementation was compiled. You can also compile NumPy with MKL and Enthought is working on MKL support for their Python distribution (see their roadmap). Here is also a recent interesting blog post about this.

On the other hand, if you need more specialized operations or data structures then both Python and MATLAB offer you various ways for optimization (like Cython, PyCUDA,...).

Edit: I corrected this answer to take into account different BLAS implementations. I hope it is now a fair representation of the current situation.

Solution 3

The only valid test is to benchmark it. It really depends on what your platform is, and how well the Biot-Savart Law maps to Matlab or NumPy/SciPy built-in operations.

As for making Python faster, Google's working on Unladen Swallow, a JIT compiler for Python. There are probably other projects like this as well.

Solution 4

As per your edit 2, I recommend very strongly that you use Fortran because you can leverage the available linear algebra subroutines (Lapack and Blas) and it is way simpler than C/C++ for matrix computations.

If you prefer to go with a C/C++ approach, I would use C, because you presumably need raw performance on a presumably simple interface (matrix computations tend to have simple interfaces and complex algorithms).

If, however, you decide to go with C++, you can use the TNT (the Template Numerical Toolkit, the C++ implementation of Lapack).

Good luck.

Solution 5

If you're just using Python (with NumPy), it may be slower, depending on which pieces you use, whether or not you have optimized linear algebra libraries installed, and how well you know how to take advantage of NumPy.

To make it faster, there are a few things you can do. There is a tool called Cython that allows you to add type declarations to Python code and translate it into a Python extension module in C. How much benefit this gets you depends a bit on how diligent you are with your type declarations - if you don't add any at all, you won't see much of any benefit. Cython also has support for NumPy types, though these are a bit more complicated than other types.

If you have a good graphics card and are willing to learn a bit about GPU computing, PyCUDA can also help. (If you don't have an nvidia graphics card, I hear there is a PyOpenCL in the works as well). I don't know your problem domain, but if it can be mapped into a CUDA problem then it should be able to handle your 10^9 elements nicely.

View more solutions

Comments

[extraneon]

It's difficult to estimate speed without code. If you have some Python code that works you can post it again for tips on speedup.

[BlueRaja - Danny Pflughoeft]

Matlab is normally ridiculously good about optimizing matrix computations

[Mike DeSimone]

@Blue: The individual computations should run pretty fast. But we don't know how well Biot-Savart maps to Matlab computations. If it's not well-suited to vectorization, it will get rather slow.

[Admin]

Of course, you must realize that this will require you make at least one matrix that has 10^9 elements. If they are all doubles, then this is about 8 gigabytes of memory. No matter what you do, this will take some time.

[Boldewyn]

At my Physics department, we mostly do C/C++ or FORTRAN, but some use Python as kind of "frontend" to C, which is quite a nice way to go IMHO. I'd go for the Python+C approach.

[Meh]

Do not use C/C++ if you never used them before. It would be an exercise in frustration.

[kame]

But could you make a rough estimation?

[Mike DeSimone]

Not really. Deep down, if everything is done right, both of them will be running vectorized C code. I don't know how well Matlab is optimized (no access to the code) or NumPy/SciPy (haven't looked) in terms of using SSE (or equivalent) instructions. I also don't know how much faster Unladen Swallow will make the Python code. There's also Matlab's preference for storing data in double precision; you don't tell us whether your Python code is using float or double or something else. In short, this is a classic case of insufficient data. Thus, "The only valid test is combat."

[Mike DeSimone]

You should elaborate what you mean by "the same underlying numeric libraries." Matlab is closed source and has been around longer than Python, much less NumPy, so I'm having a hard time thinking what could be common ground beyond, say, the SSE instruction set.

[High Performance Mark]

Upvoted. No-one (I exaggerate) writes matrix manipulation routines, everyone calls them. Of course, someone has to write them in the first place, but if you were writing Matlab or SciPy you'd find a screamingly-fast implementation of BLAS for your target platform(s) and call that. I'll be very surprised to learn that one is significantly faster than the other.

[nikow]

@Mike: This is pretty common knowledge, but for people with no experience in scientific computing I added some more information in my answer.

[Mike DeSimone]

My experience in this area is over six years ending seven years ago. Back then, I used libraries provided by several vendors (Intel MKL was one of them). Matlab's insistence on using double at the time (they had only recently started supporting unsigned 8-bit) meant that we had to write some algorithms in C or C++ to speed them up. So I wrote a library as a layer over the various implementations so our devs would have only one API to deal with. Some algorithms were still too slow and had to be rewritten in assembly. That said, I don't see where my answer was misleading.

[Royi]

The MATLAB version is pretty old. I wonder how much difference it makes.

[Gabriel Ziegler]

Can't access the first link anymore