Decisions and loops

The programs in Lesson 2 ran straight through from top to bottom, doing the same thing every time. Real engineering programs need to make decisions (is this member overstressed? is the flow laminar?) and to repeat work (check every reading, try every section size, iterate until an answer converges). Decisions and loops are what make a program more than a calculator.

This chapter covers comparisons and logical operators, if statements, while loops and for loops, the accumulator pattern for totals and maximums, break and continue, and input validation. It finishes with two workhorse numerical methods built from loops, bisection and Newton's method, and a brute-force design search. These are the patterns behind a large share of engineering software.

Comparisons and Boolean logic

A comparison produces a bool, True or False:

• == equal, != not equal, < less than, <= less than or equal, > greater than, >= greater than or equal.

Remember: one = assigns, two == compares. And from Lesson 2, never compare floats with == (use math.isclose).

Comparisons combine with the logical operators and, or and not. Python also allows chained comparisons that read like mathematics: 0 <= angle < 360.

stress_MPa = 159.2
allowable_MPa = 165
temperature_C = -38
print(stress_MPa <= allowable_MPa)
print(stress_MPa <= allowable_MPa and temperature_C >= -40)
print(not (temperature_C < -30))
print(0 <= 45 < 90)

True
True
False
True

if, elif and else

An if statement runs a block of code only when a condition is True. The block is marked by indentation, four spaces by convention, and the line before it ends with a colon. Indentation is not decoration in Python; it is how the language knows which lines belong to the block.

stress_MPa = 172.0
allowable_MPa = 165

if stress_MPa <= allowable_MPa:
    print("OK")
else:
    overstress = (stress_MPa / allowable_MPa - 1) * 100
    print(f"Overstressed by {overstress:.1f}%")

Output: Overstressed by 4.2%.

For more than two cases, add elif ("else if") branches. Python checks the conditions in order and runs only the first block whose condition is True.

Loops: repeating work

Python has two kinds of loop. A while loop repeats as long as a condition stays True; use it when you do not know in advance how many repetitions are needed. A for loop repeats once for each item in a sequence; use it when you do.

while loops

That last point is important. If the body never changes the condition (say, you forgot to update demand), the loop runs forever. If a program seems to hang, an infinite loop is the first suspect; stop it with Ctrl+C.

for loops and range

A for loop takes each item of a sequence in turn. The built-in range() produces sequences of integers: range(5) gives 0, 1, 2, 3, 4 (five values, starting at 0, stopping before 5); range(10, 51, 10) gives 10, 20, 30, 40, 50.

A for loop can also go straight through the items of a list, a collection written in square brackets. Lists get a full treatment in Lesson 5; for now, readings = [612, 655, 701] is a list of three numbers, and for r in readings: visits each one.

The accumulator pattern

Many loops build up a result as they go: a running total, a count, a maximum. Set the result to a starting value before the loop and update it inside. This is the pseudocode from Lesson 1, turned into Python.

Starting largest at the first reading, not at 0, matters: if all readings were negative (compressive strain), starting at 0 would wrongly report 0 as the maximum.

break and continue

break leaves the loop immediately; continue skips the rest of the current pass and moves to the next item. Use them sparingly; they are clearest for "stop at the first match" and "skip bad data".

readings = [612, 655, -999, 748, 790, 823, 845]   # -999 marks a dropped reading
for hour, r in enumerate(readings):
    if r == -999:
        continue                  # skip missing data
    if r > 800:
        print(f"First exceedance at hour {hour}: {r}")
        break

Output: First exceedance at hour 5: 823. The built-in enumerate() supplies a counter (starting at 0) alongside each item.

Validating input

Programs that take input from people or files must expect bad input. A while loop that repeats until the input is acceptable, combined with try and except to catch conversion errors, is the standard pattern.

while True:
    text = input("Span in metres (positive): ")
    try:
        span_m = float(text)
    except ValueError:
        print("That is not a number. Try again.")
        continue
    if span_m > 0:
        break
    print("The span must be positive.")
print(f"Span accepted: {span_m} m")

while True: creates a loop that only ends at a break. The try block attempts the conversion; if float() raises a ValueError, the except block runs instead of crashing the program.

Numerical methods built from loops

Many engineering equations cannot be solved with algebra: friction factors, beam natural frequencies, chemical equilibria, the depth of flow in a channel. Loops let a program close in on the answer numerically.

Bisection

If a continuous function changes sign between two points, it has a root between them (the intermediate value theorem from MATH-100). Bisection halves the interval repeatedly, always keeping the half where the sign change is.

Newton's method

Newton's method (MATH-100, Lesson 4) uses the derivative to jump toward the root: \(x_{n+1} = x_n - f(x_n)/f'(x_n)\). It converges much faster when it works, roughly doubling the number of correct digits each step, but it needs the derivative and a reasonable starting guess.

x = 2.0
for n in range(1, 6):
    x = x - (x ** 3 - 2 * x - 5) / (3 * x ** 2 - 2)
    print(n, x)

1 2.1
2 2.094568121104185
3 2.094551481698199
4 2.0945514815423265
5 2.0945514815423265

Four steps reach full machine precision, against bisection's 20 steps for six digits. Real programs usually stop when the change between steps falls below a tolerance, with a maximum number of iterations as a safety net in case the method fails to converge.

Nested loops: a brute-force design search

A loop inside a loop runs the inner loop completely for each pass of the outer one. With computers this fast, simply trying every combination is often the easiest way to find a good design.

Brute force has limits: a search over ten parameters with ten values each needs ten billion evaluations. For larger problems, engineers use optimization methods that search intelligently. But for a few parameters, trying everything is quick, transparent and hard to get wrong.