Loops in Fortran
Fortran's DO loop is the primary construct for repeating a block of statements a known or computed number of times, and it has been central to the language since its 1957 origins because scientific computing relies heavily on iterating over arrays and numerical ranges. Modern Fortran also supports DO WHILE for condition-controlled iteration and DO with no control clause for indefinite loops that rely on EXIT to terminate.
Cricket analogy: Bowling six deliveries in an over is a fixed-count DO loop — DO ball = 1, 6 — just as Jasprit Bumrah runs the same fixed sequence of six balls before the over ends and control passes to the next bowler.
The DO Loop
The counted DO loop has the form DO i = start, stop, step ... END DO, where step defaults to 1 if omitted and can be negative to count downward; the loop variable, bounds, and step are evaluated once at loop entry, so changing the stop value inside the loop body does not affect how many iterations execute. Modern Fortran also allows naming a loop (e.g., outer: DO i = 1, n) so EXIT and CYCLE statements can target a specific enclosing loop unambiguously.
Cricket analogy: A bowler's spell of DO over = 1, 10 has its iteration count fixed at the captain's decision at the start of the spell — even if the bowler is smashed for runs mid-spell, the number of overs assigned doesn't silently change, just as Fortran fixes DO bounds at loop entry.
PROGRAM sum_and_search
IMPLICIT NONE
INTEGER :: i, total
INTEGER, PARAMETER :: n = 100
REAL :: x, tol
LOGICAL :: converged
total = 0
DO i = 1, n
total = total + i
END DO
PRINT *, 'Sum 1 to 100 = ', total
x = 1.0
tol = 1.0E-6
converged = .FALSE.
DO WHILE (.NOT. converged)
x = 0.5 * (x + 2.0 / x)
IF (ABS(x*x - 2.0) < tol) converged = .TRUE.
END DO
PRINT *, 'sqrt(2) approx = ', x
outer: DO i = 1, n
IF (MOD(i, 7) == 0 .AND. MOD(i, 5) == 0) THEN
PRINT *, 'First multiple of 35 is ', i
EXIT outer
END IF
END DO outer
END PROGRAM sum_and_searchDO WHILE and Indefinite Loops
DO WHILE (condition) ... END DO repeats as long as a logical condition remains true, checked before each iteration, useful when the number of repetitions isn't known in advance — for example, reading records from a file until end-of-file, or iterating a numerical solver until it converges within a tolerance. A bare DO ... END DO with no control clause loops indefinitely and must contain an IF...EXIT (or plain EXIT inside a conditional) to avoid an infinite loop.
Cricket analogy: A team batting DO WHILE (wickets_remaining > 0 .AND. overs_remaining > 0) keeps sending batters in until either all ten wickets fall or the overs run out — the condition, not a fixed count, determines when the innings loop ends.
You can loop backward with a negative step: DO i = 10, 1, -1 counts down from 10 to 1. If step's sign doesn't match the direction from start to stop (e.g., DO i = 1, 10, -1), the loop body executes zero times rather than raising an error.
EXIT, CYCLE, and Nested Loops
EXIT immediately terminates the (named) enclosing loop and transfers control to the statement after END DO, while CYCLE skips the rest of the current iteration and jumps to the next one, both commonly guarded by an IF. In nested loops, naming each loop (outer: DO ... inner: DO ... END DO inner ... END DO outer) lets EXIT outer break out of both loops at once from deep inside the inner loop, which is far clearer than using a GOTO to escape multiple levels.
Cricket analogy: A fielder sprinting to chase a boundary but calling off the chase once the ball crosses the rope is like EXIT — abandoning the loop of running the moment the exit condition (ball past the boundary) is met, rather than continuing needlessly.
A bare DO ... END DO with no loop control and no reachable EXIT will run forever and hang the program. Always ensure the EXIT condition is guaranteed to become true, and consider adding a safety counter as a fallback during development.
- DO i = start, stop, step ... END DO is the counted loop; step defaults to 1 and can be negative for counting down.
- Loop bounds and step are evaluated once at loop entry; modifying them inside the loop body does not change the trip count.
- DO WHILE (condition) ... END DO repeats while a condition holds, checked before each iteration — ideal when the iteration count isn't known in advance.
- A bare DO ... END DO loops indefinitely and requires an EXIT to terminate, or it will hang.
- EXIT terminates the enclosing loop immediately; CYCLE skips to the next iteration without exiting.
- Naming loops (outer: DO ...) lets EXIT and CYCLE target a specific loop from within nested loops.
- Mismatched step direction (e.g., counting up with a negative step) makes the loop body execute zero times, not an error.
Practice what you learned
1. What is the default step value in DO i = 1, 10?
2. When are the start, stop, and step values of a DO loop evaluated?
3. Which statement immediately terminates the nearest enclosing (or named) loop?
4. What happens if a DO loop's step direction doesn't match the direction from start to stop, e.g. DO i = 1, 10, -1?
5. What construct should you use when the number of iterations isn't known ahead of time, such as reading a file until end-of-file?
Was this page helpful?
You May Also Like
Conditionals in Fortran
How Fortran branches execution with block IF-THEN-ELSE, SELECT CASE, and logical operators.
Arrays in Fortran
Declaring, indexing, sectioning, and efficiently looping over Fortran's column-major arrays.
Subroutines and Functions
Structuring reusable Fortran code with SUBROUTINEs, FUNCTIONs, INTENT, and pass-by-reference arguments.
Related Reading
Related Study Notes in Programming
Browse all study notesApache Spark Study Notes
Programming · 30 topics
ProgrammingApache Flink Study Notes
Programming · 30 topics
ProgrammingHadoop Study Notes
Programming · 30 topics
ProgrammingSnowflake Study Notes
Programming · 30 topics
ProgrammingApache Airflow Study Notes
Programming · 30 topics
Programmingdbt (Data Build Tool) Study Notes
Programming · 30 topics