Ferkans — Interactive Telecom Tutor

ex-sp-ch20-01

Easy

Generate a BPSK constellation with $E_b = 1$ and compute its minimum Euclidean distance. Verify that $d_{\min} = 2\sqrt{E_b}$ .

Show Hint

BPSK symbols are $\pm\sqrt{E_b}$ .

Solution

Implementation

import numpy as np
Eb = 1.0
bpsk = np.array([np.sqrt(Eb), -np.sqrt(Eb)])
dmin = np.abs(bpsk[0] - bpsk[1])
print(f"dmin = {dmin:.4f}, 2*sqrt(Eb) = {2*np.sqrt(Eb):.4f}")

ex-sp-ch20-02

Easy

Write a function that generates an $M$ -PSK constellation for any $M$ and verify that all symbols have unit energy.

Show Hint

$s_m = \exp(j 2\pi m / M)$ for $m = 0, \dots, M-1$ .

Solution

Implementation

def psk(M):
    return np.exp(1j * 2 * np.pi * np.arange(M) / M)

for M in [2, 4, 8]:
    c = psk(M)
    print(f"{M}-PSK: |s|^2 = {np.abs(c)**2}")  # all ones

ex-sp-ch20-03

Easy

Compute the theoretical BER for BPSK at $E_b/N_0 = 0, 5, 10, 15$ dB using the $Q$ -function.

Show Hint

$P_b = Q(\sqrt{2 E_b/N_0})$ and $Q(x) = 0.5\,\mathrm{erfc}(x/\sqrt{2})$ .

Solution

Implementation

from scipy.special import erfc
Q = lambda x: 0.5 * erfc(x / np.sqrt(2))
for EbN0_dB in [0, 5, 10, 15]:
    EbN0 = 10**(EbN0_dB / 10)
    print(f"Eb/N0 = {EbN0_dB} dB: BER = {Q(np.sqrt(2*EbN0)):.2e}")

ex-sp-ch20-04

Easy

Convert $E_b/N_0 = 12$ dB to $E_s/N_0$ for QPSK, 16-QAM, and 64-QAM.

Solution

Implementation

EbN0_dB = 12
for M in [4, 16, 64]:
    k = np.log2(M)
    EsN0_dB = EbN0_dB + 10*np.log10(k)
    print(f"{int(M)}-QAM: Es/N0 = {EsN0_dB:.2f} dB")

ex-sp-ch20-05

Easy

Implement ML detection for QPSK using only sign decisions on the I and Q components (no distance computation).

Solution

Implementation

qpsk = np.array([1+1j, -1+1j, -1-1j, 1-1j]) / np.sqrt(2)
N = 10000
bits = np.random.randint(0, 2, (N, 2))
idx = bits[:, 0] * 2 + bits[:, 1]
tx = qpsk[idx]
rx = tx + 0.3*(np.random.randn(N) + 1j*np.random.randn(N))
det_I = (np.real(rx) > 0).astype(int)
det_Q = (np.imag(rx) > 0).astype(int)
det_bits = np.column_stack([1-det_I, 1-det_Q])
ber = np.mean(bits != det_bits)
print(f"BER = {ber:.5f}")

ex-sp-ch20-06

Medium

Implement a complete 16-QAM transmitter-receiver chain with Gray coding. Simulate BER at $E_b/N_0 = 0, 4, 8, 12, 16$ dB with at least 100 errors per point. Compare with the theoretical formula.

Show Hint

Use separate Gray codes for the I and Q axes.

Solution

Implementation

# See code supplement ch20/python/qam_simulation.py
# for the complete implementation with Gray coding.

ex-sp-ch20-07

Medium

Compute the union bound on the SER for 16-QAM and compare with the exact nearest-neighbor approximation. At what SNR does the bound become tight (within 0.5 dB)?

Solution

Analysis

from itertools import combinations

const = qam_constellation(16)
N_sym = len(const)

# Full union bound
EbN0_dB = np.arange(0, 20, 0.5)
for snr_db in EbN0_dB:
    snr = 10**(snr_db/10)
    sigma = np.sqrt(1/(2*4*snr))  # k=4 for 16-QAM
    ser_ub = 0
    for i, j in combinations(range(N_sym), 2):
        d = abs(const[i] - const[j])
        ser_ub += 2 * Q(d / (2*sigma)) / N_sym

ex-sp-ch20-08

Medium

Implement a BPSK matched filter receiver with root-raised-cosine pulse shaping. Measure the output SNR and verify it equals $2E_b/N_0$ .

Show Hint

Root-raised-cosine at TX and RX gives overall raised-cosine (ISI-free).

Solution

Implementation

from scipy.signal import fftconvolve
# See code supplement ch20/python/matched_filter.py

ex-sp-ch20-09

Medium

Compare BPSK and DBPSK (differential BPSK) BER over AWGN. Show that DBPSK has a 1-2 dB penalty.

Solution

Analysis

# DBPSK: BER = 0.5 * exp(-Eb/N0)
# BPSK:  BER = Q(sqrt(2*Eb/N0))
for EbN0_dB in range(0, 16, 2):
    EbN0 = 10**(EbN0_dB/10)
    ber_bpsk = Q(np.sqrt(2*EbN0))
    ber_dbpsk = 0.5 * np.exp(-EbN0)
    penalty = EbN0_dB - 10*np.log10(-np.log(2*ber_bpsk)) if ber_bpsk > 0 else float('inf')
    print(f"Eb/N0={EbN0_dB}: BPSK={ber_bpsk:.2e}, DBPSK={ber_dbpsk:.2e}")

