stdlib VS SciPyDiffEq.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.

Check out the SciML ecosystem. They are doing amazing work in that space. You might also want to integrate your methods with their libraries, as it will boost their potential audience massively. https://sciml.ai/

Interesting response. I develop the Julia SciML organization https://sciml.ai/ and we'd be more than happy to work with you to get wrappers for PRIMA into Optimization.jl's general interface (https://docs.sciml.ai/Optimization/stable/). Please get in touch and we can figure out how to set this all up. I personally would be curious to try this out and do some benchmarks against nlopt methods.

Overall, your analysis is very Python centric. It's not very clear to me why Julia should focus on convincing Python users or developers. There are many areas of numerical and scientific computing that are not well served by Python, and it's exactly those areas that Julia is pushing into. The whole SciML https://sciml.ai/ ecosystem is a great toolbox for writing models and optimizations that would have otherwise required FORTRAN, C, and MATLAB. Staying within Julia provides access to a consistent set of autodiff technologies to further accelerate those efforts.

What about the other benchmarks on the same site? https://docs.sciml.ai/SciMLBenchmarksOutput/stable/Bio/BCR/ BCR takes about a hundred seconds and is pretty indicative of systems biological models, coming from 1122 ODEs with 24388 terms that describe a stiff chemical reaction network modeling the BCR signaling network from Barua et al. Or the discrete diffusion models https://docs.sciml.ai/SciMLBenchmarksOutput/stable/Jumps/Dif... which are the justification behind the claims in https://www.biorxiv.org/content/10.1101/2022.07.30.502135v1 that the O(1) scaling methods scale better than O(log n) scaling for large enough models? I mean.

> If you use special routines (BLAS/LAPACK, ...), use them everywhere as the respective community does.

It tests with and with BLAS/LAPACK (which isn't always helpful, which of course you'd see from the benchmarks if you read them). One of the key differences of course though is that there are some pure Julia tools like https://github.com/JuliaLinearAlgebra/RecursiveFactorization... which outperform the respective OpenBLAS/MKL equivalent in many scenarios, and that's one noted factor for the performance boost (and is not trivial to wrap into the interface of the other solvers, so it's not done). There are other benchmarks showing that it's not apples to apples and is instead conservative in many cases, for example https://github.com/SciML/SciPyDiffEq.jl#measuring-overhead showing the SciPyDiffEq handling with the Julia JIT optimizations gives a lower overhead than direct SciPy+Numba, so we use the lower overhead numbers in https://docs.sciml.ai/SciMLBenchmarksOutput/stable/MultiLang....

> you must compile/write whole programs in each of the respective languages to enable full compiler/interpreter optimizations

You do realize that a .so has lower overhead to call from a JIT compiled language than from a static compiled language like C because you can optimize away some of the bindings at the runtime right? https://github.com/dyu/ffi-overhead is a measurement of that, and you see LuaJIT and Julia as faster than C and Fortran here. This shouldn't be surprising because it's pretty clear how that works?

I mean yes, someone can always ask for more benchmarks, but now we have a site that's auto updating tons and tons of ODE benchmarks with ODE systems ranging from size 2 to the thousands, with as many things as we can wrap in as many scenarios as we can wrap. And we don't even "win" all of our benchmarks because unlike for you, these benchmarks aren't for winning but for tracking development (somehow for Hacker News folks they ignore the utility part and go straight to language wars...).

If you have a concrete change you think can improve the benchmarks, then please share it at https://github.com/SciML/SciMLBenchmarks.jl. We'll be happy to make and maintain another.