数字信号处理 DIT-FFT和IFFT的 C语言程序实现

最新推荐文章于 2024-05-06 09:17:28 发布
最新推荐文章于 2024-05-06 09:17:28 发布
阅读量1.1w 收藏 46
点赞数 6
分类专栏： C语言 文章标签： fft ifft c语言 matlab
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35154082/article/details/72931452
版权

一、MATLAB的FFT、IFFT方法

通过MATLAB，来检验输入序列的FFT、IFFT，判断C语言程序的正确性

matlab的FFT IFFT方法

说明：以下资源来源于《数字信号处理的MATLAB实现》万永革主编

一.调用方法

X=FFT(x)；

X=FFT(x，N)；

x=IFFT(X);

x=IFFT(X,N)

 

用MATLAB进行谱分析时注意：

（1）函数FFT返回值的数据结构具有对称性。

例：

N=8;

n=0:N-1;

xn=[4 3 2 6 7 8 9 0];

Xk=fft(xn)

Xn=ifft(Xk)

Xk与xn的维数相同，共有8个元素。Xk的第一个数对应于直流分量，即频率值为0。

（2）做FFT分析时，幅值大小与FFT选择的点数有关，但不影响分析结果。在IFFT时已经做了处理。要得到真实的振幅值的大小，只要将得到的变换后结果乘以2除以N即可。

二、C语言程序实现DIT-FFT和IFFT

1、宏定义

#include<stdio.h>

#include<math.h>

#define uint unsigned int

#define uchar unsigned char

2、复数定义和运算

typedef struct Complex//复数结构体

{

       doubleRe;

       doubleIm;

}Complex;

Complex Mul(Complex a,Complex b)//复数相乘

{

       Complexc;

       c.Re=a.Re*b.Re-a.Im*b.Im;

       c.Im=a.Re*b.Im+a.Im*b.Re;

       returnc;

}

Complex Plus(Complex a,Complex b)//复数相加

{

       Complexc;

       c.Re=a.Re+b.Re;

       c.Im=a.Im+b.Im;

       returnc;

}

Complex Sub(Complex a,Complex b)//复数相减

{

       Complexc;

       c.Re=a.Re-b.Re;

       c.Im=a.Im-b.Im;

       returnc;

}

3、倒序运算

通过两种方法进行倒序运算，第一个倒序运算子程序Invert_order(uint N,Complex *x,uchar M)是对数组中的每一个数，进行二进制的移位运算，求出数组的倒序；第二个倒序运算子程序Invert_order(uint N,Complex *x)是按照教材上的内容进行编写的，主要是对倒序规律进行分析，直接将数组中的数进行交换。此报告中的程序采用了第二种方法。

/******************************************************************************************

函数说明：倒序运算

参数说明：N点数，等于2的M次方，*x序列的首地址

返回值：无

******************************************************************************************/

/*void Invert_order(uint N,Complex *x,ucharM)

{

       uintpower,i,j,m,tempp;//m是i的倒位序数

       Complextemp;//是临时变量

       for(i=0;i<N;i++)

       {

              power=1;

              m=0;

              for(j=0;j<M;j++)

              {

                     tempp=i;

                     tempp>>=(M-1-j);//C语言 n>>=1 中的>>=意思是先将变量n的各个二进制位顺序右移1位，最高位补二进制0，然后将这个结果再复制给n。

                     if(tempp&0x01)//判断tempp最后一位是不是1

                     {

                            m=m+power;

                     }

                     power=power*2;

              }

              if(i<m)

              {

                     temp.Im=x[i].Im;

                     temp.Re=x[i].Re;

                     x[i].Re=x[m].Re;

                     x[i].Im=x[m].Im;

                     x[m].Im=temp.Im;

                  x[m].Re=temp.Re;

              }

              for(n=0;n<N;n++)

              {

              if(x[n].Re<-10000000)

              {

                     x[n].Re=0;

              }

              if(x[n].Im<-10000000)

              {

                     x[n].Im=0;

              }

       }

}*/

void Invert_order(uint N,Complex *x)

