C++实现快速傅里叶变换（FFT）_c++实现fft

由于项目要从MATLAB搬到VS上，开始认真研究怎么在C++中实现FFT，更准确的来说是DFT和IDFT。
FFT的公式人人都知道，但要在计算机上实现需要一点小技巧：蝶形运算。

蝶形运算的原理就是通过递归缩小进行DFT的序列长度。根据Wn因子的特点，我们需要把序列分为奇数下标序列和偶数下标序列，经过了不停的拆分和重新组合，对得到的仅有的2点进行DFT，不断扩展序列长度、递归计算得到最后的结果。具体的可以百度查看蝶形算法的原理。

对于代码实现部分，进行奇偶数列的区分即是位反转置换。其原理是：

i 和 j 互为 N 位二进制的回文数，若 i ≠ j，则两个数对换。

则在代码中，我们需要：
1 计算序列长度对应的二进制位数；
2 遍历一半数组，计算当前下标对应的回文数，进行对换。

序列排序完成后就可以进行DFT的计算了！

代码中使用了C++标准库中自带的complex类，pi使用了cmath中定义的M_PI。
complex类中定义了复数的运算，使用起来很方便。

定义complex类变量： complex<T> a(real,imaginal); 
					//T：变量类型  a：自定义复数类变量名 real：实部 imaginal：虚部
complex类中包含的部分函数：
	T real(complex<T>); T imag(complex<T>); //返回复数的实部、虚部
	T abs(complex<T>);						//返回绝对值
	T norm(complex<T>);				 		//返回模值平方
	T arg(complex<T>);						//返回幅角
1
2
3
4
5
6
7

以下是实现代码。

#define _USE_MATH_DEFINES        //M_PI
#include <cmath>
#include <complex>
#include <iostream>

#define N 256  //window size

using namespace std;
/**
位反转置换
*/
void trans(complex<double>*& x,int size_x)
{
    int p = 0; int a, b;
    for (int i = 1; i < size_x; i *= 2)
    {
        p++;    //计算二进制位数
    }
    for (int i = 0; i < size_x; i++)
    {
        a = i;
        b = 0;
        for (int j = 0; j < p; j++)
        {
            b = (b << 1) + (a & 1);     //b存储当前下标的回文值
            a = a >> 1;
        }
        if (b > i)           //避免重复交换
        {
            complex<double> temp;
            temp = x[i];
            x[i] = x[b];
            x[b] = temp;
        }
    }
}

void fft(complex<double>*& x,int size,complex<double>*& X)
{
    complex<double> Wn[N];								//这里可以自己新建长度为size的数组
    for (int i = 0; i < size; i++)
    {
        X[i] = x[i];
        double real = cos(-2 * M_PI * i / size);
        double img = sin(-2 * M_PI * i / size);
        Wn[i] = complex<double>(real, img);                        //初始化Wn
    }
    complex<double>* p = X;
    trans(p, size);									//位反转置换 
    int t;
    for (int m = 2; m <= size; m *= 2)     //小序列点数
    {
        for (int k = 0; k < size; k += m)   //小序列起始下标
        {
            for (int j = 0; j < m / 2; j++)  //小序列的DFT计算
            {
                int index1 = k + j; 
                int index2 = index1 + m / 2;
                t = j * size / m;				//t是在完整序列中的下标，找到对应的旋转因子
                complex<double> temp1,temp2;
                temp2 = X[index2] * Wn[t]; 
                temp1 = X[index1];
                X[index1] = temp1 + temp2;   //Wn的性质
                X[index2] = temp1 - temp2;
            }
        }
    }
}
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

IFFT只需要把Wn的部分改一下，最后记得除以size。