Ruby.CodeCompared.To/Fortran

Every Fortran program begins with program name and ends with end program name. The print *, statement writes to standard output; the asterisk means "use default formatting." Modern Fortran programs always include implicit none immediately after the program statement.

implicit none requires every variable to be explicitly declared. Without it, Fortran automatically assigns types based on the first letter of the variable name — a legacy rule that causes hard-to-find bugs. Modern Fortran code always uses implicit none; it is the equivalent of Ruby's always-required local variable assignment before use.

Fortran uses ! for comments, both standalone and inline. This is identical to Ruby's # character in purpose. There are no block comment delimiters — each comment line requires its own !.

Fortran uses the ampersand & at the end of a line to continue onto the next. Ruby allows method chains across lines after an operator or with a backslash. The Fortran & can also appear at the start of the continuation line when breaking inside a string literal.

The contains keyword separates the executable part of a program from its internal subroutines and functions. Internal subprograms can access the host program's variables directly — similar to how Ruby methods defined inside another method have closure access, but in Fortran the access is explicit and by host association.

Fortran INTEGER is 32 bits by default (range −2,147,483,648 to 2,147,483,647) on most systems. The kind() intrinsic returns the kind value, which equals the number of bytes. Multiple variables can be declared on one line separated by commas.

Fortran real is 32-bit single precision; double precision is 64-bit, equivalent to Ruby's Float. The d0 suffix marks a double-precision literal (like Python's no-suffix float is always 64-bit). The e0 suffix marks single precision.

Fortran LOGICAL literals are .true. and .false. with surrounding dots. Boolean operators are spelled out: .and., .or., .not., .eqv. (exclusive equality), and .neqv.. This verbose syntax prevents ambiguity in expressions.

Fortran has built-in COMPLEX number support as a first-class type, making it ideal for signal processing, quantum mechanics, and electrical engineering. The intrinsics real(), aimag(), abs(), and conjg() extract components, magnitude, and conjugate respectively.

The KIND system lets you precisely control the storage size of numeric types. iso_fortran_env provides portable named constants like int64 and real64. The _kind suffix on a literal constant sets its kind: 3.14_real64 is a double-precision literal. This level of control is essential for scientific computing where memory layout affects performance.

The parameter attribute declares compile-time constants that cannot be changed at runtime. Fortran's parameter is analogous to Ruby's capitalized constants. Named parameters improve readability and prevent "magic number" bugs — the compiler catches any attempt to assign a new value to a parameter.

Like Ruby, Fortran performs integer division when both operands are integers: 17 / 5 is 3, not 3.4. The mod() intrinsic computes the remainder. To get real division, convert at least one operand with real(). This is a frequent source of bugs when porting algorithms from Ruby or Python.

Fortran uses ** for exponentiation, identical to Ruby. Mathematical intrinsics (sqrt, sin, cos, abs, exp, log) are built into the language — no require 'math' needed. These functions are elemental: they work on scalars and arrays alike.

The max() and min() intrinsics accept two or more arguments. real() converts an integer to floating point for division — without it, (score_a + score_b) / 2 would perform integer division and lose the fractional part. Fortran also provides nint() (nearest integer), int(), and anint() for rounding.

Fortran's standard library includes log10(), sin(), cos(), tan(), asin(), atan2(), sinh(), cosh(), tanh(), and the error function erf() — all intrinsic, no imports required. This breadth of built-in math reflects Fortran's scientific computing heritage.

Fortran character(len=N) declares a fixed-length string of exactly N characters, right-padded with spaces when a shorter value is assigned. len() returns the declared length; len_trim() returns the length without trailing spaces — the equivalent of Ruby's .length on a stripped string. The len=* syntax lets a parameter inherit its length from its initializer.

Fortran uses // for string concatenation. The trim() call removes trailing spaces before concatenating — without it, the fixed-length padding would appear in the result. Fortran has no string interpolation; concatenation is the only way to build strings from variables.

Fortran's trim() removes only trailing spaces — unlike Ruby's strip which removes both ends. To strip leading spaces, use adjustl() to left-justify and then trim(). adjustr() right-justifies by moving trailing spaces to the front, useful for aligning text output.

Fortran's index(string, substring) returns the 1-based position of the first occurrence, or 0 if not found. Substring extraction uses parenthesis notation string(start:end) with 1-based indices — syntactically similar to Ruby's string[start, length] but using inclusive end positions instead of lengths.

Fortran supports all standard comparison operators (==, /=, <, >, <=, >=) for character strings, using lexicographic ordering. The llt(), lgt(), lle(), lge() intrinsics perform locale-independent ASCII comparisons, which matters when code runs on systems with non-ASCII collating sequences.

Fortran arrays are 1-based by default — the first element is always index 1, not 0. This is the single biggest indexing difference from Ruby. The size() intrinsic returns the total number of elements. Fortran also supports custom lower bounds: integer :: years(2020:2030) creates an 11-element array indexed from 2020 to 2030.

The implied DO syntax [(expression, var = start, end)] is Fortran's array comprehension — similar to Ruby's map but embedded directly in the array constructor. A stride can be added: [(index, index = 1, 10, 2)] produces [1, 3, 5, 7, 9].