{

       intLH,j,N1,i,k,n;

       ComplexT;

       LH=N/2;

       j=LH;

       N1=N-2;

       for(i=1;i<=N1;i++)

       {

              if(i<j)

              {

                     T.Im=x[i].Im;

                     T.Re=x[i].Re;

                     x[i].Re=x[j].Re;

                     x[i].Im=x[j].Im;

                     x[j].Im=T.Im;

                  x[j].Re=T.Re;

              }

              k=LH;

              while(j>=k)

              {

                     j=j-k;

                     k=k/2;

              }

              j=j+k;

       }

       for(n=0;n<N;n++)

       {

              if(x[n].Re<-10000000)

              {

                     x[n].Re=0;

              }

              if(x[n].Im<-10000000)

              {

                     x[n].Im=0;

              }

       }

}

/******************************************************************************************

Invert_order函数结束：

******************************************************************************************/

4、指数和对数运算

/******************************************************************************************

函数说明：指数运算

参数说明：BaseNumber底数,IndexNumber指数

返回值：无符号整数

******************************************************************************************/

uint Pow(uchar BaseNumber,uint IndexNumber)

{

       uintm=1;//指数函数值

       uchari;

       for(i=0;i<IndexNumber;i++)

       {

              m=BaseNumber*m;

       }

       returnm;

}

/******************************************************************************************

Pow函数结束：

******************************************************************************************/

 

/******************************************************************************************

函数说明：对数运算

参数说明：BaseNumber底数,AntiNumber真数

返回值：无符号整数

******************************************************************************************/

 

uint Log(uchar BaseNumber,uint AntiNumber)

{

       uintm=0;//对数函数值

       while(1)

       {

              AntiNumber=AntiNumber/BaseNumber;

              if(AntiNumber)m++;

              elsebreak;

       }

       returnm;

}

/******************************************************************************************

log函数结束：

******************************************************************************************/

5、DIT-FFT的C语言程序

先从第一级开始，逐级进行，共进行M级运算。然后在进行第L级运算时，求出每一级的旋转因子。最后一层循环，求出每个旋转因子对应的所有蝶形。

/******************************************************************************************

函数说明：按时间抽取基二快速傅里叶算法

参数说明：N点数，等于2的M次方，*x序列的首地址

返回值：无

******************************************************************************************/

void Dit2Fft(uint N,Complex *x)

{

       inti;

       Complextemp;//临时复数变量

       uintL,M=Log(2,N);//M级蝶形图

       uintk,j;

       uintStepLength;//k值步长

       uintBank ;//两点间的距离

       constdouble pai=3.1415926;

       doubleps;

       uintr;//旋转因子的幂

       ComplexW;//旋转因子

       for(L=1;L<=M;L++)//从第一级开始，逐级进行，共进行M级运算

       {

              StepLength=Pow(2,L);

              Bank=StepLength/2;

              for(j=0;j<=Bank-1;j++)//求出每一级的旋转因子

              {

                     r=Pow(2,M-L)*j;

                     ps=2*pai/N*r;

                     W.Re=cos(ps);

                     W.Im=-sin(ps);

                     for(k=j;k<=N-1;k=k+StepLength)//求出每个旋转因子对应的所有蝶形

                     {

                            Complexx_temp;

                            x_temp=Mul(W,x[k+Bank]);

                            temp=Plus(x[k],x_temp);

                            x[k+Bank]=Sub(x[k],x_temp);

                            x[k].Re=temp.Re;

                            x[k].Im=temp.Im;

                     }

              }

       }

}

/******************************************************************************************

Dit2Fft函数结束：

******************************************************************************************/

6、IFFT的C语言程序

傅里叶反变换算法也有两种算法，第一种是求旋转因子的-kn，再乘1/N。

第二种是直接调用FFT程序，先将X(k)取共轭，然后直接调用FFT子程序，最后对FFT结果取共轭并乘以1/N。即

此报告中的程序采用了第一种方法。

/******************************************************************************************

函数说明：傅里叶反变换算法

参数说明：N点数，等于2的M次方，*x序列的首地址

返回值：无

1、求旋转因子的-kn，再乘1/N

2、x(n)=IFFT[x(k)]=1/N*{FFT[x*(k)]}*

******************************************************************************************/

void Ifft1(uint N,Complex *x)//1、求旋转因子的-kn，再乘1/N

