Finding Treasure in Signal Peaks

The satisfying beep of a metal detector isn’t magic—it’s mathematics. As you sweep across the ground, your detector measures electromagnetic field strength continuously. When metal disrupts the field, the signal spikes. The detector’s job is finding these peaks in a noisy stream of measurements.

Peak detection algorithms identify local maxima: points where a signal rises then falls. A simple approach checks if each point exceeds its immediate neighbours while staying above a threshold.

fn find_peaks(signal: &[f32], threshold: f32) -> Vec<usize> {
    signal.windows(3)
          .enumerate()
          .filter_map(|(i, window)| {
              let [left, center, right] = window else { return None };
              if center > left && center > right && center > &threshold {
                  Some(i + 1)
              } else { None }
          })
          .collect()
}

Rust’s iterator chains make this elegant—we slide a 3-element window across the signal, checking each center point against its neighbours. The windows(3) method handles the heavy lifting.

Haskell takes a more mathematical approach:

findPeaks :: (Ord a) => a -> [a] -> [Int]
findPeaks threshold xs = [i | (i, (l, c, r)) <- zip [1..] (zip3 xs (tail xs) (drop 2 xs)),
                              c > l && c > r && c > threshold]

The zip3 elegantly creates triplets of consecutive values, while list comprehension filters for peaks. Both approaches scan linearly, making them perfect for real-time detection as your detector sweeps.

In practice, metal detectors use more sophisticated variants—adaptive thresholds that adjust to ground conditions, or frequency-domain analysis that distinguishes silver from iron. But at the core, it’s still about finding peaks in signals, whether they represent buried treasure or hidden patterns in data streams.