The Sine Wave That Never Needed Trigonometry

The Tektronix needs sine waves—smooth, continuous, 44,100 samples per second. My laptop could compute math.sin() that fast without breaking a sweat. But in 1985, a 4.77MHz 8088 needed roughly 100 cycles per floating-point multiply. Trigonometry was a luxury.

The solution was elegantly stupid: don’t compute the sine at runtime. Compute it once, store the results in an array, and look them up by index. A lookup table—LUT to the initiated.

For audio synthesis, you’d typically store one complete cycle of 256 or 512 samples. To generate a 440Hz tone at 44.1kHz sample rate, you advance through the table by 440 × 256 / 44100 ≈ 2.56 entries per sample. The fractional part gets truncated or interpolated depending on how much quality you need.

package main

import (
    "fmt"
    "math"
)

func main() {
    const size = 256
    lut := make([]float64, size)
    for i := range lut {
        lut[i] = math.Sin(2 * math.Pi * float64(i) / size)
    }
    // Generate 8 samples at ~440Hz (assuming 44100Hz sample rate)
    phase, step := 0.0, 440.0*float64(size)/44100.0
    for i := 0; i < 8; i++ {
        fmt.Printf("%.4f ", lut[int(phase)%size])
        phase += step
    }
}

Output: 0.0000 0.0491 0.1224 0.1710 0.2430 0.2903 0.3599 0.4052

The Lua version uses the same principle—precompute once, index forever:

local size = 256
local lut = {}
for i = 0, size - 1 do
    lut[i] = math.sin(2 * math.pi * i / size)
end

local phase, step = 0, 440 * size / 44100
for _ = 1, 8 do
    io.write(string.format("%.4f ", lut[math.floor(phase) % size]))
    phase = phase + step
end

The tradeoff lives in the table size. More entries means smoother waves but costs memory—precious in 1985. Fewer entries introduces quantization noise, audible as a slight graininess. The Commodore 64’s SID chip used a 4,096-entry table burned into silicon. Modern wavetable synthesizers scale to 65,536 entries or more, but the principle hasn’t changed in forty years.

For my oscilloscope portraits, I’m generating complex paths—not pure sines—but the technique persists. Rather than computing Bézier curves frame by frame, I could precompute an entire drawing as a LUT of X-Y pairs and simply stream through it. The curve becomes data. The math becomes memory.

That’s the quiet genius of the lookup table: it converts time into space, trading RAM for CPU cycles. In 2026, we have cycles to spare. But the elegance of precomputation—of treating math as something you can store—still shows up everywhere from GPU texture mapping to DNS caching. The oscilloscope doesn’t care whether the sine was computed or recalled. It just draws.