R.CodeCompared.To/Fortran

A Fortran program needs a program name ... end program name wrapper, and implicit none is written by convention at the top of every one — R has neither ceremony, since a script is just a sequence of top-level expressions. print *, ... plays cat, with the leading * meaning “use default formatting.”

Every variable is declared with its type before it can be assigned — implicit none is what makes an undeclared variable a compile error instead of Fortran’s historical (and dangerous) default of guessing a type from the variable’s first letter. Once declared, assignment is a plain =, with no arrow.

A genuinely rare comfort: like R (and unlike almost every other migration target on this site), Fortran counts array elements from one by default — heights(1) means what it has always meant. Note the parentheses instead of brackets, and size() playing length().

The rarest kinship on this page: Fortran, like R, vectorizes elementwise arithmetic and intrinsic functions over whole arrays with no explicit loop — a feature most languages compared against R (Go, Java, C) have no answer for at all. doses * 2.0 and sqrt(doses) read almost identically to their R counterparts.

This is the sharpest edge of an otherwise gentle migration: R’s array kinship comes with a real silent-bug risk — mismatched vector lengths recycle the shorter one, sometimes with a warning, sometimes (when lengths divide evenly) with none at all. Fortran refuses the question outright: shapes must conform exactly, and a mismatch is a compile-time error whenever sizes are known at compile time, or a runtime failure otherwise. Recycling has to be spelled out by hand if it is genuinely intended.

R lets any name hold any type at any time; Fortran fixes a variable’s type at its declaration — integer, real, character, logical — and no later assignment may change it. This, combined with the compile step, is what catches an entire category of R runtime surprises (a function receiving the wrong type deep into a long-running job) before the program starts at all.

R quietly converts between types wherever an operation needs it; Fortran converts nothing without being told — mixing a logical into arithmetic is a compile error, and building a string from a number goes through an explicit formatted write statement (the I0 edit descriptor means “integer, minimum width”). More ceremony, but the conversion is always visible in the code.

sum, maxval, and minval are built-in array reductions, direct counterparts to R’s. The one gap: there is no built-in mean — Fortran has no general statistics library at all, base or otherwise, so even the average is sum(values) / size(values) written out.

Slicing is another rare point of agreement: readings(2:4) reads exactly like R’s readings[2:4], inclusive on both ends. Arbitrary-position selection also works the same way, indexing with an integer array instead of a single range.

R’s ifelse — a vectorized conditional applied elementwise — becomes the WHERE/ELSEWHERE construct: a mask expression, a branch for where it holds, a branch for where it does not, applied across the whole array with no explicit loop. It reads almost like an if/else block that happens to operate elementwise.

R’s function vectorizes for free because every operation inside it happens to vectorize on its own — write scalar logic and the free ride ends silently. Fortran is explicit about the same idea: mark a function elemental and it may be called on a scalar OR an array of any shape, applied elementwise — the intent is declared, not assumed. Without the keyword, calling a scalar function on an array is a compile error.

Unlike R, Fortran’s if has no value of its own — it cannot be assigned directly. The R idiom of “assign the result of a condition” becomes declare-then-branch-then-set, and every character-string variable must declare its maximum length (len=10) up front, since strings are fixed-width, padded fields rather than R’s flexible ones.

do trial = 1, 5 plays for (trial in 1:5) almost verbatim — inclusive on both ends, exactly like R’s ranges. A third argument is the step, matching the argument order of seq(0, 10, by = 2) rather than requiring the middle-position trap some other target languages introduce.

Every parameter’s type, the result’s type, and — for an array parameter — whether it may be modified (intent(in) declares read-only) are all stated up front. values(:) is an assumed-shape array: the size is not fixed at compile time, but is known and checked at the call site. Functions live inside a module, which also plays the role of R’s namespace-free top-level scripts.

R never lets a function mutate the caller’s data — arguments are effectively copies. Fortran has an explicit tool for the opposite: a subroutine (invoked with call, returning nothing) whose intent(inout) parameters genuinely modify the variable the caller passed in. The intent annotation is what makes this safe and legible — in, out, and inout declare the contract instead of leaving it to convention.

This is the sharpest conceptual gap on the page: Fortran has no built-in missing-value marker at all — no NA, no NaN-aware statistics, nothing checked by the compiler. Real Fortran code agrees on a sentinel value (often a suspicious constant like -999) and every computation must remember to check for it by hand, exactly the discipline na.rm = TRUE automates away in R.

R’s tagged named list becomes a declared type — fields typed and fixed up front, accessed with % instead of $. Every field’s type (and, for strings, its maximum length) is part of the declaration, so misspelling a field name is caught at compile time instead of silently returning NULL.

R strings are as long as their content and nothing more; a Fortran character variable has a FIXED declared length, padded with trailing spaces to fill it. len() always reports the declared width, not the “real” content length — len_trim() is the one that behaves like R’s nchar(). Assigning a longer string than the declared length silently truncates it.

A formatted write statement into a string variable replaces both paste and sprintf at once: the format string in parentheses (F5.1 means “fixed-point, width 5, one decimal place”) plays the role of R’s format specifiers, but ahead of the values rather than interleaved with them. trim() strips the padding before printing, undoing the fixed-width story above.

There is no exception mechanism to catch: idiomatic Fortran checks conditions before they become failures (as here), or checks an IOSTAT integer after an I/O operation — zero means success, nonzero identifies the failure. tryCatch’s job is spread across explicit conditionals at each risky point rather than wrapped once around a block.

The closest analog to stop() is Fortran’s own STOP statement, which halts the program immediately and can carry an integer exit code the operating system sees — useful for scripts that need to detect failure downstream. Unlike R’s condition system, there is no handler to catch it: STOP ends the program, full stop.

This is the honest answer to “why would an R user ever need Fortran”: R already depends on it, one layer down. The BLAS/LAPACK routines behind R’s matrix multiplication and linear algebra are themselves Fortran, and huge bodies of tuned scientific code (climate models, fluid dynamics solvers) exist only in Fortran, with no modern rewrite planned. Writing the hot inner loop of a slow R function in Fortran — called via .Fortran() or a modern FFI — is a well-worn path when profiling shows R itself is the bottleneck. Both cells are illustrative, shown display-only.