Conditionals in Fortran
Fortran conditionals let a program choose different execution paths depending on the truth of a logical expression evaluated at runtime. Modern Fortran (90 and later) favors the block IF-THEN-ELSE and SELECT CASE constructs over the older arithmetic IF and unstructured logical IF found in FORTRAN 66/77, because block constructs are easier to read, nest, and maintain in large scientific codes.
Cricket analogy: Deciding whether to declare an innings works like an IF-THEN-ELSE: if the required run rate is unreachable and overs are running out, the captain declares; otherwise, like Rohit Sharma weighing conditions at Eden Gardens, the team bats on.
The IF-THEN-ELSE Construct
The block IF construct begins with IF (condition) THEN, followed by one or more executable statements, optional ELSE IF (condition) THEN branches, an optional ELSE branch, and a terminating END IF. Each ELSE IF is evaluated only if all preceding conditions were false, and because the whole construct is a single statement block, IF constructs can be nested arbitrarily deep, with indentation (though not enforced by the compiler) critical for humans to trace which END IF closes which IF.
Cricket analogy: An umpire's DRS review follows nested block logic: IF the on-field decision is out THEN check for a no-ball first; ELSE IF the ball hit the bat THEN uphold; ELSE overturn — each ELSE IF only checked if the prior branch failed, just like Fortran's chained ELSE IF.
PROGRAM check_grade
IMPLICIT NONE
INTEGER :: score
CHARACTER(LEN=1) :: grade
score = 78
IF (score >= 90) THEN
grade = 'A'
ELSE IF (score >= 80) THEN
grade = 'B'
ELSE IF (score >= 70) THEN
grade = 'C'
ELSE
grade = 'F'
END IF
SELECT CASE (grade)
CASE ('A', 'B')
PRINT *, 'Distinction: ', grade
CASE ('C')
PRINT *, 'Pass: ', grade
CASE DEFAULT
PRINT *, 'Needs improvement: ', grade
END SELECT
END PROGRAM check_gradeSELECT CASE for Multi-Way Branching
SELECT CASE (expression) offers cleaner multi-way branching than a long ELSE IF chain when testing one variable against many discrete values or ranges. Each CASE clause can list individual values (CASE (1,3,5)), a range (CASE (10:20)), or fall through to CASE DEFAULT, and it works with INTEGER, CHARACTER, and LOGICAL selector expressions, though not REAL, since comparing floating-point values for exact equality is unreliable.
Cricket analogy: Umpires signaling outcomes use a SELECT CASE mindset: CASE (bowled, caught, lbw) all mean 'out', CASE (wide) adds a run and re-bowls, CASE DEFAULT covers dot balls — one selector value, several grouped outcomes, cleaner than checking each dismissal type separately.
SELECT CASE ranges use a colon: CASE (70:79) matches any integer from 70 to 79 inclusive. Open-ended ranges are allowed too — CASE (:59) matches anything 59 or below, and CASE (90:) matches 90 or above.
Logical Expressions and Comparison Operators
Fortran's relational operators can be written in either legacy form (.EQ., .NE., .LT., .LE., .GT., .GE.) or the modern symbolic form (==, /=, <, <=, >, >=) introduced in Fortran 90, and combine using .AND., .OR., .NOT., .EQV., and .NEQV. Crucially, the standard does not guarantee short-circuit evaluation the way C or Python do, so both operands of .AND. or .OR. may be evaluated even when the first already determines the result, which matters if the second operand could trigger a division-by-zero or out-of-bounds array access.
Cricket analogy: Checking both 'is the batter inside the crease' AND 'did the bails come off' for a run-out looks simple, but like Fortran's .AND., a third umpire reviewing frame-by-frame footage may still evaluate both angles even after the first clearly shows safe, unlike a human's instant shortcut.
Never compare REAL (floating-point) values with == or .EQ. inside an IF condition — rounding error means 0.1 + 0.2 is rarely bit-for-bit equal to 0.3. Instead test ABS(a - b) < epsilon using a small tolerance, or use the intrinsic function EPSILON(a).
- Block IF-THEN-ELSE-END IF is the modern, structured replacement for the legacy arithmetic and unstructured logical IF.
- ELSE IF chains are evaluated top to bottom; only the first true branch executes.
- SELECT CASE is clearer than long ELSE IF chains for INTEGER, CHARACTER, or LOGICAL selectors tested against many discrete values or ranges.
- CASE ranges use a colon, e.g. CASE (10:20), and can be open-ended like CASE (:0) or CASE (100:).
- Fortran offers both legacy (.EQ., .LT.) and modern (==, <) relational operators; modern symbolic operators are preferred in new code.
- Fortran does not guarantee short-circuit evaluation of .AND. and .OR., so both operands may be evaluated regardless of order.
- Never test REAL values for exact equality; use a tolerance-based comparison instead.
Practice what you learned
1. Which construct is preferred in modern Fortran for structured branching on a Boolean expression?
2. What data types can be used as the selector expression in SELECT CASE?
3. Which is true about Fortran's .AND. and .OR. operators?
4. What is the correct way to specify a CASE range from 10 to 20 inclusive?
5. Why should you avoid comparing two REAL variables with == in an IF condition?
Was this page helpful?
You May Also Like
Loops in Fortran
Fortran's DO, DO WHILE, and indefinite loop constructs, plus EXIT and CYCLE control flow.
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