ex-sp-ch20-10

Medium

Implement error vector magnitude (EVM) measurement for 16-QAM. Show the relationship between EVM and SNR.

Show Hint

$\text{EVM}_{\text{rms}} = \sqrt{E[|r - s|^2] / E[|s|^2]} = 1/\sqrt{\text{SNR}}$

Solution

Implementation

def measure_evm(tx_symbols, rx_symbols):
    error = rx_symbols - tx_symbols
    evm_rms = np.sqrt(np.mean(np.abs(error)**2) / np.mean(np.abs(tx_symbols)**2))
    evm_dB = 20 * np.log10(evm_rms)
    return evm_rms, evm_dB

ex-sp-ch20-11

Hard

Implement 8-PSK with set partitioning (Ungerboeck labeling) instead of Gray coding. Compare BER with Gray-coded 8-PSK. Why is set partitioning used in trellis-coded modulation?

Solution

Analysis

Set partitioning maximizes $d_{\min}$ within each partition, enabling trellis-coded modulation to achieve coding gain. Without the trellis code, it performs worse than Gray coding.

ex-sp-ch20-12

Hard

Design a 32-cross-QAM constellation (the "cross" shape used when $\sqrt{M}$ is not integer). Normalize to unit energy and compute $d_{\min}$ and the average number of nearest neighbors.

Solution

Implementation

# 32-cross: start with 6x6 grid, remove 4 corner points
pam6 = np.arange(6) - 2.5
I, Q = np.meshgrid(pam6, pam6)
all_pts = (I + 1j*Q).flatten()
# Remove corners: |I|=2.5 and |Q|=2.5
mask = ~((np.abs(I.flatten()) == 2.5) & (np.abs(Q.flatten()) == 2.5))
cross32 = all_pts[mask]
cross32 /= np.sqrt(np.mean(np.abs(cross32)**2))

ex-sp-ch20-13

Hard

Implement a soft-decision demapper for 16-QAM that outputs log-likelihood ratios (LLRs) for each bit. Show that soft decisions improve BER when fed to a convolutional decoder.

Show Hint

$L(b_k) = \ln \frac{P(b_k=0|r)}{P(b_k=1|r)} = \ln \frac{\sum_{s \in \mathcal{S}_0^k} \exp(-|r-s|^2/N_0)}{\sum_{s \in \mathcal{S}_1^k} \exp(-|r-s|^2/N_0)}$

Solution

LLR computation

def compute_llr(rx, constellation, bit_labels, N0):
    k = int(np.log2(len(constellation)))
    llrs = np.zeros((len(rx), k))
    for b in range(k):
        s0 = constellation[bit_labels[:, b] == 0]
        s1 = constellation[bit_labels[:, b] == 1]
        d0 = np.min(np.abs(rx[:, None] - s0[None, :])**2, axis=1)
        d1 = np.min(np.abs(rx[:, None] - s1[None, :])**2, axis=1)
        llrs[:, b] = (d1 - d0) / N0  # max-log approximation
    return llrs

ex-sp-ch20-14

Hard

Implement a complete BER simulation with importance sampling for BPSK at $E_b/N_0 = 12$ dB (where $P_b \approx 3.9 \times 10^{-6}$ ). Show that IS achieves the same accuracy as standard MC with 1000x fewer samples.

Solution

Importance sampling

# Shift the noise distribution toward the error boundary
# See variance_reduction.py from Chapter 9

ex-sp-ch20-15

Challenge

Design an optimal 8-ary constellation for AWGN that minimizes SER at $E_s/N_0 = 12$ dB. Compare rectangular 8-QAM, 8-PSK, and your optimized constellation. Use gradient descent to optimize symbol positions.

Solution

Approach

Use the union bound as the objective function. Initialize with 8-PSK, then use scipy.optimize.minimize to move symbols. The optimal constellation should be close to a hexagonal packing.

ex-sp-ch20-16

Challenge

Implement a probabilistic constellation shaping (PCS) scheme for 64-QAM where inner constellation points are transmitted more frequently. Show the shaping gain by comparing with uniform 64-QAM at the same average bit rate.

Show Hint

Use a Maxwell-Boltzmann distribution: $P(s_m) \propto \exp(-\lambda |s_m|^2)$

Solution

Approach

Maxwell-Boltzmann shaping approximates the capacity-achieving Gaussian input distribution. The shaping gain is up to 1.53 dB.

Exercises

ex-sp-ch20-01

Implementation

ex-sp-ch20-02

Implementation

ex-sp-ch20-03

Implementation

ex-sp-ch20-04

Implementation

ex-sp-ch20-05

Implementation

ex-sp-ch20-06

Implementation

ex-sp-ch20-07

Analysis

ex-sp-ch20-08

Implementation

ex-sp-ch20-09

Analysis

ex-sp-ch20-10

Implementation

ex-sp-ch20-11

Analysis

ex-sp-ch20-12

Implementation

ex-sp-ch20-13

LLR computation

ex-sp-ch20-14

Importance sampling

ex-sp-ch20-15

Approach

ex-sp-ch20-16

Approach