Fortran.CodeCompared.To/Ruby

Ruby has no program/end program wrapper and nothing to compile: a script is a plain sequence of statements executed top to bottom. puts writes a line to standard output — the list-directed print *, of Ruby, but with no leading space.

Ruby marks a comment with # rather than Fortran’s !, and it runs to the end of the line the same way. There is no block-comment form in everyday use; Rubyists prefix each line with #.

Ruby has no implicit-typing rule to defend against, so there is no implicit none and no type-and-kind declaration line. A variable springs into existence on first assignment and simply refers to whatever object you gave it.

Ruby keeps C-style format strings through printf and format, so the F6.3 edit descriptor becomes %6.3f. The format lives inline rather than in a separate FORMAT statement or a parenthesized descriptor string.

Ruby infers everything at run time — there is no integer :: / real :: declaration section. The type belongs to the object, not the variable, so you can ask any value its class. A type mismatch surfaces only when an operation actually runs.

In Ruby even an integer is an object, so operations are methods you send to it (value.abs) rather than intrinsic functions applied from outside (abs(value)). There are no unboxed primitives and no distinction between an INTEGER and a "boxed" integer.

A Ruby variable is just a label with no fixed type, so reassigning it to a value of a different class is ordinary and legal. In Fortran a name’s type is fixed by its declaration for the entire scope; there is no equivalent freedom.

Ruby has no parameter attribute; instead any name beginning with a capital letter is a constant. Reassigning one produces a warning rather than an error, so the convention is enforced socially — much weaker than Fortran’s compile-time parameter.

Ruby’s Integer and Float stand in for INTEGER and REAL, but a Float is always double precision — there is no single/double split and no KIND to specify. Convert explicitly with to_f/to_i rather than REAL()/INT().

A Ruby Integer grows to whatever size the value needs, transparently — there is no fixed width, no KIND=8, and no overflow. This trades Fortran’s predictable machine-word performance for never having to reason about integer range.

The rule matches Fortran: integer divided by integer truncates, and a single Float operand promotes the whole expression to Float. Ruby decides by the runtime classes of the operands, the way Fortran decides by declared types.

Ruby has a built-in Complex class, so complex arithmetic works out of the box as it does in Fortran — but the imaginary literal is 2i and the parts are read with the methods real and imaginary rather than the intrinsics REAL()/AIMAG().

Transcendental functions live in the Math module (Math.sqrt, Math::PI) rather than being global intrinsics. Note max is a method on an array of values or on the numbers themselves, not a free function taking a list.

A Ruby String has no declared length — it is a dynamic, resizable object, so there is no fixed character(len=20) width and no trailing blanks to trim. Its length is simply however many characters it currently holds.

Ruby’s #{expression} interpolates any value directly into a string literal, evaluating its to_s — there is no concatenation operator needed for the common case. When you do want to join strings, + plays the role of Fortran’s //.

String manipulation is a rich set of methods on the object: strip removes surrounding whitespace (both adjustl and trim in one), and upcase/reverse do what standard Fortran has no intrinsic for. They chain because each returns a new string.

The big adjustment: Ruby strings are 0-based, so Fortran’s phrase(1:5) becomes phrase[0..4]. Ruby also allows negative indices counting from the end and open-ended ranges — neither of which Fortran substring notation offers.

This is the single most important adjustment: Ruby arrays are 0-based, so the first element is numbers[0], not numbers(1). There is no way to declare a custom lower bound as Fortran’s numbers(0:2) allows; 0 is always the first index.

The [ ] literal looks like a Fortran array constructor, but a Ruby Array is a dynamic, heterogeneous object — it can hold values of different classes at once, which a Fortran array (uniform type and kind) cannot.

A Ruby array grows and shrinks on demand with push/<</pop — no allocatable attribute, no allocate, and no reallocation dance. It is a stack, queue, and vector all in one object.

Ruby slices with a Range (values[1..3]), 0-based and inclusive. There is no built-in strided slice like Fortran’s values(1:5:2); you express a stride with values_at, step, or each_slice.

Ruby has no whole-array arithmetic — a + b concatenates two arrays rather than adding elementwise. You express Fortran’s c = a + b by zip-ing the arrays into pairs and map-ing over them. (For heavy numerics, the numo-narray gem restores Fortran-style vectorized operations.)

The Fortran reduction intrinsics map to Enumerable methods: sum, max, and min read the same, and product becomes reduce(:*), which folds the multiplication operator over the array.

Fortran’s where masked assignment becomes a map with a conditional expression, and Fortran’s pack/masking becomes select (keep matching) or reject (drop matching). Each returns a new array rather than assigning into an existing one.

Ruby has no built-in multidimensional array; a nested array is just an array of arrays with no elementwise or matmul semantics. The standard-library Matrix class supplies real linear algebra, where * is matrix multiplication — but there is nothing as fundamental as Fortran’s native rank-2 arrays and reshape.

The structure matches, with cosmetic differences: no then keyword, no parentheses required around the condition, elsif (one word) for else if, and a single end instead of end if. An if in Ruby is also an expression that returns a value.

