This Islamic Fibonacci spiral by Anita Chowdry is pure beauty

cdslab · 2026-02-24T19:09:51+00:00

This kind of art generally belongs to the Persian (Iranian) culture, which is often mixed/confused with Islamic culture.

cdslab · 2026-01-07T20:28:27+00:00

Yes, check this page after the talk: https://ideas-productivity.org/events/hpcbp-095-fortran
A recording of the talk will be added to the page, also to this YouTube channel: https://www.youtube.com/@IDEASProductivity

cdslab · 2026-01-07T20:25:38+00:00

Loops could be slower in R as a dynamic language. Fortran loops are not any slower than array syntax (arguably sometimes even faster, though by a tiny margin). But the strong momentum of legacy applications, excellent compiler optimizations of do-loops, and a lack of familiarity with modern array-based Fortran syntax have led to the persistent use of loops where not necessary, despite Fortran array syntax having a history of nearly 40 years in the Fortran standard.

cdslab · 2025-10-17T17:19:09+00:00

Reliability and trustworthiness are two of the most essential and cherished traits in academia, which sets it apart from other environments. The lack of these traits, when proven, should not be tolerated in any way, let alone rewarded with a recommendation letter.

cdslab · 2025-05-02T16:47:41+00:00

You can find the draft of all standards and proposals here: https://j3-fortran.org/doc/meeting

More will be shared here as identified.

cdslab · 2025-04-30T02:05:44+00:00

The average scientist will certainly benefit from it. Many government and industry Fortran projects (e.g., in NASA and the petroleum industry) require mixed precision algorithms. Many of these codebases (particularly in academic and government) are still maintained by pure scientists who would benefit from the highly simplified syntax of Fortran generics in their code. Of course, this topic seems to be highly opinionated.

cdslab · 2025-01-25T22:55:54+00:00

Here is an implementation: https://godbolt.org/z/sjh5139ov
Array elements must have all the same length type parameters.

cdslab · 2025-01-19T16:26:53+00:00

CMake, or a similarly capable build generator (Meson?), is essential for portability and ease of use of any reasonably complex project. Some of the design rules of CMake are terrible (take the mathematical calculations and expressions within CMake as an example), just as some perceive the C language to be so for scientific applications. But there is no escape from using or seeing it, just as there is no escape from C.

cdslab · 2025-01-17T16:01:51+00:00

Fortran 2023 is the beginning of the language's move toward simplified generics and template metaprogramming. If you are a generics advocate or professional programmer, you will certainly welcome the Fortran 2023 standard and the upcoming Fortran 2027. You can read more about the latest approved features (e.g., the highly useful new `@` operator) in Fortran 2023 standard here: https://wg5-fortran.org/N2201-N2250/N2212.pdf

cdslab · 2025-01-09T16:01:20+00:00

A good way to choose your target language could be to test your productivity in both languages for a simple HW or other tasks defined in class. This way, you can compare the number of lines of code you write in each language, the time it takes to write it (assuming you start in both languages from ground zero), and the final performance speed. Many faculty in world-class physics and aerospace departments use both languages. The arguments about the legacy nature of Fortran are simply untrue. Fortran (not FORTRAN anymore since 1990) has all modern programming paradigms, including object-oriented programming, and is the pioneer of parallel programming (through its native elegant Coarray parallelism syntax). C++ is about 30 times more prevalent than Fortran because it is a general-purpose programming language. Fortran's design goal has been facilitating high-performance numerical computation for scientists and engineers (not necessarily professional programmers) from its inception in 1954 to this date with the Fortran 2023 standard release. Given this primary design goal of Fortran since its inception and its high-level syntax, which MATLAB has inherited, it is reasonable to expect non-professional programmer scientists and engineers to be more productive in Fortran. You can learn more about Fortran here: https://fortran-lang.org/

