anakin4
anakin4

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

http://blog.csdn.net/syrchina/article/details/6670517

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

[cpp]  view plain copy
  1. /******************************************************************************* 
  2. ** 程序名称：快速傅里叶变换(FFT)  
  3. ** 程序描述：本程序实现快速傅里叶变换  
  4. ** 程序作者：宋元瑞  
  5. ** 最后修改：2011年4月5日  
  6. *******************************************************************************/  
  7. #include   
  8. #include   
  9.   
  10. #define PI 3.141592653589   //圆周率，12位小数   
  11. #define N 8                 //傅里叶变换的点数   
  12. #define M 3                 //蝶形运算的级数，N = 2^M   
  13. typedef double ElemType;    //原始数据序列的数据类型,可以在这里设置  
  14.   
  15. typedef struct              //定义复数结构体   
  16. {  
  17.     ElemType real,imag;  
  18. }complex;  
  19.   
  20. complex data[N];            //定义存储单元，原始数据与负数结果均使用之   
  21. ElemType result[N];         //存储FFT后复数结果的模  
  22.   
  23. //变址   
  24. void ChangeSeat(complex *DataInput)  
  25. {  
  26.     int nextValue,nextM,i,k,j=0;  
  27.     complex temp;  
  28.       
  29.     nextValue=N/2;                  //变址运算，即把自然顺序变成倒位序，采用雷德算法  
  30.     nextM=N-1;  
  31.     for (i=0;i
  32.     {  
  33.         if (i//如果i  
  34.         {  
  35.             temp=DataInput[j];  
  36.             DataInput[j]=DataInput[i];  
  37.             DataInput[i]=temp;  
  38.         }  
  39.         k=nextValue;                //求j的下一个倒位序  
  40.         while (k<=j)             //如果k<=j,表示j的最高位为1  
  41.         {  
  42.             j=j-k;                  //把最高位变成0  
  43.             k=k/2;                  //k/2，比较次高位，依次类推，逐个比较，直到某个位为0  
  44.         }  
  45.         j=j+k;                      //把0改为1  
  46.     }                                         
  47. }  
  48. /* 
  49. //变址  
  50. void ChangeSeat(complex *DataInput) 
  51. { 
  52.     complex Temp[N]; 
  53.     int i,n,New_seat; 
  54.     for(i=0; i 
  55.     { 
  56.         Temp[i].real = DataInput[i].real; 
  57.         Temp[i].imag = DataInput[i].imag; 
  58.     } 
  59.     for(i=0; i 
  60.     { 
  61.         New_seat = 0; 
  62.         for(n=0;n 
  63.         { 
  64.             New_seat = New_seat | (((i>>n) & 0x01) << (M-n-1)); 
  65.         } 
  66.         DataInput[New_seat].real = Temp[i].real; 
  67.         DataInput[New_seat].imag = Temp[i].imag; 
  68.     } 
  69. } 
  70. */  
  71. //复数乘法   
  72. complex XX_complex(complex a, complex b)  
  73. {  
  74.     complex temp;  
  75.       
  76.     temp.real = a.real * b.real-a.imag*b.imag;  
  77.     temp.imag = b.imag*a.real + a.imag*b.real;  
  78.       
  79.     return temp;  
  80. }  
  81.   
  82. //FFT  
  83. void FFT(void)  
  84. {  
  85.     int L=0,B=0,J=0,K=0;  
  86.     int step=0;  
  87.     ElemType P=0,T=0;  
  88.     complex W,Temp_XX;  
  89.     //ElemType TempResult[N];  
  90.       
  91.     ChangeSeat(data);  
  92.     for(L=1; L<=M; L++)  
  93.     {  
  94.         B = 1<<(L-1);//B=2^(L-1)  
  95.         for(J=0; J<=B-1; J++)  
  96.         {  
  97.             P = (1<<(M-L))*J;//P=2^(M-L) *J   
  98.             step = 1<//2^L  
  99.             for(K=J; K<=N-1; K=K+step)  
  100.             {  
  101.                 W.real =  cos(2*PI*P/N);  
  102.                 W.imag = -sin(2*PI*P/N);  
  103.                   
  104.                 Temp_XX = XX_complex(data[K+B],W);  
  105.                 data[K+B].real = data[K].real - Temp_XX.real;  
  106.                 data[K+B].imag = data[K].imag - Temp_XX.imag;  
  107.                   
  108.                 data[K].real = data[K].real + Temp_XX.real;  
  109.                 data[K].imag = data[K].imag + Temp_XX.imag;  
  110.             }  
  111.         }  
  112.     }  
  113. }  
  114. void IFFT(void)  
  115. {  
  116.     int L=0,B=0,J=0,K=0;  
  117.     int step=0;  
  118.     ElemType P=0,T=0;  
  119.     complex W,Temp_XX;  
  120.     //ElemType TempResult[N];  
  121.       
  122.     ChangeSeat(data);  
  123.     for(L=1; L<=M; L++)  
  124.     {  
  125.         B = 1<<(L-1);//B=2^(L-1)  
  126.         for(J=0; J<=B-1; J++)  
  127.         {  
  128.             P = (1<<(M-L))*J;//P=2^(M-L) *J   
  129.             step = 1<//2^L  
  130.             for(K=J; K<=N-1; K=K+step)  
  131.             {  
  132.                 W.real =  cos(2*PI*P/N);  
  133.                 W.imag =  sin(2*PI*P/N);//逆运算，这里跟FFT符号相反   
  134.                   
  135.                 Temp_XX = XX_complex(data[K+B],W);  
  136.                 data[K+B].real = data[K].real - Temp_XX.real;  
  137.                 data[K+B].imag = data[K].imag - Temp_XX.imag;  
  138.                   
  139.                 data[K].real = data[K].real + Temp_XX.real;  
  140.                 data[K].imag = data[K].imag + Temp_XX.imag;  
  141.             }  
  142.         }  
  143.     }  
  144. }  
  145. int main(int argc, char *argv[])  
  146. {  
  147.     int i = 0;  
  148.     for(i=0; i//制造输入序列   
  149.     {  
  150.         data[i].real = sin(2*PI*i/N);  
  151.         printf("%lf ",data[i]);  
  152.     }  
  153.     printf("\n\n");  
  154.       
  155.       
  156.     FFT();//进行FFT计算   
  157.     printf("\n\n");  
  158.     for(i=0; i
  159.         {printf("%lf ",sqrt(data[i].real*data[i].real+data[i].imag*data[i].imag));}  
  160.       
  161.     IFFT();//进行FFT计算   
  162.     printf("\n\n");  
  163.     for(i=0; i
  164.         {printf("%lf ",data[i].real/N);}  
  165.     printf("\n");  
  166.     /*for(i=0; i 
  167.         {printf("%lf ",data[i].imag/N);} 
  168.     printf("\n");*/  
  169.     /*for(i=0; i 
  170.         {printf("%lf ",sqrt(data[i].real*data[i].real+data[i].imag*data[i].imag)/N);}*/  
  171.     return 0;  
  172. }  


 

[cpp]  view plain copy
  1. /******************************************************************************* 
  2. ** 程序名称：快速傅里叶变换(FFT)  
  3. ** 程序描述：本程序实现快速傅里叶变换  
  4. ** 性能提升：修正了IFFT的bug,使用宏定义改变N大小  
  5. ** 程序版本：V6.5 
  6. ** 程序作者：宋元瑞  
  7. ** 最后修改：2011年5月16日  
  8. *******************************************************************************/  
  9. #include   
  10. #include   
  11.   
  12. #define PI  3.14159265358979323846264338327950288419716939937510    //圆周率，50位小数   
  13. #define PI2 6.28318530717958647692528676655900576839433879875021  
  14. #define N 1024              //傅里叶变换的点数   
  15. #define M 10                //蝶形运算的级数，N = 2^M   
  16. #define Npart2 512          //创建正弦函数表时取PI的1/2   
  17. #define Npart4 256          //创建正弦函数表时取PI的1/4   
  18. #define FFT_RESULT(x)   (sqrt(data[x].real*data[x].real+data[x].imag*data[x].imag))  
  19. #define IFFT_RESULT(x)  (data[x].real/N)  
  20. typedef float ElemType;     //原始数据序列的数据类型,可以在这里设置  
  21.   
  22. typedef struct              //定义复数结构体   
  23. {  
  24.     ElemType real,imag;  
  25. }complex;  
  26.   
  27. complex data[N];            //定义存储单元，原始数据与负数结果均使用之   
  28. ElemType SIN_TABLE[Npart4+1];  
  29.   
  30. //产生模拟原始数据输入   
  31. void InputData(void)  
  32. {  
  33.     int i;  
  34.     for(i=0; i//制造输入序列   
  35.     {  
  36.         data[i].real = sin(2*PI*i/N);   //正弦波   
  37.         data[i].imag = 0;  
  38.     }  
  39. }  
  40. //创建正弦函数表   
  41. void CREATE_SIN_TABLE(void)  
  42. {  
  43.     int i=0;   
  44.     for(i=0; i<=Npart4; i++)  
  45.     {  
  46.         SIN_TABLE[i] = sin(PI*i/Npart2);//SIN_TABLE[i] = sin(PI2*i/N);  
  47.     }  
  48. }  
  49.   
  50. ElemType Sin_find(ElemType x)  
  51. {  
  52.     int i = (int)(N*x);  
  53.     i = i>>1;  
  54.     if(i>Npart4)//注意：i已经转化为0~N之间的整数了！   
  55.     {//不会超过N/2   
  56.         i = Npart2 - i;//i = i - 2*(i-Npart4);  
  57.     }   
  58.     return SIN_TABLE[i];  
  59. }  
  60. ElemType Cos_find(ElemType x)  
  61. {  
  62.     int i = (int)(N*x);  
  63.     i = i>>1;  
  64.     if(i//注意：i已经转化为0~N之间的整数了！   
  65.     {//不会超过N/2   
  66.         //i = Npart4 - i;  
  67.         return SIN_TABLE[Npart4 - i];  
  68.     }   
  69.     else//i>Npart4 && i  
  70.     {  
  71.         //i = i - Npart4;  
  72.         return -SIN_TABLE[i - Npart4];  
  73.     }  
  74. }  
  75.   
  76. //变址   
  77. void ChangeSeat(complex *DataInput)  
  78. {  
  79.     int nextValue,nextM,i,k,j=0;  
  80.     complex temp;  
  81.       
  82.     nextValue=N/2;                  //变址运算，即把自然顺序变成倒位序，采用雷德算法  
  83.     nextM=N-1;  
  84.     for (i=0;i
  85.     {  
  86.         if (i//如果i  
  87.         {  
  88.             temp=DataInput[j];  
  89.             DataInput[j]=DataInput[i];  
  90.             DataInput[i]=temp;  
  91.         }  
  92.         k=nextValue;                //求j的下一个倒位序  
  93.         while (k<=j)             //如果k<=j,表示j的最高位为1  
  94.         {  
  95.             j=j-k;                  //把最高位变成0  
  96.             k=k/2;                  //k/2，比较次高位，依次类推，逐个比较，直到某个位为0  
  97.         }  
  98.         j=j+k;                      //把0改为1  
  99.     }                                         
  100. }                                             
  101.   
  102. //复数乘法   
  103. /*complex XX_complex(complex a, complex b) 
  104. { 
  105.     complex temp; 
  106.      
  107.     temp.real = a.real * b.real-a.imag*b.imag; 
  108.     temp.imag = b.imag*a.real + a.imag*b.real; 
  109.      
  110.     return temp; 
  111. }*/  
  112.   
  113. //FFT运算函数   
  114. void FFT(void)  
  115. {  
  116.     int L=0,B=0,J=0,K=0;  
  117.     int step=0, KB=0;  
  118.     //ElemType P=0;  
  119.     ElemType angle;  
  120.     complex W,Temp_XX;  
  121.       
  122.     ChangeSeat(data);//变址   
  123.     //CREATE_SIN_TABLE();  
  124.     for(L=1; L<=M; L++)  
  125.     {  
  126.         step = 1<//2^L  
  127.         B = step>>1;//B=2^(L-1)  
  128.         for(J=0; J
  129.         {  
  130.             //P = (1<<(M-L))*J;//P=2^(M-L) *J   
  131.             angle = (double)J/B;            //这里还可以优化   
  132.             W.imag =  -Sin_find(angle);     //用C++该函数课声明为inline   
  133.             W.real =   Cos_find(angle);     //用C++该函数课声明为inline   
  134.             //W.real =  cos(angle*PI);  
  135.             //W.imag = -sin(angle*PI);  
  136.             for(K=J; K
  137.             {  
  138.                 KB = K + B;  
  139.                 //Temp_XX = XX_complex(data[KB],W);  
  140.                 //用下面两行直接计算复数乘法，省去函数调用开销   
  141.                 Temp_XX.real = data[KB].real * W.real-data[KB].imag*W.imag;  
  142.                 Temp_XX.imag = W.imag*data[KB].real + data[KB].imag*W.real;  
  143.                   
  144.                 data[KB].real = data[K].real - Temp_XX.real;  
  145.                 data[KB].imag = data[K].imag - Temp_XX.imag;  
  146.                   
  147.                 data[K].real = data[K].real + Temp_XX.real;  
  148.                 data[K].imag = data[K].imag + Temp_XX.imag;  
  149.             }  
  150.         }  
  151.     }  
  152. }  
  153. //IFFT运算函数   
  154. void IFFT(void)  
  155. {  
  156.     int L=0,B=0,J=0,K=0;  
  157.     int step=0, KB=0;  
  158.     //ElemType P=0;  
  159.     ElemType angle;  
  160.     complex W,Temp_XX;  
  161.       
  162.     ChangeSeat(data);//变址   
  163.     //CREATE_SIN_TABLE();  
  164.     for(L=1; L<=M; L++)  
  165.     {  
  166.         step = 1<//2^L  
  167.         B = step>>1;//B=2^(L-1)  
  168.         for(J=0; J
  169.         {  
  170.             //P = (1<<(M-L))*J;//P=2^(M-L) *J   
  171.             angle = (double)J/B;            //这里还可以优化   
  172.               
  173.             W.imag =   Sin_find(angle);     //用C++该函数课声明为inline   
  174.             W.real =   Cos_find(angle);     //用C++该函数课声明为inline   
  175.             //W.real =  cos(angle*PI);  
  176.             //W.imag = -sin(angle*PI);  
  177.             for(K=J; K
  178.             {  
  179.                 KB = K + B;  
  180.                 //Temp_XX = XX_complex(data[KB],W);  
  181.                 //用下面两行直接计算复数乘法，省去函数调用开销   
  182.                 Temp_XX.real = data[KB].real * W.real-data[KB].imag*W.imag;  
  183.                 Temp_XX.imag = W.imag*data[KB].real + data[KB].imag*W.real;  
  184.                   
  185.                 data[KB].real = data[K].real - Temp_XX.real;  
  186.                 data[KB].imag = data[K].imag - Temp_XX.imag;  
  187.                   
  188.                 data[K].real = data[K].real + Temp_XX.real;  
  189.                 data[K].imag = data[K].imag + Temp_XX.imag;  
  190.             }  
  191.         }  
  192.     }  
  193. }  
  194. //主函数   
  195. int main(int argc, char *argv[])  
  196. {  
  197.     int i = 0;  
  198.       
  199.     CREATE_SIN_TABLE(); //创建正弦函数表 ,这句只需在程序开始时执行一次   
  200.       
  201.     InputData();        //输入原始数据 ，此处用公式模拟；实际应用时为AD采样数据   
  202.     FFT();              //进行 FFT计算   
  203.       
  204.     for(i=0; i
  205.         {printf("%f ",FFT_RESULT(i));}/**/  
  206.       
  207.     IFFT();//进行 IFFT计算   
  208.     for(i=0; i
  209.         {printf("%f ",IFFT_RESULT(i));}/**/  
  210.       
  211.     return 0;  
  212. }  


 

[cpp]  view plain copy
  1. /******************************************************************************* 
  2. ** 程序名称：快速傅里叶变换(FFT) 
  3. ** 程序描述：本程序实现快速傅里叶变换及其逆变换 
  4. ** 性能提升：修正了FFT的bug,变量重新命名,并将 N_FFT改为动态值 
  5. ** 程序版本：V6.6 
  6. ** 程序作者：宋元瑞 
  7. ** 最后修改：2011年5月16日 
  8. *******************************************************************************/  
  9. #include   
  10. #include   
  11. #include   
  12.   
  13. //#define OUTPRINT printf  
  14. //#define DEL /##/  
  15.   
  16. #define 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)  
  17. #define PI  3.14159265358979323846264338327950288419716939937510    //圆周率，50位小数  
  18. #define PI2 6.28318530717958647692528676655900576839433879875021  
  19. int N_FFT=0;                //傅里叶变换的点数  
  20. int M_of_N_FFT=0;           //蝶形运算的级数，N = 2^M  
  21. int Npart2_of_N_FFT=0;      //创建正弦函数表时取PI的1/2  
  22. int Npart4_of_N_FFT=0;      //创建正弦函数表时取PI的1/4  
  23.   
  24. typedef float ElemType;     //原始数据序列的数据类型,可以在这里设置  
  25.   
  26. typedef struct              //定义复数结构体  
  27. {  
  28.     ElemType real,imag;  
  29. }complex_of_N_FFT,*ptr_complex_of_N_FFT;  
  30.   
  31. ptr_complex_of_N_FFT data_of_N_FFT=NULL;//开辟存储单元，原始数据与负数结果均使用之  
  32. ElemType* SIN_TABLE_of_N_FFT=NULL;  
  33.   
  34. //产生模拟原始数据输入  
  35. void InputData(void)  
  36. {  
  37.     int i;  
  38.     for (i=0; i//制造输入序列  
  39.     {  
  40.         data_of_N_FFT[i].real = sin(2*PI*i/N_FFT);  //正弦波  
  41.         data_of_N_FFT[i].imag = 0;  
  42.         printf("%f ",data_of_N_FFT[i].real);  
  43.     }  
  44. }  
  45.   
  46. //创建正弦函数表  
  47. void CREATE_SIN_TABLE(void)  
  48. {  
  49.     int i=0;  
  50.     for (i=0; i<=Npart4_of_N_FFT; i++)  
  51.     {  
  52.         SIN_TABLE_of_N_FFT[i] = sin(PI*i/Npart2_of_N_FFT);//SIN_TABLE[i] = sin(PI2*i/N);  
  53.     }  
  54. }  
  55.   
  56.   
  57. ElemType Sin_find(ElemType x)  
  58. {  
  59.     int i = (int)(N_FFT*x);  
  60.     i = i>>1;  
  61.     if (i>Npart4_of_N_FFT)//注意：i已经转化为0~N之间的整数了！  
  62.     {  
  63.         //不会超过N/2  
  64.         i = Npart2_of_N_FFT - i;//i = i - 2*(i-Npart4);  
  65.     }  
  66.     return SIN_TABLE_of_N_FFT[i];  
  67. }  
  68.   
  69. ElemType Cos_find(ElemType x)  
  70. {  
  71.     int i = (int)(N_FFT*x);  
  72.     i = i>>1;  
  73.     if (i//注意：i已经转化为0~N之间的整数了！  
  74.     {  
  75.         //不会超过N/2  
  76.         //i = Npart4 - i;  
  77.         return SIN_TABLE_of_N_FFT[Npart4_of_N_FFT - i];  
  78.     }  
  79.     else//i>Npart4 && i  
  80.     {  
  81.         //i = i - Npart4;  
  82.         return -SIN_TABLE_of_N_FFT[i - Npart4_of_N_FFT];  
  83.     }  
  84. }  
  85.   
  86. //变址  
  87. void ChangeSeat(complex_of_N_FFT *DataInput)  
  88. {  
  89.     int nextValue,nextM,i,k,j=0;  
  90.     complex_of_N_FFT temp;  
  91.   
  92.     nextValue=N_FFT/2;                  //变址运算，即把自然顺序变成倒位序，采用雷德算法  
  93.     nextM=N_FFT-1;  
  94.     for (i=0;i
  95.     {  
  96.         if (i//如果i  
  97.         {  
  98.             temp=DataInput[j];  
  99.             DataInput[j]=DataInput[i];  
  100.             DataInput[i]=temp;  
  101.         }  
  102.         k=nextValue;                //求j的下一个倒位序  
  103.         while (k<=j)             //如果k<=j,表示j的最高位为1  
  104.         {  
  105.             j=j-k;                  //把最高位变成0  
  106.             k=k/2;                  //k/2，比较次高位，依次类推，逐个比较，直到某个位为0  
  107.         }  
  108.         j=j+k;                      //把0改为1  
  109.     }  
  110. }  
  111.   
  112. //复数乘法  
  113. /*complex XX_complex(complex a, complex b) 
  114. { 
  115.     complex temp; 
  116.  
  117.     temp.real = a.real * b.real-a.imag*b.imag; 
  118.     temp.imag = b.imag*a.real + a.imag*b.real; 
  119.  
  120.     return temp; 
  121. }*/  
  122.   
  123. //FFT运算函数  
  124. void FFT(void)  
  125. {  
  126.     int L=0,B=0,J=0,K=0;  
  127.     int step=0, KB=0;  
  128.     //ElemType P=0;  
  129.     ElemType angle;  
  130.     complex_of_N_FFT W,Temp_XX;  
  131.   
  132.     ChangeSeat(data_of_N_FFT);//变址  
  133.     //CREATE_SIN_TABLE();  
  134.     for (L=1; L<=M_of_N_FFT; L++)  
  135.     {  
  136.         step = 1<//2^L  
  137.         B = step>>1;//B=2^(L-1)  
  138.         for (J=0; J
  139.         {  
  140.             //P = (1<<(M-L))*J;//P=2^(M-L) *J  
  141.             angle = (double)J/B;            //这里还可以优化  
  142.             W.imag =  -Sin_find(angle);     //用C++该函数课声明为inline  
  143.             W.real =   Cos_find(angle);     //用C++该函数课声明为inline  
  144.             //W.real =  cos(angle*PI);  
  145.             //W.imag = -sin(angle*PI);  
  146.             for (K=J; K
  147.             {  
  148.                 KB = K + B;  
  149.                 //Temp_XX = XX_complex(data[KB],W);  
  150.                 //用下面两行直接计算复数乘法，省去函数调用开销  
  151.                 Temp_XX.real = data_of_N_FFT[KB].real * W.real-data_of_N_FFT[KB].imag*W.imag;  
  152.                 Temp_XX.imag = W.imag*data_of_N_FFT[KB].real + data_of_N_FFT[KB].imag*W.real;  
  153.   
  154.                 data_of_N_FFT[KB].real = data_of_N_FFT[K].real - Temp_XX.real;  
  155.                 data_of_N_FFT[KB].imag = data_of_N_FFT[K].imag - Temp_XX.imag;  
  156.   
  157.                 data_of_N_FFT[K].real = data_of_N_FFT[K].real + Temp_XX.real;  
  158.                 data_of_N_FFT[K].imag = data_of_N_FFT[K].imag + Temp_XX.imag;  
  159.             }  
  160.         }  
  161.     }  
  162. }  
  163.   
  164. //IFFT运算函数  
  165. void IFFT(void)  
  166. {  
  167.     int L=0,B=0,J=0,K=0;  
  168.     int step=0, KB=0;  
  169.     //ElemType P=0;  
  170.     ElemType angle;  
  171.     complex_of_N_FFT W,Temp_XX;  
  172.   
  173.     ChangeSeat(data_of_N_FFT);//变址  
  174.     //CREATE_SIN_TABLE();  
  175.     for (L=1; L<=M_of_N_FFT; L++)  
  176.     {  
  177.         step = 1<//2^L  
  178.         B = step>>1;//B=2^(L-1)  
  179.         for (J=0; J
  180.         {  
  181.             //P = (1<<(M-L))*J;//P=2^(M-L) *J  
  182.             angle = (double)J/B;            //这里还可以优化  
  183.   
  184.             W.imag =   Sin_find(angle);     //用C++该函数课声明为inline  
  185.             W.real =   Cos_find(angle);     //用C++该函数课声明为inline  
  186.             //W.real =  cos(angle*PI);  
  187.             //W.imag = -sin(angle*PI);  
  188.             for (K=J; K
  189.             {  
  190.                 KB = K + B;  
  191.                 //Temp_XX = XX_complex(data[KB],W);  
  192.                 //用下面两行直接计算复数乘法，省去函数调用开销  
  193.                 Temp_XX.real = data_of_N_FFT[KB].real * W.real-data_of_N_FFT[KB].imag*W.imag;  
  194.                 Temp_XX.imag = W.imag*data_of_N_FFT[KB].real + data_of_N_FFT[KB].imag*W.real;  
  195.   
  196.                 data_of_N_FFT[KB].real = data_of_N_FFT[K].real - Temp_XX.real;  
  197.                 data_of_N_FFT[KB].imag = data_of_N_FFT[K].imag - Temp_XX.imag;  
  198.   
  199.                 data_of_N_FFT[K].real = data_of_N_FFT[K].real + Temp_XX.real;  
  200.                 data_of_N_FFT[K].imag = data_of_N_FFT[K].imag + Temp_XX.imag;  
  201.             }  
  202.         }  
  203.     }  
  204. }  
  205.   
  206. //初始化FFT程序  
  207. //N_FFT是 FFT的点数，必须是2的次方  
  208. void Init_FFT(int N_of_FFT)  
  209. {  
  210.     int i=0;  
  211.     int temp_N_FFT=1;  
  212.     N_FFT = N_of_FFT;                   //傅里叶变换的点数 ，必须是 2的次方  
  213.     M_of_N_FFT = 0;                 //蝶形运算的级数，N = 2^M  
  214.     for (i=0; temp_N_FFT
  215.     {  
  216.         temp_N_FFT = 2*temp_N_FFT;  
  217.         M_of_N_FFT++;  
  218.     }  
  219.     printf("\n%d\n",M_of_N_FFT);  
  220.     Npart2_of_N_FFT = N_FFT/2;      //创建正弦函数表时取PI的1/2  
  221.     Npart4_of_N_FFT = N_FFT/4;      //创建正弦函数表时取PI的1/4  
  222.   
  223.     //ptr_complex_of_N_FFT data_of_N_FFT=NULL;//开辟存储单元，原始数据与负数结果均使用之  
  224.     data_of_N_FFT = (ptr_complex_of_N_FFT)malloc(N_FFT * sizeof(complex_of_N_FFT));  
  225.     //ptr_complex_of_N_FFT SIN_TABLE_of_N_FFT=NULL;  
  226.     SIN_TABLE_of_N_FFT = (ElemType *)malloc((Npart4_of_N_FFT+1) * sizeof(ElemType));  
  227.   
  228.     CREATE_SIN_TABLE();             //创建正弦函数表  
  229. }  
  230.   
  231. //结束 FFT运算，释放相关内存  
  232. void Close_FFT(void)  
  233. {  
  234.     if (data_of_N_FFT != NULL)  
  235.     {  
  236.         free(data_of_N_FFT);          //释放内存  
  237.         data_of_N_FFT = NULL;  
  238.     }  
  239.     if (SIN_TABLE_of_N_FFT != NULL)  
  240.     {  
  241.         free(SIN_TABLE_of_N_FFT);     //释放内存  
  242.         SIN_TABLE_of_N_FFT = NULL;  
  243.     }  
  244. }  
  245.   
  246. //主函数  
  247. int main(int argc, char *argv[])  
  248. {  
  249.     int i = 0;  
  250.   
  251.     Init_FFT(1024);     //初始化各项参数，此函数只需执行一次  
  252.   
  253.     InputData();        //输入原始数据  
  254.     FFT();              //进行 FFT计算  
  255.   
  256.     printf("\n\n");  
  257.     for (i=0; i
  258.     {  
  259.         printf("%f ",RESULT(i));  
  260.     }  
  261.   
  262.     IFFT();//进行 IFFT计算  
  263.     printf("\n\n");  
  264.     for (i=0; i
  265.     {  
  266.         printf("%f ",data_of_N_FFT[i].real/N_FFT);  
  267.     }  
  268.   
  269.     Close_FFT();        //结束 FFT运算，释放相关内存  
  270.   
  271.     return 0;  
  272. }  


 

[cpp]  view plain copy
  1. /******************************************************************************* 
  2. ** 模块名称：快速傅里叶变换(FFT)  
  3. ** 模块描述：本程序实现快速傅里叶变换  
  4. ** 性能提升：已达到网上同类程序最高速度  
  5. ** 模块版本：V6.0 
  6. ** 模块作者：宋元瑞  
  7. ** 最后修改：2011年5月6日 
  8. *******************************************************************************/  
  9. /******************************************************************************* 
  10. **  程序说明： 
  11.     FFT运算输入参数 source_Data(i) 是一个N大小的数组（注意是小括号） 
  12.     FFT运算输出结果 result_Data(i) 是一个N大小的数组（注意是小括号） 
  13. **  调用举例： 
  14. int main(int argc, char *argv[]) 
  15. { 
  16.     int i = 0; 
  17.     ///以下为FFT运算的调用方式  
  18.     FFT_prepare();      //为FFT做好准备，此函数只需程序开始时执行一次即可，切勿写在循环中  
  19.     while(1) 
  20.     { 
  21.         for(i=0;i 
  22.             {source_Data(i) = sin(2*PI*i/N_FFT);}//注意inputData后面是小括号  
  23.         FFT();              //进行FFT计算  
  24.         //输出结果：XXX =  result_Data(i); 
  25.     } 
  26.     return 0; 
  27. } 
  28. *******************************************************************************/   
  29. #ifndef SYRFFT_H  
  30. //#pragma once  
  31.   
  32. //#include   
  33. #include   
  34.   
  35. #define FFT_prepare() CREATE_SIN_TABLE();   //创建正弦函数表   
  36. #define source_Data(i) data_FFT[i].imag     //接收输入数据的数组，大小为N   
  37. #define result_Data(i) sqrt(data_FFT[i].real*data_FFT[i].real+data_FFT[i].imag*data_FFT[i].imag)//FFT结果   
  38.   
  39. #define PI  3.14159265358979323846264338327950288419716939937510    //圆周率，50位小数   
  40. #define PI2 6.28318530717958647692528676655900576839433879875021  
  41. #define N_FFT 1024              //傅里叶变换的点数   
  42. #define M_of_N_FFT 10               //蝶形运算的级数，N = 2^M   
  43. #define Npart2_of_N_FFT 512         //创建正弦函数表时取PI的1/2   
  44. #define Npart4_of_N_FFT 256         //创建正弦函数表时取PI的1/4   
  45.   
  46. typedef float ElemType;     //原始数据序列的数据类型,可以在这里设置  
  47.   
  48. typedef struct              //定义复数结构体   
  49. {  
  50.     ElemType real,imag;  
  51. }complex_of_N_FFT;  
  52.   
  53. complex_of_N_FFT data_FFT[N_FFT];       //存放要进行FFT运输的数据，运算结果也存放这里   
  54. ElemType SIN_TABLE[Npart4_of_N_FFT+1];  
  55.   
  56. //产生模拟原始数据输入   
  57. /* 
  58. void InputData(void) 
  59. { 
  60.     int i; 
  61.     for(i=0; i 
  62.     { 
  63.         source_Data(i) = sin(2*PI*i/N_FFT); //模拟输入正弦波  
  64.         //data_FFT[i].imag = sin(2*PI*i/N); //正弦波  
  65.         //printf("%f ",data_FFT[i].imag); 
  66.     } 
  67. }*/  
  68. //创建正弦函数表   
  69. void CREATE_SIN_TABLE(void)  
  70. {  
  71.     int i=0;   
  72.     for(i=0; i<=Npart4_of_N_FFT; i++)  
  73.     {  
  74.         SIN_TABLE[i] = sin(PI*i/Npart2_of_N_FFT);//SIN_TABLE[i] = sin(PI2*i/N);  
  75.     }  
  76. }  
  77.   
  78. ElemType Sin_find(ElemType x)  
  79. {  
  80.     int i = (int)(N_FFT*x);  
  81.     i = i>>1;  
  82.     if(i>Npart4_of_N_FFT)//注意：i已经转化为0~N之间的整数了！   
  83.     {//不会超过N/2   
  84.         i = Npart2_of_N_FFT - i;//i = i - 2*(i-Npart4);  
  85.     }   
  86.     return SIN_TABLE[i];  
  87. }  
  88. ElemType Cos_find(ElemType x)  
  89. {  
  90.     int i = (int)(N_FFT*x);  
  91.     i = i>>1;  
  92.     if(i//注意：i已经转化为0~N之间的整数了！   
  93.     {//不会超过N/2   
  94.         //i = Npart4 - i;  
  95.         return SIN_TABLE[Npart4_of_N_FFT - i];  
  96.     }   
  97.     else//i>Npart4 && i  
  98.     {  
  99.         //i = i - Npart4;  
  100.         return -SIN_TABLE[i - Npart4_of_N_FFT];  
  101.     }  
  102. }  
  103.   
  104. //变址   
  105. void ChangeSeat(complex_of_N_FFT *DataInput)  
  106. {  
  107.     //变址前data_FFT[i].imag存储了输入数据，变址后data_FFT[i].real存储了输入数据  
  108.     int i,n,New_seat;  
  109.       
  110.     for(i=0; i
  111.     {  
  112.         New_seat = 0;  
  113.         for(n=0;n
  114.         {  
  115.             New_seat = New_seat | (((i>>n) & 0x01) << (M_of_N_FFT-n-1));  
  116.         }  
  117.         DataInput[New_seat].real = DataInput[i].imag;  
  118.     }  
  119.     for(i=0; i
  120.     {  
  121.         DataInput[i].imag = 0;  
  122.     }  
  123. }                                                        
  124.   
  125. //复数乘法   
  126. /* 
  127. complex_of_N_FFT XX_complex(complex_of_N_FFT a, complex_of_N_FFT b) 
  128. { 
  129.     complex_of_N_FFT temp; 
  130.      
  131.     temp.real = a.real * b.real-a.imag*b.imag; 
  132.     temp.imag = b.imag*a.real + a.imag*b.real; 
  133.      
  134.     return temp; 
  135. }*/  
  136.   
  137. //FFT运算函数   
  138. void FFT(void)  
  139. {  
  140.     int L=0,B=0,J=0,K=0;  
  141.     int step=0, KB=0;  
  142.     //ElemType P=0;  
  143.     ElemType angle;  
  144.     complex_of_N_FFT W,Temp_XX;  
  145.       
  146.     ChangeSeat(data_FFT);   //变址   
  147.       
  148.     for(L=1; L<=M_of_N_FFT; L++)  
  149.     {  
  150.         step = 1<//2^L  
  151.         B = step>>1;//B=2^(L-1)  
  152.         for(J=0; J
  153.         {  
  154.             //P = (1<<(M-L))*J;//P=2^(M-L) *J   
  155.             angle = (double)J/B;            //这里还可以优化   
  156.             W.imag =  -Sin_find(angle);     //用C++该函数课声明为inline   
  157.             W.real =   Cos_find(angle);     //用C++该函数课声明为inline   
  158.             //W.real =  cos(angle*PI);  
  159.             //W.imag = -sin(angle*PI);  
  160.             for(K=J; K
  161.             {  
  162.                 KB = K + B;  
  163.                 //Temp_XX = XX_complex(data_FFT[KB],W);  
  164.                 //用下面两行直接计算复数乘法，省去函数调用开销   
  165.                 Temp_XX.real = data_FFT[KB].real * W.real-data_FFT[KB].imag*W.imag;  
  166.                 Temp_XX.imag = W.imag*data_FFT[KB].real + data_FFT[KB].imag*W.real;  
  167.                   
  168.                 data_FFT[KB].real = data_FFT[K].real - Temp_XX.real;  
  169.                 data_FFT[KB].imag = data_FFT[K].imag - Temp_XX.imag;  
  170.                   
  171.                 data_FFT[K].real = data_FFT[K].real + Temp_XX.real;  
  172.                 data_FFT[K].imag = data_FFT[K].imag + Temp_XX.imag;  
  173.             }  
  174.         }  
  175.     }  
  176. }  
  177.   
  178. #define SYRFFT_H  
  179. #endif  

 

[cpp]  view plain copy
  1. /******************************************************************************* 
  2. ** 程序名称：快速傅里叶变换(FFT)  
  3. ** 程序描述：本程序实现快速傅里叶变换  
  4. ** 程序版本：V6.0 
  5. ** 程序作者：宋元瑞  
  6. ** 最后修改：2011年5月6日 
  7. *******************************************************************************/  
  8.   
  9. #include   
  10. #include "syrFFT_H.h"   //包含FFT运算头文件   
  11.   
  12. //主函数   
  13. int main(int argc, char *argv[])  
  14. {  
  15.     int i = 0;  
  16.       
  17.     //以下3句为FFT运算的调用函数   
  18.     FFT_prepare();      //为FFT做好准备，此函数只需程序开始时执行一次即可，切勿写在循环中   
  19.     //while(1)  
  20.     {  
  21.         for(i=0;i//模拟输入   
  22.             {source_Data(i) = sin(2*PI*i/N_FFT);}//注意inputData后面是小括号   
  23.         FFT();  
  24.   
  25.         for(i=0; i//输出结果   
  26.             {printf("%lf ",result_Data(i));}  
  27.     }   
  28.       
  29.     return 0;  
  30. }  

 


 

[cpp]  view plain copy
  1. #ifndef FFT_H  
  2.   
  3. #include   
  4. #include   
  5.   
  6. #define 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)  
  7. #define PI  3.14159265358979323846264338327950288419716939937510    //圆周率，50位小数   
  8. #define PI2 6.28318530717958647692528676655900576839433879875021  
  9. int N_FFT=0;                //傅里叶变换的点数   
  10. int M_of_N_FFT=0;           //蝶形运算的级数，N = 2^M   
  11. int Npart2_of_N_FFT=0;      //创建正弦函数表时取PI的1/2   
  12. int Npart4_of_N_FFT=0;      //创建正弦函数表时取PI的1/4   
  13.   
  14. typedef float ElemType;     //原始数据序列的数据类型,可以在这里设置  
  15.   
  16. typedef struct              //定义复数结构体   
  17. {  
  18.     ElemType real,imag;  
  19. }complex_of_N_FFT,*ptr_complex_of_N_FFT;  
  20.   
  21. ptr_complex_of_N_FFT data_of_N_FFT=NULL;//开辟存储单元，原始数据与负数结果均使用之   
  22. ElemType* SIN_TABLE_of_N_FFT=NULL;  
  23.   
  24.   
  25. //创建正弦函数表   
  26. void CREATE_SIN_TABLE(void)  
  27. {  
  28.     int i=0;   
  29.     for(i=0; i<=Npart4_of_N_FFT; i++)  
  30.     {  
  31.         SIN_TABLE_of_N_FFT[i] = sin(PI*i/Npart2_of_N_FFT);//SIN_TABLE[i] = sin(PI2*i/N);  
  32.     }  
  33. }  
  34.   
  35. ElemType Sin_find(ElemType x)  
  36. {  
  37.     int i = (int)(N_FFT*x);  
  38.     i = i>>1;  
  39.     if(i>Npart4_of_N_FFT)//注意：i已经转化为0~N之间的整数了！   
  40.     {//不会超过N/2   
  41.         i = Npart2_of_N_FFT - i;//i = i - 2*(i-Npart4);  
  42.     }   
  43.     return SIN_TABLE_of_N_FFT[i];  
  44. }  
  45. ElemType Cos_find(ElemType x)  
  46. {  
  47.     int i = (int)(N_FFT*x);  
  48.     i = i>>1;  
  49.     if(i//注意：i已经转化为0~N之间的整数了！   
  50.     {//不会超过N/2   
  51.         //i = Npart4 - i;  
  52.         return SIN_TABLE_of_N_FFT[Npart4_of_N_FFT - i];  
  53.     }   
  54.     else//i>Npart4 && i  
  55.     {  
  56.         //i = i - Npart4;  
  57.         return -SIN_TABLE_of_N_FFT[i - Npart4_of_N_FFT];  
  58.     }  
  59. }  
  60.   
  61. //变址   
  62. void ChangeSeat(complex_of_N_FFT *DataInput)  
  63. {  
  64.     int nextValue,nextM,i,k,j=0;  
  65.     complex_of_N_FFT temp;  
  66.       
  67.     nextValue=N_FFT/2;                  //变址运算，即把自然顺序变成倒位序，采用雷德算法  
  68.     nextM=N_FFT-1;  
  69.     for (i=0;i
  70.     {  
  71.         if (i//如果i  
  72.         {  
  73.             temp=DataInput[j];  
  74.             DataInput[j]=DataInput[i];  
  75.             DataInput[i]=temp;  
  76.         }  
  77.         k=nextValue;                //求j的下一个倒位序  
  78.         while (k<=j)             //如果k<=j,表示j的最高位为1  
  79.         {  
  80.             j=j-k;                  //把最高位变成0  
  81.             k=k/2;                  //k/2，比较次高位，依次类推，逐个比较，直到某个位为0  
  82.         }  
  83.         j=j+k;                      //把0改为1  
  84.     }                                         
  85. }                                             
  86.   
  87. //复数乘法   
  88. /*complex XX_complex(complex a, complex b) 
  89. { 
  90.     complex temp; 
  91.      
  92.     temp.real = a.real * b.real-a.imag*b.imag; 
  93.     temp.imag = b.imag*a.real + a.imag*b.real; 
  94.      
  95.     return temp; 
  96. }*/  
  97.   
  98. //FFT运算函数   
  99. void FFT(void)  
  100. {  
  101.     int L=0,B=0,J=0,K=0;  
  102.     int step=0, KB=0;  
  103.     //ElemType P=0;  
  104.     ElemType angle;  
  105.     complex_of_N_FFT W,Temp_XX;  
  106.       
  107.     ChangeSeat(data_of_N_FFT);//变址   
  108.     //CREATE_SIN_TABLE();  
  109.     for(L=1; L<=M_of_N_FFT; L++)  
  110.     {  
  111.         step = 1<//2^L  
  112.         B = step>>1;//B=2^(L-1)  
  113.         for(J=0; J
  114.         {  
  115.             //P = (1<<(M-L))*J;//P=2^(M-L) *J   
  116.             angle = (double)J/B;            //这里还可以优化   
  117.             W.imag =  -Sin_find(angle);     //用C++该函数课声明为inline   
  118.             W.real =   Cos_find(angle);     //用C++该函数课声明为inline   
  119.             //W.real =  cos(angle*PI);  
  120.             //W.imag = -sin(angle*PI);  
  121.             for(K=J; K
  122.             {  
  123.                 KB = K + B;  
  124.                 //Temp_XX = XX_complex(data[KB],W);  
  125.                 //用下面两行直接计算复数乘法，省去函数调用开销   
  126.                 Temp_XX.real = data_of_N_FFT[KB].real * W.real-data_of_N_FFT[KB].imag*W.imag;  
  127.                 Temp_XX.imag = W.imag*data_of_N_FFT[KB].real + data_of_N_FFT[KB].imag*W.real;  
  128.                   
  129.                 data_of_N_FFT[KB].real = data_of_N_FFT[K].real - Temp_XX.real;  
  130.                 data_of_N_FFT[KB].imag = data_of_N_FFT[K].imag - Temp_XX.imag;  
  131.                   
  132.                 data_of_N_FFT[K].real = data_of_N_FFT[K].real + Temp_XX.real;  
  133.                 data_of_N_FFT[K].imag = data_of_N_FFT[K].imag + Temp_XX.imag;  
  134.             }  
  135.         }  
  136.     }  
  137. }  
  138. //IFFT运算函数   
  139. void IFFT(void)  
  140. {  
  141.     int L=0,B=0,J=0,K=0;  
  142.     int step=0, KB=0;  
  143.     //ElemType P=0;  
  144.     ElemType angle;  
  145.     complex_of_N_FFT W,Temp_XX;  
  146.       
  147.     ChangeSeat(data_of_N_FFT);//变址   
  148.     //CREATE_SIN_TABLE();  
  149.     for(L=1; L<=M_of_N_FFT; L++)  
  150.     {  
  151.         step = 1<//2^L  
  152.         B = step>>1;//B=2^(L-1)  
  153.         for(J=0; J
  154.         {  
  155.             //P = (1<<(M-L))*J;//P=2^(M-L) *J   
  156.             angle = (double)J/B;            //这里还可以优化   
  157.               
  158.             W.imag =   Sin_find(angle);     //用C++该函数课声明为inline   
  159.             W.real =   Cos_find(angle);     //用C++该函数课声明为inline   
  160.             //W.real =  cos(angle*PI);  
  161.             //W.imag = -sin(angle*PI);  
  162.             for(K=J; K
  163.             {  
  164.                 KB = K + B;  
  165.                 //Temp_XX = XX_complex(data[KB],W);  
  166.                 //用下面两行直接计算复数乘法，省去函数调用开销   
  167.                 Temp_XX.real = data_of_N_FFT[KB].real * W.real-data_of_N_FFT[KB].imag*W.imag;  
  168.                 Temp_XX.imag = W.imag*data_of_N_FFT[KB].real + data_of_N_FFT[KB].imag*W.real;  
  169.                   
  170.                 data_of_N_FFT[KB].real = data_of_N_FFT[K].real - Temp_XX.real;  
  171.                 data_of_N_FFT[KB].imag = data_of_N_FFT[K].imag - Temp_XX.imag;  
  172.                   
  173.                 data_of_N_FFT[K].real = data_of_N_FFT[K].real + Temp_XX.real;  
  174.                 data_of_N_FFT[K].imag = data_of_N_FFT[K].imag + Temp_XX.imag;  
  175.             }  
  176.         }  
  177.     }  
  178. }  
  179.   
  180. //初始化FFT程序   
  181. //N_FFT是 FFT的点数，必须是2的次方   
  182. void Init_FFT(int N_of_FFT)  
  183. {  
  184.     int i=0;  
  185.     int temp_N_FFT=1;  
  186.     N_FFT = N_of_FFT;                   //傅里叶变换的点数 ，必须是 2的次方   
  187.     M_of_N_FFT = 0;                 //蝶形运算的级数，N = 2^M   
  188.     for(i=0; temp_N_FFT
  189.     {  
  190.         temp_N_FFT = 2*temp_N_FFT;  
  191.         M_of_N_FFT++;  
  192.     }  
  193.     //printf("\n%d\n",M_of_N_FFT);  
  194.     Npart2_of_N_FFT = N_FFT/2;      //创建正弦函数表时取PI的1/2   
  195.     Npart4_of_N_FFT = N_FFT/4;      //创建正弦函数表时取PI的1/4   
  196.       
  197.     //ptr_complex_of_N_FFT data_of_N_FFT=NULL;//开辟存储单元，原始数据与负数结果均使用之   
  198.     data_of_N_FFT = (ptr_complex_of_N_FFT)malloc(N_FFT * sizeof(complex_of_N_FFT));  
  199.     //ptr_complex_of_N_FFT SIN_TABLE_of_N_FFT=NULL;  
  200.     SIN_TABLE_of_N_FFT = (ElemType *)malloc((Npart4_of_N_FFT+1) * sizeof(ElemType));  
  201.   
  202.     CREATE_SIN_TABLE();             //创建正弦函数表   
  203. }  
  204. //结束 FFT运算，释放相关内存   
  205. void Close_FFT(void)  
  206. {  
  207.     if(data_of_N_FFT != NULL)  
  208.     {  
  209.         free(data_of_N_FFT);          //释放内存  
  210.         data_of_N_FFT = NULL;  
  211.     }  
  212.     if(SIN_TABLE_of_N_FFT != NULL)  
  213.     {  
  214.         free(SIN_TABLE_of_N_FFT);     //释放内存  
  215.         SIN_TABLE_of_N_FFT = NULL;  
  216.     }  
  217. }  
  218.   
  219. #define FFT_H  
  220. #endif  
[cpp]  view plain copy
  1. /******************************************************************************* 
  2. ** 程序名称：快速傅里叶变换(FFT)  
  3. ** 程序描述：本程序实现快速傅里叶变换及其逆变换  
  4. ** 性能提升：修正了FFT的bug  
  5. ** 程序版本：V6.6 
  6. ** 程序作者：宋元瑞  
  7. ** 最后修改：2011年5月16日  
  8. *******************************************************************************/  
  9.   
  10. #include "jxust_fft6_6.h"  
  11.   
  12. //产生模拟原始数据输入 ,在实际应用时替换为AD采样数据   
  13. void InputData(void)  
  14. {  
  15.     int i;  
  16.     for(i=0; i//制造输入序列   
  17.     {  
  18.         data_of_N_FFT[i].real = sin(2*PI*i/N_FFT);  //输入采样数据   
  19.         data_of_N_FFT[i].imag = 0;  
  20.     }  
  21. }  
  22.   
  23. //主函数 ，示例如何调用FFT运算   
  24. int main(int argc, char *argv[])  
  25. {  
  26.     int i = 0;  
  27.       
  28.     Init_FFT(1024);     //①初始化各项参数，此函数只需执行一次 ; 参数为FFT的点数，必须为2的次方   
  29.       
  30.     InputData();        //②输入原始数据 ,此处在实际应用时替换为AD采样数据   
  31.     FFT();              //③进行 FFT计算   
  32.     //for(i=0; i  
  33.         //{printf("%f ",RESULT(i));}  
  34.       
  35.     IFFT();//进行 IFFT计算   
  36.     //for(i=0; i  
  37.         //{printf("%f ",data_of_N_FFT[i].real/N_FFT);}  
  38.     Close_FFT();    //结束 FFT运算，释放相关内存 ;此函数在彻底结束FFT运算后调用，   
  39.       
  40.     return 0;  
  41. }  


 

[cpp]  view plain copy
  1. #ifndef SYRFFT_6_55_H  
  2.   
  3. #include   
  4.   
  5. #define FFT_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))  
  6. #define IFFT_RESULT(x)  (data_of_N_FFT[x].real/N_FFT)  
  7.   
  8. #define PI  3.14159265358979323846264338327950288419716939937510    //圆周率，50位小数   
  9. #define PI2 6.28318530717958647692528676655900576839433879875021  
  10. #define N_FFT           1024        //傅里叶变换的点数   
  11. #define M_of_N_FFT      10          //蝶形运算的级数，N = 2^M   
  12. #define Npart2_of_N_FFT 512         //创建正弦函数表时取PI的1/2   
  13. #define Npart4_of_N_FFT 256         //创建正弦函数表时取PI的1/4   
  14.   
  15. typedef float ElemType;     //原始数据序列的数据类型,可以在这里设置  
  16.   
  17. typedef struct              //定义复数结构体   
  18. {  
  19.     ElemType real,imag;  
  20. }complex_of_N_FFT,*ptr_complex_of_N_FFT;  
  21.   
  22. complex_of_N_FFT data_of_N_FFT[N_FFT];          //定义存储单元，原始数据与负数结果均使用之   
  23. ElemType SIN_TABLE_of_N_FFT[Npart4_of_N_FFT+1];  
  24.   
  25. //创建正弦函数表   
  26. void CREATE_SIN_TABLE(void)  
  27. {  
  28.     int i=0;   
  29.     for(i=0; i<=Npart4_of_N_FFT; i++)  
  30.     {  
  31.         SIN_TABLE_of_N_FFT[i] = sin(PI*i/Npart2_of_N_FFT);//SIN_TABLE[i] = sin(PI2*i/N);  
  32.     }  
  33. }  
  34.   
  35. ElemType Sin_find(ElemType x)  
  36. {  
  37.     int i = (int)(N_FFT*x);//注意：i已经转化为0~N之间的整数了！   
  38.     i = i>>1;// i = i / 2;  
  39.     if(i>Npart4_of_N_FFT)  
  40.     {//根据FFT相关公式，sin()参数不会超过PI， 即i不会超过N/2   
  41.         i = Npart2_of_N_FFT - i;//i = i - 2*(i-Npart4);  
  42.     }   
  43.     return SIN_TABLE_of_N_FFT[i];  
  44. }  
  45. ElemType Cos_find(ElemType x)  
  46. {  
  47.     int i = (int)(N_FFT*x);//注意：i已经转化为0~N之间的整数了！   
  48.     i = i>>1;  
  49.     if(i < Npart4_of_N_FFT )   
  50.     { //不会超过N/2   
  51.         //i = Npart4 - i;  
  52.         return SIN_TABLE_of_N_FFT[Npart4_of_N_FFT - i];  
  53.     }   
  54.     else //i > Npart4 && i < N/2   
  55.     {  
  56.         //i = i - Npart4;  
  57.         return -SIN_TABLE_of_N_FFT[i - Npart4_of_N_FFT];  
  58.     }  
  59. }  
  60.   
  61. //变址   
  62. void ChangeSeat(complex_of_N_FFT *DataInput)  
  63. {  
  64.     int nextValue,nextM,i,k,j=0;  
  65.     complex_of_N_FFT temp;  
  66.       
  67.     nextValue=N_FFT/2;                  //变址运算，即把自然顺序变成倒位序，采用雷德算法  
  68.     nextM=N_FFT-1;  
  69.     for (i=0;i
  70.     {  
  71.         if (i//如果i  
  72.         {  
  73.             temp=DataInput[j];  
  74.             DataInput[j]=DataInput[i];  
  75.             DataInput[i]=temp;  
  76.         }  
  77.         k=nextValue;                //求j的下一个倒位序  
  78.         while (k<=j)             //如果k<=j,表示j的最高位为1  
  79.         {  
  80.             j=j-k;                  //把最高位变成0  
  81.             k=k/2;                  //k/2，比较次高位，依次类推，逐个比较，直到某个位为0  
  82.         }  
  83.         j=j+k;                      //把0改为1  
  84.     }                                         
  85. }                                             
  86.   
  87. //复数乘法   
  88. /*complex XX_complex(complex a, complex b) 
  89. { 
  90.     complex temp; 
  91.      
  92.     temp.real = a.real * b.real-a.imag*b.imag; 
  93.     temp.imag = b.imag*a.real + a.imag*b.real; 
  94.      
  95.     return temp; 
  96. }*/  
  97.   
  98. //FFT运算函数   
  99. void FFT(void)  
  100. {  
  101.     int L=0,B=0,J=0,K=0;  
  102.     int step=0, KB=0;  
  103.     //ElemType P=0;  
  104.     ElemType angle;  
  105.     complex_of_N_FFT W,Temp_XX;  
  106.       
  107.     ChangeSeat(data_of_N_FFT);//变址   
  108.     //CREATE_SIN_TABLE();  
  109.     for(L=1; L<=M_of_N_FFT; L++)  
  110.     {  
  111.         step = 1<//2^L  
  112.         B = step>>1;//B=2^(L-1)  
  113.         for(J=0; J
  114.         {  
  115.             //P = (1<<(M-L))*J;//P=2^(M-L) *J   
  116.             angle = (double)J/B;            //这里还可以优化   
  117.             W.imag =  -Sin_find(angle);     //用C++该函数课声明为inline   
  118.             W.real =   Cos_find(angle);     //用C++该函数课声明为inline   
  119.             //W.real =  cos(angle*PI);  
  120.             //W.imag = -sin(angle*PI);  
  121.             for(K=J; K
  122.             {  
  123.                 KB = K + B;  
  124.                 //Temp_XX = XX_complex(data[KB],W);  
  125.                 //用下面两行直接计算复数乘法，省去函数调用开销   
  126.                 Temp_XX.real = data_of_N_FFT[KB].real * W.real-data_of_N_FFT[KB].imag*W.imag;  
  127.                 Temp_XX.imag = W.imag*data_of_N_FFT[KB].real + data_of_N_FFT[KB].imag*W.real;  
  128.                   
  129.                 data_of_N_FFT[KB].real = data_of_N_FFT[K].real - Temp_XX.real;  
  130.                 data_of_N_FFT[KB].imag = data_of_N_FFT[K].imag - Temp_XX.imag;  
  131.                   
  132.                 data_of_N_FFT[K].real = data_of_N_FFT[K].real + Temp_XX.real;  
  133.                 data_of_N_FFT[K].imag = data_of_N_FFT[K].imag + Temp_XX.imag;  
  134.             }  
  135.         }  
  136.     }  
  137. }  
  138.   
  139. //IFFT运算函数   
  140. void IFFT(void)  
  141. {  
  142.     int L=0,B=0,J=0,K=0;  
  143.     int step=0, KB=0;  
  144.     //ElemType P=0;  
  145.     ElemType angle;  
  146.     complex_of_N_FFT W,Temp_XX;  
  147.       
  148.     ChangeSeat(data_of_N_FFT);//变址   
  149.     //CREATE_SIN_TABLE();  
  150.     for(L=1; L<=M_of_N_FFT; L++)  
  151.     {  
  152.         step = 1<//2^L  
  153.         B = step>>1;//B=2^(L-1)  
  154.         for(J=0; J
  155.         {  
  156.             //P = (1<<(M-L))*J;//P=2^(M-L) *J   
  157.             angle = (double)J/B;            //这里还可以优化   
  158.               
  159.             W.imag =   Sin_find(angle);     //用C++该函数课声明为inline   
  160.             W.real =   Cos_find(angle);     //用C++该函数课声明为inline   
  161.             //W.real =  cos(angle*PI);  
  162.             //W.imag = -sin(angle*PI);  
  163.             for(K=J; K
  164.             {  
  165.                 KB = K + B;  
  166.                 //Temp_XX = XX_complex(data[KB],W);  
  167.                 //用下面两行直接计算复数乘法，省去函数调用开销   
  168.                 Temp_XX.real = data_of_N_FFT[KB].real * W.real-data_of_N_FFT[KB].imag*W.imag;  
  169.                 Temp_XX.imag = W.imag*data_of_N_FFT[KB].real + data_of_N_FFT[KB].imag*W.real;  
  170.                   
  171.                 data_of_N_FFT[KB].real = data_of_N_FFT[K].real - Temp_XX.real;  
  172.                 data_of_N_FFT[KB].imag = data_of_N_FFT[K].imag - Temp_XX.imag;  
  173.                   
  174.                 data_of_N_FFT[K].real = data_of_N_FFT[K].real + Temp_XX.real;  
  175.                 data_of_N_FFT[K].imag = data_of_N_FFT[K].imag + Temp_XX.imag;  
  176.             }  
  177.         }  
  178.     }  
  179. }  
  180.   
  181. //初始化FFT程序   
  182. void Init_FFT()  
  183. {  
  184.     CREATE_SIN_TABLE();             //创建正弦函数表   
  185. }  
  186.   
  187. //结束 FFT运算，释放相关内存   
  188. void Close_FFT(void)  
  189. {  
  190.       
  191. }  
  192.   
  193. #define SYRFFT_6_55_H  
  194. #endif  

 

[cpp]  view plain copy
  1. /******************************************************************************* 
  2. ** 程序名称：快速傅里叶变换(FFT)  
  3. ** 程序描述：本程序实现快速傅里叶变换  
  4. ** 性能提升：修正了IFFT的bug,变量重新命名,使用宏定义改变N大小  
  5. ** 程序版本：V6.55 
  6. ** 程序作者：宋元瑞  
  7. ** 最后修改：2011年5月22日  
  8. *******************************************************************************/  
  9. #include "syrFFT_6_55.h"   
  10.   
  11. //产生模拟原始数据输入 ,在实际应用时替换为AD采样数据   
  12. void InputData(void)  
  13. {  
  14.     int i;  
  15.     for(i=0; i//制造输入序列   
  16.     {  
  17.         data_of_N_FFT[i].real = sin(2*PI*i/N_FFT);  //输入采样数据   
  18.         data_of_N_FFT[i].imag = 0;  
  19.     }  
  20. }  
  21.   
  22. //主函数 ，示例如何调用FFT运算   
  23. int main(int argc, char *argv[])  
  24. {  
  25.     int i = 0;  
  26.       
  27.     Init_FFT();         //①初始化各项参数，此函数只需执行一次 ; 修改FFT的点数去头文件的宏定义处修改   
  28.       
  29.     InputData();        //②输入原始数据 ,此处在实际应用时替换为AD采样数据   
  30.     FFT();              //③进行 FFT计算   
  31.     //for(i=0; i  
  32.         //{printf("%f ",FFT_RESULT(i));}  
  33.       
  34.     IFFT();//进行 IFFT计算   
  35.     //for(i=0; i  
  36.         //{printf("%f ",IFFT_RESULT(i));}  
  37.       
  38.     Close_FFT();    //结束 FFT运算，此版本此句无用，可不写   
  39.       
  40.     return 0;  
  41. }  



 

你可能感兴趣的:(用于ARM上的FFT与IFFT源代码（C语言，不依赖特定平台）)

  • 在瑞芯微RK3588平台上使用RKNN部署YOLOv8Pose模型的C++实战指南 机 ＿ 长 YOLO系列模型有效涨点改进深度学习落地实战YOLOc++开发语言
    在人工智能和计算机视觉领域，人体姿态估计是一项极具挑战性的任务，它对于理解人类行为、增强人机交互等方面具有重要意义。YOLOv8Pose作为YOLO系列中的新成员，以其高效和准确性在人体姿态估计任务中脱颖而出。本文将详细介绍如何在瑞芯微RK3588平台上，使用RKNN（RockchipNeuralNetworkToolkit）框架部署YOLOv8Pose模型，并进行C++代码的编译和运行。注本文全
  • 国内大厂面试一般流程——扫盲 weixin_49526058 面试职场和发展
    中国大型互联网企业的面试流程通常分为若干轮，具体轮数和考察内容可能因公司、岗位及招聘需求有所不同，但一般来说，大致可以分为以下几轮：1.简历筛选考察内容：主要看简历是否符合岗位要求，关注工作经历、项目经验、技术栈、学历背景等。如果简历突出，通常会进入下一轮面试。2.电话/视频初面（HR面）考察内容：HR面试主要是了解你的基本情况、动机和软技能。一般会问一些关于简历的问题，了解你对公司的了解、为什么
  • transformer模型构建 AI耽误的大厨 自然语言处理nlptransformer算法人工智能神经网络word2vec
    2.6模型构建学习目标掌握编码器-解码器结构的实现过程.掌握Transformer模型的构建过程.通过上面的小节,我们已经完成了所有组成部分的实现,接下来就来实现完整的编码器-解码器结构.Transformer总体架构图:编码器-解码器结构的代码实现#使用EncoderDecoder类来实现编码器-解码器结构classEncoderDecoder(nn.Module):def__init__(se
  • 深度学习之目标检测的常用标注工具 铭瑾熙 人工智能机器学习深度学习深度学习目标检测目标跟踪
    1LabelImgLabelImg是一款开源的图像标注工具，标签可用于分类和目标检测，它是用Python编写的，并使用Qt作为其图形界面，简单好用。注释以PASCALVOC格式保存为XML文件，这是ImageNet使用的格式。此外，它还支持COCO数据集格式。2labelmelabelme是一款开源的图像/视频标注工具，标签可用于目标检测、分割和分类。灵感是来自于MIT开源的一款标注工具Label
  • 34、深度学习-自学之路-深入理解-NLP自然语言处理-RNN一个简单的程序，可以从程序中理解RNN的基本思想。 小宇爱 深度学习-自学之路深度学习自然语言处理rnn
    importsys,random,mathfromcollectionsimportCounterimportnumpyasnpf=open('tasks_1-20_v1/en/qa1_single-supporting-fact_train.txt','r')raw=f.readlines()f.close()tokens=list()forlineinraw[0:1000]:tokens.ap
  • ug12在win8计算机名错,我电脑是win8.1的 装ug8.0 装ug为什么会提示错误?? zc791022 ug12在win8计算机名错
    可以安装，64位的可能要通用许可证才能安装。安装NX8.0.0.25之前，最好卸载掉“大于4.0”的许可服务(因为你只要装了8.0的许可服务，7.0/6.0/5.0都可以启动的)，安装后打不开NX8.0的，重启电脑试试！1.用记事本方式打开安装文件夹下的“crack\UGSLicensing\NX8.0.lic”(把里面SERVERthis_hostID=20110555528000里面的this
  • ug12无法连接服务器系统,NX许可证错误：无法连接至许可证服务器系统。SPLM_LICENSE_SERVER错误[-15]... 逍遥药师 ug12无法连接服务器系统
    问题原因这个问题可以说只要用过NX软件的工程师，都会遇到过，是最常见的NX许可证错误，可以说没有之一，因为这个提示只是告诉你，你的当前NX许可服务没有启动，就算是你安装完NX主程序不安装许可服务，也是这个提示。所以这个警告提示，实际上对你的问题参考没多大帮助。能让NX许可服务不能启动的原因有很多，所以只能自己去排查以下几种情况。解决方案1、检查你的NX许可服务有没有安装。(这是最基本，一般情况下不
  • DeepSeek-R1 技术全景解析：从原理到实践的“炼金术配方” ——附多阶段训练流程图与核心误区澄清... 雪停时偶遇一叶春 流程图
    合集-人工智能(5)1.如何改进AI模型在特定环境中的知识检索2024-09-242.深度学习与统计学中的时间序列预测2024-10-033.《使用coze搭建一个会搜索、写ppt、思维导图的Agent》2024-10-294.深入浅出：Agent如何调用工具——从OpenAIFunctionCall到CrewAI框架01-145.DeepSeek-R1技术全景解析：从原理到实践的“炼金术配方”—
  • heidisql连接远程数据库_【已解决】HeidiSQL连接（登录）MySQL数据库报错10061问题... weixin_39589511 heidisql连接远程数据库
    windows核心编程---第六章线程的调度每个线程都有一个CONTEXT结构,保存在线程内核对象中.大约每隔20mswindows就会查看所有当前存在的线程内核对象.并在可调度的线程内核对象中选择一个,将其保存在CONTEXT结构的值载入c...【转】SQLite提示databasediskimageismalformed的解决方法SQLite有一个很严重的缺点就是不提供Repair命令.导致死
  • 计算机程序制作的小作品,义乌市中小学生电脑作品制作比赛201203 东南前哨 计算机程序制作的小作品
    《义乌市中小学生电脑作品制作比赛201203》由会员分享，可在线阅读，更多相关《义乌市中小学生电脑作品制作比赛201203(4页珍藏版)》请在人人文库网上搜索。1、浙江省义乌市教育研修院关于举办2012年义乌市中小学生电脑作品制作比赛暨首届青少年网络道德建设专题创作活动的通知各中小学：为进一步推进和加强中小学信息技术教育，普及信息技术知识，培养学生创新精神和实践能力，提高信息技术水平，根据上级文件
  • Python 舆论风向分析爬虫：全流程数据获取、清洗与情感剖析 西攻城狮北 python爬虫开发语言实战案例
    引言在当今信息爆炸的时代，互联网上充斥着海量的用户言论和观点。了解舆论风向对于企业、政府机构以及研究者等具有重要的意义，可以帮助他们及时把握公众情绪、调整策略与决策。Python作为一种强大的编程语言，在数据爬取与分析方面具有得天独厚的优势，能够助力我们高效地实现舆情监测与深入剖析。一、环境搭建与目标确定1.环境搭建为了顺利完成爬虫与数据分析任务，首先需要确保你的开发环境已经安装了以下Python
  • 最新版AndroidStudio踩坑(新建项目无法正常运行) 沙漠蓝色披头 androidstudio
    2023.7.20日雨今天花了六个小时才搞定新版AS创建app应用并可以运行，所以记录一下as版本是：AndroidStudioFlamingo|2022.2.1Patch2新建一个app应用，结果gradle一直下载不下来，提示connectrefuse，如果你配置了代理，建议设置为无代理同时要记得把.gradle/gradle.properties里面相关的代理设置给清除了，如果设置了代理的话
  • Android. WebView出现net::ERR_UNKNOWN_URL_SCHEME错误 沙漠蓝色披头 小技巧webviewandroid
    1.仔细观察图中url可以发现这是一个自定协议的url，究其原因，就是拦截webview中的url,如果url是自定义协议(如:tel,weixin,alipays等等)开头的,就url转换成原生调用(intent跳转),因为webview只能识别http,https这样的协议.webview其实就相当于pc端的浏览器,遇到http/https开头的url时会向host发起一个请求,而遇到自定义的
  • Flutter一直停在 flutter pub get 的解决方法 沙漠蓝色披头 Flutter移动开发
    设置用户变量FLUTTER_STORAGE_BASE_URL：https://storage.flutter-io.cnPUB_HOSTED_URL：https://pub.flutter-io.cn重启androidstudio亲测有效
  • 【HarmonyOS Next】鸿蒙监听手机按键 GeorgeGcs HarmonyOS解决方案OpenHarmony知识体系harmonyos华为onKeyEvent按键监听事件按下鸿蒙
    【HarmonyOSNext】鸿蒙监听手机按键一、前言应用开发中我们会遇到监听用户实体按键，或者扩展按键的需求。亦或者是在某些场景下，禁止用户按下某些按键的业务需求。这两种需求，鸿蒙都提供了对应的监听事件进行处理。onKeyEvent默认的按钮监听事件onKeyPreIme这是优先级最高的监听回调，别上面多了一个return开关，用于告诉系统监听事件是否再向下传递。窗口是第一级接收按钮事件的实体。
  • 【vue】Mammoth.js的使用：将.docx转换成HTML 暴富暴富暴富啦啦啦 1024程序员节
    mammoth.convertToHtml(input,options）：把源文档转换为HTML文档mammoth.convertToMarkdown(input,options)：把源文档转换为Markdown文档。mammoth.extractRawText(input)：提取文档的原始文本。这将忽略文档中的所有格式。每个段落后跟两个换行符。npminstallelement-uimammot
  • 麒麟v10安装mysql5.7（ARM架构） qqxinxi arm开发
    下载路径：华为云镜像麒麟v10是潮流时代的新时髦的linux操作系统，但随着ARM架构流行，出现了一些卡点，不以为然，没当回事的大吃一惊。经常卡住。例如:在安装mysql5.7（ARM架构）最简单：使用rpmmysql-5.7.27.1.el7.aarch64.rpm文件比较小下载完之后rpm-ivhmysql-5.7.27.1.el7.aarch64.rpm比较简单常用的方法，再不能连接互联网时
  • YOLOv8 Pose使用RKNN进行推理 い不靠譜︶朱Sir 实用项目部署YOLO人工智能pythonlinuxpip
    关注微信公众号：朱sir的小站，发送202411081即可免费获取源代码下载链接一、简单介绍YOLOv8-Pose是一种基于YOLOv8架构的姿态估计模型，能够识别图像中的关键点位置，这些关键点通常表示人体的关节、特征点或其他显著位置。该模型在COCO关键点数据集上训练，适合多种姿势估计任务。二、ONNX推理1.首先需要先将Pytorch模型转换为Onnx模型，下载pt模型这里给出官方的权重下载地
  • 分布式数据库解析 qcidyu 文章归档数据分片高可用架构云数据库共识算法全球一致性分布式事务CAP定理
    title:分布式数据库解析date:2025/2/20updated:2025/2/20author:cmdragonexcerpt:通过金融交易、社交平台、物联网等9大真实场景，结合GoogleSpanner跨洲事务、DynamoDB毫秒级扩展等38个生产级案例，揭示分布式数据库的核心原理与工程实践。内容涵盖CAP定理的动态权衡策略、Paxos/Raft协议的工程实现差异、TrueTime时钟
  • 五大常考SQL面试题 Begin to change MySQLsql面试
    目录一、找出连续7天登陆，连续30天登陆的用户（小红书笔试，电信云面试），最大连续登陆天数的问题--窗口函数二、求连续点击三次的用户数，而且中间不能有别人的点击三、计算除去部门最高工资，和最低工资的平均工资（字节跳动面试）--窗口函数四、留存的计算，和累计求和的计算--窗口函数，自联结（pdd面试）一、找出连续7天登陆，连续30天登陆的用户（小红书笔试，电信云面试），最大连续登陆天数的问题--窗口
  • PyCharm 集成 DeepSeek：本地运行 or API 直连？打造你的 AI 编程神器！ AI云极 【AI智能系列】pycharm人工智能idedeepseek
    在AI赋能编程的时代，如何让AI辅助写代码，提升开发效率？DeepSeek作为一款开源、强大、免费的AI编程助手，结合PyCharm，能够大幅提升Python编程体验。今天，我们就来详细讲解如何在PyCharm中接入DeepSeek，无论你想使用本地部署的DeepSeek，还是官方API版本，都能轻松实现！为什么选择DeepSeek+PyCharm？DeepSeekR1采用6710亿参数的MoE（
  • Python3.5源码分析-sys模块及site模块导入 小屋子大侠 pythonPython分析python源码
    Python3源码分析本文环境python3.5.2。参考书籍>python官网Python3的sys模块初始化根据分析完成builtins初始化后，继续分析sys模块的初始化，继续分析_Py_InitializeEx_Private函数的执行，void_Py_InitializeEx_Private(intinstall_sigs,intinstall_importlib){...sysmod=
  • RealtimeSTT：实时语音转文本的开源神器，轻松实现高效语音处理 AI云极 【开源系列】语音识别开源
    在语音技术飞速发展的时代，实时语音转文本（Speech-to-Text，简称STT）技术已逐渐成为语音助手、在线会议记录、字幕生成等应用的核心功能。今天要为大家推荐的是一款开源的实时语音转文本工具——RealtimeSTT，它功能强大且易于集成，为开发者提供了快速构建实时语音处理应用的能力。项目地址：GitHub-RealtimeSTT一、什么是RealtimeSTT？RealtimeSTT是一款
  • java竞赛优化输入输出效率 px不是xp 蓝桥准备java开发语言
    在编程竞赛中，输入输出效率至关重要。Java的`Scanner`和`System.out.println`虽然简单，但在处理大规模数据时会严重拖慢速度。以下是**竞赛专用输入输出模板**及其原理详解，助你轻松应对高频I/O场景。---###⚡竞赛级输入输出模板（Java）importjava.io.*;importjava.util.*;publicclassMain{  publicstatic
  • 快速复制A库表数据前10000行到B库 musk1212 数据库sqlmysql
    提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档文章目录应用场景一、存储过程，快速复制A库表数据前10000行到B库二、使用优化点说明结构优化性能调整错误处理增强安全改进调用示例应用场景表结构可预先存在或不存在mysql5.7快速复制A库表数据前10000行到B库一、存储过程，快速复制A库表数据前10000行到B库/*设置自定义分隔符以处理存储过程中的分号*/DELIMITER$$
  • 十大排序算法 myprogramc 排序算法算法数据结构
    排序算法插入排序冒泡排序选择排序希尔排序计数排序快速排序1经典Lomuto分区法2经典Lomuto分区法3随机快排堆排序归并排序桶排序基数排序插入排序从i=1开始，判断nums[i-1]和nums[i]的大小，一直到nums[i]插入到自己的位置。模拟抓扑克牌的过程：将元素插入到已排序的部分，使其有序voidinsertionSort(vector&nums){for(inti=1;i=0&&nu
  • 4070与3070ti显卡性能对比：哪款更适合您的需求？ mmoo_python windows
    4070与3070ti显卡性能对比：哪款更适合您的需求？在高性能显卡市场中，4070和3070ti无疑是两款备受瞩目的产品。它们专为那些对游戏或其他图形密集型任务有高要求的用户而设计，提供了卓越的性能和体验。然而，尽管这两款显卡都拥有强大的性能，但它们在某些方面仍有所不同。本文将详细对比4070和3070ti显卡，以帮助您根据自己的需求做出明智的选择。一、性能对比：3070ti略胜一筹首先，我们来
  • TK群发器：提升TikTok营销效率的智能工具 @ V:ZwaitY09 矩阵tiktok
    随着短视频平台TikTok的快速发展，许多企业和内容创作者都将其作为重要的营销渠道。但随着平台的竞争加剧，如何高效管理多个账号、提升曝光度和互动率，成为了营销者的一大挑战。为了解决这一问题，TK群发器应运而生。它通过智能化的操作方式，帮助用户精准高效地进行多账号管理和内容群发，极大提高了营销效率。TK群发器的主要功能：多账号精准群发：TK群发器支持同时管理多个TikTok账号，用户可以通过该工具实
  • HarmonyOS进程通信及原理 拥有一颗学徒的心 HarmonyOSharmonyos华为鸿蒙信息与通信分布式
    大家好，我是学徒小z，最近在研究鸿蒙中一些偏底层原理的内容，今天分析进程通信给大家，请用餐文章目录进程间通信1.通过公共事件（@ohos.commonEventManager）公共事件的底层原理2.IPCKit能力LiteIPC的归属与特点1.所属内核2.核心思想3.公共事件子系统鸿蒙内核小知识进程间通信1.通过公共事件（@ohos.commonEventManager）公共事件的底层原理公共事件
  • 深入了解 CDN：概念、原理、过程、作用及工作场景 羊村懒哥 网络网络加速缓存
    目录一、CDN的概念二、CDN的工作原理三、CDN的工作过程四、CDN的作用五、CDN可结合使用的技术六、CDN能够解决的网络问题七、CDN的工作场景在当今互联网飞速发展的时代，用户对于网页加载速度和内容获取的时效性要求越来越高。CDN（ContentDeliveryNetwork，⭐内容分发网络）应运而生，它在提升网络性能和用户体验方面发挥着关键作用。本文将详细介绍CDN的概念、工作原理、工作过
  • 解线性方程组 qiuwanchi
    package gaodai.matrix; import java.util.ArrayList; import java.util.List; import java.util.Scanner; public class Test { public static void main(String[] args) { Scanner scanner = new Sc
  • 在mysql内部存储代码 annan211 性能mysql存储过程触发器
    在mysql内部存储代码 在mysql内部存储代码，既有优点也有缺点，而且有人倡导有人反对。 先看优点： 1 她在服务器内部执行，离数据最近，另外在服务器上执行还可以节省带宽和网络延迟。 2 这是一种代码重用。可以方便的统一业务规则，保证某些行为的一致性，所以也可以提供一定的安全性。 3 可以简化代码的维护和版本更新。 4 可以帮助提升安全，比如提供更细
  • Android使用Asynchronous Http Client完成登录保存cookie的问题 hotsunshine android
    Asynchronous Http Client是android中非常好的异步请求工具 除了异步之外还有很多封装比如json的处理，cookie的处理 引用 Persistent Cookie Storage with PersistentCookieStore This library also includes a PersistentCookieStore whi
  • java面试题 Array_06 java面试
    java面试题 第一，谈谈final, finally, finalize的区别。 final-修饰符（关键字）如果一个类被声明为final，意味着它不能再派生出新的子类，不能作为父类被继承。因此一个类不能既被声明为 abstract的，又被声明为final的。将变量或方法声明为final，可以保证它们在使用中不被改变。被声明为final的变量必须在声明时给定初值，而在以后的引用中只能
  • 网站加速 oloz 网站加速
    前序:本人菜鸟，此文研究总结来源于互联网上的资料，大牛请勿喷！本人虚心学习，多指教. 1、减小网页体积的大小，尽量采用div+css模式，尽量避免复杂的页面结构，能简约就简约。 2、采用Gzip对网页进行压缩；    GZIP最早由Jean-loup Gailly和Mark Adler创建，用于UNⅨ系统的文件压缩。我们在Linux中经常会用到后缀为.gz
  • 正确书写单例模式 随意而生 java 设计模式 单例
    　　单例模式算是设计模式中最容易理解，也是最容易手写代码的模式了吧。但是其中的坑却不少，所以也常作为面试题来考。本文主要对几种单例写法的整理，并分析其优缺点。很多都是一些老生常谈的问题，但如果你不知道如何创建一个线程安全的单例，不知道什么是双检锁，那这篇文章可能会帮助到你。 　　懒汉式，线程不安全 　　当被问到要实现一个单例模式时，很多人的第一反应是写出如下的代码，包括教科书上也是这样
  • 单例模式 香水浓 java
    懒汉  调用getInstance方法时实例化 public class Singleton { private static Singleton instance; private Singleton() {} public static synchronized Singleton getInstance() { if(null == ins
  • 安装Apache问题：系统找不到指定的文件 No installed service named "Apache2" AdyZhang apachehttp server
    安装Apache问题：系统找不到指定的文件 No installed service named "Apache2" 每次到这一步都很小心防它的端口冲突问题，结果，特意留出来的80端口就是不能用，烦。 解决方法确保几处： 1、停止IIS启动 2、把端口80改成其它 （譬如90，800，，，什么数字都好） 3、防火墙(关掉试试) 在运行处输入 cmd 回车，转到apa
  • 如何在android 文件选择器中选择多个图片或者视频？ aijuans android
    我的android app有这样的需求，在进行照片和视频上传的时候，需要一次性的从照片/视频库选择多条进行上传 但是android原生态的sdk中，只能一个一个的进行选择和上传。 我想知道是否有其他的android上传库可以解决这个问题，提供一个多选的功能，可以使checkbox之类的，一次选择多个 处理方法 官方的图片选择器(但是不支持所有版本的androi，只支持API Level
  • mysql中查询生日提醒的日期相关的sql baalwolf mysql
    SELECT sysid,user_name,birthday,listid,userhead_50,CONCAT(YEAR(CURDATE()),DATE_FORMAT(birthday,'-%m-%d')),CURDATE(),  dayofyear( CONCAT(YEAR(CURDATE()),DATE_FORMAT(birthday,'-%m-%d')))-dayofyear(
  • MongoDB索引文件破坏后导致查询错误的问题 BigBird2012 mongodb
    问题描述： MongoDB在非正常情况下关闭时，可能会导致索引文件破坏，造成数据在更新时没有反映到索引上。 解决方案：   使用脚本，重建MongoDB所有表的索引。 var names = db.getCollectionNames(); for( var i in names ){ var name = names[i]; print(name);
  • Javascript Promise bijian1013 JavaScriptPromise
            Parse JavaScript SDK现在提供了支持大多数异步方法的兼容jquery的Promises模式，那么这意味着什么呢，读完下文你就了解了。 一.认识Promises         “Promises”代表着在javascript程序里下一个伟大的范式，但是理解他们为什么如此伟大不是件简
  • [Zookeeper学习笔记九]Zookeeper源代码分析之Zookeeper构造过程 bit1129 zookeeper
       Zookeeper重载了几个构造函数，其中构造者可以提供参数最多，可定制性最多的构造函数是     public ZooKeeper(String connectString, int sessionTimeout, Watcher watcher, long sessionId, byte[] sessionPasswd, boolea
  • 【Java命令三】jstack bit1129 jstack
    jstack是用于获得当前运行的Java程序所有的线程的运行情况(thread dump），不同于jmap用于获得memory dump   [hadoop@hadoop sbin]$ jstack Usage: jstack [-l] <pid> (to connect to running process) jstack -F
  • jboss 5.1启停脚本　动静分离部署 ronin47
    以前启动jboss，往各种xml配置文件，现只要运行一句脚本即可。start nohup sh /**/run.sh -c servicename  -b ip -g  clustername   -u broatcast jboss.messaging.ServerPeerID=int  -Djboss.service.binding.set=p
  • UI之如何打磨设计能力? brotherlamp UIui教程ui自学ui资料ui视频
      在越来越拥挤的初创企业世界里，视觉设计的重要性往往可以与杀手级用户体验比肩。在许多情况下，尤其对于 Web 初创企业而言，这两者都是不可或缺的。前不久我们在《右脑革命：别学编程了，学艺术吧》中也曾发出过重视设计的呼吁。如何才能提高初创企业的设计能力呢?以下是 9 位创始人的体会。 1.找到自己的方式 如果你是设计师，要想提高技能可以去设计博客和展示好设计的网站如D-lists或
  • 三色旗算法 bylijinnan java算法
    import java.util.Arrays; /** 问题： 假设有一条绳子，上面有红、白、蓝三种颜色的旗子，起初绳子上的旗子颜色并没有顺序， 您希望将之分类，并排列为蓝、白、红的顺序，要如何移动次数才会最少，注意您只能在绳 子上进行这个动作，而且一次只能调换两个旗子。 网上的解法大多类似： 在一条绳子上移动，在程式中也就意味只能使用一个阵列，而不使用其它的阵列来
  • 警告:No configuration found for the specified action: \'s chiangfai configuration
    1.index.jsp页面form标签未指定namespace属性。 <!--index.jsp代码--> <%@taglib prefix="s" uri="/struts-tags"%> ... <s:form action="submit" method="post"&g
  • redis -- hash_max_zipmap_entries设置过大有问题 chenchao051 redishash
    使用redis时为了使用hash追求更高的内存使用率，我们一般都用hash结构，并且有时候会把hash_max_zipmap_entries这个值设置的很大，很多资料也推荐设置到1000，默认设置为了512，但是这里有个坑   #define ZIPMAP_BIGLEN 254 #define ZIPMAP_END 255     /* Return th
  • select into outfile access deny问题 daizj mysqltxt导出数据到文件
    本文转自：http://hatemysql.com/2010/06/29/select-into-outfile-access-deny%E9%97%AE%E9%A2%98/ 为应用建立了rnd的帐号，专门为他们查询线上数据库用的，当然，只有他们上了生产网络以后才能连上数据库，安全方面我们还是很注意的，呵呵。 授权的语句如下： grant select on armory.* to rn
  • phpexcel导出excel表简单入门示例 dcj3sjt126com PHPExcelphpexcel
    <?php error_reporting(E_ALL); ini_set('display_errors', TRUE); ini_set('display_startup_errors', TRUE);   if (PHP_SAPI == 'cli') die('This example should only be run from a Web Brows
  • 美国电影超短200句 dcj3sjt126com 电影
    1. I see． 我明白了。2. I quit! 我不干了!3. Let go! 放手!4. Me too． 我也是。5. My god! 天哪!6. No way! 不行!7. Come on． 来吧(赶快)8. Hold on． 等一等。9. I agree。 我同意。10. Not bad． 还不错。11. Not yet． 还没。12. See you． 再见。13. Shut up!
  • Java访问远程服务 dyy_gusi httpclientwebservicegetpost
        随着webService的崛起，我们开始中会越来越多的使用到访问远程webService服务。当然对于不同的webService框架一般都有自己的client包供使用，但是如果使用webService框架自己的client包，那么必然需要在自己的代码中引入它的包，如果同时调运了多个不同框架的webService，那么就需要同时引入多个不同的clien
  • Maven的settings.xml配置 geeksun settings.xml
    settings.xml是Maven的配置文件，下面解释一下其中的配置含义： settings.xml存在于两个地方： 1.安装的地方：$M2_HOME/conf/settings.xml 2.用户的目录：${user.home}/.m2/settings.xml 前者又被叫做全局配置，后者被称为用户配置。如果两者都存在，它们的内容将被合并，并且用户范围的settings.xml优先。
  • ubuntu的init与系统服务设置 hongtoushizi ubuntu
    转载自：  http://iysm.net/?p=178 init Init是位于/sbin/init的一个程序，它是在linux下，在系统启动过程中，初始化所有的设备驱动程序和数据结构等之后，由内核启动的一个用户级程序，并由此init程序进而完成系统的启动过程。 ubuntu与传统的linux略有不同，使用upstart完成系统的启动，但表面上仍维持init程序的形式。 运行
  • 跟我学Nginx+Lua开发目录贴 jinnianshilongnian nginxlua
    使用Nginx+Lua开发近一年的时间，学习和实践了一些Nginx+Lua开发的架构，为了让更多人使用Nginx+Lua架构开发，利用春节期间总结了一份基本的学习教程，希望对大家有用。也欢迎谈探讨学习一些经验。    目录 第一章 安装Nginx+Lua开发环境 第二章 Nginx+Lua开发入门 第三章 Redis/SSDB+Twemproxy安装与使用 第四章 L
  • php位运算符注意事项 home198979 位运算PHP&
    $a = $b = $c = 0; $a & $b = 1; $b | $c = 1  问a,b,c最终为多少?   当看到这题时，我犯了一个低级错误，误 以为位运算符会改变变量的值。所以得出结果是1 1 0 但是位运算符是不会改变变量的值的，例如： $a=1;$b=2; $a&$b;  这样a,b的值不会有任何改变
  • Linux shell数组建立和使用技巧 pda158 linux
    1.数组定义 　　[chengmo@centos5 ~]$ a=(1 2 3 4 5) 　　[chengmo@centos5 ~]$ echo $a 　　1 　　一对括号表示是数组，数组元素用“空格”符号分割开。 　　 2.数组读取与赋值 　　得到长度： 　　[chengmo@centos5 ~]$ echo ${#a[@]} 　　5 　　用${#数组名[@或
  • hotspot源码(JDK7) ol_beta javaHotSpotjvm
    源码结构图，方便理解：   ├─agent                            Serviceab
  • Oracle基本事务和ForAll执行批量DML练习 vipbooks oraclesql
    基本事务的使用： 从账户一的余额中转100到账户二的余额中去，如果账户二不存在或账户一中的余额不足100则整笔交易回滚 select * from account; -- 创建一张账户表 create table account( -- 账户ID id number(3) not null, -- 账户名称 nam
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他