The Art of Forgetting Most of What You Hear

The S-meter on my Icom bounces constantly when I’m tuned to 40 metres at night. Static crashes from thunderstorms over Brazil, the rhythmic sweep of over-the-horizon radar, the faint carrier of a station I haven’t identified yet—all of it hitting the AGC circuit in rapid succession. But the needle doesn’t seizure. It rises and falls smoothly, tracking something more useful than the instantaneous chaos.

What it’s tracking is a weighted average that forgets. Not uniformly—recent samples matter more than old ones, and the rate of forgetting is tuneable. In the 1970s, as digital signal processing moved from theory to silicon, this became the exponential moving average: each new sample blends with the accumulated history using a single parameter, α, that controls how much attention to pay to the present versus the past.

The formula looks almost too simple: smoothed = α × new + (1 - α) × smoothed. When α is high (say, 0.9), you’re tracking fast changes—the meter jumps. When α is low (0.1), you’re averaging over a longer window—the meter barely moves. Radio receivers typically use values around 0.1 to 0.3, which is why that Romanian broadcast could fade over thirty seconds without the S-meter flicking around like a nervous eye.

fn ema(samples: &[f64], alpha: f64) -> Vec<f64> {
    samples.iter().scan(samples[0], |acc, &x| {
        *acc = alpha * x + (1.0 - alpha) * *acc;
        Some(*acc)
    }).collect()
}

fn main() {
    let noisy = [0.2, 0.9, 0.1, 0.85, 0.15, 0.88, 0.12, 0.9];
    println!("{:.2?}", ema(&noisy, 0.2));
    // [0.20, 0.34, 0.29, 0.40, 0.35, 0.46, 0.39, 0.49]
}

Rust’s scan is perfect here—it threads state through an iterator without mutation escaping. Each call updates the accumulator and yields the smoothed value. The type signature enforces that you’re folding, not side-effecting.

ema :: Double -> [Double] -> [Double]
ema alpha = scanl1 (\acc x -> alpha * x + (1 - alpha) * acc)

main :: IO ()
main = print $ ema 0.2 [0.2, 0.9, 0.1, 0.85, 0.15, 0.88, 0.12, 0.9]
-- [0.2,0.34,0.292,0.4036,0.35288,0.458304,0.3966432,0.4973146]

Haskell’s scanl1 does the same thing with less ceremony. No explicit accumulator variable, no mutable state—just a binary function and a list. The output is the history of the smoothing process, not just the final value, which turns out to be useful when you want to see how quickly the filter responds to step changes.

What I find interesting is the tradeoff encoded in α. High values give you responsiveness but jitter. Low values give you stability but lag. There’s no correct answer—it depends on whether you care more about detecting a signal’s arrival or measuring its sustained strength. My receiver’s AGC circuit makes this choice hundreds of times per second, and I never think about it until I’m trying to copy a weak CW signal and wish the gain would stop adjusting quite so fast.

The ionosphere itself does something similar. The D layer absorbs, the F layer reflects, and the boundary between them shifts with solar radiation in a way that resembles exponential decay. Propagation prediction models use similar smoothing functions to estimate what frequencies will be usable at what times. The math that quiets my S-meter is also the math that tells me when Romania might come through.

Some filters are infinite impulse response—they never completely forget any sample, just weight it less and less. The exponential moving average is one of these. Every signal that ever hit the antenna is still in there somewhere, decayed to insignificance but technically present. There’s something poetic about that, or maybe just something true about how memory works.