Iterative Relaxation: Solving by Gradual Adjustment

Wire wrapped around a juniper branch doesn’t force it into position—it holds a constraint while the wood slowly conforms. Every few days the tension eases as cellulose yields. By week six the shape is set. Remove the wire and the bend remains.

In the 1970s, when engineers needed to solve large systems of equations—heat distribution across a metal plate, stress in a bridge girder—direct methods choked on the scale. Relaxation methods offered an alternative: start with a guess, then sweep through the system repeatedly, adjusting each value based on its neighbours’ current state. Each pass brings you closer to equilibrium. Eventually the changes become negligible and you stop.

Gauss-Seidel relaxation updates values in place, using the newest information immediately:

(define (relax grid)
  (let ((n (vector-length grid)))
    (do ((i 1 (+ i 1)))
        ((= i (- n 1)) grid)
      (vector-set! grid i
        (/ (+ (vector-ref grid (- i 1))
              (vector-ref grid (+ i 1))) 2.0)))))

(define vals (vector 0.0 1.0 1.0 1.0 0.0))
(relax vals)  ; => #(0.0 0.5 1.0 0.5 0.0)
(relax vals)  ; => #(0.0 0.25 0.625 0.3125 0.0)

Each interior point becomes the average of its neighbours. Run it enough times and the gradient smooths out.

Java’s mutable arrays make the in-place update explicit:

class Relaxation {
    static void relax(double[] grid) {
        for (int i = 1; i < grid.length - 1; i++) {
            grid[i] = (grid[i-1] + grid[i+1]) / 2.0;
        }
    }
    public static void main(String[] args) {
        double[] v = {0.0, 1.0, 1.0, 1.0, 0.0};
        relax(v); relax(v); relax(v);
        System.out.println(java.util.Arrays.toString(v));
        // [0.0, 0.125, 0.5, 0.125, 0.0]
    }
}

The boundary conditions—the endpoints fixed at zero—constrain the system. The interior points adjust iteration by iteration until they settle. It’s not elegant algebra; it’s patient repetition. The wire holds the constraint. The tree does the work.