Is Mathematica faster than FORTRAN

Python versus FORTRAN


Which is better: FORTRAN or Python? And in both cases you need Gnuplot, right?

I am currently working on a Windows computer.

I would like to use it to get numerical solutions to physical problems including Monte Carlo simulations, numerical integration and differentiation, molecular dynamics, etc.

I saw a course on computational physics that introduced both FORTRAN (I think) and Python. I plan to start with one and then learn the other, but I don't know which transition might be the easiest.

Also, which compilers would you recommend?

The basic question for me is: which is the easiest to learn, which is the fastest, which is the most user-friendly and above all which is the most used (so a comparison of these 4)? And besides, which compilers (free or paid) are used most often? I am currently considering converting an old laptop (formerly Intel Dual Core) to Linux. hopefully that's quick enough.

Thanks for the previous answers! The answers I am looking for are those of LKlevin and SAAD.

I know the basics of C ++, Maple and have almost complete command of MATLAB and Mathematica9 if that helps.






Reply:


Python and Fortran are relatively easy languages ​​to learn. It is probably easier to find good Python learning materials than good Fortran learning materials because Python is more widely used and Fortran is currently considered a specialty language for numerical arithmetic.

I think the transition from Python to Fortran would be easier. Python is an interpreted language, so the number of steps required to get your first program up and running is fewer (open the interpreter, type at the command prompt) than that for Fortran (write a "hello World "program, compile, run). I also think there is better material in Python for teaching object-oriented style than there is in Fortran, and that there is more Python code available on GitHub than in Fortran code.

Installing Python should be less painful. Windows distributions are available. I recommend a scientific distro like Anaconda or Enthought Canopy. There is no compiler per se; The interpreter takes on this role. You should use a CPython-based interpreter as more numeric libraries are available and work well with C, C ++, and Fortran. Other interpreter implementations include Jython and PyPy.

Installing a Fortran compiler on a Windows computer is annoying. Typical command line compilers are programs like gfortran, ifort (from Intel; free for personal use, otherwise they cost money), and pgfortran (from PGI; free trials, otherwise they cost money). To install these compilers you may need to install some kind of UNIX / POSIX compatibility layer like Cygwin or MinGW. I found it difficult to work with, but some people like this workflow. You can also install a compiler with a graphical user interface like Visual Fortran (again you will have to pay for a license).

On Linux, it's easier to install Python and compilers. I would still install Anaconda or Enthought Canopy as a Python distribution.

If you're using Python (or MATLAB, Mathematica, Maple, or any other interpreted language), you're giving up performance for productivity. Compared to Fortran (or C ++, C, or any other compiled language), you write fewer lines of code to do the same task, which generally means it will take you less time to find a working solution.

The effective performance penalty for using Python varies and is mitigated by delegating computationally intensive tasks to compiled languages. MATLAB does something similar. When you do matrix multiplication in MATLAB, BLAS is called. The performance penalty is practically zero, and you didn't have to write Fortran, C, or C ++ to get the high performance. A similar situation exists in Python. If you can use libraries (e.g. NumPy, SciPy, petsc4py, dolfin from FEniCS, PyClaw) then you can write all your code in Python and get good performance (a penalty of maybe 10-40%) because all computationally Intensive parts are calls to quickly compiled language libraries. However, if you were to write everything in pure Python, the performance degradation would be a factor of 100-1000x. So if you wanted to use Python and had to include a custom one, with a computationally intensive routine, it is better to write this part in a compiled language like C, C ++, or Fortran and then package it with a Python interface. There are libraries (like Cython and f2py) to make this process easier and tutorials to help you. it is generally not a nuisance.

Python is widely used as a general purpose language. Fortran is largely limited to numerical and scientific computing and mainly competes with C and C ++ for users in this domain.

In computer science, Python does not usually compete directly with compiled languages ​​because of the performance drawbacks I mentioned. You would use Python in cases where high productivity and performance are of minor importance, such as: B. in prototyping numerically intensive algorithms, data processing and visualization. You would use Fortran (or any other compiled language) when you have a good idea of ​​what your algorithm and application design should be, you are willing to spend more time writing and debugging your code, and the performance is up paramount importance. (For example, performance is a limiting step in your simulation process or an integral part of your research.) A common strategy is to mix Python and a compiled language (usually C or C ++, but Fortran was also used). Use the compiled language only for the most performance sensitive parts of the code. The development cost, of course, is that it is more difficult to write and debug a program in two languages ​​than it is to write a program in a single language.

In terms of parallelism, the current MPI standard (MPI-3) has native Fortran and C bindings. The MPI-2 standard had native C ++ bindings, but MPI-3 did not, and you would have to use the C bindings. There are third-party MPI bindings such as: B. mpi4py. I used MPI4PY. it works well and is easy to use. For large-scale parallelism (tens of thousands of cores), you will probably want to use a compiled language, as things like dynamically loading the Python modules will get your ass off if you do it in a naive way. There are ways to get around this bottleneck, as the PyClaw developers have shown, but it is easier to avoid it.

I have about a decade of experience in Fortran 90/95 and I have programmed in Fortran 2003 as well. I have about five years of programming experience in Python. I use Python a lot more than Fortran because I honestly do more in Python. Most of the work I have to do doesn't require huge supercomputing resources and is generally not worth redeveloping in another language. Python is therefore well suited to solving ODEs and PDEs. When I need to use a compiled language, I use C, C ++, or Fortran in that order.

