FFT(快速傅里叶变换)的C++实现_c++ 傅里叶变换

笔者最近在研究数学中的一些算法在实际生活中的应用，其中不乏快速傅里叶变换，发现这个算法在实际生活中运用确实很广，而且FFT在多项式相乘的过程中可以减少运算，提高程序的效率，例如求卷积的过程。接下来我用代码来进行解释（借鉴自斯坦福大学）：

#include <complex>
#include <iostream>
#include <valarray>
 
const double PI = 3.141592653589793238460;
 
typedef std::complex<double> Complex;
typedef std::valarray<Complex> CArray;
 
// 更高的内存需求，虽然很直观
void fft(CArray& x)
{
	const size_t N = x.size();
	if (N <= 1) return;
	// 分治
	CArray even = x[std::slice(0, N / 2, 2)];	//相等
	CArray  odd = x[std::slice(1, N / 2, 2)];	//相反
 
	// 迭代
	fft(even);
	fft(odd);
 
	// 结合
	for (size_t k = 0; k < N / 2; ++k)
	{
		Complex t = std::polar(1.0, -2 * PI * k / N) * odd[k];
		x[k] = even[k] + t;
		x[k + N / 2] = even[k] - t;
	}
}
 
void dft(CArray &x)
{
	// DFT
	unsigned int N = x.size(), k = N, n;
	double thetaT = 3.14159265358979323846264338328L / N;
	Complex phiT = Complex(cos(thetaT), -sin(thetaT)), T;
	while (k > 1)
	{
		n = k;
		k >>= 1;	//将所有位向右移动一位不足的补0其实是除以2
		//例如100转化为010 即4变为2这样实现的更快的二进制操作
		phiT = phiT * phiT;	//复数相乘
		T = 1.0L;
		for (unsigned int l = 0; l < k; l++)
		{
			for (unsigned int a = l; a < N; a += n)
			{
				unsigned int b = a + k;
				Complex t = x[a] - x[b];
				x[a] += x[b];
				x[b] = t * T;
			}
			T *= phiT;
		}
	}
	// 消项
	unsigned int m = (unsigned int)log2(N);
	for (unsigned int a = 0; a < N; a++)
	{
		unsigned int b = a;
		// 反转位
		b = (((b & 0xaaaaaaaa) >> 1) | ((b & 0x55555555) << 1));	//| 或运算符
		b = (((b & 0xcccccccc) >> 2) | ((b & 0x33333333) << 2));	//如果不懂请自行百度，还可以留言问我
		b = (((b & 0xf0f0f0f0) >> 4) | ((b & 0x0f0f0f0f) << 4));
		b = (((b & 0xff00ff00) >> 8) | ((b & 0x00ff00ff) << 8));
		b = ((b >> 16) | (b << 16)) >> (32 - m);
		if (b > a)
		{
			Complex t = x[a];
			x[a] = x[b];
			x[b] = t;
		}
	}
	 正常化
	//Complex f = 1.0 / sqrt(N);
	//for (unsigned int i = 0; i < N; i++)
	//	x[i] *= f;
}
 
// 求FFT的逆矩阵(求出卷积后的多项式的系数)
void ifft(CArray& x)
{
	// 共轭复数
	x = x.apply(std::conj);
 
	//快速处理
	fft(x);
 
 
	// 再次求其共轭复数
	x = x.apply(std::conj);
 
	// 将其规范化，变为系数
	x /= x.size();
}
 
int main()
{
	const Complex test[] = { 1.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0 };
	CArray data(test, 8);
 
	// forward fft
	fft(data);
 
	std::cout << "fft" << std::endl;
	for (int i = 0; i < 8; ++i)
	{
		std::cout << data[i] << std::endl;
	}
 
	// inverse fft·	
	ifft(data);
 
	std::cout << std::endl << "ifft" << std::endl;
	for (int i = 0; i < 8; ++i)
	{
		std::cout << data[i] << std::endl;
	}
	return 0;
}
 

运行后的结果为：

fft
(4,0)
(1,-2.41421)
(0,0)
(1,-0.414214)
(0,0)
(1,0.414214)
(0,0)
(1,2.41421)
 
ifft
(1,-0)
(1,-5.55112e-17)
(1,2.4895e-17)
(1,-5.55112e-17)
(5.55112e-17,0)
(5.55112e-17,5.55112e-17)
(0,-2.4895e-17)
(5.55112e-17,5.55112e-17)

以上便是FFT的C++实现，如果对FFT不懂的可以私信问我，代码简单的实现了FFT，还可以对其他的多项式相乘进行优化，有兴趣的小伙伴可以继续研究。