Fixed-Point Arithmetic and the Problem of Scale

Interferometry works because you’re measuring against the wavelength of light itself—a built-in ruler that expands and contracts with you. The interference fringes count how many wavelengths fit between your specimen and the optical flat. No external calibration, no drift, just integer counts of a physical constant.

Fixed-point arithmetic uses the same principle: pick a scale factor up front (say, 16 bits for the integer part, 16 bits for the fractional part), then do all your math as integer operations. Representing 3.14159 as 205887 when your scale is 2⁻¹⁶ means you’re counting sixty-five-thousandths, not approximating a real number. Every addition, multiplication, and division becomes an integer operation—no rounding error accumulation, no hidden precision loss.

Scheme’s rational arithmetic makes this explicit:

(define scale (expt 2 16))
(define (to-fixed x) (inexact->exact (round (* x scale))))
(define (from-fixed fx) (/ fx scale))

(define a (to-fixed 0.1))
(define sum (+ a a a a a a a a a a))  ; 10 × 0.1
(from-fixed sum)  ; exactly 1, not 0.9999999999999999

Java before hardware FPUs did this everywhere—game engines, audio processing, financial systems:

class Fixed {
    static final int SCALE = 16;
    static final int ONE = 1 << SCALE;
    
    static int mul(int a, int b) {
        return (int)(((long)a * b) >> SCALE);
    }
    
    static int div(int a, int b) {
        return (int)(((long)a << SCALE) / b);
    }
}

The DSP processors of the late ’80s had dedicated fixed-point multiply-accumulate units because this was faster and more predictable than floating-point. You gave up dynamic range for guaranteed behaviour—same reason you choose monochromatic light for interferometry instead of trying to measure with white light and correcting for dispersion afterward.