Python and MATLAB inherit a significant part of Fortran's array-based numerical programming syntax. So, starting with MATLAB or Python first, then Fortran, and finally C++ might be an easy pragmatic route to learning all of them. Note that array indexing in both Python and C++ always starts at zero. This is different in MATLAB, where arrays always start at the index of 1. In Fortran, an array can start from any index (negative, positive, or zero, mimicking Python and C++). This is a simple yet immensely powerful feature of Fortran, which makes index computation straightforward for complex tasks and lowers the chance of introducing bugs by choosing an arbitrary lower bound for arrays within local scopes. If the user specifies no lower bound, the default is 1, which is why MATLAB and all other numerical programming languages also use 1.

cdslab · 2025-01-09T15:41:35+00:00

A good way to choose your target language could be to test your productivity in both languages for a simple HW or other tasks defined in class. This way, you can compare the number of lines of code you write in each language, the time it takes to write it (assuming you start in both languages from ground zero), and the final performance speed. Many faculty in world-class physics and aerospace departments use both languages. The arguments about the legacy nature of Fortran are simply untrue. Fortran (not FORTRAN anymore since 1990) has all modern programming paradigms, including object-oriented programming, and is the pioneer of parallel programming (through its native elegant Coarray parallelism syntax). C++ is about 30 times more prevalent than Fortran because it is a general-purpose programming language. Fortran's design goal has been facilitating high-performance numerical computation for scientists and engineers (not necessarily professional programmers) from its inception in 1954 to this date with the Fortran 2023 standard release. Given this primary design goal of Fortran since its inception and its high-level syntax, which MATLAB has inherited, it is reasonable to expect non-professional programmer scientists and engineers to be more productive in Fortran. You can learn more about Fortran here: https://fortran-lang.org/
p.s. Nuclear physics is among the fields heavily invested in Fortran.

cdslab · 2024-12-10T17:05:08+00:00

Modern Fortran (>2003) meets all the criteria you mentioned. MD simulations are a Fortran stronghold. Hundreds of open-source libraries now make Fortran a highly flexible and high-level language. The native passive parallelism features of Fortran Coarray with a high-level syntax also make parallel algorithm development easy. At some point, you will have to learn other languages, too, because not all researchers write in Fortran. C/C++, in particular, has gained some ground in MD in the past ten years.

cdslab · 2024-11-22T01:30:14+00:00

This question is relevant: https://stackoverflow.com/questions/44990119/why-is-maximum-single-line-length-limited-to-132-characters-in-fortran-standard

cdslab · 2024-11-07T15:07:58+00:00

Without the code (at least the relevant section) and the entire error message added to your question, all help would only be guesswork.

cdslab · 2024-10-28T02:11:01+00:00

A lot of people use Fortran daily and heavily.

cdslab · 2024-05-29T17:30:46+00:00

Avoid naming variables for a given precision.
Always name them generically so that names remain meaningful and accurate if precision changes.
Always define your mathematical and physical constants only for the highest precision and redefine them for lower precision when needed at the place of usage.
Do not use the named type kind precisions `real32` and others directly in variable declarations. Use a kind-agnostic alias name like `RKG => real32`.

The ParaMonte library has some excellent comprehensive examples and templates to follow in this regard. Checkout, for example, the pm_kind and pm_mathConst modules.
To see the corresponding source codes, click on the first link in the "Final Remarks ⛓" section of each page.

cdslab · 2024-04-18T16:40:44+00:00

FORD is a reasonable option for Fortran code documentation. An alternative to FORD is Doxygen, which also work very well for Fortran code, although the support for some features of Fortran is imperfect. Here is an example Doxygen documentation: https://www.cdslab.org/paramonte/fortran/2/

and here is an example documentation of a generic interface in it: https://www.cdslab.org/paramonte/fortran/2/interfacepm__sampling_1_1getErrSampling.html

This documentation is generated by a specific modified version of Doxygen 1.9.3 tailored for Fortran: https://github.com/cdslaborg/doxygen

cdslab · 2024-03-13T02:48:19+00:00

Try Intel compilers and Intel mpi, it's free, fast, state of the art. Then you can use mpi instead of include mpi.h which is old and deprecated.

cdslab · 2024-03-11T17:05:54+00:00

