Quadrature Amplitude Modulation (QAM)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92

import numpy as np
 
def calculate_spectral_efficiency(M, alpha):
    """
    Calculate spectral efficiency for M-QAM with roll-off factor alpha.
    
    Returns:
        eta: spectral efficiency in bps/Hz
    """
    bits_per_symbol = np.log2(M)
    eta = bits_per_symbol / (1 + alpha)
    return eta
 
def calculate_data_rate(bandwidth_hz, M, alpha, code_rate=1.0):
    """
    Calculate achievable data rate given bandwidth and modulation.
    
    Args:
        bandwidth_hz: Available bandwidth in Hz
        M: QAM constellation size
        alpha: Roll-off factor (0 to 1)
        code_rate: FEC code rate (0 to 1)
    
    Returns:
        data_rate: Achievable data rate in bps
    """
    # Symbol rate from bandwidth
    symbol_rate = bandwidth_hz / (1 + alpha)
    
    # Bits per symbol
    bits_per_symbol = np.log2(M)
    
    # Raw bit rate
    raw_rate = symbol_rate * bits_per_symbol
    
    # After coding
    data_rate = raw_rate * code_rate
    
    return {
        'symbol_rate': symbol_rate,
        'bits_per_symbol': bits_per_symbol,
        'raw_bit_rate': raw_rate,
        'data_rate_with_coding': data_rate,
        'spectral_efficiency': bits_per_symbol / (1 + alpha) * code_rate,
    }
 
def design_system_for_rate(target_rate_bps, bandwidth_hz, alpha=0.25, code_rate=0.75):
    """
    Determine minimum QAM order needed to achieve target data rate.
    """
    available_symbol_rate = bandwidth_hz / (1 + alpha)
    
    # Required uncoded bits per symbol
    required_bits_per_symbol = target_rate_bps / (available_symbol_rate * code_rate)
    
    # Minimum QAM order
    min_qam_order = 2 ** np.ceil(required_bits_per_symbol)
    
    # Actual achieved rate
    actual_bits_per_symbol = np.log2(min_qam_order)
    actual_rate = available_symbol_rate * actual_bits_per_symbol * code_rate
    
    return {
        'required_bits_per_symbol': required_bits_per_symbol,
        'selected_qam_order': int(min_qam_order),
        'actual_bits_per_symbol': actual_bits_per_symbol,
        'actual_data_rate': actual_rate,
    }
 
# Example: LTE resource block analysis
print("LTE Resource Block Capacity Analysis")
print("=" * 50)
 
# LTE RB: 12 subcarriers × 14 OFDM symbols per 1ms slot
# Subcarrier spacing: 15 kHz
rb_bandwidth = 12 * 15e3  # 180 kHz per RB
symbols_per_slot = 12 * 14  # 168 resource elements
 
for M in [4, 16, 64, 256]:
    modulation_name = {4: 'QPSK', 16: '16-QAM', 64: '64-QAM', 256: '256-QAM'}[M]
    bits = np.log2(M)
    raw_bits_per_slot = symbols_per_slot * bits
    rate_mbps = raw_bits_per_slot / 1e-3 / 1e6  # 1ms slot
    print(f"{modulation_name:>8}: {bits:.0f} bits/symbol × {symbols_per_slot} RE = {raw_bits_per_slot:.0f} bits/slot = {rate_mbps:.2f} Mbps/RB")
 
print("\nSpectral Efficiency Comparison")
print("-" * 50)
for alpha in [0.0, 0.1, 0.25, 0.35, 0.5]:
    print(f"\nRoll-off α = {alpha}:")
    for M in [16, 64, 256, 1024]:
        eta = calculate_spectral_efficiency(M, alpha)
        print(f"  {M:4d}-QAM: {eta:.2f} bps/Hz")

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76

import numpy as np
import matplotlib.pyplot as plt
 
def shannon_limit(snr_db):
    """Calculate Shannon capacity in bps/Hz."""
    snr_linear = 10 ** (snr_db / 10)
    return np.log2(1 + snr_linear)
 
def qam_required_snr(M, target_ber=1e-5):
    """
    Approximate required SNR (Eb/N0 in dB) for M-QAM at target BER.
    Empirical formula for uncoded AWGN channel.
    """
    k = np.log2(M)  # bits per symbol
    
    # Approximate formula (valid for M >= 4, BER around 1e-5)
    # Based on: Eb/N0 ≈ (M-1)/(3*log2(M)) * (erfc_inv(BER*k))^2
    # Simplified empirical fit:
    eb_n0_db = 2.5 * k + 4  # Rough approximation
    
    # Convert Eb/N0 to SNR: SNR = Eb/N0 * k
    snr_db = eb_n0_db + 10 * np.log10(k)
    
    return snr_db
 
def qam_spectral_efficiency(M, alpha=0):
    """Calculate QAM spectral efficiency for ideal pulse shaping."""
    return np.log2(M) / (1 + alpha)
 
