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: Could somebody give an advice for which is better in my case: C or C++?
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.
I don't know if it's faster than Matlab, but to make python faster you could use Psyco. It speeds up your python code without any changes to your source code.
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.
You might find some useful results at the bottom of this link
http://www.scipy.org/PerformancePython
From the intro
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+Numpy
Of course this is only a specific example, your application might be allow better or worse performance. 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
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 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.
Matlab (Matrix Laboratory) is optimized for Matrix operations.
I think in the best case Python would have the same speed as Matlab, but to be honest i doubt it.
edit: http://old.nabble.com/performance-matrix-multiplication-vs.-matlab-td23870127.html
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.
I would also like to point out that Python (+NumPy) can easily interface with Fortran via the F2Py module, which basically nets you native Fortran speeds on the pieces of code you offload into it.
And here is an updated "comparison" between matlab and numpy/mkl based on some linear algebra functions :
http://dpinte.wordpress.com/2010/03/16/numpymkl-vs-matlab-performance/
The dot product is not that slow ;-)