{

       inti;

       Complextemp;//临时复数变量

       uintL,M=Log(2,N);//M级蝶形图

       uintk,j;

       uintStepLength;//k值步长

       uintBank ;//两点间的距离

       constdouble pai=3.1415926;

       doubleps;

       uintr;//旋转因子的幂

       ComplexW;//旋转因子

       Invert_order(N,x);//位倒序输入

       for(L=1;L<=M;L++)

       {

              StepLength=Pow(2,L);

              Bank=StepLength/2;

              for(j=0;j<=Bank-1;j++)

              {

                     r=Pow(2,M-L)*j;

                     ps=2*pai/N*r;

                     W.Re=cos(ps);

                     W.Im=sin(ps);//改变旋转因子

                     for(k=j;k<=N-1;k=k+StepLength)

                     {

                            Complexx_temp;

                            x_temp=Mul(W,x[k+Bank]);

                            temp=Plus(x[k],x_temp);

                            x[k+Bank]=Sub(x[k],x_temp);

                            x[k].Re=temp.Re;

                            x[k].Im=temp.Im;

                     }

              }

       }

       for(k=0;k<N;k++)

       {

              x[k].Re=x[k].Re/N;

              x[k].Im=x[k].Im/N;

       }

}

 

void Ifft2(uint N,Complex *x)//2、x(n)=IFFT[x(k)]=1/N*{FFT[x*(k)]}*

{

       uintk;

       Invert_order(N,x);//位倒序输入

       for(k=0;k<N;k++)

       {

              x[k].Re=x[k].Re;

              x[k].Im=-x[k].Im;

       }

       Dit2Fft(N,x);//直接调用FFT

       for(k=0;k<N;k++)

       {

              x[k].Re=x[k].Re;

              x[k].Im=-x[k].Im;

       }

       for(k=0;k<N;k++)

       {

              x[k].Re=x[k].Re/N;

              x[k].Im=x[k].Im/N;

       }

}

/******************************************************************************************

Ifft函数结束：

******************************************************************************************/

7、main函数

#define DATA_LEN 1024//设定数据长度为1024

void main()

{

       uinty[10]={0,1,2,3,4,5,6,7,8,9};//学号

       uintN,M;

       inti,j,k;

       Complexx[DATA_LEN];

       N=DATA_LEN;

       M=Log(2,N);

       printf("初始序列:\n");

       for(i=0;i<DATA_LEN/10;i++)//长度为DATA_LEN的学号

       {

              for(j=0,k=0;j<10;j++,k=j+i*10)

              {

              x[k].Im=0;

              x[k].Re=y[j];

              printf("%lf%lfi\n",x[k].Re,x[k].Im);

              }

       }

       for(i=k,j=0;i<DATA_LEN&&j<(DATA_LEN-k);i++,j++)

       {

              x[i].Im=0;

              x[i].Re=y[j];

              printf("%lf%lfi\n",x[i].Re,x[i].Im);

       }

       printf("\n");

       Invert_order(N,x);//倒序第一种算法Invert_order(N,x,M);(使用需将子程序块注释更换)

       Dit2Fft(N,x);

       printf("FFT运算后的序列:\n");

       for(i=0;i<DATA_LEN;i++)//FFT后再次输出

       {

              printf("%lf%lfi",x[i].Re,x[i].Im);

              printf("\n");

       }

       printf("\n");

       Ifft1(N,x);//IFFT的第二种算法Ifft2(N,x);

       printf("IFFT运算后的序列:\n");

       for(i=0;i<DATA_LEN;i++)//IFFT后再次输出

       {

              printf("%lf%lfi",x[i].Re,x[i].Im);

              printf("\n");

       }

       printf("\n");

}

完整代码如下

/*matlab的FFT IFFT方法
说明：以下资源来源于《数字信号处理的MATLAB实现》万永革主编
一.调用方法
X=FFT(x)；
X=FFT(x，N)；
x=IFFT(X);
x=IFFT(X,N)

用MATLAB进行谱分析时注意：
（1）函数FFT返回值的数据结构具有对称性。
例：
N=8;
n=0:N-1;
xn=[4 3 2 6 7 8 9 0];
Xk=fft(xn)
Xn=ifft(Xk)
Xk与xn的维数相同，共有8个元素。Xk的第一个数对应于直流分量，即频率值为0。
（2）做FFT分析时，幅值大小与FFT选择的点数有关，但不影响分析结果。在IFFT时已经做了处理。要得到真实的振幅值的大小，只要将得到的变换后结果乘以2除以N即可。
*/
#include
   
   
    
    
#include
    
    
     
     
#define uint unsigned int
#define uchar unsigned char

