QUANTIZATION

WHAT YOU ARE LOOKING AT

An analog-to-digital converter does two separate things, and it is worth keeping them apart in your head. It makes time discrete (sampling) and it makes value discrete (quantization). The three spectra along the bottom are the same signal after each step: continuous time and continuous value, then discrete time and continuous value, then discrete time and discrete value.

These are complex FFTs, so they show both negative and positive frequencies, which is why one sine gives two spikes — sin(x) = (e^ix − e^-ix)/2i, and both exponentials are there. Everything is normalised to its own peak, so 0 dB is the tone.

Quantization replaces the signal with the nearest of 2^B levels spread over the full scale, so one LSB is 2/2^B for a ±1 input. The difference is the error in the top middle panel, bounded by ±½ LSB by construction. If that error looks like noise, treating it as noise gives the familiar SQNR ≈ 6.02·B + 1.76 dB. If it does not — at one bit it very much does not — the error is a deterministic function of the signal and lands in harmonics instead of spreading out, and the formula stops describing anything.

THINGS WORTH TRYING

• Start at 1 bit, the default: two levels, one comparator, and the output is a square wave. The error is a triangle locked to the signal, and the spectrum has clear spikes at 3f_1, 5f_1 and 7f_1 rather than a floor. Measured SQNR is about 6 dB against the formula's 7.8. Do not read anything into the gap — at one bit the error is not noise, it is a deterministic function of the input, and 6.02B + 1.76 is derived by assuming the opposite.
• Walk the bits up. Every extra bit buys about 6 dB, the harmonics sink into the floor, and by 4 bits the measured SQNR is within a few tenths of a dB of the formula. That convergence is the whole justification for the “quantization noise is white” assumption.
• Set the input noise to 1/2¹⁰ and then walk the bits up past 9. The measured SQNR peels away from the formula and flattens out around 58 dB: the quantizer is now quieter than the noise already on the signal, so more bits buy nothing. At the default 1/2¹⁵ that never happens within the slider's range, and the measurement tracks 6.02B + 1.76 all the way to 12 bits.
• Tick use the old one-liner. The level count jumps from 2^B to 2^B+1+1 — five levels at “1 bit” — and the SQNR gains a whole bit, because round(x·2B)/2B takes B to mean bits after the binary point rather than converter resolution. Its step is 2^-B, so a signal spanning ±1 gets 2^B+1 steps. This is a mistake worth making once on purpose: a “1-bit” converter that produces five different outputs is not a 1-bit converter, and the SQNR readout tells on it immediately. ex/q.py now uses a proper mid-rise quantizer.
• Turn the noise up to 1/2⁸ at 3 or 4 bits. The added noise dithers the quantizer: the harmonics break up into a noise floor. The total noise power goes up, but it is now noise rather than distortion, which is often the better trade. This is dither, and it is why converters deliberately add some.
• Increase Sample ÷. Fewer points go into the second and third FFT, so the same noise power lands in fewer bins and the floor rises. That is the noise folding and reduced FFT length the lecture notes mention.
• Drop the amplitude to 0.1. The quantizer step has not changed, so the error has not changed, but the signal has: SQNR falls by 20 dB per decade of amplitude. A converter is only at its data-sheet SNR near full scale.
• Untick coherent sampling to see the off-bin failure mode (ex/q.py used a np.linspace(0,N,N) time vector with step N/(N−1) before it was fixed). The tone sits a fraction of a bin off, leaks through the window sidelobes, and pins the measured SQNR at around 69 dB however many bits you ask for. Getting the time vector right matters as much as getting the converter right.

THE PYTHON

def adc(x,bits):
    levels = 2**bits
    y = np.round(x*levels)/levels
    return y

#- Sampling frequency is 1/nfs of the time vector
x_sn = x_s[0::nfs]
y_sn = adc(x_sn,bits)

def freqDomain(x,hann=True):
    N = len(x)
    w = np.hanning(N+1) if hann else np.ones(N+1)
    X = np.fft.fftshift(np.fft.fft(np.multiply(w[0:N],x)))
    return X/np.max(np.abs(X))   # normalise to max output power

Source: ex/q.py, ex/quantization.py (the same thing with np.sign(), i.e. a real one-bit case). This page defaults to a conventional B-bit converter — 2^B levels, step 2/2^B, mid-riser, saturating at the end codes — so that the slider, the level count and 6.02B + 1.76 all agree with each other. The script's adc() is one tick box away.