DO Loops in Fortran Counted Loops

Loops are one of the most important control structures in Fortran, allowing programs to repeat a block of code multiple times without rewriting it. Among the various loop constructs in Fortran, the DO loop—also known as a counted loop—is particularly powerful for iterating a fixed number of times. Counted loops are extensively used in scientific computing, data processing, array operations, and numerical simulations, making them a core tool for any Fortran programmer.

In this post, we will explore the concept of DO loops, their syntax, usage, variations, and practical examples. By the end, you will understand how to implement counted loops efficiently and write readable, maintainable code.

What is a DO Loop?

A DO loop in Fortran repeatedly executes a block of code for a predetermined number of iterations. Unlike DO WHILE loops, which are conditional and may execute an unknown number of times, DO loops execute a fixed number of iterations specified by a start, end, and optional step value.

Key Characteristics of DO Loops:

1. Loop variable: Controls the number of iterations.
2. Start value: The initial value of the loop variable.
3. End value: The termination value of the loop variable.
4. Step value: Optional; specifies the increment (default is 1).

DO loops are commonly used when the number of repetitions is known beforehand, such as iterating through array indices or performing repeated calculations.

---

Syntax of DO Loops

The general syntax of a DO loop in Fortran is as follows:

do variable = start, end, step
! code to repeat
end do

• variable is the loop counter.
• start is the initial value of the loop counter.
• end is the value at which the loop stops.
• step is optional; defaults to 1 if omitted.
• The block of code inside the loop executes for each value of the loop counter from start to end in increments of step.

---

Simple Example of a DO Loop

Let’s consider a basic example:

integer :: i
do i = 1, 5
print *, i
end do

Explanation:

• The loop variable i starts at 1 and increments by 1 (default) until it reaches 5.
• For each iteration, the program prints the current value of i.
• Output:

1
2
3
4
5

This is the simplest form of a counted loop in Fortran.

---

Using the Step Value

The step value allows the loop to increment or decrement by a value other than 1. This is useful when skipping values or iterating backward.

Example: Incrementing by 2

integer :: i
do i = 1, 10, 2
print *, i
end do

Output:

1
3
5
7
9

• The loop starts at 1 and increments by 2 each time, stopping before exceeding 10.

Example: Decrementing Loop

integer :: i
do i = 5, 1, -1
print *, i
end do

Output:

5
4
3
2
1

• By using a negative step, the loop counts downward.

---

Loop Variable Scope

The loop variable in Fortran is local to the DO loop and typically should not be modified inside the loop. Modifying it may lead to undefined behavior or incorrect results.

Example of improper modification:

integer :: i
do i = 1, 5
i = i + 1  ! Not recommended
print *, i
end do

• Modifying the loop variable manually can disrupt the expected iteration sequence.

---

Nested DO Loops

DO loops can be nested inside one another, allowing iteration over multi-dimensional data, such as matrices or grids.

Example: Nested Loop

integer :: i, j
do i = 1, 3
do j = 1, 2
    print *, "i =", i, ", j =", j
end do
end do

Output:

i = 1 , j = 1
i = 1 , j = 2
i = 2 , j = 1
i = 2 , j = 2
i = 3 , j = 1
i = 3 , j = 2

• The inner loop completes all its iterations for each iteration of the outer loop.
• Nested loops are essential for operations on 2D arrays or matrices.

---

Loop Control Statements: EXIT and CYCLE

Fortran provides special statements to control loop execution:

1. EXIT: Terminates the loop immediately.
2. CYCLE: Skips the current iteration and continues with the next iteration.

Example:

integer :: i
do i = 1, 10
if (i == 5) exit
if (i == 3) cycle
print *, i
end do

Output:

1
2
4

• i == 3 is skipped using CYCLE.
• Loop terminates when i == 5 using EXIT.

---

Using DO Loops with Arrays

DO loops are particularly useful for array operations, such as initializing, summing, or modifying array elements.

Example: Sum of Array Elements

integer, dimension(5) :: arr
integer :: i, sum

arr = (/1, 2, 3, 4, 5/)
sum = 0

do i = 1, 5
sum = sum + arr(i)
end do

print *, "Sum of array elements:", sum

Output:

Sum of array elements: 15

• The loop iterates through all elements of the array to compute the sum.

Example: Multiplying Array Elements

integer, dimension(5) :: arr
integer :: i

arr = (/1, 2, 3, 4, 5/)

do i = 1, 5
arr(i) = arr(i) * 2
end do

print *, "Array after doubling:", arr

Output:

Array after doubling: 2 4 6 8 10

• Each element of the array is doubled using a DO loop.

---

Advanced Example: Nested Loops for Matrices

Consider a 3×3 matrix where we want to initialize values:

integer, dimension(3,3) :: matrix
integer :: i, j

do i = 1, 3
do j = 1, 3
    matrix(i,j) = i * j
end do
end do

print *, "Matrix elements:"
do i = 1, 3
print *, matrix(i,1:3)
end do

Output:

Matrix elements:
1 2 3
2 4 6
3 6 9

• Nested DO loops allow iteration over rows (i) and columns (j).
• This approach is widely used in numerical simulations and scientific computing.

---

Common Pitfalls with DO Loops

1. Incorrect Step Value: Using the wrong step may lead to infinite loops or skipped iterations.
2. Modifying Loop Variable: Avoid altering the loop counter inside the loop.
3. Off-by-One Errors: Ensure start, end, and step values are correctly defined to include all intended iterations.
4. Nested Loops Confusion: Clearly indent nested loops to maintain readability.

---

Practical Applications of DO Loops

DO loops are used in a variety of scenarios:

1. Scientific Computing: Repeating calculations, numerical integration, simulations.
2. Data Processing: Iterating through datasets, arrays, and matrices.
3. Algorithm Implementation: Sorting, searching, and iterative methods.
4. Generating Sequences: Creating arithmetic sequences or repetitive outputs.

Example: Factorial Calculation Using DO Loop

integer :: n, i, fact
n = 5
fact = 1

do i = 1, n
fact = fact * i
end do

print *, "Factorial of", n, "is", fact

Output:

Factorial of 5 is 120

• The DO loop multiplies numbers from 1 to n to calculate the factorial.

---

Best Practices for Using DO Loops

1. Use Meaningful Loop Variables: Avoid generic names like i in complex programs.
2. Indent Properly: Improves readability, especially for nested loops.
3. Keep Loops Simple: Avoid excessive logic inside a single loop; break into smaller loops if needed.
4. Use EXIT and CYCLE Wisely: Control loops efficiently without overcomplicating the code.
5. Comment Complex Loops: Document nested loops or loops with multiple conditions.

---

Summary

The DO loop in Fortran is a powerful counted loop used to repeat code a fixed number of times. This post covered:

1. Definition and purpose: Repeating operations efficiently.
2. Syntax: do variable = start, end, step.
3. Examples: Incrementing, decrementing, and nested loops.
4. Loop control: Using EXIT and CYCLE for flexible iteration.
5. Array operations: Summing, modifying, and initializing arrays.
6. Practical applications: Scientific computations, data processing, algorithms.
7. Best practices: Clear loop variables, proper indentation, and readability.

Mastering DO loops is essential for writing efficient Fortran programs capable of handling repetitive tasks, iterative calculations, and multidimensional data processing.