Constellation Design and Mapping

An $M$-ary constellation is a set of $M$ complex-valued symbols $\mathcal{S} = \{s_0, s_1, \dots, s_{M-1}\}$ where each symbol represents $k = \log_2 M$ bits. The average symbol energy is:

$$E_s = \frac{1}{M} \sum_{m=0}^{M-1} |s_m|^2$$

and the average bit energy is $E_b = E_s / k$.

import numpy as np

# QPSK constellation (M=4, k=2 bits/symbol)
M = 4
qpsk = np.exp(1j * np.pi * np.array([1, 3, 7, 5]) / 4)
Es = np.mean(np.abs(qpsk)**2)
Eb = Es / np.log2(M)

A Gray code assigns bit labels to constellation points such that adjacent symbols differ in exactly one bit. When noise causes a symbol error to a neighbor, only one bit is wrong, so:

$$P_b \approx \frac{P_s}{\log_2 M}$$

at moderate-to-high SNR, where $P_s$ is the symbol error rate.

def gray_code(n_bits):
    """Generate Gray code sequence for n_bits."""
    if n_bits == 0:
        return [0]
    lower = gray_code(n_bits - 1)
    return lower + [x + (1 << (n_bits - 1)) for x in reversed(lower)]

The minimum Euclidean distance of a constellation is:

$$d_{\min} = \min_{i \neq j} |s_i - s_j|$$

This quantity dominates the high-SNR error probability. For $M$-QAM with average energy $E_s$:

$$d_{\min} = \sqrt{\frac{6 E_s}{M - 1}}$$

from itertools import combinations

def compute_dmin(constellation):
    """Compute minimum Euclidean distance."""
    dists = [abs(si - sj) for si, sj in combinations(constellation, 2)]
    return min(dists)

An $M$-QAM constellation ($M = 4^k$ for some integer $k$) is the Cartesian product of two $\sqrt{M}$-PAM alphabets:

$$s_{m} = (2i - \sqrt{M} + 1) + j(2q - \sqrt{M} + 1), \quad i, q \in \{0, 1, \dots, \sqrt{M}-1\}$$

After normalization to unit average energy:

def qam_constellation(M):
    """Generate normalized M-QAM constellation."""
    sqrt_M = int(np.sqrt(M))
    assert sqrt_M**2 == M, "M must be a perfect square"
    pam = np.arange(sqrt_M) - (sqrt_M - 1) / 2
    I, Q = np.meshgrid(pam, pam)
    constellation = (I + 1j * Q).flatten()
    # Normalize to unit average energy
    constellation /= np.sqrt(np.mean(np.abs(constellation)**2))
    return constellation

An $M$-PSK constellation places symbols uniformly on the unit circle:

$$s_m = \exp\!\left(j \frac{2\pi m}{M}\right), \quad m = 0, 1, \dots, M-1$$

All symbols have the same energy $|s_m|^2 = 1$, making PSK attractive for nonlinear channels (constant envelope). The minimum distance is $d_{\min} = 2\sin(\pi/M)$.

def psk_constellation(M):
    """Generate M-PSK constellation."""
    return np.exp(1j * 2 * np.pi * np.arange(M) / M)

A mapper takes a binary bit stream and groups $k = \log_2 M$ consecutive bits into an integer index, which selects a constellation point. With Gray coding, the mapping is:

$$\text{bits} \to \text{Gray index} \to s_m$$

def bits_to_symbols(bits, constellation, gray_map):
    """Map bits to constellation symbols using Gray mapping."""
    k = int(np.log2(len(constellation)))
    n_symbols = len(bits) // k
    bit_groups = bits[:n_symbols * k].reshape(n_symbols, k)
    indices = np.array([int(''.join(map(str, b)), 2) for b in bit_groups])
    symbols = constellation[gray_map[indices]]
    return symbols