傅里叶变换c语言实现
❶ 求个快速傅里叶变换的c语言程序
voidfft()
{
intnn,n1,n2,i,j,k,l,m,s,l1;
floatar[1024],ai[1024];//实部虚部
floata[2050];
floatt1,t2,x,y;
floatw1,w2,u1,u2,z;
floatfsin[10]={0.000000,1.000000,0.707107,0.3826834,0.1950903,0.09801713,0.04906767,0.02454123,0.01227154,0.00613588,};//优化
floatfcos[10]={-1.000000,0.000000,0.7071068,0.9238796,0.9807853,0.99518472,0.99879545,0.9996988,0.9999247,0.9999812,};
nn=1024;
s=10;
n1=nn/2;n2=nn-1;
j=1;
for(i=1;i<=nn;i++)
{
a[2*i]=ar[i-1];
a[2*i+1]=ai[i-1];
}
for(l=1;l<n2;l++)
{
if(l<j)
{
t1=a[2*j];
t2=a[2*j+1];
a[2*j]=a[2*l];
a[2*j+1]=a[2*l+1];
a[2*l]=t1;
a[2*l+1]=t2;
}
k=n1;
while(k<j)
{
j=j-k;
k=k/2;
}
j=j+k;
}
for(i=1;i<=s;i++)
{
u1=1;
u2=0;
m=(1<<i);
k=m>>1;
w1=fcos[i-1];
w2=-fsin[i-1];
for(j=1;j<=k;j++)
{
for(l=j;l<nn;l=l+m)
{
l1=l+k;
t1=a[2*l1]*u1-a[2*l1+1]*u2;
t2=a[2*l1]*u2+a[2*l1+1]*u1;
a[2*l1]=a[2*l]-t1;
a[2*l1+1]=a[2*l+1]-t2;
a[2*l]=a[2*l]+t1;
a[2*l+1]=a[2*l+1]+t2;
}
z=u1*w1-u2*w2;
u2=u1*w2+u2*w1;
u1=z;
}
}
for(i=1;i<=nn/2;i++)
{
ar[i]=a[2*i+2]/nn;
ai[i]=-a[2*i+3]/nn;
a[i]=4*sqrt(ar[i]*ar[i]+ai[i]*ai[i]);//幅值
}
}
❷ 一个关于128点的快速傅立叶的C语言程序
这是我写的1024点的快速傅里叶变换程序，下面有验证，你把数组
double
A[2049]={0};
double
B[1100]={0};
double
powerA[1025]={0};
改成
A[256]={0};
B[130]={0};
power[129]={0};就行了，
void
FFT(double
data[],
int
nn,
int
isign)
的程序可以针对任何点数，只要是2的n次方
具体程序如下：
#include
<iostream.h>
#include
"math.h"
#include<stdio.h>
#include<string.h>
#include
<stdlib.h>
#include
<fstream.h>
#include
<afx.h>
void
FFT(double
data[],
int
nn,
int
isign)
{
//复数的快速傅里叶变换
int
n,j,i,m,mmax,istep;
double
tempr,tempi,theta,wpr,wpi,wr,wi,wtemp;
n
=
2
*
nn;
j
=
1;
for
(i
=
1;
i<=n
;
i=i+2)
//这个循环进行的是码位倒置。
{
if(
j
>
i)
{
tempr
=
data[j];
tempi
=
data[j
+
1];
data[j]
=
data[i];
data[j
+
1]
=
data[i
+
1];
data[i]
=
tempr;
data[i
+
1]
=
tempi;
}
m
=
n
/
2;
while
(m
>=
2
&&
j
>
m)
{
j
=
j
-
m;
m
=
m
/
2;
}
j
=
j
+
m;
}
mmax
=
2;
while(
n
>
mmax
)
{
istep
=
2
*
mmax;
//这里表示一次的数字的变化。也体现了级数，若第一级时，也就是书是的第0级，其为两个虚数，所以对应数组应该增加4，这样就可以进入下一组运算
theta
=
-6.28318530717959
/
(isign
*
mmax);
wpr
=
-2.0
*
sin(0.5
*
theta)*sin(0.5
*
theta);
wpi
=
sin(theta);
wr
=
1.0;
wi
=
0.0;
for(
m
=
1;
m<=mmax;
m=m+2)
{
for
(i
=
m;
i<=n;
i=i+istep)
{
j
=
i
+
mmax;
tempr=double(wr)*data[j]-double(wi)*data[j+1];//这两句表示蝶形因子的下一个数乘以W因子所得的实部和虚部。
tempi=double(wr)*data[j+1]+double(wi)*data[j];
data[j]
=
data[i]
-
tempr;
//蝶形单元计算后下面单元的实部，下面为虚部，注意其变换之后的数组序号与书上蝶形单元是一致的
data[j
+
1]
=
data[i
+
1]
-
tempi;
data[i]
=
data[i]
+
tempr;
data[i
+
1]
=
data[i
+
1]
+
tempi;
}
wtemp
=
wr;
wr
=
wr
*
wpr
-
wi
*
wpi
+
wr;
wi
=
wi
*
wpr
+
wtemp
*
wpi
+
wi;
}
mmax
=
istep;
}
}
void
main()
{
//本程序已经和MATLAB运算结果对比，准确无误，需要注意的的是，计算中数组都是从1开始取得，丢弃了A[0]等数据
double
A[2049]={0};
double
B[1100]={0};
double
powerA[1025]={0};
char
line[50];
char
dataA[20],
dataB[20];
int
ij;
char
ch1[3]="\t";
char
ch2[3]="\n";
int
strl1,strl2;
CString
str1,str2;
ij=1;
//********************************读入文件data1024.txt中的数据,
其中的数据格式见该文件
FILE
*fp
=
fopen("data1024.txt","r");
if(!fp)
{
cout<<"Open
file
is
failing!"<<endl;
return;
}
while(!feof(fp))
//feof(fp)有两个返回值:如果遇到文件结束，函数feof（fp）的值为1，否则为0。
{
memset(line,0,50);
//清空为0
memset(dataA,0,20);
memset(dataB,0,20);
fgets(line,50,fp);
//函数的功能是从fp所指文件中读入n-1个字符放入line为起始地址的空间内
sscanf(line,
"%s%s",
dataA,
dataB);
//我同时读入了两列值，但你要求1024个，那么我就只用了第一列的1024个值
//dataA读入第一列，dataB读入第二列
B[ij]=atof(dataA);
//将字符型的dataA值转化为float型
ij++;
}
for
(int
mm=1;mm<1025;mm++)//A[2*mm-1]是实部，A[2*mm]是虚部，当只要输入实数时，那么保证虚部A[mm*2]为零即可
{
A[2*mm-1]=B[mm];
A[2*mm]=0;
}
//*******************************************正式计算FFT
FFT(A,1024,1);
//********************************************写入数据到workout.txt文件中
for
(int
k=1;k<2049;k=k+2)
{
powerA[(k+1)/2]=sqrt(pow(A[k],2.0)+pow(A[k+1],2.0));//求功率谱
FILE
*pFile=fopen("workout.txt","a+");
//?a+只能在文件最后补充，光标在结尾。没有则创建
memset(ch1,0,15);
str1.Format("%.4f",powerA[(k+1)/2]);
if
(A[k+1]>=0)
str2.Format("%d\t%6.4f%s%6.4f
%s",(k+1)/2,A[k],"+",A[k+1],"i");//保存fft计算的频谱，是复数频谱
else
str2.Format("%d\t%6.4f%6.4f
%s",(k+1)/2,A[k],A[k+1],"i");
strl1=strlen(str1);
strl2=strlen(str2);
//
用
法:fwrite(buffer,size,count,fp);
//
buffer：是一个指针，对fwrite来说，是要输出数据的地址。
//
size：要写入的字节数；
//
count:要进行写入size字节的数据项的个数；
//
fp:目标文件指针。
fwrite(str2,1,strl2,pFile);
fwrite(ch1,1,3,pFile);
fwrite(ch1,1,3,pFile);
fwrite(str1,1,strl1,pFile);
fwrite(ch2,1,3,pFile);
fclose(pFile);
}
cout<<"计算完毕，到fft_test\workout.txt查看结果"<<endl;
}
❸ 怎样用C语言实现FFT算法啊
1、二维FFT相当于对行和列分别进行一维FFT运算。具体的实现办法如下：
先对各行逐一进行一维FFT，然后再对变换后的新矩阵的各列逐一进行一维FFT。相应的伪代码如下所示：
for (int i=0; i<M; i++)
FFT_1D(ROW[i]，N);
for (int j=0; j<N; j++)
FFT_1D(COL[j]，M);
其中，ROW[i]表示矩阵的第i行。注意这只是一个简单的记法，并不能完全照抄。还需要通过一些语句来生成各行的数据。同理，COL[i]是对矩阵的第i列的一种简单表示方法。
所以，关键是一维FFT算法的实现。
2、例程：
#include<stdio.h>
#include<math.h>
#include<stdlib.h>
#defineN1000
/*定义复数类型*/
typedefstruct{
doublereal;
doubleimg;
}complex;
complexx[N],*W;/*输入序列,变换核*/
intsize_x=0;/*输入序列的大小，在本程序中仅限2的次幂*/
doublePI;/*圆周率*/
voidfft();/*快速傅里叶变换*/
voidinitW();/*初始化变换核*/
voidchange();/*变址*/
voidadd(complex,complex,complex*);/*复数加法*/
voidmul(complex,complex,complex*);/*复数乘法*/
voidsub(complex,complex,complex*);/*复数减法*/
voidoutput();
intmain(){
inti;/*输出结果*/
system("cls");
PI=atan(1)*4;
printf("Pleaseinputthesizeofx: ");
scanf("%d",&size_x);
printf("Pleaseinputthedatainx[N]: ");
for(i=0;i<size_x;i++)
scanf("%lf%lf",&x[i].real,&x[i].img);
initW();
fft();
output();
return0;
}
/*快速傅里叶变换*/
voidfft(){
inti=0,j=0,k=0,l=0;
complexup,down,proct;
change();
for(i=0;i<log(size_x)/log(2);i++){/*一级蝶形运算*/
l=1<<i;
for(j=0;j<size_x;j+=2*l){/*一组蝶形运算*/
for(k=0;k<l;k++){/*一个蝶形运算*/
mul(x[j+k+l],W[size_x*k/2/l],&proct);
add(x[j+k],proct,&up);
sub(x[j+k],proct,&down);
x[j+k]=up;
x[j+k+l]=down;
}
}
}
}
/*初始化变换核*/
voidinitW(){
inti;
W=(complex*)malloc(sizeof(complex)*size_x);
for(i=0;i<size_x;i++){
W[i].real=cos(2*PI/size_x*i);
W[i].img=-1*sin(2*PI/size_x*i);
}
}
/*变址计算，将x(n)码位倒置*/
voidchange(){
complextemp;
unsignedshorti=0,j=0,k=0;
doublet;
for(i=0;i<size_x;i++){
k=i;j=0;
t=(log(size_x)/log(2));
while((t--)>0){
j=j<<1;
j|=(k&1);
k=k>>1;
}
if(j>i){
temp=x[i];
x[i]=x[j];
x[j]=temp;
}
}
}
/*输出傅里叶变换的结果*/
voidoutput(){
inti;
printf("Theresultareasfollows ");
for(i=0;i<size_x;i++){
printf("%.4f",x[i].real);
if(x[i].img>=0.0001)printf("+%.4fj ",x[i].img);
elseif(fabs(x[i].img)<0.0001)printf(" ");
elseprintf("%.4fj ",x[i].img);
}
}
voidadd(complexa,complexb,complex*c){
c->real=a.real+b.real;
c->img=a.img+b.img;
}
voidmul(complexa,complexb,complex*c){
c->real=a.real*b.real-a.img*b.img;
c->img=a.real*b.img+a.img*b.real;
}
voidsub(complexa,complexb,complex*c){
c->real=a.real-b.real;
c->img=a.img-b.img;
}
❹ 求基2、基4、基8FFT（快速傅里叶变换）的c语言程序，要能运行得出来的
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
typedef struct{
double r;
double i;
}my_complex
;
//检查a是否为2的整数次方数
#define NOT2POW(a) (((a)-1)&(a)||(a)<=0)
//pi
#define MYPI 3.14159265358979323846
my_complex* fft(const my_complex* x, unsigned int len){
unsigned int ex=0,t=len;
unsigned int i,j,k;
my_complex *y;
double tr,ti,rr,ri,yr,yi;
if(NOT2POW(len)) return NULL; //如果失败，返回空指针
for(;!(t&1);t>>=1) ex++; //len应该等于2的ex次方
y=(my_complex*)malloc(len*sizeof(my_complex));
if(!y) return NULL;
//变址计算，库里-图基算法
for(i=0;i<len;i++){
k=i;
j=0;
t=ex;
while((t--)>0){
j<<=1;
j|=k&1;
k>>=1;
}
if(j>=i){
y[i]=x[j];
y[j]=x[i];
}
}
//用变址后的y向量进行计算
for(i=0;i<ex;i++){
t=1<<i;
for(j=0;j<len;j+=t<<1){
for(k=0;k<t;k++){
ti=-MYPI*k/t;
rr=cos(ti);
ri=sin(ti);
tr=y[j+k+t].r;
ti=y[j+k+t].i;
yr=rr*tr-ri*ti;
yi=rr*ti+ri*tr;
tr=y[j+k].r;
ti=y[j+k].i;
y[j+k].r=tr+yr;
y[j+k].i=ti+yi;
y[j+k+t].r=tr-yr;
y[j+k+t].i=ti-yi;
}
}
}
return y;
}
//以下为测试
int main()
{
int i,DATA_LEN;
my_complex *x,*y;
printf("基二FFT测试\n输入生成序列长度:");
scanf("%d",&DATA_LEN);
x=(my_complex*)malloc(DATA_LEN*sizeof(my_complex));
for(i=0;i<DATA_LEN;i++){
x[i].r=i;
x[i].i=i-1;
}
printf("处理前...\n实部\t\t虚部\n");
for(i=0;i<DATA_LEN;i++)
printf("%lf\t%lf\n",x[i].r,x[i].i);
y=fft(x,DATA_LEN);
if(!y){
printf("序列长度不为2的整数次方!\n");
return 0;
}
printf("处理后...\n实部\t\t虚部\n");
for(i=0;i<DATA_LEN;i++)
printf("%lf\t%lf\n",y[i].r,y[i].i);
free(y);
free(x);
return 0;
}
❺ 音频算法入门-傅里叶变换
上一篇文章中讲了一个时域处理的算法wsola，接下来会学习频域处理算法，在这之前必须得对频域有所了解，这就不得不提傅里叶变换了，本文的目的是让大家学会用傅里叶变换公式和傅里叶逆变换公式进行计算。数学公式是人们对世界中的现象的描述，我们学习数学公式也不该只停留在使用公式来解决问题的层次，得明白公式到底在描述什么现象，从这些天才数学家的角度来看世界。懂的地方可跳过。项目地址在文章末尾给出。
我直接说结论，傅里叶级数公式包含了傅里叶变换和傅里叶逆变换（不严谨的说就是这么回事）。
先简单说下具体关系，法国数学家傅里叶发现，任何周期函数都可以用正弦函数和余弦函数构成的无穷级数来表示，这种表示方式就是傅里叶级数。假如有个波形比较复杂的周期函数，那么找出能用来构成这个周期函数的正弦函数和余弦函数的频率的方法就叫做傅里叶变换，用这些频率的正弦函数和余弦函数叠加起来表示这个周期函数的方法就叫做傅里叶逆变换。
再从公式中看下他们的关系，首先介绍傅里叶级数到底是什么，首先级数是指将数列的项依次用加号连接起来的函数。这么说可能大家还不理解，举个例子：e^x=1+x/1!+x^2/2!+...x^n/n!....，等号左边是指数函数，等号右边就是级数。傅里叶级数公式如下：
我们主要看这个指数形式的傅里叶级数公式，把求和符号去掉，展开一下就是f(t)=Fa*e^jaω0t+Fb*e^jbω0t+Fc*e^jcω0t+Fd*e^jdω0.....。现在看下面的周期函数叠加效果图，图中显示的是3个周期函数分别在坐标轴（横轴时间，纵轴幅度）的图像，写成傅里叶级数形式就是f(t)=fa(t)+fb(t)+0+0....，这就是傅里叶级数公式要描述的现象。其中Fa*e^jaω0t=fa(t),Fb*e^jbω0t=fb(t),Fc*e^jcω0t=0....。
看下图的傅里叶变换和逆变换公式，你会发现傅里叶逆变换公式和傅里叶级数公式极其相似，而傅里叶级数系数公式Fn又和傅里叶变换公式极其相似。所以对一个周期函数进行傅里叶级数展开的过程可以认为是先做傅里叶变换再做傅里叶逆变换的过程。
上图就是傅里叶变换公式也叫连续傅里叶变换公式，有个很重要的事情，就是傅里叶变换公式和逆变换公式一定要一起给出，不然就会让人误解，你们在网上会看到各种各样的写法，但这些写法都是对的，常见的如下图所示。
为了方便后面的讲解我把角频率ω换成2πf，如上图所示，ω是希腊字母读作Omega，大写是Ω，小写是ω，以后这两个字母会经常看到，都是等于2πf。不要和电学中的电阻单位搞混了，要明白字母只不过是一个符号而已，在不同学科领域都是混着用的，只要不和自己公式中其他字母冲突就行，例如上图傅里叶变换公式中的j其实就是虚数单位i，一般时候我们会把虚数单位写成i，但因为傅立叶变换经常用于电学解决一些问题，为了不和电流符号i混淆，所以公式就把i写成j 。
要想了解傅里叶变换公式，首先要了解欧拉公式e^ix=cosx+isinx在图像中的含义。以实部的值cosx作为横坐标值，虚部sinx的值作为纵坐标值，x的取值从负无穷到正无穷，画出所有的e^ix点后，你会发现这些点会形成一个周期为2π的圆。如下图1所示（如果不理解，建议看3Blue1Brown的视频，视频连接：https://www.bilibili.com/video/BV1pW411J7s8）
所以欧拉公式e^ix其实就是随着x的增大而在坐标系上逆时针画圆的过程，那么e^-ix就表示顺时针画圆，e^-i2πx就表示画圆的速度提高2π倍，也就是说x从0到1的过程就是顺时针画出一个完整圆的过程（当然x从1到2或者2到3等等，都能画出一个完整的圆），把x换成t后，e^-i2πt表示每秒都会顺时针画出一个圆。e^-i2πft表示每秒都会顺时针画出f个圆。f(t)表示t时刻的振幅，f(t)函数画出来就是时域波形图。f(t)*e^-i2πft表示每经过1秒会顺时针画出f个圆，并在画圆的同时，t时刻的圆半径要乘上t时刻的振幅，其实就是以每秒的音频振幅数据绕f圈的速度进行旋转缠绕（为了方便理解，没有用复杂的音频数据，用的是一个频率为3的正弦波音频做的实验，请看下图2，图的上半部分是时域波形图，图的左下角是f等于0.4的时候，用公式f(t)*e^-i2πft在实部和虚部构成的坐标系画的图，图的右下角是频谱图，频谱图的横坐标是频率，纵坐标是振幅，振幅的值就是左下角图中数据形成的图案的质心（图中的红点）到坐标系原点的距离的2倍）。当改变f的值，你会发现数据大多数时候是和我们想的一样，以坐标系原点为圆心环绕着，也就是振幅一直都是0，但是当f的值，也就每秒的圈数等于该音频数据的频率时，你会发现一个神奇的现象，那就是所有的数据会在实部或虚部坐标轴的一侧形成一个圆（如下图3所示，如此一来就知道这段音频数据包含了一个频率为3振幅为0.5的正弦波）。所以将多个正弦波叠加的音频数据用傅里叶公式，f从负无穷到正无穷遍历一遍，就可以把这个音频数据里包含的正弦波都一一找出来。（如果不理解，建议看3Blue1Brown的视频，视频连接：https://www.bilibili.com/video/BV1pW411J7s8）
平时我们说的对音频进行傅里叶变换处理，其实说的是短时离散傅里叶变换。短时离散傅里叶变换的公式（也可以直接叫做离散傅里叶变换公式）如下。
下面将教大家如何理解这个公式。上面说的连续傅里叶变换公式中有两个原因导致我们无法使用，第一点要求是音频数据的时间从负无穷到正无穷，第二点要求是任意时间t都要有幅度值x(t)才能代入公式进行计算。所以为了解决这两个问题，把公式变为短时且离散的傅里叶变换公式，这个公式可以把一段时间（时间假设为Ts秒）的离散音频数据（有N个采样数据）进行傅里叶变换。你可以把离散傅里叶变换公式理解成连续傅里叶变换的变形，最重要的一点是连续傅里叶变换公式的f和离散傅里叶变换公式的k不是一个意思，他们的关系是k=f*Ts。所以离散傅里叶变换公式也可以写成F(f)=1/n*∑f(t)*e^-j2πf*Ts*n/N，其中的Ts*n/N对应的就是连续傅里叶变换公式的t，只不过这个t没办法取任意时间了，t的取值也就随着n的取值成为了离散的时间点，所以前面的系数由1/2π变为1/N。这样这两个公式就对应起来了。下面将进一步详细介绍这个公式。
上一段说了k=f*Ts，这段我来解释下为什么，其实离散傅里叶变换公式中k表示的是这段Ts秒的音频数据环绕坐标系原点的圈数，所以k并不是连续傅里叶变换公式里的频率f，而频率f指的是1秒钟震荡的次数，在这个公式中频率f也对应着1秒的音频数据环绕的圈数，所以真正的频率f=k/Ts。
有人可能会好奇，那为什么不把离散傅里叶变换公式的自变量k换成f呢，这样不是更好理解吗？是会更好理解，但是没有必要，用f的话还要做一次无用的换算。因为采样点只有N个的原因，k的取值范围就被限制住了，k的取值范围只能是0~N-1的整数，这也是为什么用k来做自变量而不是用f的原因。
还有人可能会好奇，傅里叶逆变换到底是怎么把频域的信息还原回时域的，其实公式计算出来的F(k)是一个复数，这个复数包含了这个频率的周期函数的振幅和相位的信息，假设F(k)=a+ib，，F(k)的模|F(k)|=(a^2+b^2)^1/2，频率f=k/Ts时的振幅为|F(k)|*2（因为求出来的值相当于圆心，但实际上振幅是圆离圆心最远点到坐标原点的距离，所以要乘2），频率f=k/Ts时的相位为arctan(b/a)。所以如果你知道一个周期函数包含了哪些频率的周期函数，并且你这到这些周期函数的振幅和相位，你就可以像下图一样把fa(t)和fb(t)叠加在一起还原回f(t)。傅里叶逆变换的做法略有不同，但意思就是这么个意思，理解了离散傅里叶变换公式的计算，逆变换其实也是差不多代入数值计算就是了。（如果不理解怎么用离散傅里叶变换公式计算，建议看视频，视频里有离散傅里叶变换完整的计算过程，视频连接：https://www.hu.com/zvideo/1276595628009377792）
快速傅里叶变换推荐看下面两个视频
https://www.bilibili.com/video/BV1za411F76U
https://www.bilibili.com/video/BV1Jh411d7CN
下面是我用java实现的离散傅里叶变换及逆变换和快速傅里叶变换及逆变换，从他们的运行时间就可以看出来快速傅里叶变换快得多。（学完快速傅里叶变换再想想频谱为何Y轴对称？为何N/2对称？）
❻ c语言实现音乐信号的快速傅里叶变换，为什么要有周期中断来ad采集音乐，这个周期采集的周期怎么确定
频率和周期互为倒数。 f = 1/T; T=1/f;
f = 40khz = 40000 hz = 40000 ( 1 秒 多少次 叫 多少 赫兹）；
T = 1/f = 1.0 / 40000.0; 采样的时间间隔。
傅里叶变换 -- 时域到频域变换，用于研究时序信号的频域特性
快速傅里叶变换 -- 数据点数 必须是 2 的整数次方，例如 1024，2048，4096 。。。。不足时要补点，补点有多种方法，最常用是补0 或 假定信号从头再来。
-------
你想用 40000 hz 采样频率，1秒就要有 40000 点。
总的信号长度若是几分钟，点数就吓人地多，FFT 耗时也要很长。
你也许可以把信号分段来FFT, 或1次就分析4096点，或 设一个 t0 时步推进，分段信号 重叠 几分之1，得动态频谱。。。。看你的需要。
❼ 求FFT的c语言程序
快速傅里叶变换 要用C++ 才行吧 你可以用MATLAB来实现更方便点啊
此FFT 是用VC6.0编写，由FFT.CPP；STDAFX.H和STDAFX.CPP三个文件组成，编译成功。程序可以用文件输入和输出为文件。文件格式为TXT文件。测试结果如下：
输入文件：8.TXT 或手动输入
8 //N
1
2
3
4
5
6
7
8
输出结果为：或保存为TXT文件。（8OUT.TXT）
8
(36,0)
(-4,9.65685)
(-4,4)
(-4,1.65685)
(-4,0)
(-4,-1.65685)
(-4,-4)
(-4,-9.65685)
下面为FFT.CPP文件：
// FFT.cpp : 定义控制台应用程序的入口点。
#include "stdafx.h"
#include <iostream>
#include <complex>
#include <bitset>
#include <vector>
#include <conio.h>
#include <string>
#include <fstream>
using namespace std;
bool inputData(unsigned long &, vector<complex<double> >&); //手工输入数据
void FFT(unsigned long &, vector<complex<double> >&); //FFT变换
void display(unsigned long &, vector<complex<double> >&); //显示结果
bool readDataFromFile(unsigned long &, vector<complex<double> >&); //从文件中读取数据
bool saveResultToFile(unsigned long &, vector<complex<double> >&); //保存结果至文件中
const double PI = 3.1415926;
int _tmain(int argc, _TCHAR* argv[])
{
vector<complex<double> > vecList; //有限长序列
unsigned long ulN = 0; //N
char chChoose = ' '; //功能选择
//功能循环
while(chChoose != 'Q' && chChoose != 'q')
{
//显示选择项
cout << "\nPlease chose a function" << endl;
cout << "\t1.Input data manually, press 'M':" << endl;
cout << "\t2.Read data from file, press 'F':" << endl;
cout << "\t3.Quit, press 'Q'" << endl;
cout << "Please chose:";
//输入选择
chChoose = getch();
//判断
switch(chChoose)
{
case 'm': //手工输入数据
case 'M':
if(inputData(ulN, vecList))
{
FFT(ulN, vecList);
display(ulN, vecList);
saveResultToFile(ulN, vecList);
}
break;
case 'f': //从文档读取数据
case 'F':
if(readDataFromFile(ulN, vecList))
{
FFT(ulN, vecList);
display(ulN, vecList);
saveResultToFile(ulN, vecList);
}
break;
}
}
return 0;
}
bool Is2Power(unsigned long ul) //判断是否是2的整数次幂
{
if(ul < 2)
return false;
while( ul > 1 )
{
if( ul % 2 )
return false;
ul /= 2;
}
return true;
}
bool inputData(unsigned long & ulN, vector<complex<double> >& vecList)
{
//题目
cout<< "\n\n\n==============================Input Data===============================" << endl;
//输入N
cout<< "\nInput N:";
cin>>ulN;
if(!Is2Power(ulN)) //验证N的有效性
{
cout<< "N is invalid (N must like 2, 4, 8, .....), please retry." << endl;
return false;
}
//输入各元素
vecList.clear(); //清空原有序列
complex<double> c;
for(unsigned long i = 0; i < ulN; i++)
{
cout << "Input x(" << i << "):";
cin >> c;
vecList.push_back(c);
}
return true;
}
bool readDataFromFile(unsigned long & ulN, vector<complex<double> >& vecList) //从文件中读取数据
{
//题目
cout<< "\n\n\n===============Read Data From File==============" << endl;
//输入文件名
string strfilename;
cout << "Input filename:" ;
cin >> strfilename;
//打开文件
cout << "open file " << strfilename << "......." <<endl;
ifstream loadfile;
loadfile.open(strfilename.c_str());
if(!loadfile)
{
cout << "\tfailed" << endl;
return false;
}
else
{
cout << "\tsucceed" << endl;
}
vecList.clear();
//读取N
loadfile >> ulN;
if(!loadfile)
{
cout << "can't get N" << endl;
return false;
}
else
{
cout << "N = " << ulN << endl;
}
//读取元素
complex<double> c;
for(unsigned long i = 0; i < ulN; i++)
{
loadfile >> c;
if(!loadfile)
{
cout << "can't get enough infomation" << endl;
return false;
}
else
cout << "x(" << i << ") = " << c << endl;
vecList.push_back(c);
}
//关闭文件
loadfile.close();
return true;
}
bool saveResultToFile(unsigned long & ulN, vector<complex<double> >& vecList) //保存结果至文件中
{
//询问是否需要将结果保存至文件
char chChoose = ' ';
cout << "Do you want to save the result to file? (y/n):";
chChoose = _getch();
if(chChoose != 'y' && chChoose != 'Y')
{
return true;
}
//输入文件名
string strfilename;
cout << "\nInput file name:" ;
cin >> strfilename;
cout << "Save result to file " << strfilename << "......" << endl;
//打开文件
ofstream savefile(strfilename.c_str());
if(!savefile)
{
cout << "can't open file" << endl;
return false;
}
//写入N
savefile << ulN << endl;
//写入元素
for(vector<complex<double> >::iterator i = vecList.begin(); i < vecList.end(); i++)
{
savefile << *i << endl;
}
//写入完毕
cout << "save succeed." << endl;
//关闭文件
savefile.close();
return true;
}
void FFT(unsigned long & ulN, vector<complex<double> >& vecList)
{
//得到幂数
unsigned long ulPower = 0; //幂数
unsigned long ulN1 = ulN - 1;
while(ulN1 > 0)
{
ulPower++;
ulN1 /= 2;
}
//反序
bitset<sizeof(unsigned long) * 8> bsIndex; //二进制容器
unsigned long ulIndex; //反转后的序号
unsigned long ulK;
for(unsigned long p = 0; p < ulN; p++)
{
ulIndex = 0;
ulK = 1;
bsIndex = bitset<sizeof(unsigned long) * 8>(p);
for(unsigned long j = 0; j < ulPower; j++)
{
ulIndex += bsIndex.test(ulPower - j - 1) ? ulK : 0;
ulK *= 2;
}
if(ulIndex > p)
{
complex<double> c = vecList[p];
vecList[p] = vecList[ulIndex];
vecList[ulIndex] = c;
}
}
//计算旋转因子
vector<complex<double> > vecW;
for(unsigned long i = 0; i < ulN / 2; i++)
{
vecW.push_back(complex<double>(cos(2 * i * PI / ulN) , -1 * sin(2 * i * PI / ulN)));
}
for(unsigned long m = 0; m < ulN / 2; m++)
{
cout<< "\nvW[" << m << "]=" << vecW[m];
}
//计算FFT
unsigned long ulGroupLength = 1; //段的长度
unsigned long ulHalfLength = 0; //段长度的一半
unsigned long ulGroupCount = 0; //段的数量
complex<double> cw; //WH(x)
complex<double> c1; //G(x) + WH(x)
complex<double> c2; //G(x) - WH(x)
for(unsigned long b = 0; b < ulPower; b++)
{
ulHalfLength = ulGroupLength;
ulGroupLength *= 2;
for(unsigned long j = 0; j < ulN; j += ulGroupLength)
{
for(unsigned long k = 0; k < ulHalfLength; k++)
{
cw = vecW[k * ulN / ulGroupLength] * vecList[j + k + ulHalfLength];
c1 = vecList[j + k] + cw;
c2 = vecList[j + k] - cw;
vecList[j + k] = c1;
vecList[j + k + ulHalfLength] = c2;
}
}
}
}
void display(unsigned long & ulN, vector<complex<double> >& vecList)
{
cout << "\n\n===========================Display The Result=========================" << endl;
for(unsigned long d = 0; d < ulN;d++)
{
cout << "X(" << d << ")\t\t\t = " << vecList[d] << endl;
}
}
下面为STDAFX.H文件：
// stdafx.h : 标准系统包含文件的包含文件，
// 或是常用但不常更改的项目特定的包含文件
#pragma once
#include <iostream>
#include <tchar.h>
// TODO: 在此处引用程序要求的附加头文件
下面为STDAFX.CPP文件：
// stdafx.cpp : 只包括标准包含文件的源文件
// FFT.pch 将成为预编译头
// stdafx.obj 将包含预编译类型信息
#include "stdafx.h"
// TODO: 在 STDAFX.H 中
//引用任何所需的附加头文件，而不是在此文件中引用