DFT与FFT

最新推荐文章于 2025-03-03 15:59:01 发布

aichitang2024

最新推荐文章于 2025-03-03 15:59:01 发布

阅读量1.3k

点赞数 14

分类专栏：算法，数学知识点讲解文章标签：傅立叶分析 c++

本文链接：https://blog.csdn.net/aichitang2024/article/details/145441693

版权

算法，数学知识点讲解专栏收录该内容

38 篇文章

订阅专栏

DFT与FFT：原理与实现整合

在数字信号处理领域，傅立叶分析扮演着举足轻重的角色。而离散傅立叶变换（DFT）作为离散信号分析的基础手段，更是深入影响着现代通信、语音与图像处理、滤波器设计等众多应用场景。为了高效地计算DFT，人们提出了快速傅立叶变换（FFT）。本文将详细介绍DFT与FFT的基本概念、联系与区别，并给出简要的实现示例，帮助你在实际项目中快速上手。

一、DFT 的回顾

1. 概念与定义

对于长度为 N 的离散序列 x[n]（n = 0, 1, …, N-1），它的离散傅立叶变换（DFT）定义为：

X[k] = ∑(n=0→N-1)[x[n] · e^(-j·2πkn / N)], k = 0, 1, …, N-1

这里：

X[k] 是第 k 个离散频率处的复数值，包含幅度和相位。
N 为序列长度，j 表示虚数单位。

2. 计算复杂度

直接 DFT：需要两层嵌套循环，运算量为 O(N²)。当 N 很大时，计算时间会急剧增加。
适用场景：小规模数据或理论教学演示。

二、FFT 的引入

1. FFT 的诞生

快速傅立叶变换（Fast Fourier Transform, FFT）是一类高效计算DFT的算法族，典型代表是 Cooley–Tukey 算法，它将 O(N²) 的计算复杂度降低到 O(N log N)，大幅提升了大规模数据处理的速度。

2. FFT 关键思路

通过对离散信号进行“分而治之”的策略，将原本的一次 DFT 分解为若干较小规模的DFT，最终组合结果，减少了大量重复计算的开销。

3. FFT 常见应用

信号处理：实时频谱分析、滤波器实现、通信调制解调等。
图像处理：快速卷积、频域过滤等。
音频处理：均衡器、混响、回声消除、语音识别等领域广泛使用 FFT。

三、DFT与FFT的联系与区别

数学本质相同
- FFT 是实现 DFT 的高效算法，两者的数学含义和最终输出结果完全一致，只是计算方法上做了优化。
计算复杂度
- DFT：O(N²)，适合信号点数较小的场景。
- FFT：O(N log N)，适合大规模数据处理，性能提升明显。
实现难易度
- DFT：逻辑简单，直接使用公式。
- FFT：实现需要考虑序列长度（通常要求2的整数次幂），但很多现成库已经封装了快速算法。
在工程应用中的地位
- 每当提到将时域信号转换为频域，往往直接使用 FFT。理解 DFT 有助于掌握傅立叶变换的原理与FFT背后的思想。

四、DFT与FFT 的示例实现

以下示例采用 C++ 语言，演示如何在同一个程序中集成 DFT 与 FFT 的思路。FFT 这里可以调用常见的开源库或自己实现一个简易版本。为了突出重点，示例仅提供一个非常简化的 FFT 实现示意。

#include <iostream>
#include <vector>
#include <complex>
#include <cmath>
#include <algorithm>

// ========================== //
//    DFT 实现（O(N^2))
// ========================== //
std::vector<std::complex<double>> dft(const std::vector<double>& x) {
    size_t N = x.size();
    std::vector<std::complex<double>> X(N);
    
    for (size_t k = 0; k < N; ++k) {
        std::complex<double> sumVal(0.0, 0.0);
        for (size_t n = 0; n < N; ++n) {
            double angle = -2.0 * M_PI * k * n / static_cast<double>(N);
            // real part: cos(angle), image part: sin(angle)
            std::complex<double> expTerm(std::cos(angle), std::sin(angle));
            sumVal += x[n] * expTerm;
        }
        X[k] = sumVal;
    }
    return X;
}

// ========================== //
//   FFT 实现示意（O(N log N)）
//   仅适用序列长度为 2^m
// ========================== //
void fft(std::vector<std::complex<double>>& X) {
    size_t N = X.size();
    if (N <= 1) return;
    
    // 按奇偶分组
    std::vector<std::complex<double>> even(N/2), odd(N/2);
    for (size_t i = 0; i < N/2; ++i) {
        even[i] = X[2*i];
        odd[i]  = X[2*i + 1];
    }
    
    // 递归调用
    fft(even);
    fft(odd);
    
    // 蝶形运算合并
    for (size_t k = 0; k < N/2; ++k) {
        double angle = -2.0 * M_PI * k / static_cast<double>(N);
        std::complex<double> t = std::complex<double>(std::cos(angle), std::sin(angle)) * odd[k];
        X[k]       = even[k] + t;
        X[k+N/2]   = even[k] - t;
    }
}

int main() {
    // 1. 构造一个简单的实数序列，长度 8 (2^3)
    std::vector<double> x = {1.0, 2.0, 1.0, -1.0, 0.5, 2.5, 0.0, 1.0};
    
    // =============== DFT ===============
    auto X_dft = dft(x);
    std::cout << "[DFT] 结果:\n";
    for (size_t k = 0; k < X_dft.size(); ++k) {
        std::cout << "k = " << k << " : " << X_dft[k] << "\n";
    }
    
    // =============== FFT ===============
    // 对 FFT，需要先把实数序列扩展到复数向量
    std::vector<std::complex<double>> X_fft(x.begin(), x.end());
    fft(X_fft);
    std::cout << "\n[FFT] 结果:\n";
    for (size_t k = 0; k < X_fft.size(); ++k) {
        std::cout << "k = " << k << " : " << X_fft[k] << "\n";
    }
    
    return 0;
}

示例要点

dft 函数：
- 计算复杂度 O(N²)，直接使用 DFT 公式。
- 适用于小规模或教学演示，对应传统理论定义。
fft 函数：
- 示意性地实现了 Cooley–Tukey 递归算法。
- 要求输入序列长度为 2 的整数次幂。
- 通过频域“蝶形”运算减少不必要的重复计算，复杂度 O(N log N)。
注意事项：
- FFT 要处理复数输入时效果才完整，这里仅以实数序列为例做一个简单演示。
- 对于任意长度 N，可考虑使用零填充(Padding) 至最近 2^m 的长度。
- 实际项目中通常会采用更成熟的库（如 FFTW、KFR 等）来处理大规模数据。