typedef struct Complex//复数结构体
{
	double Re;
	double Im;
}Complex;

Complex Mul(Complex a,Complex b)//复数相乘
{
	Complex c;
	c.Re=a.Re*b.Re-a.Im*b.Im;
	c.Im=a.Re*b.Im+a.Im*b.Re;
	return c;
}

Complex Plus(Complex a,Complex b)//复数相加
{
	Complex c;
	c.Re=a.Re+b.Re;
	c.Im=a.Im+b.Im;
	return c;
}

Complex Sub(Complex a,Complex b)//复数相减
{
	Complex c;
	c.Re=a.Re-b.Re;
	c.Im=a.Im-b.Im;
	return c;
}

/******************************************************************************************

函数说明：倒序运算

参数说明：N点数，等于2的M次方，*x序列的首地址

返回值：无

******************************************************************************************/
/*void Invert_order(uint N,Complex *x,uchar M)
{
	uint power,i,j,m,tempp;//m是i的倒位序数
	Complex temp;//是临时变量
	for(i=0;i<N;i++)
	{
		power=1;
		m=0;
		for(j=0;j
     
     
      
      >=(M-1-j);//C语言 n>>=1 中的>>=意思是先将变量n的各个二进制位顺序右移1位，最高位补二进制0，然后将这个结果再复制给n。
			if(tempp&0x01)//判断tempp最后一位是不是1
			{
				m=m+power;
			}
			power=power*2;
		}
		if(i<m)
		{
			temp.Im=x[i].Im;
			temp.Re=x[i].Re;
			x[i].Re=x[m].Re;
			x[i].Im=x[m].Im;
			x[m].Im=temp.Im;
		    x[m].Re=temp.Re;
		}
		for(n=0;n<N;n++)
		{
		if(x[n].Re<-10000000)
		{
			x[n].Re=0;
		}
		if(x[n].Im<-10000000)
		{
			x[n].Im=0;
		}
	}
}*/
void Invert_order(uint N,Complex *x)
{
	int LH,j,N1,i,k,n;
	Complex T;
	LH=N/2;
	j=LH;
	N1=N-2;
	for(i=1;i<=N1;i++)
	{
		if(i
      
      
       
       =k)
		{
			j=j-k;
			k=k/2;
		}
		j=j+k;
	}
	for(n=0;n<N;n++)
	{
		if(x[n].Re<-10000000)
		{
			x[n].Re=0;
		}
		if(x[n].Im<-10000000)
		{
			x[n].Im=0;
		}
	}
}

/******************************************************************************************

Invert_order函数结束：

******************************************************************************************/

/******************************************************************************************

函数说明：指数运算

参数说明：BaseNumber底数,IndexNumber指数

返回值：无符号整数

******************************************************************************************/

uint Pow(uchar BaseNumber,uint IndexNumber)
{
	uint m=1;//指数函数值
	uchar i;
	for(i=0;i<IndexNumber;i++)
	{
		m=BaseNumber*m;
	}
	return m;
}

/******************************************************************************************

Pow函数结束：

******************************************************************************************/

/******************************************************************************************

函数说明：对数运算

参数说明：BaseNumber底数,AntiNumber真数

返回值：无符号整数

******************************************************************************************/

uint Log(uchar BaseNumber,uint AntiNumber)
{
	uint m=0;//对数函数值
	while(1)
	{
		AntiNumber=AntiNumber/BaseNumber;
		if(AntiNumber)m++;
		else break;
	}
	return m;
}

/******************************************************************************************

log函数结束：

******************************************************************************************/

/******************************************************************************************

函数说明：按时间抽取基二快速傅里叶算法

参数说明：N点数，等于2的M次方，*x序列的首地址

返回值：无

******************************************************************************************/

