stdlib VS Bessels.jl

Hopefully, the SciPy community can stay open-minded about modern Fortran libraries.

Modern Fortran is quite different from Fortran 77, while being as powerful, if not more.

In addition, there has been a significant community effort on improving and modernising the legacy packages, the ecosystem, and the language itself.

With projects like LFortran (https://lfortran.org/), fpm (https://github.com/fortran-lang/fpm), and stdlib (https://github.com/fortran-lang/stdlib), I believe that Fortran will enjoy prosperity again.

They're currently working on a Fortran standard library and it's pretty far along: https://github.com/fortran-lang/stdlib

I also like FPM and the ecosystem. In case anyone is just getting started with Fortran, definitely checkout the Fortran Standard Library project:

https://github.com/fortran-lang/stdlib

In general, it is necessary to know the length of a string in Fortran before using it. There is no general string with unspecified strength. Some libraries do provide such an object (e.g. Fortran Standard Library, but it is not available in the standard language. To obtain the length of the string in your example, you could use the length option in get_command_argument as integer :: clen character(len=:), allocatable :: string_b call get_command_argument(2, length=clen) allocate(string_b(clen)) string_b = '' call get_command_argument(2, string_b) write(*,*) string_b deallocate(string_b)

If you need to clear memory in the local scope, you need to deallocate a variable explicitly. Otherwise, all Fortran variables are cleared automatically when they go out of scope. One exception are Fortran pointers (different from C pointers) which are discouraged unless really necessary. We have a discussion for a high-level wrapper for files here: https://github.com/fortran-lang/stdlib/issues/14. So, it's in scope we just haven't gotten far with the design and implementation.

FYPP syntax is ugly, but is the best tool available for now to build the Fortran stdlib. People do not have to use the FYPP version of stdlib. There is also a clean post-processed version of the stdlib completely free of FYPP or any other FPP, which looks great: https://github.com/fortran-lang/stdlib/tree/stdlib-fpm

What if we try to evaluate this using standard-compliant Fortran? Interestingly, this is an open issue in the fortran-lang/stdlib project. f90 real(8) function f(x) real(8) :: x f = x**(1d0/3d0) endfunction I know real(8) isn't standard compliant but fixing that for this tiny example would be a headache. Then, compiling with -O3 gets us f_: movsd xmm1, QWORD PTR .LC0[rip] movsd xmm0, QWORD PTR [rdi] jmp pow .LC0: .long 1431655765 .long 1070945621

learn Fortran (supports both FP and OO, but when we say Fortran we think FP mostly). And the best way to learn is contributing. You can checkout their GitHub org (Fortran-lang) and you might be astonished to see that you too can make contributions there. But you should be ready to learn and search things on your own as well. They have a discourse group too, if you get stuck somewhere. Good luck. At the moment of writing this post they have a good first issue (Greatest Common Divisor) on their stdlib repo.

I recently started learning Fortran for a lark. It reminds me a lot of R, in some respects. It's clearly a very, very good language for doing the parts of one's job that are very math-centric. But it's equally underwhelming as a general purpose programming language.

Largely, I think, due to gaps in the library ecosystem. But there are other challenges. You can see from the install instructions on the linked page, for example, that Fortran still lacks a package manager.

What's interesting, though, is that that's changing. There are currently serious efforts to give it a "standard" library (https://github.com/fortran-lang/stdlib) and package manager (https://github.com/fortran-lang/fpm).

And I've been watching the new LFortran compiler (https://lfortran.org) with extreme interest.

https://github.com/JuliaMath/Bessels.jl/blob/master/src/bess...

Thanks! I love it, so easy to understand and follow.

My favourite work on the subject is Fredrik Johansson's:

https://github.com/fredrik-johansson/arb

Whenever I feel down and without energy I just read something in there

Most of the old Fortran code isn't that great. To the extent it's optimized, it's optimized for PDP era hardware where memory was fast, floating point was slow, fma didn't exist, vectorization didn't exist, computers weren't fast enough to do tedious symbolic math to find better routines, and they weren't fast enough to test hundreds of millions of inputs to ensure correctness and accuracy. The datastructures, algorithms and tuning and testing were never great, and are worse on modern computers. For a simple example of how much of a difference this can make, look at https://github.com/JuliaMath/Bessels.jl which is often 10x faster than AMOS (the old reliable Fortran code).