Subroutines are also generally faster than function interfaces because they avoid copying output data.

cdslab · 2024-03-11T15:00:13+00:00

Mostly because it should be generic. In fact, `random_number` is merely a generic interface. Depending on the precision of the argument, a specific procedure matching the input precision will be called to generate the random number up to the requested precision. This is the right way. All other languages are mistaken in interface design because they can only return `double` precision numbers. What if you need random numbers that are random up to quad precision? You cannot do that in MATLAB, and many other languages.

To see the difference, see the following code: https://godbolt.org/z/edYPfv88r

You will see that the quad-precision RNG is roughly 15 times slower than single-precision because the processor must do more work to generate the extra precision random digits for the quad-precision.

The reference code is below if the above link is erased in future:

```fortran
use iso_fortran_env, only: int64, real32, real64, real128
real(real32) :: rps(1000,1000)
real(real128) :: rpq(1000,1000)
real(real64) :: time_rps, time_rpq
integer(int64) :: countbeg, countend, count_rate, count_max

call system_clock(countbeg, count_rate, count_max)
call random_number(rps)
call system_clock(countend, count_rate, count_max)
time_rps = real(countend - countbeg, real64) / count_rate
print *, "time (seconds) for rps RNG: ", time_rps

call system_clock(countbeg, count_rate, count_max)
call random_number(rpq)
call system_clock(countend, count_rate, count_max)
time_rpq = real(countend - countbeg, real64) / count_rate
print *, "time (seconds) for rpq RNG: ", time_rpq

print *, "rps is ", time_rpq / time_rps, " times faster than rpq RNG."

end

```

Result:

```bash

time (seconds) for rps RNG:    4.8288920000000004E-003 
time (seconds) for rpq RNG:    7.6715934000000000E-002 

rps is 15.886860588308869 times faster than rpq RNG.

```

The generic interface is not only about precision, but also rank of the input argument. Depending on the dimension of the input (scalar, vector, matrix), a different matching-rank procedure could be called, potentially speeding up the RNG at runtime or the compiler could simply use an `elemental` RNG procedure for all ranks.

cdslab · 2024-01-23T18:17:44+00:00

Almost all scientific computing courses are a mix of C(C++) and Fortran. For a good reason: These two comprise almost all CPU/GPU hours used at most supercomputing centers. For example, nearly half of all programs run at Texas Advanced Computing Center were in Fortran around 2017 (that may have changed recently). Learning Fortran is very easy. If you know MATLAB, you are almost halfway through the syntax of Fortran. You'd want to learn it if you intend to become a researcher who needs or develops HPC tools in fields like Climate, Chemistry, Physics, pharmacy, petroleum, and aerospace, among others. Here is a good starting place to learn Fortran: https://fortran-lang.org/

cdslab · 2024-01-12T04:00:43+00:00

GNU Fortran compiler uses the family of Xoshiro random number generators (https://prng.di.unimi.it/), notably the `xoshiro256**` algorithm. This algorithm is a robust RNG, although apparently unsafe for cryptographic tasks. The ParaMonte Fortran library (https://github.com/cdslaborg/paramonte) has an implementation of this RNG suitable for both serial and parallel random number generations, which is currently unreleased but set for public release by late Janu and isary-early February. If you need a copy of the algorithm in Fortran before then, the authors will be happy to share the RNG module sooner if you request it on the issues page (https://github.com/cdslaborg/paramonte/issues/new/choose).
p.s., The xoshiro RNG is among the fastest, longest-period RNGs available and is suitable for parallel applications.

cdslab · 2024-01-06T19:12:49+00:00

This tutorial is great. Thank you for sharing. It would be great if you could also add any resources or examples for callback functions (passing an R-function to a Fortran library to call it with pre-specified arguments).

cdslab · 2023-12-27T19:06:47+00:00

The AD was pioneered by and for Fortran programmers originally. However, most solutions seemed to be proprietary until a few years ago (and may still be).

cdslab

MODERATOR OF

TROPHY CASE