void Dit2Fft(uint N,Complex *x)
{
	int i;
	Complex temp;//临时复数变量
	uint L,M=Log(2,N);//M级蝶形图
	uint k,j;
	uint StepLength;//k值步长
	uint Bank ;//两点间的距离
	const double pai=3.1415926;
	double ps;
	uint r;//旋转因子的幂
	Complex W;//旋转因子
	for(L=1;L<=M;L++)
	{
		StepLength=Pow(2,L);
		Bank=StepLength/2;
		for(j=0;j<=Bank-1;j++)
		{
			r=Pow(2,M-L)*j;
			ps=2*pai/N*r;
			W.Re=cos(ps);
			W.Im=-sin(ps);
			for(k=j;k<=N-1;k=k+StepLength)
			{
				Complex x_temp;
				x_temp=Mul(W,x[k+Bank]);
				temp=Plus(x[k],x_temp);
				x[k+Bank]=Sub(x[k],x_temp);
				x[k].Re=temp.Re;
				x[k].Im=temp.Im;
			}
		}
	}
}

/******************************************************************************************

Dit2Fft函数结束：

******************************************************************************************/
/******************************************************************************************

函数说明：傅里叶反变换算法

参数说明：N点数，等于2的M次方，*x序列的首地址

返回值：无

1、求旋转因子的共轭，再乘1/N
2、x(n)=IFFT[x(k)]=1/N*{FFT[x*(k)]}*
******************************************************************************************/

void Ifft1(uint N,Complex *x)
{
	int i;
	Complex temp;//临时复数变量
	uint L,M=Log(2,N);//M级蝶形图
	uint k,j;
	uint StepLength;//k值步长
	uint Bank ;//两点间的距离
	const double pai=3.1415926;
	double ps;
	uint r;//旋转因子的幂
	Complex W;//旋转因子
	Invert_order(N,x);//位倒序输入
	for(L=1;L<=M;L++)
	{
		StepLength=Pow(2,L);
		Bank=StepLength/2;
		for(j=0;j<=Bank-1;j++)
		{
			r=Pow(2,M-L)*j;
			ps=2*pai/N*r;
			W.Re=cos(ps);
			W.Im=sin(ps);
			for(k=j;k<=N-1;k=k+StepLength)
			{
				Complex x_temp;
				x_temp=Mul(W,x[k+Bank]);
				temp=Plus(x[k],x_temp);
				x[k+Bank]=Sub(x[k],x_temp);
				x[k].Re=temp.Re;
				x[k].Im=temp.Im;
			}
		}
	}
	for(k=0;k<N;k++)
	{
		x[k].Re=x[k].Re/N;
		x[k].Im=x[k].Im/N;
	}
}

void Ifft2(uint N,Complex *x)
{

	uint k;
	Invert_order(N,x);//位倒序输入
	for(k=0;k<N;k++)
	{
		x[k].Re=x[k].Re;
		x[k].Im=-x[k].Im;
	}
	Dit2Fft(N,x);
	for(k=0;k<N;k++)
	{
		x[k].Re=x[k].Re;
		x[k].Im=-x[k].Im;
	}
	for(k=0;k<N;k++)
	{
		x[k].Re=x[k].Re/N;
		x[k].Im=x[k].Im/N;
	}
}
/******************************************************************************************

Ifft函数结束：

******************************************************************************************/

#define DATA_LEN 1024
void main()
{
	uint y[10]={0,1,2,3,4,5,6,7,8,9};//学号
	uint N,M;
	int i,j,k;
	Complex x[DATA_LEN];
	N=DATA_LEN;
	M=Log(2,N);
	printf("初始序列:\n");
	for(i=0;i<DATA_LEN/10;i++)//长度为N的学号
	{
		for(j=0,k=0;j<10;j++,k=j+i*10)
		{
		x[k].Im=0;
		x[k].Re=y[j];
		printf("%lf %lfi\n",x[k].Re,x[k].Im);
		}
	}
	for(i=k,j=0;i<DATA_LEN&&j<(DATA_LEN-k);i++,j++)
	{
		x[i].Im=0;
		x[i].Re=y[j];
		printf("%lf %lfi\n",x[i].Re,x[i].Im);
	}
	printf("\n");
	Invert_order(N,x);//Invert_order(N,x,M);
	Dit2Fft(N,x);
	printf("FFT运算后的序列:\n");
	for(i=0;i<DATA_LEN;i++)//FFT后再次输出
	{
		printf("%lf %lfi",x[i].Re,x[i].Im);
		printf("\n");
	}
	printf("\n");
	Ifft1(N,x);//Ifft2(N,x);
	printf("IFFT运算后的序列:\n");
	for(i=0;i<DATA_LEN;i++)//IFFT后再次输出
	{
		printf("%lf %lfi",x[i].Re,x[i].Im);
		printf("\n");
	}
	printf("\n");
}