Fortran array sections use the syntax array(start:end:stride) — syntactically similar to Python's slice notation. The stride can be negative to reverse. Array sections are themselves arrays and can be used anywhere a full array can, including as arguments and in expressions.

Fortran's most celebrated feature is whole-array arithmetic: operations on an array apply to every element simultaneously. prices * 0.9 is equivalent to Ruby's prices.map { |p| p * 0.9 } but is a single compiler instruction that can be vectorized automatically. This is the foundation of Fortran's performance advantage in scientific computing.

Fortran's reduction intrinsics map directly to Ruby's Enumerable methods. sum() and product() reduce an entire array in one call. Logical tests like numbers > 3 produce a logical array (a mask); count(), any(), and all() then operate on that mask.

maxloc() and minloc() return the 1-based index of the extreme value as a rank-1 integer array. The result is an array (not a scalar) to handle multidimensional arrays where the location has multiple indices. For a 1D array you can use maxloc(data, 1) to get a scalar. This is unlike Ruby's each_with_index.max which returns a pair.

Fortran uses array(row, col) notation for 2D arrays. Critically, Fortran stores matrices in column-major order — columns are contiguous in memory. The colon : selects all elements along a dimension, making matrix(1, :) the first row and matrix(:, 2) the second column.

reshape(source, shape) rearranges array elements into a new shape, filling in column-major order. The where construct applies an operation only to elements that satisfy a condition — the equivalent of Ruby's map with a conditional, but operating on all matching elements simultaneously without a loop.

Fortran's if / else if / else / end if is directly parallel to Ruby's if / elsif / else / end. The condition must be in parentheses. Fortran also supports single-line logical IF without then: if (condition) statement, but the block form with then / end if is preferred for clarity.

Fortran's select case works on integers, characters, and logicals. Case ranges use low:high syntax; multiple values use a comma list — similar to Ruby's when. Unlike Ruby's case/when with its fall-through-free design, Fortran also never falls through. SELECT CASE cannot be used on real numbers.

Character-based select case supports exact values, comma-separated lists, and character ranges using the same low:high notation as integer ranges. Ranges use ASCII order, so "A":"Z" covers all uppercase letters. This is more expressive than Ruby's case/when for character matching.

Fortran's logical operators .and., .or., .not., .eqv., and .neqv. surround their names with dots. The .eqv. operator is logical equivalence (both true or both false) and .neqv. is exclusive-or. Comparison operators include both modern symbols (==, /=, <) and older forms (.eq., .ne., .lt.).

Fortran's do counter = start, stop, stride is equivalent to Ruby's start.step(stop, stride). The loop variable is automatically incremented by the stride (default 1) after each iteration. The stride can be negative for counting down. Unlike Ruby's blocks, Fortran DO loops cannot be nested into an expression — they are pure statements.

do while (condition) continues as long as the condition is true. A bare do without a condition creates an infinite loop — the equivalent of Ruby's loop do — which must be exited with exit. This pattern is common when the exit condition is complex or appears in the middle of the loop body.

cycle in Fortran is Ruby's next — it skips the remainder of the loop body and starts the next iteration. exit is Ruby's break — it leaves the enclosing loop entirely. Both work with all loop forms: counted DO, DO WHILE, and bare DO.

Fortran supports named (labeled) loops: a name before do and after end do. exit outer breaks out of the outer loop directly, while cycle outer skips to the next outer iteration. This is cleaner than Ruby's catch/throw for breaking nested loops, and more readable than boolean flag variables.

Fortran subroutines are called with the call keyword. They can modify their arguments in place (like pass-by-reference) and return no value — similar to a Ruby method that produces side effects. Internal subroutines placed after contains have access to the host program's variables by host association.

intent(in) marks a parameter as read-only — the compiler reports an error if the subroutine tries to modify it. intent(out) means the subroutine must write the value before reading it. intent(inout) allows both reading and writing. Ruby has no equivalent mechanism; intent declarations serve as both documentation and compiler-enforced contracts.

intent(inout) declares a parameter that the subroutine both reads and modifies — analogous to Ruby's bang methods that modify their receiver in place. The (:) notation declares an assumed-shape array argument that automatically takes the shape of whatever array is passed in, without requiring the caller to pass the size separately.

The (:) assumed-shape notation lets a subroutine accept arrays of any size — the size is queried at runtime with size(). The expression (data - mean_out)**2 demonstrates whole-array arithmetic in a subroutine: the subtraction and squaring apply to every element simultaneously, without a loop.

Fortran functions assign their return value by assigning to the function name itself — to_fahrenheit = expression. Unlike Ruby where the last expression is the return value, Fortran requires this explicit assignment. The result(name) clause provides an alternative where the return variable gets a different name from the function.

Fortran requires the recursive keyword to enable recursion — a function cannot call itself without it. The result(name) clause is required for recursive functions to avoid the ambiguity of assigning to both the function name and calling it. Ruby functions are always recursive without any special declaration.