Ruby’s case/when mirrors select case, including multiple values per branch (when 2, 3). It is more powerful, though: a when can match a range (when 1..10), a class, or a regular expression, because it tests with the === operator.

Ruby uses the C-style &&, ||, and ! in place of .and., .or., and .not., and the literals are the bare words true/false without the surrounding dots. Only false and nil are falsy; every other object, including 0, is truthy.

The counting do loop becomes iteration over a Range with each, or 5.times when the counter itself does not matter. Ruby rarely manages a bare loop index — you ask a collection to hand you each element instead.

Fortran’s three-part do index = start, stop, step becomes start.step(stop, step) or range.step(size). Both directions work; a negative step counts down, exactly as in Fortran.

Ruby’s while drops the do keyword and the parentheses. Note there is no ++; use total += 3. Ruby also offers until (loop while the condition is false), the inverse form Fortran lacks.

Rather than loop an index from 1 to size and subscript the array, Ruby hands you each element directly with each. When you genuinely need the position, each_with_index yields both — and the index is 0-based.

A subroutine — a procedure with no return value — becomes an ordinary def, invoked without a call keyword. There is no contains section or separate declaration of the dummy argument’s type; the parameter is just a name.

A Ruby method returns its last evaluated expression implicitly — there is no result variable to assign (as Fortran assigns to the function name) and an explicit return is rarely written. The return type is not declared; it is whatever object the body produces.

Ruby has no intent(inout) and no pass-by-reference for a rebind: an integer argument cannot be changed in the caller’s scope. You return the new value and reassign. (Mutable objects like arrays can be changed in place, since the reference is shared — but the variable binding itself never is.)

Ruby gives a parameter a default value directly in the signature, so there is no optional attribute and no present() check — an omitted argument simply takes its default. This is terser than Fortran’s optional-plus-present idiom.

Ruby methods are recursive by default — there is no recursive keyword to opt in, and no result variable. The ternary condition ? a : b keeps the whole body to one expression here.

A Fortran type becomes a Ruby class. Struct.new generates one with accessor methods in a single line — fields are read as origin.x (a method call), not origin%x. Use Data.define instead when you want an immutable value object.

Where Fortran attaches a type-bound procedure and passes self explicitly, a Ruby class defines methods that reach instance state through @radius — no explicit self parameter and no separate contains block. The constructor is the special method initialize.

Ruby inheritance uses < where Fortran uses extends. Beyond inheriting fields, a Ruby subclass can override methods and call super — full polymorphism, versus Fortran’s type extension which mainly adds components and type-bound procedures.

A Ruby module groups constants and methods under a namespace, like a Fortran module. A def self.name method is called on the module itself (Geometry.circle_area) — the counterpart of a module procedure made available through use.

Fortran’s use brings a module’s public names into scope. Ruby splits this: require loads a file, while include mixes a module’s methods into a class — a form of code reuse (a mixin) that Fortran has no direct equivalent for, sitting between a module and inheritance.

This is a capability Fortran simply lacks: the Hash is a built-in, growable map from keys to values with O(1) lookup. Where Fortran forces parallel arrays and a linear search, Ruby indexes by any object as a key — no fixed size, no manual scanning.

A Hash.new(0) returns 0 for any absent key, turning frequency counting into a single line — no pre-sized arrays, no search. Iterating yields each key–value pair to the block, which destructures it into two parameters.

A block — an anonymous chunk of code in { } — is Ruby’s central idiom and has no Fortran equivalent. map applies it to each element and collects the results, replacing the explicit index loop and temporary result array.

A running accumulation over a loop is captured by reduce (also called inject): it threads an accumulator through the block for each element and returns the final value — the general form behind sum, product, and the rest.

A Ruby lambda (->(a, b) { … }) is a first-class function value you store and pass around — much simpler than a Fortran procedure pointer with its matching abstract interface. You invoke it with call (or the .() shorthand).

Ruby has true exceptions: raise throws one and begin/rescue catches it, unwinding the stack until a handler is found. Fortran’s only comparable tool is stop/error stop, which halts the program outright — there is no catching or recovery.

Where Fortran threads an iostat integer through every fallible call and checks it by hand, Ruby lets the failure raise and handles it in one rescue. A method body is an implicit begin, so the rescue can sit at method level with no explicit block.

The ensure clause runs whether the body returns normally or raises, guaranteeing cleanup in one place. Fortran has no such construct — you repeat the close/deallocate on every exit path, which is exactly the bookkeeping ensure removes.

Ruby splits output by audience: puts writes a value’s to_s plus a newline, p writes the inspect form (with brackets and quotes) for debugging, and print writes to_s with no newline. There is no * list-directed format to remember.

gets reads one line from standard input as a string; chomp removes the trailing newline. It returns nil at end of input rather than raising, and there is no format descriptor or fixed-width buffer to declare.

Ruby opens, reads, and closes a file in a single File.read call — no unit number, no open/close pairing, and no read-loop terminated by an iostat code. each_line streams lines, and readlines returns them all as an array.