diff --git a/REPORT.md b/REPORT.md new file mode 100644 index 0000000..67a1d82 --- /dev/null +++ b/REPORT.md @@ -0,0 +1,114 @@ +# 数字调制解调实验报告 + +## 1. 实验目的 + +本实验围绕无线通信中的数字基带调制展开，目标是用 Python 实现并验证 BPSK、QPSK 和 16-QAM 三种典型调制方式。通过本实验，我希望完成以下任务： + +1. 理解二进制比特到复平面符号的映射关系。 +2. 掌握格雷编码在 QPSK 与 16-QAM 星座映射中的作用。 +3. 使用 NumPy 完成向量化调制实现，并保证符号能量归一化。 +4. 使用 Matplotlib 生成星座图，观察不同调制方式的星座结构。 +5. 结合自动化测试和 AI 编程工具，改进代码质量与实验报告表达。 + +## 2. 实验原理 + +### 2.1 BPSK + +BPSK 是最简单的相移键控方式，每个符号只承载 1 bit 信息。实验中采用的映射为： + +```text +0 -> +1 +1 -> -1 +``` + +因此 BPSK 的两个星座点位于实轴两端，虚部为 0。它的优点是抗噪声能力强、判决边界简单；缺点是频谱效率较低，因为一个符号只能传输一个比特。 + +### 2.2 QPSK + +QPSK 每个符号承载 2 bit 信息，本实验采用格雷编码映射： + +```text +00 -> ( 1 + j) / sqrt(2) +01 -> (-1 + j) / sqrt(2) +11 -> (-1 - j) / sqrt(2) +10 -> ( 1 - j) / sqrt(2) +``` + +除以 `sqrt(2)` 后，每个 QPSK 符号的模长为 1，平均符号功率也为 1。格雷编码保证相邻星座点只相差 1 bit，因此当噪声导致符号落到相邻判决区域时，通常只产生单比特错误。 + +### 2.3 16-QAM + +16-QAM 同时利用幅度和相位传输信息，每个符号承载 4 bit。实验中把 4 bit 分成 I、Q 两组，每组 2 bit，并在两个轴上采用相同的格雷编码电平： + +```text +00 -> +3 +01 -> +1 +11 -> -1 +10 -> -3 +``` + +最终符号为 `(I + jQ) / sqrt(10)`。其中 `sqrt(10)` 来自 16-QAM 星座的平均能量归一化：单个轴的平均能量为 `(9 + 1 + 1 + 9) / 4 = 5`，I/Q 两轴合计为 10，因此除以 `sqrt(10)` 后平均符号功率约为 1。16-QAM 的频谱效率高于 BPSK 和 QPSK，但星座点间距更小，对噪声更敏感。 + +## 3. 实验方法与步骤 + +1. 阅读作业给出的 `grading` 测试文件，确认评分关注的函数名、输入输出长度、星座映射、功率归一化和报告完整性。 +2. 在 `src/modulation.py` 中实现三个调制函数：`bpsk_modulate`、`qpsk_modulate` 和 `qam16_modulate`。 +3. 对输入比特进行数组化和合法性检查，确保只接受 0/1 比特；QPSK 要求长度为 2 的倍数，16-QAM 要求长度为 4 的倍数。 +4. 使用字典明确表示格雷编码映射，避免分支逻辑过多导致映射顺序错误。 +5. 调用绘图函数生成星座图；同时让绘图成为辅助行为，避免文件被占用时影响调制数值结果。 +6. 运行自动化测试脚本，检查 BPSK、QPSK、16-QAM、环境测试、报告检查和 pylint 代码质量评分。 + +核心实现片段如下： + +```python +_QAM16_LEVELS = { + (0, 0): 3, + (0, 1): 1, + (1, 1): -1, + (1, 0): -3, +} + +groups = bit_array.reshape(-1, 4) +in_phase = np.array([_QAM16_LEVELS[tuple(group[:2])] for group in groups]) +quadrature = np.array([_QAM16_LEVELS[tuple(group[2:])] for group in groups]) +symbols = (in_phase + 1j * quadrature) / np.sqrt(10) +``` + +## 4. 实验结果 + +### 4.1 星座图 + +![BPSK 星座图](results/bpsk_constellation.png) + +![QPSK 星座图](results/qpsk_constellation.png) + +![16-QAM 星座图](results/16qam_constellation.png) + +### 4.2 BER 曲线 + +![BER 对比曲线](results/ber_comparison.png) + +从星座图可以看出，BPSK 只有两个点，判决最简单；QPSK 有四个等能量点，分布在四个象限；16-QAM 有 16 个点，并且不同点的瞬时功率不同，但整体平均功率经过归一化后约为 1。 + +## 5. 结果分析与讨论 + +BPSK 的星座点距离较远，在相同信噪比下通常具有最低误码率，但它的传输效率最低。QPSK 在不增加符号率的情况下把每个符号携带的信息量提高到 2 bit，是通信系统中常用的折中方案。16-QAM 每个符号携带 4 bit，频谱效率最高，但由于星座点更密集，噪声稍大时就更容易跨越判决边界。 + +本实验中的关键细节是能量归一化。如果不对 QPSK 除以 `sqrt(2)`，或者不对 16-QAM 除以 `sqrt(10)`，不同调制方式的平均功率就不一致，后续比较 BER 曲线时会引入不公平因素。格雷编码也是影响误码表现的重要设计：相邻点只差 1 bit，可以降低符号判决错误对比特错误数量的放大效应。 + +在实现层面，最容易出错的地方是比特分组顺序。例如 16-QAM 中前两位映射到 I 轴，后两位映射到 Q 轴；如果把顺序写反，星座图看起来仍然像 16-QAM，但测试中的具体映射会失败。因此我在实现中使用显式映射表，而不是依赖复杂公式推导。 + +## 6. 实验心得与 AI Coding 体会 + +这次作业中，AI 编程工具对我最大的帮助不是直接“替我写完”，而是帮助我快速发现自动评分真正关心的接口和边界条件。通过阅读测试脚本，可以把任务拆成更明确的工程目标：输出长度正确、映射点正确、平均功率正确、异常处理正确、报告格式完整。 + +我也体会到 AI 生成代码后仍然必须运行测试验证。调制函数看似简单，但文件输出、绘图、编码、pylint 等细节都会影响最终评分。比较有效的协作方式是：先让 AI 帮助梳理测试要求，再由我确认实验原理和报告表达，最后用自动化测试逐项闭环。 + +另一个收获是，报告不能只写“实现了什么”，还应该解释“为什么这样实现”。例如 16-QAM 为什么要除以 `sqrt(10)`、格雷编码为什么有利于降低比特错误扩散，这些内容比单纯贴代码更能体现对实验的理解。 + +## 7. 参考资料 + +1. John G. Proakis, Masoud Salehi, *Digital Communications*, 5th Edition. +2. NumPy 官方文档：https://numpy.org/doc/ +3. Matplotlib 官方文档：https://matplotlib.org/stable/ +4. GitHub Copilot 文档：https://docs.github.com/en/copilot diff --git a/grading/calculate_grade.py b/grading/calculate_grade.py index 6efd2e5..919372a 100644 --- a/grading/calculate_grade.py +++ b/grading/calculate_grade.py @@ -280,4 +280,3 @@ def calculate_grade(): if __name__ == "__main__": calculate_grade() - diff --git a/grading/check_report.py b/grading/check_report.py index 800dfc3..25f2de8 100644 --- a/grading/check_report.py +++ b/grading/check_report.py @@ -112,4 +112,4 @@ def generate_report_score(): if __name__ == "__main__": score = generate_report_score() - print(f"\n最终报告得分: {score}") + print(f"\n最终报告得分: {score}") \ No newline at end of file diff --git a/grading/test_bpsk.py b/grading/test_bpsk.py index 4d191f9..ee008c8 100644 --- a/grading/test_bpsk.py +++ b/grading/test_bpsk.py @@ -88,4 +88,4 @@ def test_constellation_file_exists(): if __name__ == "__main__": - pytest.main([__file__, "-v"]) + pytest.main([__file__, "-v"]) \ No newline at end of file diff --git a/grading/test_qam16.py b/grading/test_qam16.py index bc8d4e4..d4ff633 100644 --- a/grading/test_qam16.py +++ b/grading/test_qam16.py @@ -157,4 +157,4 @@ def test_constellation_file_exists(): if __name__ == "__main__": - pytest.main([__file__, "-v"]) + pytest.main([__file__, "-v"]) \ No newline at end of file diff --git a/grading/test_qpsk.py b/grading/test_qpsk.py index 6d2334d..10c0cf3 100644 --- a/grading/test_qpsk.py +++ b/grading/test_qpsk.py @@ -118,4 +118,4 @@ def test_constellation_file_exists(): if __name__ == "__main__": - pytest.main([__file__, "-v"]) + pytest.main([__file__, "-v"]) \ No newline at end of file diff --git a/requirements.txt b/requirements.txt index 48749dc..702f80b 100644 --- a/requirements.txt +++ b/requirements.txt @@ -4,4 +4,5 @@ scipy>=1.7.0 matplotlib>=3.4.0 pytest>=7.0.0 pytest-cov>=3.0.0 +pytest-json-report>=1.5.0 pylint>=2.12.0 diff --git a/src/demodulation.py b/src/demodulation.py index 77d95e2..5828c2d 100644 --- a/src/demodulation.py +++ b/src/demodulation.py @@ -35,10 +35,9 @@ def bpsk_demodulate(symbols): [0 1 0] """ - # TODO: 实现BPSK解调 - # 提示：使用np.real()获取实部，然后判断正负 - - raise NotImplementedError("请实现BPSK解调函数") + # BPSK解调：实部>0判为0，否则判为1 + bits = (np.real(symbols) <= 0).astype(int) + return bits def qpsk_demodulate(symbols): @@ -72,21 +71,25 @@ def qpsk_demodulate(symbols): >>> print(bits) # 应该是 [0, 0, 0, 1] """ - # 定义QPSK参考星座点（格雷码） - constellation = { - 0: (1 + 1j) / np.sqrt(2), # 00 - 1: (-1 + 1j) / np.sqrt(2), # 01 - 3: (-1 - 1j) / np.sqrt(2), # 11 - 2: (1 - 1j) / np.sqrt(2) # 10 + # QPSK解调：最小欧氏距离判决 + ref_points = [ + (1 + 1j) / np.sqrt(2), # 00 + (-1 + 1j) / np.sqrt(2), # 01 + (1 - 1j) / np.sqrt(2), # 10 + (-1 - 1j) / np.sqrt(2) # 11 + ] + bit_map = { + 0: [0, 0], + 1: [0, 1], + 2: [1, 0], + 3: [1, 1] } - - # TODO: 实现QPSK解调 - # 提示步骤： - # 1. 对每个接收符号，计算到4个参考点的欧氏距离 - # 2. 找到距离最小的参考点 - # 3. 将参考点的索引转换为2个比特 - - raise NotImplementedError("请实现QPSK解调函数") + bits_out = [] + for s in symbols: + dists = [np.abs(s - pt) for pt in ref_points] + idx = int(np.argmin(dists)) + bits_out.extend(bit_map[idx]) + return np.array(bits_out, dtype=int) def qam16_demodulate(symbols): @@ -114,12 +117,24 @@ def qam16_demodulate(symbols): < -2/√10 → 10 """ - # TODO: 实现16-QAM解调 - # 提示：可以采用两种方法 - # 方法1：遍历16个参考点，找最小距离（简单但慢） - # 方法2：分别判决I路和Q路（快速且实用） - - raise NotImplementedError("请实现16-QAM解调函数") + # 16-QAM解调：分别判决I/Q分量 + norm = np.sqrt(10) + I = np.real(symbols) * norm + Q = np.imag(symbols) * norm + def gray_decode(x): + if x > 2: + return [0, 0] + elif x > 0: + return [0, 1] + elif x > -2: + return [1, 1] + else: + return [1, 0] + bits_out = [] + for i, q in zip(I, Q): + bits_out.extend(gray_decode(i)) + bits_out.extend(gray_decode(q)) + return np.array(bits_out, dtype=int) def test_demodulation(): diff --git a/src/modulation.py b/src/modulation.py index a8b5581..8c43343 100644 --- a/src/modulation.py +++ b/src/modulation.py @@ -1,230 +1,118 @@ +"""Digital modulation functions used by the grading tests. + +The module implements BPSK, Gray-coded QPSK, and Gray-coded 16-QAM. The +returned symbols are normalized so that the average symbol power is one for +the random bit streams used in the experiment. """ -数字调制模块 -实现BPSK、QPSK、16-QAM调制算法 -""" + +from __future__ import annotations + +import os import numpy as np + from utils import plot_constellation -def bpsk_modulate(bits): - """ - BPSK (Binary Phase Shift Keying) 调制 - - 任务要求： - - 输入：二进制比特序列（NumPy数组），元素为0或1 - - 输出：调制后的复数符号序列 - - 映射规则： - 比特 0 → 符号 +1 - 比特 1 → 符号 -1 - - 参数: - bits: 二进制比特数组，例如 np.array([0, 1, 0, 1, 1, 0]) - - 返回: - symbols: 复数符号数组，例如 np.array([1, -1, 1, -1, -1, 1]) - - 提示： - - 使用NumPy的数组运算可以很简洁地实现映射 - - 可以使用条件表达式或数学运算来完成转换 - - BPSK符号实际上是实数，但为了统一接口返回复数类型 - - 示例： - >>> bits = np.array([0, 1, 0, 1]) - >>> symbols = bpsk_modulate(bits) - >>> print(symbols) - [ 1.+0.j -1.+0.j 1.+0.j -1.+0.j] - """ - - # TODO: 在这里实现BPSK调制 - # 提示：可以尝试以下方式之一： - # 方法1: 使用 np.where() - # 方法2: 使用数学运算 1 - 2*bits - # 方法3: 使用字典映射 - - # 你的代码： - raise NotImplementedError("请实现BPSK调制函数") - - # return symbols - - -def qpsk_modulate(bits): - """ - QPSK (Quadrature Phase Shift Keying) 调制 - - 任务要求： - - 输入：二进制比特序列（长度必须是2的倍数） - - 输出：调制后的复数符号序列 - - 每2个比特映射到1个符号（格雷码映射）： - 00 → (1+1j)/√2 (第一象限，45°) - 01 → (-1+1j)/√2 (第二象限，135°) - 11 → (-1-1j)/√2 (第三象限，225°) - 10 → (1-1j)/√2 (第四象限，315°) - - 参数: - bits: 二进制比特数组，长度必须是偶数 - - 返回: - symbols: 复数符号数组，长度是bits的一半 - - 提示： - - 先将比特序列按2个一组进行分组 - - 可以使用reshape: bits.reshape(-1, 2) - - 符号的幅度应该归一化到单位功率：除以√2 - - 格雷码可以避免相邻星座点之间有多个比特差异 - - 示例： - >>> bits = np.array([0, 0, 0, 1, 1, 1, 1, 0]) - >>> symbols = qpsk_modulate(bits) - >>> print(symbols) - [ 0.707+0.707j -0.707+0.707j -0.707-0.707j 0.707-0.707j] - """ - - # 检查输入长度 - if len(bits) % 2 != 0: - raise ValueError("QPSK要求比特序列长度为偶数") - - # TODO: 在这里实现QPSK调制 - # 提示步骤： - # 1. 将比特序列reshape成(N/2, 2)的形状 - # 2. 对每一对比特，根据格雷码映射生成对应的复数符号 - # 3. 别忘了归一化：除以√2使符号功率为1 - - # 你的代码： - raise NotImplementedError("请实现QPSK调制函数") - - # return symbols - - -def qam16_modulate(bits): - """ - 16-QAM (16-Quadrature Amplitude Modulation) 调制 - - 任务要求： - - 输入：二进制比特序列（长度必须是4的倍数） - - 输出：调制后的复数符号序列 - - 每4个比特映射到1个符号 - - I路和Q路分量取值：{-3, -1, +1, +3} - - 使用格雷码映射（推荐） - - 参数: - bits: 二进制比特数组，长度必须是4的倍数 - - 返回: - symbols: 复数符号数组，长度是bits的四分之一 - - 提示： - - 16-QAM有16个星座点，排列成4×4的方格 - - 可以将4个比特分成两组：前2位决定I分量，后2位决定Q分量 - - I/Q分量的映射（格雷码）： - 00 → +3 - 01 → +1 - 11 → -1 - 10 → -3 - - 需要对星座图进行功率归一化 - - 平均功率 = (3²+1²+1²+3²)/4 = 5，归一化因子 = √10 - - 示例： - >>> bits = np.array([0, 0, 0, 0, 0, 1, 0, 1]) - >>> symbols = qam16_modulate(bits) - # 应该得到两个符号在正确位置 +_QPSK_MAP = { + (0, 0): (1 + 1j) / np.sqrt(2), + (0, 1): (-1 + 1j) / np.sqrt(2), + (1, 1): (-1 - 1j) / np.sqrt(2), + (1, 0): (1 - 1j) / np.sqrt(2), +} + +_QAM16_LEVELS = { + (0, 0): 3, + (0, 1): 1, + (1, 1): -1, + (1, 0): -3, +} + + +def _as_bit_array(bits: np.ndarray) -> np.ndarray: + """Return a one-dimensional integer bit array.""" + bit_array = np.asarray(bits, dtype=int).reshape(-1) + if np.any((bit_array != 0) & (bit_array != 1)): + raise ValueError("Input bits must contain only 0 and 1.") + return bit_array + + +def _plot_once(symbols: np.ndarray, title: str, filename: str) -> None: + """Create a constellation image if it is missing. + + The numerical modulation result should not depend on file-system state. + Plotting is therefore best-effort: existing figures are reused, and a + locked or read-only result file does not break the modulation tests. """ - - # 检查输入长度 - if len(bits) % 4 != 0: - raise ValueError("16-QAM要求比特序列长度为4的倍数") - - # TODO: 在这里实现16-QAM调制 - # 提示步骤： - # 1. 将比特序列reshape成(N/4, 4)的形状 - # 2. 对每组4个比特： - # - 前2位映射到I分量（实部） - # - 后2位映射到Q分量（虚部） - # 3. 使用格雷码映射：00→+3, 01→+1, 11→-1, 10→-3 - # 4. 归一化：除以√10使平均功率为1 - - # 格雷码映射字典（可选使用） - gray_map = { - (0, 0): 3, - (0, 1): 1, - (1, 1): -1, - (1, 0): -3 - } - - # 你的代码： - raise NotImplementedError("请实现16-QAM调制函数") - - # return symbols - - -def test_modulation(): + filepath = os.path.join("results", filename) + if os.path.exists(filepath) and os.path.getsize(filepath) > 1000: + return + + try: + plot_constellation(symbols, title=title, filename=filename) + except OSError: + pass + + +def bpsk_modulate(bits: np.ndarray) -> np.ndarray: + """Modulate bits with BPSK using 0 -> +1 and 1 -> -1.""" + bit_array = _as_bit_array(bits) + symbols = (1 - 2 * bit_array).astype(np.complex128) + _plot_once(symbols, "BPSK Constellation", "bpsk_constellation.png") + return symbols + + +def qpsk_modulate(bits: np.ndarray) -> np.ndarray: + """Modulate bits with Gray-coded QPSK. + + Mapping: + 00 -> ( 1 + 1j) / sqrt(2) + 01 -> (-1 + 1j) / sqrt(2) + 11 -> (-1 - 1j) / sqrt(2) + 10 -> ( 1 - 1j) / sqrt(2) """ - 测试调制函数并生成星座图 + bit_array = _as_bit_array(bits) + if len(bit_array) % 2 != 0: + raise ValueError("QPSK requires an even number of input bits.") + + pairs = bit_array.reshape(-1, 2) + symbols = np.array([_QPSK_MAP[tuple(pair)] for pair in pairs], dtype=np.complex128) + _plot_once(symbols, "QPSK Constellation", "qpsk_constellation.png") + return symbols + + +def qam16_modulate(bits: np.ndarray) -> np.ndarray: + """Modulate bits with Gray-coded square 16-QAM. + + Each four-bit group is split into I and Q bit pairs. Both axes use the + Gray-coded amplitude mapping 00 -> +3, 01 -> +1, 11 -> -1, 10 -> -3 and + are divided by sqrt(10) for unit average symbol power. """ - print("=" * 50) - print("数字调制测试") - print("=" * 50) - - # 测试BPSK - print("\n1. 测试BPSK调制...") - try: - bits_bpsk = np.random.randint(0, 2, 1000) - symbols_bpsk = bpsk_modulate(bits_bpsk) - print(f" 输入比特数: {len(bits_bpsk)}") - print(f" 输出符号数: {len(symbols_bpsk)}") - print(f" 唯一符号: {np.unique(symbols_bpsk)}") - - # 绘制星座图 - plot_constellation(symbols_bpsk[:100], - "BPSK星座图", - "bpsk_constellation.png") - print(" ✅ BPSK测试通过") - except NotImplementedError: - print(" ⏸️ BPSK尚未实现") - except Exception as e: - print(f" ❌ BPSK测试失败: {e}") - - # 测试QPSK - print("\n2. 测试QPSK调制...") - try: - bits_qpsk = np.random.randint(0, 2, 1000) - symbols_qpsk = qpsk_modulate(bits_qpsk) - print(f" 输入比特数: {len(bits_qpsk)}") - print(f" 输出符号数: {len(symbols_qpsk)}") - print(f" 符号幅度: {np.abs(symbols_qpsk[:4])}") - - # 绘制星座图 - plot_constellation(symbols_qpsk[:200], - "QPSK星座图", - "qpsk_constellation.png") - print(" ✅ QPSK测试通过") - except NotImplementedError: - print(" ⏸️ QPSK尚未实现") - except Exception as e: - print(f" ❌ QPSK测试失败: {e}") - - # 测试16-QAM - print("\n3. 测试16-QAM调制...") - try: - bits_qam = np.random.randint(0, 2, 1000) - symbols_qam = qam16_modulate(bits_qam) - print(f" 输入比特数: {len(bits_qam)}") - print(f" 输出符号数: {len(symbols_qam)}") - print(f" 唯一符号数量: {len(np.unique(symbols_qam))}") - - # 绘制星座图 - plot_constellation(symbols_qam[:250], - "16-QAM星座图", - "16qam_constellation.png") - print(" ✅ 16-QAM测试通过") - except NotImplementedError: - print(" ⏸️ 16-QAM尚未实现") - except Exception as e: - print(f" ❌ 16-QAM测试失败: {e}") - - print("\n" + "=" * 50) - print("测试完成！请检查results/目录中的星座图。") - print("=" * 50) + bit_array = _as_bit_array(bits) + if len(bit_array) % 4 != 0: + raise ValueError("16-QAM requires the input length to be a multiple of 4.") + + groups = bit_array.reshape(-1, 4) + in_phase = np.array([_QAM16_LEVELS[tuple(group[:2])] for group in groups]) + quadrature = np.array([_QAM16_LEVELS[tuple(group[2:])] for group in groups]) + symbols = (in_phase + 1j * quadrature) / np.sqrt(10) + symbols = symbols.astype(np.complex128) + _plot_once(symbols, "16-QAM Constellation", "16qam_constellation.png") + return symbols + + +def test_modulation() -> None: + """Run a small manual smoke test and generate constellation images.""" + rng = np.random.default_rng(42) + + bpsk_bits = rng.integers(0, 2, 1000) + qpsk_bits = rng.integers(0, 2, 1000) + qam16_bits = rng.integers(0, 2, 1000) + + print("BPSK symbols:", bpsk_modulate(bpsk_bits)[:4]) + print("QPSK symbols:", qpsk_modulate(qpsk_bits)[:4]) + print("16-QAM symbols:", qam16_modulate(qam16_bits)[:4]) + print("Constellation images are available in the results directory.") if __name__ == "__main__": diff --git a/src/test_environment.py b/src/test_environment.py index 8e3892d..a031915 100644 --- a/src/test_environment.py +++ b/src/test_environment.py @@ -1,146 +1,107 @@ -""" -环境测试脚本 -验证Python环境和依赖包是否正确安装 -""" +"""Environment smoke tests for the digital modulation experiment.""" +from __future__ import annotations + +import os import sys +import tempfile -def test_python_version(): - """测试Python版本""" +def test_python_version() -> bool: + """Check that the Python version is new enough.""" version = sys.version_info - print(f"Python版本: {version.major}.{version.minor}.{version.micro}") - + print(f"Python version: {version.major}.{version.minor}.{version.micro}") + if version.major < 3 or (version.major == 3 and version.minor < 8): - print("❌ Python版本过低，需要3.8或更高版本") + print("[FAIL] Python 3.8 or newer is required.") return False - else: - print("✅ Python版本符合要求") - return True + + print("[OK] Python version is supported.") + return True -def test_packages(): - """测试必需的包""" - required_packages = { - 'numpy': '1.21.0', - 'scipy': '1.7.0', - 'matplotlib': '3.4.0', - 'pytest': '7.0.0' - } - +def test_packages() -> bool: + """Check that required packages can be imported.""" + packages = ("numpy", "scipy", "matplotlib", "pytest") all_ok = True - - for package, min_version in required_packages.items(): + + for package in packages: try: - if package == 'numpy': - import numpy as np - version = np.__version__ - print(f"✅ NumPy {version} 已安装") - - elif package == 'scipy': - import scipy - version = scipy.__version__ - print(f"✅ SciPy {version} 已安装") - - elif package == 'matplotlib': - import matplotlib - version = matplotlib.__version__ - print(f"✅ Matplotlib {version} 已安装") - - elif package == 'pytest': - import pytest - version = pytest.__version__ - print(f"✅ Pytest {version} 已安装") - + module = __import__(package) + version = getattr(module, "__version__", "unknown") + print(f"[OK] {package} {version} is available.") except ImportError: - print(f"❌ {package} 未安装，请运行: pip install {package}") + print(f"[FAIL] {package} is not installed.") all_ok = False - + return all_ok -def test_numpy_operations(): - """测试NumPy基本操作""" +def test_numpy_operations() -> bool: + """Check basic NumPy array and complex-number operations.""" try: import numpy as np - - # 测试数组创建 - arr = np.array([1, 2, 3, 4]) - - # 测试复数运算 - complex_arr = np.array([1+1j, -1+1j, -1-1j, 1-1j]) - - # 测试数学运算 - result = np.abs(complex_arr) - - print("✅ NumPy基本操作测试通过") + + samples = np.array([1 + 1j, -1 + 1j, -1 - 1j, 1 - 1j]) + magnitudes = np.abs(samples) + if not np.allclose(magnitudes, np.sqrt(2)): + print("[FAIL] NumPy complex magnitude calculation is unexpected.") + return False + + print("[OK] NumPy operations work.") return True - - except Exception as e: - print(f"❌ NumPy操作测试失败: {e}") + except Exception as exc: # pragma: no cover - diagnostic path + print(f"[FAIL] NumPy operation test failed: {exc}") return False -def test_matplotlib(): - """测试Matplotlib绘图功能""" +def test_matplotlib() -> bool: + """Check that Matplotlib can save a simple figure.""" try: + import matplotlib + + matplotlib.use("Agg") import matplotlib.pyplot as plt import numpy as np - import os - - # 创建测试目录 - os.makedirs('results', exist_ok=True) - - # 创建简单图表 - plt.figure(figsize=(6, 6)) - x = np.array([1, -1, -1, 1, 1]) - y = np.array([1, 1, -1, -1, 1]) - plt.plot(x, y, 'b-') + + x_values = np.array([1, -1, -1, 1, 1]) + y_values = np.array([1, 1, -1, -1, 1]) + + plt.figure(figsize=(4, 4)) + plt.plot(x_values, y_values, "b-") plt.grid(True) - plt.savefig('results/test_plot.png') + output_path = os.path.join(tempfile.gettempdir(), "wireless_modulation_test_plot.png") + plt.savefig(output_path) plt.close() - - print("✅ Matplotlib绘图测试通过") + + print("[OK] Matplotlib can save figures.") return True - - except Exception as e: - print(f"❌ Matplotlib测试失败: {e}") + except Exception as exc: # pragma: no cover - diagnostic path + print(f"[FAIL] Matplotlib test failed: {exc}") return False -def main(): - """主测试函数""" +def main() -> int: + """Run all environment checks.""" print("=" * 50) - print("数字调制解调实验 - 环境测试") + print("Digital modulation experiment - environment test") print("=" * 50) - print() - - results = [] - - print("1. 检查Python版本...") - results.append(test_python_version()) - print() - - print("2. 检查依赖包...") - results.append(test_packages()) - print() - - print("3. 测试NumPy操作...") - results.append(test_numpy_operations()) - print() - - print("4. 测试Matplotlib绘图...") - results.append(test_matplotlib()) - print() - + + results = [ + test_python_version(), + test_packages(), + test_numpy_operations(), + test_matplotlib(), + ] + print("=" * 50) if all(results): - print("🎉 所有测试通过！环境配置正确。") - print("你可以开始实验了！") - else: - print("⚠️ 部分测试未通过，请检查并修复环境问题。") - print("=" * 50) + print("All environment checks passed.") + return 0 + + print("Some environment checks failed.") + return 1 if __name__ == "__main__": - main() + raise SystemExit(main())