用于ARM上的FFT与IFFT源代码（C语言，不依赖特定平台）

设计模式 前端之家
前端之家收集整理的这篇文章主要介绍了用于ARM上的FFT与IFFT源代码（C语言，不依赖特定平台），前端之家小编觉得挺不错的，现在分享给大家，也给大家做个参考。

http://blog.csdn.net/piaojun_pj/article/details/5911914


代码在2011年全国电子大赛结束后（2011年9月3日）发布，多个版本，注释详细。

[cpp] view plain copy
  1. /*******************************************************************************
  2. **程序名称：快速傅里叶变换(FFT)
  3. **程序描述：本程序实现快速傅里叶变换
  4. **程序作者：宋元瑞
  5. **最后修改：2011年4月5日
  6. *******************************************************************************/
  7. #include<stdio.h>
  8. #include<math.h>
  10. #definePI3.141592653589//圆周率，12位小数
  11. #defineN8//傅里叶变换的点数
  12. #defineM3//蝶形运算的级数，N=2^M
  13. typedefdoubleElemType;//原始数据序列的数据类型,可以在这里设置
  15. typedefstruct//定义复数结构体
  16. {
  17. ElemTypereal,imag;
  18. }complex;
  19. complexdata[N];//定义存储单元，原始数据与负数结果均使用之
  20. ElemTyperesult[N];//存储FFT后复数结果的模
  21. //变址
  22. voidChangeSeat(complex*DataInput)
  23. {
  24. intnextValue,nextM,i,k,j=0;
  25. complextemp;
  26. nextValue=N/2;//变址运算，即把自然顺序变成倒位序，采用雷德算法
  27. nextM=N-1;
  28. for(i=0;i<nextM;i++)
  29. if(i<j)//如果i<j,即进行变址
  30. temp=DataInput[j];
  31. DataInput[j]=DataInput[i];
  32. DataInput[i]=temp;
  33. }
  34. k=nextValue;//求j的下一个倒位序
  35. while(k<=j)//如果k<=j,表示j的最高位为1
  36. j=j-k;//把最高位变成0
  37. k=k/2;//k/2，比较次高位，依次类推，逐个比较，直到某个位为0
  38. j=j+k;//把0改为1
  39. }
  40. /*
  41. //变址
  42. voidChangeSeat(complex*DataInput)
  43. {
  44. complexTemp[N];
  45. inti,n,New_seat;
  46. for(i=0;i<N;i++)
  47. Temp[i].real=DataInput[i].real;
  48. Temp[i].imag=DataInput[i].imag;
  49. }
  50. for(i=0;i<N;i++)
  51. {
  52. New_seat=0;
  53. for(n=0;n<M;n++)
  54. New_seat=New_seat|(((i>>n)&0x01)<<(M-n-1));
  55. }
  56. DataInput[New_seat].real=Temp[i].real;
  57. DataInput[New_seat].imag=Temp[i].imag;
  58. */
  59. //复数乘法
  60. complexXX_complex(complexa,complexb)
  61. complextemp;
  62. temp.real=a.real*b.real-a.imag*b.imag;
  63. temp.imag=b.imag*a.real+a.imag*b.real;
  64. returntemp;
  65. //FFT
  66. voidFFT(void)
  67. intL=0,B=0,J=0,K=0;
    68. @H_475_404@intstep=0;
  68. ElemTypeP=0,T=0;
  69. complexW,Temp_XX;
  70. //ElemTypeTempResult[N];
  71. ChangeSeat(data);
  72. for(L=1;L<=M;L++)
  73. B=1<<(L-1);//B=2^(L-1)
  74. for(J=0;J<=B-1;J++)
  75. P=(1<<(M-L))*J;//P=2^(M-L)*J
  76. step=1<<L;//2^L
  77. for(K=J;K<=N-1;K=K+step)
  78. W.real=cos(2*PI*P/N);
  79. W.imag=-sin(2*PI*P/N);
  80. Temp_XX=XX_complex(data[K+B],W);
  81. data[K+B].real=data[K].real-Temp_XX.real;
  82. data[K+B].imag=data[K].imag-Temp_XX.imag;
  83. data[K].real=data[K].real+Temp_XX.real;
  84. data[K].imag=data[K].imag+Temp_XX.imag;
  85. voidIFFT(void)
  86. intstep=0;
  87. ElemTypeP=0,T=0;
  88. complexW,Temp_XX;
  89. //ElemTypeTempResult[N];
  90. ChangeSeat(data);
  91. for(L=1;L<=M;L++)
  92. B=1<<(L-1);//B=2^(L-1)
  93. for(J=0;J<=B-1;J++)
  94. P=(1<<(M-L))*J;//P=2^(M-L)*J
  95. step=1<<L;//2^L
  96. for(K=J;K<=N-1;K=K+step)
  97. W.real=cos(2*PI*P/N);
  98. W.imag=sin(2*PI*P/N);//逆运算，这里跟FFT符号相反
  99. Temp_XX=XX_complex(data[K+B],W);
  100. data[K+B].real=data[K].real-Temp_XX.real;
  101. data[K+B].imag=data[K].imag-Temp_XX.imag;
  102. data[K].real=data[K].real+Temp_XX.real;
  103. data[K].imag=data[K].imag+Temp_XX.imag;
  104. intmain(intargc,char*argv[])
    105. @H_475_404@inti=0;
  105. for(i=0;i<N;i++)//制造输入序列
  106. data[i].real=sin(2*PI*i/N);
  107. printf("%lf",data[i]);
  108. printf("\n\n");
  109. FFT();//进行FFT计算
  110. for(i=0;i<N;i++)
  111. {printf("%lf",sqrt(data[i].real*data[i].real+data[i].imag*data[i].imag));}
  112. IFFT();//进行FFT计算
  113. printf("\n\n");
  114. for(i=0;i<N;i++)
  115. {printf("%lf",data[i].real/N);}
  116. printf("\n");
  117. /*for(i=0;i<N;i++)
  118. {printf("%lf",data[i].imag/N);}
  119. printf("\n");*/
  120. /*for(i=0;i<N;i++)
  122. return0;
  123. }


copy
    **性能提升：修正了IFFT的bug,使用宏定义改变N大小
  1. **程序版本：V6.5
  2. **最后修改：2011年5月16日
  3. #definePI3.14159265358979323846264338327950288419716939937510//圆周率，50位小数
  4. #definePI26.28318530717958647692528676655900576839433879875021
  5. #defineN1024//傅里叶变换的点数
  6. #defineM10//蝶形运算的级数，N=2^M
  7. #defineNpart2512//创建正弦函数表时取PI的1/2
  8. #defineNpart4256//创建正弦函数表时取PI的1/4
  9. #defineFFT_RESULT(x)(sqrt(data[x].real*data[x].real+data[x].imag*data[x].imag))
  10. #defineIFFT_RESULT(x)(data[x].real/N)
    11. @H_475_404@floatElemType;
  11. //定义复数结构体
  12. ElemTypereal,imag;
  13. }complex;
  14. complexdata[N];//定义存储单元，原始数据与负数结果均使用之
  15. ElemTypeSIN_TABLE[Npart4+1];
  16. //产生模拟原始数据输入
  17. voidInputData(inti;
  18. data[i].real=sin(2*PI*i/N);//正弦波
  19. data[i].imag=0;
  20. //创建正弦函数表
  21. voidCREATE_SIN_TABLE(for(i=0;i<=Npart4;i++)
  22. SIN_TABLE[i]=sin(PI*i/Npart2);//SIN_TABLE[i]=sin(PI2*i/N);
  23. ElemTypeSin_find(ElemTypex)
  24. inti=(int)(N*x);
  25. i=i>>1;
  26. if(i>Npart4)//注意：i已经转化为0~N之间的整数了！
  27. {//不会超过N/2
  28. i=Npart2-i;//i=i-2*(i-Npart4);
  29. returnSIN_TABLE[i];
  30. ElemTypeCos_find(ElemTypex)
  31. if(i<Npart4)//i=Npart4-i;
  32. returnSIN_TABLE[Npart4-i];
  33. else//i>Npart4&&i<N/2
  34. //i=i-Npart4;
  35. return-SIN_TABLE[i-Npart4];
  36. //变址
  37. voidChangeSeat(complex*DataInput)
  38. nextValue=N/2;//变址运算，即把自然顺序变成倒位序，采用雷德算法
  39. nextM=N-1;
  40. for(i=0;i<nextM;i++)
  42. temp=DataInput[j];
  43. DataInput[j]=DataInput[i];
  44. DataInput[i]=temp;
  45. k=nextValue;//求j的下一个倒位序
  47. j=j-k;//把最高位变成0
  48. k=k/2;//k/2，比较次高位，依次类推，逐个比较，直到某个位为0
  49. j=j+k;//把0改为1
  50. //复数乘法
  51. /*complexXX_complex(complexa,complexb)
  52. complextemp;
  54. temp.real=a.real*b.real-a.imag*b.imag;
  55. temp.imag=b.imag*a.real+a.imag*b.real;
  57. returntemp;
  58. }*/
  59. //FFT运算函数
    60. @H_475_404@intstep=0,KB=0;
  60. //ElemTypeP=0;
  61. ElemTypeangle;
  62. ChangeSeat(data);//CREATE_SIN_TABLE();
  63. B=step>>1;for(J=0;J<B;J++)
  64. //P=(1<<(M-L))*J;//P=2^(M-L)*J
  65. angle=(double)J/B;//这里还可以优化
  66. W.imag=-Sin_find(angle);//用C++该函数课声明为inline
  67. W.real=Cos_find(angle);//用C++该函数课声明为inline
  68. //W.real=cos(angle*PI);
  69. //W.imag=-sin(angle*PI);
  70. for(K=J;K<N;K=K+step)
  71. KB=K+B;
  72. //Temp_XX=XX_complex(data[KB],W);
  73. //用下面两行直接计算复数乘法，省去函数调用开销
  74. Temp_XX.real=data[KB].real*W.real-data[KB].imag*W.imag;
  75. Temp_XX.imag=W.imag*data[KB].real+data[KB].imag*W.real;
  76. data[KB].real=data[K].real-Temp_XX.real;
  77. data[KB].imag=data[K].imag-Temp_XX.imag;
  78. //IFFT运算函数
  79. W.imag=Sin_find(angle); W.real=Cos_find(angle);//W.real=cos(angle*PI);
  80. //W.imag=-sin(angle*PI);
  81. for(K=J;K<N;K=K+step)
  82. KB=K+B;
  84. //用下面两行直接计算复数乘法，省去函数调用开销
  85. Temp_XX.real=data[KB].real*W.real-data[KB].imag*W.imag;
  86. Temp_XX.imag=W.imag*data[KB].real+data[KB].imag*W.real;
  87. data[KB].real=data[K].real-Temp_XX.real;
  88. data[KB].imag=data[K].imag-Temp_XX.imag;
  89. //主函数
  90. CREATE_SIN_TABLE();//创建正弦函数表,这句只需在程序开始时执行一次
  91. InputData();//输入原始数据，此处用公式模拟；实际应用时为AD采样数据
  92. {printf("%f",FFT_RESULT(i));}/**/
  93. //进行IFFT计算
  94. copy
    **程序描述：本程序实现快速傅里叶变换及其逆变换
  1. **性能提升：修正了FFT的bug,变量重新命名,并将N_FFT改为动态值
  2. **程序版本：V6.6
  3. #include<stdlib.h>
  4. #include<math.h>
  5. //#defineOUTPRINTprintf
  6. //#defineDEL/##/
  7. #defineRESULT(x)sqrt(data_of_N_FFT[x].real*data_of_N_FFT[x].real+data_of_N_FFT[x].imag*data_of_N_FFT[x].imag)
  8. #definePI3.14159265358979323846264338327950288419716939937510//圆周率，50位小数
  9. #definePI26.28318530717958647692528676655900576839433879875021
  10. intN_FFT=0;//傅里叶变换的点数
    11. @H_475_404@intM_of_N_FFT=0;//蝶形运算的级数，N=2^M
  11. intNpart2_of_N_FFT=0;//创建正弦函数表时取PI的1/2
    12. @H_475_404@intNpart4_of_N_FFT=0;//创建正弦函数表时取PI的1/4
  12. }complex_of_N_FFT,*ptr_complex_of_N_FFT;
  13. ptr_complex_of_N_FFTdata_of_N_FFT=NULL;//开辟存储单元，原始数据与负数结果均使用之
  14. ElemType*SIN_TABLE_of_N_FFT=NULL;
  15. for(i=0;i<N_FFT;i++) data_of_N_FFT[i].real=sin(2*PI*i/N_FFT); data_of_N_FFT[i].imag=0;
  16. printf("%f",data_of_N_FFT[i].real);
  17. for(i=0;i<=Npart4_of_N_FFT;i++)
  18. SIN_TABLE_of_N_FFT[i]=sin(PI*i/Npart2_of_N_FFT); ElemTypeSin_find(ElemTypex)
    19. @H_475_404@int)(N_FFT*x);
  19. i=i>>1;
  20. if(i>Npart4_of_N_FFT)//注意：i已经转化为0~N之间的整数了！
  21. i=Npart2_of_N_FFT-i;returnSIN_TABLE_of_N_FFT[i];
  22. ElemTypeCos_find(ElemTypex)
  23. if(i<Npart4_of_N_FFT)returnSIN_TABLE_of_N_FFT[Npart4_of_N_FFT-i];
  24. return-SIN_TABLE_of_N_FFT[i-Npart4_of_N_FFT];
  25. voidChangeSeat(complex_of_N_FFT*DataInput)
  26. complex_of_N_FFTtemp;
  27. nextValue=N_FFT/2; nextM=N_FFT-1;
  28. complex_of_N_FFTW,248); line-height:18px; margin:0px!important; padding:0px 3px 0px 10px!important"> ChangeSeat(data_of_N_FFT);for(L=1;L<=M_of_N_FFT;L++)
  29. for(K=J;K<N_FFT;K=K+step)
  30. Temp_XX.real=data_of_N_FFT[KB].real*W.real-data_of_N_FFT[KB].imag*W.imag;
  31. Temp_XX.imag=W.imag*data_of_N_FFT[KB].real+data_of_N_FFT[KB].imag*W.real;
  32. data_of_N_FFT[KB].real=data_of_N_FFT[K].real-Temp_XX.real;
  33. data_of_N_FFT[KB].imag=data_of_N_FFT[K].imag-Temp_XX.imag;
  34. data_of_N_FFT[K].real=data_of_N_FFT[K].real+Temp_XX.real;
  35. data_of_N_FFT[K].imag=data_of_N_FFT[K].imag+Temp_XX.imag;
  36. //IFFT运算函数
  37. //ElemTypeP=0;
  38. ElemTypeangle;
  39. complex_of_N_FFTW,108); list-style:decimal-leading-zero outside; color:inherit; line-height:18px; margin:0px!important; padding:0px 3px 0px 10px!important"> ChangeSeat(data_of_N_FFT);//CREATE_SIN_TABLE();
  40. for(L=1;L<=M_of_N_FFT;L++)
  41. B=step>>1;for(J=0;J<B;J++)
  42. //P=(1<<(M-L))*J;//P=2^(M-L)*J
  43. angle=(//这里还可以优化
  44. W.imag=Sin_find(angle);//初始化FFT程序
  45. //N_FFT是FFT的点数，必须是2的次方
  46. voidInit_FFT(intN_of_FFT)
  47. inti=0;
  48. inttemp_N_FFT=1;
  49. N_FFT=N_of_FFT;//傅里叶变换的点数，必须是2的次方
  50. M_of_N_FFT=0;//蝶形运算的级数，N=2^M
  51. for(i=0;temp_N_FFT<N_FFT;i++)
  52. temp_N_FFT=2*temp_N_FFT;
  53. M_of_N_FFT++;
  54. printf("\n%d\n",M_of_N_FFT);
  55. Npart2_of_N_FFT=N_FFT/2;//创建正弦函数表时取PI的1/2
  56. Npart4_of_N_FFT=N_FFT/4;//创建正弦函数表时取PI的1/4
  57. //ptr_complex_of_N_FFTdata_of_N_FFT=NULL;//开辟存储单元，原始数据与负数结果均使用之
  58. data_of_N_FFT=(ptr_complex_of_N_FFT)malloc(N_FFT*sizeof(complex_of_N_FFT));
  59. //ptr_complex_of_N_FFTSIN_TABLE_of_N_FFT=NULL;
  60. SIN_TABLE_of_N_FFT=(ElemType*)malloc((Npart4_of_N_FFT+1)*sizeof(ElemType));
  61. CREATE_SIN_TABLE();//结束FFT运算，释放相关内存
  62. voidClose_FFT(if(data_of_N_FFT!=NULL)
  63. free(data_of_N_FFT);//释放内存
  64. data_of_N_FFT=NULL;
  65. if(SIN_TABLE_of_N_FFT!=NULL)
  66. free(SIN_TABLE_of_N_FFT);//释放内存
  67. SIN_TABLE_of_N_FFT=NULL;
  68. Init_FFT(1024);//初始化各项参数，此函数只需执行一次
  69. //输入原始数据
  70. for(i=0;i<N_FFT;i++)
  71. printf("%f",RESULT(i));
  72. IFFT();//进行IFFT计算
  73. for(i=0;i<N_FFT;i++)
  74. Close_FFT();copy
    **模块名称：快速傅里叶变换(FFT)
  1. **模块描述：本程序实现快速傅里叶变换
  2. **性能提升：已达到网上同类程序最高速度
  3. **模块版本：V6.0
  4. **模块作者：宋元瑞
  5. **最后修改：2011年5月6日
  6. **程序说明：
  7. FFT运算输入参数source_Data(i)是一个N大小的数组（注意是小括号）
  8. FFT运算输出结果result_Data(i)是一个N大小的数组（注意是小括号）
  9. **调用举例：
  10. intmain(intargc,char*argv[])
  11. inti=0;
  12. ///以下为FFT运算的调用方式
  13. FFT_prepare();//为FFT做好准备，此函数只需程序开始时执行一次即可，切勿写在循环中
  14. while(1)
  15. for(i=0;i<N_FFT;i++)//输入原始数据
  16. {source_Data(i)=sin(2*PI*i/N_FFT);}//注意inputData后面是小括号
  17. FFT();//进行FFT计算
  18. //输出结果：XXX=result_Data(i);
  19. return0;
  20. #ifndefSYRFFT_H
  21. //#pragmaonce
  22. //#include<stdio.h>
  23. #defineFFT_prepare()CREATE_SIN_TABLE();//创建正弦函数表
  24. #definesource_Data(i)data_FFT[i].imag//接收输入数据的数组，大小为N
  25. #defineresult_Data(i)sqrt(data_FFT[i].real*data_FFT[i].real+data_FFT[i].imag*data_FFT[i].imag)//FFT结果
  26. #defineN_FFT1024//傅里叶变换的点数
  27. #defineM_of_N_FFT10//蝶形运算的级数，N=2^M
  28. #defineNpart2_of_N_FFT512//创建正弦函数表时取PI的1/2
  29. #defineNpart4_of_N_FFT256//创建正弦函数表时取PI的1/4
  30. }complex_of_N_FFT;
  31. complex_of_N_FFTdata_FFT[N_FFT];//存放要进行FFT运输的数据，运算结果也存放这里
  32. ElemTypeSIN_TABLE[Npart4_of_N_FFT+1];
  33. /*
  34. voidInputData(void)
  35. inti;
  36. for(i=0;i<N_FFT;i++)//制造输入序列
  37. source_Data(i)=sin(2*PI*i/N_FFT);//模拟输入正弦波
  38. //data_FFT[i].imag=sin(2*PI*i/N);//正弦波
  39. //printf("%f",data_FFT[i].imag);
  40. SIN_TABLE[i]=sin(PI*i/Npart2_of_N_FFT);int)(N_FFT*x);
  41. returnSIN_TABLE[Npart4_of_N_FFT-i];
  42. return-SIN_TABLE[i-Npart4_of_N_FFT];
  43. //变址前data_FFT[i].imag存储了输入数据，变址后data_FFT[i].real存储了输入数据
    44. @H_475_404@inti,New_seat;
  44. New_seat=0;
  45. for(n=0;n<M_of_N_FFT;n++)
  46. New_seat=New_seat|(((i>>n)&0x01)<<(M_of_N_FFT-n-1));
  47. DataInput[New_seat].real=DataInput[i].imag;
  48. DataInput[i].imag=0;
  49. complex_of_N_FFTXX_complex(complex_of_N_FFTa,complex_of_N_FFTb)
  50. complex_of_N_FFTtemp;
  51. ChangeSeat(data_FFT);//Temp_XX=XX_complex(data_FFT[KB],108); list-style:decimal-leading-zero outside; color:inherit; line-height:18px; margin:0px!important; padding:0px 3px 0px 10px!important"> Temp_XX.real=data_FFT[KB].real*W.real-data_FFT[KB].imag*W.imag;
  52. Temp_XX.imag=W.imag*data_FFT[KB].real+data_FFT[KB].imag*W.real;
  53. data_FFT[KB].real=data_FFT[K].real-Temp_XX.real;
  54. data_FFT[KB].imag=data_FFT[K].imag-Temp_XX.imag;
  55. data_FFT[K].real=data_FFT[K].real+Temp_XX.real;
  56. data_FFT[K].imag=data_FFT[K].imag+Temp_XX.imag;
  57. #defineSYRFFT_H
  58. #endif

copy
    **程序版本：V6.0
  1. **程序作者：宋元瑞
  2. **最后修改：2011年5月6日
  3. *******************************************************************************/
  4. #include"syrFFT_H.h"//包含FFT运算头文件
  5. //以下3句为FFT运算的调用函数
  6. FFT_prepare();//为FFT做好准备，此函数只需程序开始时执行一次即可，切勿写在循环中
  7. //while(1)
  8. //模拟输入
  9. {source_Data(i)=sin(2*PI*i/N_FFT);}//注意inputData后面是小括号
  10. FFT();
  11. //输出结果

  12. copy

      #ifndefFFT_H
    1. #include<stdlib.h>
    2. //创建正弦函数表
    3. for(i=0;i<=Npart4_of_N_FFT;i++)
    4. SIN_TABLE_of_N_FFT[i]=sin(PI*i/Npart2_of_N_FFT);//SIN_TABLE[i]=sin(PI2*i/N);
    5. {//不会超过N/2
    6. i=Npart2_of_N_FFT-i;//i=i-2*(i-Npart4);
    7. returnSIN_TABLE_of_N_FFT[i];
    8. //i=Npart4-i;
    9. returnSIN_TABLE_of_N_FFT[Npart4_of_N_FFT-i];
    10. //i>Npart4&&i<N/2
    11. //i=i-Npart4;
    12. return-SIN_TABLE_of_N_FFT[i-Npart4_of_N_FFT];
    13. voidChangeSeat(complex_of_N_FFT*DataInput)
    14. complex_of_N_FFTtemp;
    15. nextValue=N_FFT/2; nextM=N_FFT-1;
    16. complextemp;
    17. temp.real=a.real*b.real-a.imag*b.imag;
    18. temp.imag=b.imag*a.real+a.imag*b.real;
    19. returntemp;
    20. }*/
    21. //FFT运算函数
    22. W.imag=-Sin_find(angle);for(K=J;K<N_FFT;K=K+step)
    23. Temp_XX.real=data_of_N_FFT[KB].real*W.real-data_of_N_FFT[KB].imag*W.imag;
    24. Temp_XX.imag=W.imag*data_of_N_FFT[KB].real+data_of_N_FFT[KB].imag*W.real;
    25. data_of_N_FFT[KB].real=data_of_N_FFT[K].real-Temp_XX.real;
    26. data_of_N_FFT[KB].imag=data_of_N_FFT[K].imag-Temp_XX.imag;
    27. data_of_N_FFT[K].real=data_of_N_FFT[K].real+Temp_XX.real;
    28. data_of_N_FFT[K].imag=data_of_N_FFT[K].imag+Temp_XX.imag;
    29. //printf("\n%d\n",M_of_N_FFT);
    30. //结束FFT运算，释放相关内存
    31. if(data_of_N_FFT!=NULL)
    32. free(data_of_N_FFT); data_of_N_FFT=NULL;
    33. if(SIN_TABLE_of_N_FFT!=NULL)
    34. free(SIN_TABLE_of_N_FFT); SIN_TABLE_of_N_FFT=NULL;
    35. #defineFFT_H
    36. #endif
    copy
      **性能提升：修正了FFT的bug
    1. #include"jxust_fft6_6.h"
    2. //产生模拟原始数据输入,在实际应用时替换为AD采样数据
    3. //输入采样数据
    4. //主函数，示例如何调用FFT运算
      5. @H_475_404@char*argv[])
    5. Init_FFT(1024);//①初始化各项参数，此函数只需执行一次;参数为FFT的点数，必须为2的次方
    6. InputData();//②输入原始数据,此处在实际应用时替换为AD采样数据
    7. FFT();//③进行FFT计算
    8. //for(i=0;i<N_FFT;i++)//④输出FFT频谱结果sqrt(data_of_N_FFT[i].real*data_of_N_FFT[i].real+data_of_N_FFT[i].imag*data_of_N_FFT[i].imag)
    9. //{printf("%f",RESULT(i));}
    10. //for(i=0;i<N_FFT;i++)//(可选步骤)⑤输出IFFT结果，滤波时会用到；暂时不用
    12. Close_FFT();//结束FFT运算，释放相关内存;此函数在彻底结束FFT运算后调用，
    13. return0;
    14. }

    copy

      #ifndefSYRFFT_6_55_H
    1. #defineFFT_RESULT(x)(sqrt(data_of_N_FFT[x].real*data_of_N_FFT[x].real+data_of_N_FFT[x].imag*data_of_N_FFT[x].imag))
    2. #defineIFFT_RESULT(x)(data_of_N_FFT[x].real/N_FFT)
    3. #defineN_FFT1024//傅里叶变换的点数
    4. #defineM_of_N_FFT10//蝶形运算的级数，N=2^M
    5. #defineNpart2_of_N_FFT512//创建正弦函数表时取PI的1/2
    6. #defineNpart4_of_N_FFT256//创建正弦函数表时取PI的1/4
    7. }complex_of_N_FFT,*ptr_complex_of_N_FFT;
    8. complex_of_N_FFTdata_of_N_FFT[N_FFT]; ElemTypeSIN_TABLE_of_N_FFT[Npart4_of_N_FFT+1];
      9. @H_475_404@int)(N_FFT*x); i=i>>1;//i=i/2;
    9. if(i>Npart4_of_N_FFT)
    10. //根据FFT相关公式，sin()参数不会超过PI，即i不会超过N/2
    11. if(i<Npart4_of_N_FFT)
    12. else//初始化FFT程序
    13. voidInit_FFT()
    14. #defineSYRFFT_6_55_H
    15. #endif

    copy

      **程序版本：V6.55
    1. **最后修改：2011年5月22日
    2. #include"syrFFT_6_55.h"
    3. @H_475_404@inti;
    4. //制造输入序列
    5. data_of_N_FFT[i].real=sin(2*PI*i/N_FFT);//输入采样数据
    6. data_of_N_FFT[i].imag=0;
    7. //主函数，示例如何调用FFT运算
    8. Init_FFT();//①初始化各项参数，此函数只需执行一次;修改FFT的点数去头文件的宏定义处修改
    10. //③进行FFT计算
    11. //for(i=0;i<N_FFT;i++)//④输出FFT频谱结果sqrt(data_of_N_FFT[i].real*data_of_N_FFT[i].real+data_of_N_FFT[i].imag*data_of_N_FFT[i].imag)
    13. //for(i=0;i<N_FFT;i++)//(可选步骤)⑤输出IFFT结果，滤波时会用到；暂时不用
    15. //结束FFT运算，此版本此句无用，可不写
    16. }

    猜你在找的设计模式相关文章

    适配器模式-让不兼容的接口得以适配
    适配器模式将一个类的接口转换成客户期望的另一个接口，使得原本接口不兼容的类可以相互合...
    策略模式-定义一个算法族
    策略模式定义了一系列算法族，并封装在类中，它们之间可以互相替换，此模式让算法的变化独...
    设计模式之高质量代码
    设计模式讲的是如何编写可扩展、可维护、可读的高质量代码，它是针对软件开发中经常遇到的...
    模板方法模式-封装一套算法流程
    模板方法模式在一个方法中定义一个算法的骨架，而将一些步骤延迟到子类中，使得子类可以在...
    迭代器模式-统一集合的遍历方式
    迭代器模式提供了一种方法，用于遍历集合对象中的元素，而又不暴露其内部的细节。
    单例模式的五种实现方式及优缺点
    单例模式（Singleton Design Pattern）保证一个类只能有一个实例，并提供一个全局访问点。
    组合模式-统一的处理个别对象与组合对象
    组合模式可以将对象组合成树形结构来表示“整体-部分”的层次结构，使得客户可以用一致的方...
    装饰者模式-动态的包装原有对象的行为
    装饰者模式能够更灵活的，动态的给对象添加其它功能，而不需要修改任何现有的底层代码。
    观察者模式-将消息通知给观察者
    观察者模式（Observer Design Pattern）定义了对象之间的一对多依赖，当对象状态改变的时候...
    代理模式-访问对象的代理而非其本身
    代理模式为对象提供一个代理，来控制对该对象的访问。代理模式在不改变原始类代码的情况下...
    算法设计模式多媒体技术正则表达式ElasticsearchFlinkHadoopIDE
    受约束摘*day25Java常用类库置信lamda留存持续录入年后正则表达式303.17regularexpre匹多模适20130322基础理论pathmunge涵义reectok需要转义的特资源分享validationex简明魔法里弄形如源码实现完备actionscript