# Analysis
print("Shannon Limit vs QAM Spectral Efficiency")
print("=" * 60)
print(f"{'QAM':>8} {'η (bps/Hz)':>12} {'Req SNR (dB)':>14} {'Shannon at SNR':>16} {'Gap':>10}")
print("-" * 60)
 
for M in [4, 16, 64, 256, 1024, 4096]:
    eta = qam_spectral_efficiency(M)
    snr = qam_required_snr(M)
    shannon = shannon_limit(snr)
    gap = shannon - eta
    qam_name = f"{M}-QAM"
    print(f"{qam_name:>8} {eta:>12.1f} {snr:>14.1f} {shannon:>16.2f} {gap:>10.2f}")
 
print("\nInterpretation:")
print("-" * 60)
print("The 'Gap' column shows how much capacity is wasted by using")
print("uncoded QAM instead of capacity-achieving coded modulation.")
print("Modern LDPC/Turbo codes recover most of this gap.")
 
# Compare coded vs uncoded
print("\n")
print("Practical Coded Systems (approximate)")
print("=" * 60)
coding_gains = {
    'Uncoded': 0,
    'Conv R=1/2': 3,
    'Turbo R=1/2': 6,
    'LDPC R=3/4': 8,
    'LDPC R=5/6': 9,
}
 
M = 64  # Use 64-QAM as example
eta_raw = qam_spectral_efficiency(M)
snr_uncoded = qam_required_snr(M)
 
print(f"Example: 64-QAM (6 bps/Hz raw)")
print("-" * 60)
print(f"{'Coding':>12} {'Code Rate':>12} {'Eff. η':>10} {'Req SNR':>12} {'Shannon η':>12}")
print("-" * 60)
 
for code_name, gain in coding_gains.items():
    code_rate = 0.5 if 'R=1/2' in code_name else (0.75 if 'R=3/4' in code_name else (0.833 if 'R=5/6' in code_name else 1.0))
    eff_eta = eta_raw * code_rate
    eff_snr = snr_uncoded - gain
    shannon = shannon_limit(eff_snr)
    print(f"{code_name:>12} {code_rate:>12.2f} {eff_eta:>10.2f} {eff_snr:>12.1f} {shannon:>12.2f}")

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117

import numpy as np
import matplotlib.pyplot as plt
 
def raised_cosine_pulse(t, T, alpha):
    """
    Generate raised-cosine pulse shape.
    
    Args:
        t: Time array
        T: Symbol period
        alpha: Roll-off factor (0 to 1)
    
    Returns:
        h: Pulse shape values
    """
    h = np.zeros_like(t)
    
    for i, ti in enumerate(t):
        if ti == 0:
            h[i] = 1.0
        elif alpha > 0 and abs(abs(ti) - T/(2*alpha)) < 1e-10:
            h[i] = alpha/2 * np.sin(np.pi/(2*alpha))
        else:
            numerator = np.sin(np.pi * ti / T) * np.cos(np.pi * alpha * ti / T)
            denominator = (np.pi * ti / T) * (1 - (2 * alpha * ti / T)**2)
            if abs(denominator) > 1e-10:
                h[i] = numerator / denominator
            else:
                h[i] = 0
    
    return h
 
def raised_cosine_spectrum(f, T, alpha):
    """
    Frequency response of raised-cosine filter.
    """
    H = np.zeros_like(f)
    
    f_low = (1 - alpha) / (2 * T)
    f_high = (1 + alpha) / (2 * T)
    
    for i, fi in enumerate(f):
        fi_abs = abs(fi)
        if fi_abs <= f_low:
            H[i] = T
        elif fi_abs <= f_high:
            H[i] = T/2 * (1 + np.cos(np.pi * T / alpha * (fi_abs - f_low)))
        else:
            H[i] = 0
    
    return H
 
# Time domain analysis
T = 1.0  # Symbol period
oversampling = 32
t = np.arange(-8*T, 8*T, T/oversampling)
 
# Compare different roll-off factors
fig, axes = plt.subplots(2, 2, figsize=(14, 10))
 
# Time domain pulses
ax1 = axes[0, 0]
for alpha in [0.0, 0.25, 0.5, 1.0]:
    h = raised_cosine_pulse(t, T, alpha)
    ax1.plot(t/T, h, label=f'α = {alpha}')
ax1.axhline(y=0, color='gray', linestyle='--', alpha=0.5)
ax1.set_xlabel('Time (t/T)')
ax1.set_ylabel('Amplitude')
ax1.set_title('Raised-Cosine Pulses (Time Domain)')
ax1.legend()
ax1.grid(True, alpha=0.3)
ax1.set_xlim(-4, 4)
 
# Zero-crossing verification
ax2 = axes[0, 1]
for alpha in [0.0, 0.25, 0.5, 1.0]:
    h = raised_cosine_pulse(t, T, alpha)
    ax2.plot(t/T, h, label=f'α = {alpha}')
# Mark symbol instants
for n in range(-3, 4):
    ax2.axvline(x=n, color='red', linestyle=':', alpha=0.5)