YvonneMYF
关注
  • 6
    点赞
  • 踩
  • 46
    收藏
    觉得还不错? 一键收藏
  • 6
    评论
专栏目录
实验二:fft算法的matlab实现_C语言系列之FFT算法实现
weixin_39973410的博客
12-03 2628
0x10 序言 长文预警，详细介绍FFT算法的编程原理和C实现，并在文章的最后附上了本文的所有源代码。0x11 速览1）FFT背后的数学原理2）码位倒序3）蝶形运算设计4）利用复数FFT编写复数IFT，实数FFT和实数IFFT5）总结0x20 FFT背后的数学原理01前言本文阅读前提知识准备：已经初步了解傅里叶变换。傅里叶变换公式： 本文不刨根问底，只讲跟FFT编程相关必须知道的知识，相...
FFT及IFFT的C语言实现
01-29
对照西电版本的《数字信号处理》，实现了FFT和IFFT的运算，懂一点原理的都能看懂该函数，经过测试是可以用的。
用C语言写的FFT和IFFT算法
SharenFish的博客
11-29 1401
我自己写的1024点CFFT小工具; 此CFFT算法为第一版，在算法模型上可以继续优化运算速度，生成的程序段长度也可以继续精简 ; 但是我保证了在我能轻松愉快地编程的能力范围内，这是兼顾了运算精度与运算速度的最佳版本，如果要继续优化代码的话那我感觉就很难受 了; 下面是工具的测试和使用例，以及头文件： 1. #define _CRT_SECURE_NO_WARNINGS #include <stdio.h> #include "cfft.h" #define PO
利用FFT模块求IFFT
最新发布
u010672293的博客
05-06 363
（2）进行FFT计算；（1）将输入取共轭；（3）将输出取共轭；
利用C语言实现FFT、IFFT运算
热门推荐
mddh_123的博客
11-01 1万+
一、FFT、IFFT算法实现 上述分别为FFT、IFFT公式。下面首先讨论FFT的算法实现。本文采用输入逆序、输出顺序的FFT计算方法。**实质上就是在时域对x(n)进行“奇偶分类”、在频域上对X(k)进行“前后分类”。**值得说明的是，这里的“奇”和“偶”是相对的概念，并不完全是通常我们所理解的“奇”和“偶”。下面将给出一个例子进行说明： ...
C 实现FFT与IFFT
小马哔哔
07-30 1170
说明 本代码根据网上的例程整理，具体出处已无从考察 库代码 FFT.h #ifndef __FFT_H_ #define __FFT_H_ #ifdef __cplusplus extern "C" { #endif #include <math.h> #define PI 3.1415926535897932384626433832795028841971f //定义圆周率值 typedef struct compx {float real,imag;}
DIT-FFT算法c语言实现
02-06
在给定的文件“fft”中，可能包含了使用C语言实现的DIT-FFT算法，包括了上述的各个步骤和细节。这个实现可以帮助读者理解FFT的工作原理，并为他们提供一个可复用的代码基础，以便在自己的项目中使用或扩展。通过阅读...
dit-fft.c.zip_dit-fft_fft.c_makingbis
09-19
在标题“dit-fft.c.zip_dit-fft_fft.c_makingbis”中，"dit-fft"指的是分治算法实现的FFT，而"fft.c"则表明包含了一个名为"fft.c"的C语言源代码文件，该文件很可能实现了FFT算法。"makingbis"可能是编译或构建过程的...
数字图像处理(8):实现FFT快速算法(C语言)
ZhaoDongyu_AK47的博客
06-26 5745
文章目录1. 实验内容1.1 使用平台及语言1.2 代码流程1.3 FFT、IFFT2. 实验结果2.1 输入图片及其频谱2.2 进行低频滤波2.3 去除直流分量2.4 低频滤波2.5 高频滤波2.6 进一步的高频率波2.7 更进一步的高频滤波3. 遇到的问题及收获3.1 问题一3.2 问题二3.3 问题三附代码： 1. 实验内容 1.1 使用平台及语言 使用平台：VS2015 语言：C语言 1.2 代码流程 其中，对频谱图像进行了一三、二四象限的对调，这样便于观察分析。 1.3 FFT、IFFT 对图像
定点化FFT与IFFT
03-18
代码是C语言编写的基2时间抽取的fft与ifft定点化函数，方便用于定点DSP处理。
C语言实现FFT和IFFT
05-26
用C语言实现快速付立叶变换和快速付立叶逆变换
FFT 和IFFT基二的C语言和MATLAB实现
12-02
FFT 基二的C语言和MATLAB实现 可以运行，但注释很好结构也很清楚，可作参考
FFT和IFFT的C代码实现
misterdo的专栏
06-05 5752
#include #include #include #define intsize sizeof(int) #define complexsize sizeof(complex) #define PI 3.1415926 int *a,*b; int nLen,init_nLen,mLen,init_mLen,N,M; FILE *dataFile;
用c实现的fft和ifft
sbf2011的专栏
04-06 2244
对百度文库中coffealove的代码进行了如下验证 代码如下#include <stdio.h> #include <math.h> #include <stdlib.h> #define N 1000 typedef struct { double real; double img; }complex; void fft(); /*快速傅里叶
C语言实现FFT or IFFT
梦 醉了谁的博客
03-04 1373
C语言实现FFT or IFFTmatlab实现仿真结果C语言实现仿真结果 matlab实现 close all; clear all; clc; count=2; y=[1+2i,2+3i]; y_FFT=fft(y,count); % 傅里叶变换 P=abs(y_FFT)/count; % 幅度谱 u=max(P); % 得到波束1接收到的信号的幅度值 仿真结果 C语言实现 /************FFT***********/ #include <stdi
FFT原理（基2DIT-FFT）及C语言编程思路及实现
小张爱学习哦的博客
02-07 1万+
基2DIT-FFT原理及c语言编程思路
数字信号处理算法c语言实现,几个数字信号处理算法程序
weixin_42516021的博客
05-24 1974
摘要在学习数字信号处理算法程序中用VC编写的几个通用算法程序。关键词 离散卷积 FIR在学习信号处理的过程中,看到书上的大部分算法都是用Fortan或者Basic实现,于是自己试验着用VC实现了一下。1、卷积计算离散卷积公式的算法实现图1 卷积计算界面1.1 主程序代码(省略了部分不关键代码)void CInterVolveDlg::CalTheNumByArray(){this->Upda...
dit-fft算法c语言实现-c文档类资源-csdn下载
09-18
dit-fft算法是一种基于分治策略的快速傅里叶变换算法。它通过将时域上的信号序列分解成多个较短的子序列，然后对每个子序列进行傅里叶变换，并最终合并得到整个频域上的频谱分析结果。 为了在C语言中实现dit-fft算法，可以按照以下步骤进行： 1. 使用C语言编写一个FFT函数，接受输入信号序列和输出频谱序列。 2. 在FFT函数中，首先根据输入信号序列的长度N，计算出需要进行迭代的次数，使用log2(N)即可得到。 3. 对于每一次迭代，将输入信号序列分解成两部分，分别进入下一级迭代。 4. 使用蝶形算法（Butterfly Algorithm）对每个子序列进行傅里叶变换，并得到频谱序列。 5. 递归合并得到的频谱序列，直到恢复到最初的输入信号序列长度为止。 6. 在主函数中，读取输入信号，调用FFT函数进行傅里叶变换，并将结果输出。 在CSDN等资源网站上，可以找到一些关于dit-fft算法的C语言实现的文档类资源，可以通过下载来学习和参考这些实现代码。这些资源通常提供了完整的实现代码、详细的说明和注释，帮助理解算法原理和实现细节，可以提供很好的学习和参考材料。
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值