The pure attribute declares that a function has no side effects and performs no I/O. The compiler can then safely parallelize calls, reorder them, or eliminate dead code. Pure functions can only call other pure procedures. Ruby has no equivalent compiler enforcement — purity is a convention, not a guarantee.

An elemental function is automatically both scalar and vectorized: write it once for a single value and call it with an array of any shape. The compiler applies it element-wise. This is one of Fortran's most powerful features — in Ruby you must choose between a scalar function and map.

Fortran modules are the equivalent of Ruby modules: they group related constants and procedures. The use module_name statement (like Ruby's include) brings all public module entities into the current scope. Modules can be defined in the same source file, before the program that uses them.

The use module, only: name1, name2 syntax imports only the listed names. This prevents namespace pollution and makes dependencies explicit — you can immediately see what a program uses from each module. Fortran also supports renaming on import: use module, local_name => module_name.

The private statement makes all module entities private by default; public then selectively exposes specific names. This is the same encapsulation principle as Ruby's private and public method modifiers. Module variables (like transaction_count) persist between calls — they are the Fortran equivalent of class variables.

Fortran derived types are analogous to Ruby's Struct — they group related fields under one name. Component access uses % instead of Ruby's .. Derived types are value types by default: assignment copies all components, unlike Ruby's reference semantics for objects.

The structure constructor type_name(val1, val2, ...) initializes all components in declaration order — equivalent to Ruby's Struct.new.call. Named component constructors are also possible: point_2d(x=3.0, y=4.0). Unlike Ruby, Fortran derived types do not support methods directly (that requires Fortran 2003 type-bound procedures).

The syntax array_of_types(:)%component extracts a named component from every element of an array of derived types, producing a regular array. Here, class_students(:)%grade extracts all three grades as a real array, which sum() then reduces. This avoids an explicit loop for simple reductions.

Allocatable arrays let you determine array size at runtime rather than compile time. allocate(array(size)) reserves memory; deallocate(array) releases it. In modern Fortran 2003+, allocatable arrays are automatically deallocated when they go out of scope — so explicit deallocate is only needed for early release or when managing memory carefully.

The allocated() intrinsic tests whether an allocatable array has been allocated — analogous to Ruby's .nil? check. Calling deallocate on an unallocated array is a runtime error; wrapping it in if (allocated(array)) prevents this. Fortran 2003 also supports move_alloc to transfer ownership without copying.

allocate(matrix(rows, cols)) creates a 2D allocatable array whose dimensions are determined at runtime. The inner loop runs over row (contiguous in memory for column-major storage) — looping over the leftmost index in the innermost loop is the cache-friendly access pattern for Fortran arrays.

print *, ... and write(*, *) ... are equivalent — both write to standard output with default formatting. The first asterisk in write(unit, format) means "standard output"; the second means "default format." Fortran's format strings in write(*, '(format)') resemble printf but use descriptors like i5 (integer, width 5) and f8.2 (float, 8 wide, 2 decimal places).

Fortran format descriptors: i (integer), f (fixed-point real), e/es (scientific notation), a (character), g (general numeric). Width and decimal places follow: f10.3 is a real in a 10-character field with 3 decimal places. i0 is unique to Fortran — it prints the integer using exactly as many characters as needed.

Fortran's "internal file" feature uses a character variable as the unit in a write or read statement, providing an sprintf/sscanf-equivalent. This is essential for constructing formatted strings without printing them — filenames, labels, or text that will be processed further.

Fortran file I/O uses unit numbers (integers) as file handles. open() opens or creates a file; close() flushes and releases it. The iostat= argument captures errors as an integer (0 = success) instead of raising an exception. This example cannot run in the browser sandbox where file system access is blocked.

Fortran arrays are 1-based — the first element is always index 1. This is the most disorienting difference from Ruby (0-based), Python (0-based), and JavaScript (0-based). Fortran uniquely allows any lower bound: integer :: data(-5:5) creates an 11-element array indexed from −5 to 5. The block construct creates a new scope, like Ruby's begin/end.

Fortran stores 2D arrays in column-major order — the first index (row) varies fastest in memory. This is the opposite of C, Ruby, and Python (row-major). The consequence: iterating over matrix(:, col) in the inner loop is cache-friendly; iterating over matrix(row, :) is not. For performance-critical code, always put the row index innermost.

Without implicit none, Fortran automatically assigns types based on the first letter of a variable name: I through N → integer, everything else → real. A typo in a variable name silently creates a new variable and the original is unchanged — a notoriously hard-to-find bug. implicit none is the Fortran equivalent of Ruby's requirement that variables be assigned before use.

Fortran's default real is 32-bit single precision — only about 7 decimal digits of accuracy. This surprises Rubyists because Ruby's Float is always 64-bit. Scientific code should use real(real64) or double precision for numerical stability. Always use the d0 or _real64 suffix on double-precision literals to avoid silently losing precision.

Fortran integer arithmetic wraps on overflow without raising an error — unlike Ruby's arbitrary-precision integers that never overflow. Adding 1 to the maximum 32-bit integer gives the most negative 32-bit integer silently. For large counts, sums, or factorials, always use integer(int64) or integer(int128) (where supported). Ruby programmers accustomed to no-overflow arithmetic must be especially vigilant.