Most of the Fortran code I've seen was ugly, largely because most computer scientists were ignorant of or disapproved of best practices discovered by software engineers over the past 30 years. That means: There is no good unit testing framework in Fortran. (The best I've come across is FUnit from NASA, and it's no longer maintained.) There are some good Python unit testing frameworks, good Python documentation generators, and, in general, many better examples of good programming practice.







I would stay away from now or, if you have to, use a reasonably new version (2003 instead of 77). A lot of physical software (especially Monte Carlo simulations) was written in Fortran simply because the projects originally started in the 1980s.

That being said, Python and Fortran are two very different languages, and what they should be used for are very different. Python is on a high level and generally not that fast (compared to Fortran & C ++). The reason it's used so widely is because it's fast enough for most things and has excellent (Fortran powered) libraries for many (but not all) things you would like to do. It also has the excellent matplotlib for plotting (so no GNUplot is needed) and you can get pretty decent performance using things like Cython to write the expensive bits. However, it won't be as fast as Fortran or C ++, and the parallelization is pretty terrible, which makes it unsuitable for high-performance numerical computing. If what you want can be done by calling Fortran or C libraries,

Fortran is a slightly lower language. For numeric data, library support is surprisingly good, but it's still very low, leaving you with a multitude of errors that you could otherwise avoid, such as: For example, accidentally passing the wrong array size to a method. These errors are hard to find, and you may not even notice them. Trust me, I've spent quite a while writing Fortran 77.

C ++ is (in my humble opinion) a happy medium. With libraries like Armadillo or Eigen, you can handle a relatively high level of coding and a low level of performance.

In terms of performance, CPython is the only real choice for numeric Python right now. Downloading something like WinPython will also give you most of the libraries you need.

It's a little more difficult for Fortran on windows. I would recommend switching to Linux and using either Gfortran or Intel Ifort compilers. In my experience, Ifort is usually faster for numeric code, but it is only free for non-commercial, non-academic use.

In conclusion, unless you want to run really heavy simulations, Python is the easier choice and makes the job a lot more enjoyable. It should also be fast enough for most student-level projects. When you need better performance, first look at the wasted amounts of libraries already written and leave it to your language. When you need to write things from scratch, use C ++.

Also a warning: most of the code written by physicists is pretty terrible, presumably because physicists have a tendency to assume that programming is easy and doesn't require the same rigor that they might apply to math. Consider attending a class or buying a book that teaches programming.

Disclaimer: I am a physicist who has spent some time with Monte Carlo codes based on Fortran 77 and currently processes all data in Python.







Python is a very slow high-level language. For fast number processing you have to write the main arithmetic cores in simple languages ​​like C / C ++, which means that you now have to learn not just one but at least two languages. You will also have to deal with additional headaches related to debugging / installation / maintenance etc. Most people use Python as a syntactic sugar to hide the shortcomings of C / C ++.

The modern Fortran (90 and up) is both fast and at a high level with almost MATLAB-like syntax. So you can do things like:

or

or even easier

Etc.

There are a number of free Fortran compilers on Linux. I use

  1. GCC
  2. Solaris Studio
  3. Open64
  4. Intel (for non-commercial use only)

I don't use Mac / OSX, but there is free PGI.

And please do not use FORTRAN 77. Nobody uses it to write new code.

Disclaimer: I personally looked at Python to write my own small, unstructured FE code (built on top of PETSc), but the amount of work / coding involved was more than just writing Fortran 95.



python is very useful for a full simulation analysis with well-documented, versatile packages: grid generation, array computation and data structure processing (numpy and pandas) as well as data visualization with matplotlib. For complex simulations with large result files, it is even better to work with the VTK package, which can be used to read data exports from advanced open source applications (such as Paraview or Visit).

Fortran has been the preferred language for various areas in simulations for some time. It's easy to read (but less readable than Python code). Handling arrays is one of the language's strengths. It is quite easy to define and use in all kinds of array operations. This is also useful when debugging.

The comparison comes down to the Performance on : I've only done extensive calculations with compiled languages ​​(C ++ and Fortran 90), but never with Python. Another thread has more information on interpreted and compiled language performance: What language should I use when teaching a basic computer programming course?

Personally, I like working with Python in general, especially for post-processing. Python programming is fun!






With Python you don't need Gnuplot, for example you can use matplotlib and / or the IPython shell. IPython is an interactive Python shell that provides almost the same drawing commands in% pylab mode that you have in MATLAB.

It is very likely that scientific computing will shift on a large scale from MATLAB to Python in the next 5 years.



I would continue to use MATLAB. It calls fast math libraries, and you won't see a huge difference in performance if you switch to FORTRAN on Windows. At the same time, MATLAB gives you a better infrastructure for reporting results and running your code. The disadvantage of MATLAB is its cost. FORTRAN is basically free and there are a number of free libraries.

FORTRAN is very easy to learn and program. It essentially does what the name suggests: it translates your formulas into code that is easy to read and understand. That's why physicists used it a lot in the past. As long as your code is mostly about solving physical problems (not building GUIs or doing other cool things), FORTRAN code is easy to maintain.

I would only recommend Python if you enjoy programming. Remember, when you are programming a solution to a physical problem, do you enjoy programming part of the solution? If you do this, Python is an option because the language is much better than MATLAB's.



We use cookies and other tracking technologies to improve your browsing experience on our website, to show you personalized content and targeted ads, to analyze our website traffic, and to understand where our visitors are coming from.

By continuing, you consent to our use of cookies and other tracking technologies and affirm you're at least 16 years old or have consent from a parent or guardian.

You can read details in our Cookie policy and Privacy policy.