ax2.axhline(y=0, color='gray', linestyle='--', alpha=0.5)
ax2.set_xlabel('Time (t/T)')
ax2.set_ylabel('Amplitude')
ax2.set_title('Zero ISI: Pulses Cross Zero at t=nT (n≠0)')
ax2.legend()
ax2.grid(True, alpha=0.3)
ax2.set_xlim(-3.5, 3.5)
 
# Frequency domain
ax3 = axes[1, 0]
f = np.linspace(-2/T, 2/T, 1000)
for alpha in [0.0, 0.25, 0.5, 1.0]:
    H = raised_cosine_spectrum(f, T, alpha)
    ax3.plot(f*T, H/T, label=f'α = {alpha}')
ax3.set_xlabel('Frequency (f·T)')
ax3.set_ylabel('|H(f)|')
ax3.set_title('Raised-Cosine Frequency Response')
ax3.legend()
ax3.grid(True, alpha=0.3)
 
# Bandwidth comparison
ax4 = axes[1, 1]
alphas = np.linspace(0, 1, 100)
bandwidths = 1 + alphas
efficiencies = 1 / bandwidths  # Normalized to α=0
 
ax4.plot(alphas, bandwidths, label='Bandwidth factor', color='blue')
ax4.plot(alphas, efficiencies, label='Efficiency factor', color='red')
ax4.set_xlabel('Roll-off factor (α)')
ax4.set_ylabel('Relative Value')
ax4.set_title('Bandwidth vs Efficiency Trade-off')
ax4.legend()
ax4.grid(True, alpha=0.3)
 
plt.tight_layout()
plt.show()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

import numpy as np
 
def calculate_practical_efficiency(
    qam_order,
    code_rate,
    roll_off=0.25,
    guard_overhead=0.10,
    pilot_overhead=0.07,
    cp_overhead=0.20,
    control_overhead=0.05
):
    """
    Calculate practical spectral efficiency accounting for all overheads.
    
    Args:
        qam_order: QAM constellation size (16, 64, 256, etc.)
        code_rate: FEC code rate (0 to 1)
        roll_off: Pulse shaping roll-off factor
        guard_overhead: Fraction of bandwidth lost to guard bands
        pilot_overhead: Fraction of resources used for pilots
        cp_overhead: Cyclic prefix overhead (OFDM only)
        control_overhead: Protocol/signaling overhead
    
    Returns:
        Dictionary with efficiency breakdown
    """
    # Theoretical maximum
    bits_per_symbol = np.log2(qam_order)
    eta_raw = bits_per_symbol  # With α=0
    eta_with_rolloff = bits_per_symbol / (1 + roll_off)
    
    # Apply overheads
    eta_after_guard = eta_with_rolloff * (1 - guard_overhead)
    eta_after_cp = eta_after_guard * (1 - cp_overhead)
    eta_after_pilot = eta_after_cp * (1 - pilot_overhead)
    eta_after_control = eta_after_pilot * (1 - control_overhead)
    eta_after_coding = eta_after_control * code_rate
    
    return {
        'qam_order': qam_order,
        'bits_per_symbol': bits_per_symbol,
        'eta_raw': eta_raw,
        'eta_with_rolloff': eta_with_rolloff,
        'eta_after_guard': eta_after_guard,
        'eta_after_cp': eta_after_cp,
        'eta_after_pilot': eta_after_pilot,
        'eta_after_control': eta_after_control,
        'eta_final': eta_after_coding,
        'efficiency_ratio': eta_after_coding / eta_raw,
    }
 
# Compare different systems
print("Practical Spectral Efficiency Analysis")
print("=" * 70)
 
configs = [
    ("WiFi 802.11ac MCS9", 256, 5/6, 0.25, 0.10, 0.07, 0.20, 0.05),
    ("WiFi 802.11ax MCS11", 1024, 5/6, 0.25, 0.08, 0.05, 0.10, 0.03),
    ("LTE Cat 4", 64, 0.93, 0.35, 0.10, 0.10, 0.07, 0.08),
    ("5G NR FR1", 256, 0.93, 0.22, 0.05, 0.08, 0.07, 0.05),
    ("DOCSIS 3.1", 4096, 0.94, 0.10, 0.02, 0.01, 0.00, 0.02),
]
 
for name, M, code, rolloff, guard, pilot, cp, ctrl in configs:
    result = calculate_practical_efficiency(M, code, rolloff, guard, pilot, cp, ctrl)
    print(f"\n{name}:")
    print(f"  QAM Order: {M}, Code Rate: {code:.2f}")
    print(f"  Theoretical Max: {result['eta_raw']:.1f} bps/Hz")
    print(f"  After roll-off (α={rolloff}): {result['eta_with_rolloff']:.2f} bps/Hz")
    print(f"  After all overhead: {result['eta_final']:.2f} bps/Hz")
    print(f"  Efficiency: {result['efficiency_ratio']*100:.1f}%")