FFT(DFT)-C语言源码

最新推荐文章于 2021-05-17 15:22:51 发布
最新推荐文章于 2021-05-17 15:22:51 发布
阅读量2k 收藏 19
点赞数 3
分类专栏： 算法 文章标签： 算法 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/ysu_wangli/article/details/104347951
版权

一、介绍；
最近在做控制中发现，信号的频谱分析是对于做控制的学生或者工作者来说举足轻重。傅立叶变换，说白了，就是将时间域信号转换成频域信号。看待数据问题的方式不同而已。
DFT（Discrete Fourier Transform）离散傅立叶变化，在实际应用中99%都是处理离散情况，所以更加需要关注。DFT的计算方式比较简单，理解起来也很容易，这里不做赘述。FFT（Fast Fourier Transform）快速傅立叶变换，目的是提高DFT的计算速度，理论上没有任何创新。
其他作者C代码地址

二、实例；
傅立叶变换、DFT、FFT的理论，需要先自行学习，然后才能看懂代码。
DFT理论介绍
FFT理论介绍
这里直接使用C语言编写的实际例子来进行对比。写的不够严谨，发现问题请指正。
原文如下；这里只针对采样点个数等于：N = 2^M情况，如果N != 2^M，在后面补0凑成2的M次幂即可。

/*Heard Files 头文件---------------------*/
#include  "typedef.h"
#include  <string.h>
#include  <math.h>
#include  <stdlib.h>

/*Mecro Define 宏定义--------------------*/
#define  N    (1<<8)
#define  FS  (1<<8)
#define  F1  ( 4)
#define  F2  (12)


/*Struct&Union 结构体&联合体-------------*/
typedef struct {
	f32  value;
	f32  frq;
	f32  real;
	f32  imag;
	f32  ampl;
} S_POINT;

typedef struct {
	f32  real;
	f32  imag;
} S_COMPLEX;



/*Gloable Veriable 全局变量--------------------*/
S_POINT    g_PointParam[N] = { 0 };
S_COMPLEX  g_FFTParam[N]  = { 0 };
u16        g_FFTNum = 0 ;

/*Internel Veriable 局部变量--------------------*/
S_COMPLEX * pW = 0;

/*Gloable Function 全局函数--------------------*/
void main(void);
void DFT(void);
void FFT(void);


/*Internel Function 内部函数--------------------*/
void  ChangePlace(void);
void  FFTCaculate(void);
void  ComplexMul(S_COMPLEX Target1 , S_COMPLEX Target2 , S_COMPLEX * pResult );
void  ComplexAdd(S_COMPLEX Target1, S_COMPLEX Target2  , S_COMPLEX * pResult );
void  ComplexSub(S_COMPLEX Target1, S_COMPLEX Target2  , S_COMPLEX * pResult );





/**************************************************
*函数名称：void main(void)
*输入：无
*输出：无
*备注：2020-02-16
**************************************************/
void main(void) 
{
	printf("start\n");

	DFT();
	FFT();
	while (1) {
		;
	}
}



/**************************************************
*函数名称：void DFT(void)
*输入：无
*输出：无
*备注：2020-02-16
**************************************************/
void DFT(void)
{
	//0.0  局部变量
	u16  i = 0;
	u16  j = 0;

	//1.0  开始标志
	printf("FDT\n");

	//2.0  参数复位
	memset(g_PointParam, 0, sizeof(S_POINT)*N);

	//1.0  输入参数
	for ( i = 0; i < N; i++) {
		g_PointParam[i].value = 10*sin( 2*PI*F1*i/FS ) + 10 * sin(2 * PI*F2*i / FS);
	}

	//2.0  计算DFT
	for (i = 0; i < N; i++) {
		g_PointParam[i].real = 0;
		g_PointParam[i].imag = 0;
		g_PointParam[i].ampl = 0;
		for (j = 0; j < N; j++) {
			g_PointParam[i].real += g_PointParam[j].value * cos(2 * PI / N*i*j);
			g_PointParam[i].imag -= g_PointParam[j].value * sin(2 * PI / N*i*j);
		}
		g_PointParam[i].ampl = sqrt(g_PointParam[i].real*g_PointParam[i].real + g_PointParam[i].imag*g_PointParam[i].imag);
		g_PointParam[i].frq  = (f32)i * FS / N;
	}

	//3.0  结果打印
	for (i = 0; i < N/2; i++) {
		printf("N= %d,Frq =%0.1f,AMP =%0.1f\n", i, g_PointParam[i].frq, g_PointParam[i].ampl);
	}
}




/**************************************************
*函数名称：void FFT(void)
*输入：无
*输出：无
*备注：2020-02-16
**************************************************/
void FFT(void)
{
	//0.0  局部变量
	u16  i = 0;
	u16  j = 0;
	f32 mReultFrq ;
	f32 mReultAmp ;

	//1.0  开始标志
	printf("FFT\n");

	//2.0  参数复位
	memset(g_FFTParam, 0, sizeof(S_COMPLEX)*N);

	//1.0  输入参数
	for (i = 0; i < N; i++) {
		g_FFTParam[i].real = 10 * sin(2 * PI*F1*i / FS) + 10 * sin(2 * PI*F2*i / FS);
		g_FFTParam[i].imag = 0 ;
	}
	pW = (S_COMPLEX *)malloc(sizeof(S_COMPLEX) * N);  // 保存 ( cos(2*pi/N*i) - j sin(2*pi/N*i) )计算值

	//2.0  计算器W值
	for (i = 0; i < N; i++) {
		pW[i].real =  cos(2 * PI / N * i);
		pW[i].imag = -sin(2 * PI / N * i);
	}

	//3.0  计算FFT蝶形层数
	g_FFTNum = log2(N);

	//4.0  原数据交换位置，推到过程与交换规则可以百度
	ChangePlace();

	//5.0  计算FFT值
	FFTCaculate();

	//6.0  输出结果
	for ( i = 0; i < N / 2; i++) {
		mReultFrq = (f32)i * FS / N;
		mReultAmp = sqrt(g_FFTParam[i].real*g_FFTParam[i].real + g_FFTParam[i].imag*g_FFTParam[i].imag);
		printf("N= %d,Frq =%0.1f,AMP =%0.1f\n", i, mReultFrq , mReultAmp);
	}
}



/**************************************************
*函数名称：void  ChangePlace(void)
*输入：无
*输出：无
*备注：2020-02-16
**************************************************/
void  ChangePlace(void)
{
	//0.0  局部变量定义
	u16 mNowNum = 0 ;
	u16 j = 0;
	u16 mChangeNum  = 0;
	S_COMPLEX mTemp = {0};

	//1.0  循环查看搜索原序列数据
	for ( mNowNum = 0 ; mNowNum < N; mNowNum++) {
		mChangeNum = 0 ;
		
		for (j = 0; j < g_FFTNum; j++) {    // 每bit位轮流判断是否为1
			if ( (mNowNum&(1 << j)) == (1 << j) ) { // 当前Bit等于1
				mChangeNum += 1 << (g_FFTNum - 1 - j);
			}
		}

		if ( mChangeNum > mNowNum ) {       // 一组数据仅交换一次
			mTemp = g_FFTParam[mChangeNum];
			g_FFTParam[mChangeNum] = g_FFTParam[mNowNum];
			g_FFTParam[mNowNum]    = mTemp;
		}
	}
}


/**************************************************
*函数名称：void  FFTCaculate(void)
*输入：无
*输出：无
*备注：2020-02-16
**************************************************/
void  FFTCaculate(void)
{
	u16  mNowLayerTick = 0; // 层数计数器
	u16  mButterflyContinuNum = 0; // 碟型连续乘法次数
	u16  mButterflyTick = 0;// 碟型计数器
	u16  mButterflyContinuTick = 0;// 碟型连续乘法计数器
	S_COMPLEX  mTemp = {0};

	//1.0  循环层次
	for (mNowLayerTick = 0; mNowLayerTick < g_FFTNum ; mNowLayerTick++) {
		mButterflyContinuNum = 1 << mNowLayerTick; // 1个碟型连续计算次数
		for (mButterflyTick = 0; mButterflyTick < N; mButterflyTick += mButterflyContinuNum * 2) { // 碟型个数循环
			for ( mButterflyContinuTick = 0 ; mButterflyContinuTick < mButterflyContinuNum ; mButterflyContinuTick ++) {// 当前碟型内部计算
				ComplexMul( g_FFTParam[ mButterflyTick + mButterflyContinuTick + mButterflyContinuNum], pW[ mButterflyContinuTick * (1<<( g_FFTNum - 1 -  mNowLayerTick))], &mTemp );
				ComplexSub( g_FFTParam[ mButterflyTick + mButterflyContinuTick ], mTemp , &g_FFTParam[mButterflyTick + mButterflyContinuTick + mButterflyContinuNum] );
				ComplexAdd( g_FFTParam[mButterflyTick + mButterflyContinuTick]  , mTemp , &g_FFTParam[mButterflyTick + mButterflyContinuTick] );	
			}
		}
	}
}



/**************************************************
*函数名称：void  ComplexMul(S_COMPLEX Target1 , S_COMPLEX Target2 , S_COMPLEX * pResult );
*输入：无
*输出：无
*备注：2020-02-16
**************************************************/
void  ComplexMul(S_COMPLEX Target1, S_COMPLEX Target2, S_COMPLEX * pResult)
{
	pResult->real = Target1.real * Target2.real - Target1.imag * Target2.imag;
	pResult->imag = Target1.real * Target2.imag + Target2.real * Target1.imag;
}

/**************************************************
*函数名称：void  ComplexAdd(S_COMPLEX Target1 , S_COMPLEX Target2 , S_COMPLEX * pResult );
*输入：无
*输出：无
*备注：2020-02-16
**************************************************/
void  ComplexAdd(S_COMPLEX Target1, S_COMPLEX Target2, S_COMPLEX * pResult)
{
	pResult->real = Target1.real + Target2.real ;
	pResult->imag = Target1.imag + Target2.imag ;
}


/**************************************************
*函数名称：void  ComplexSub(S_COMPLEX Target1 , S_COMPLEX Target2 , S_COMPLEX * pResult );
*输入：无
*输出：无
*备注：2020-02-16
**************************************************/
void  ComplexSub(S_COMPLEX Target1, S_COMPLEX Target2, S_COMPLEX * pResult)
{
	pResult->real = Target1.real - Target2.real;
	pResult->imag = Target1.imag - Target2.imag;
}

附录文件：h文件，帮助对C不熟悉的朋友。

/**********************************************
*文件名称：typedef.h
*文件内容：定义工程中的通用类型
*备    注：2020-02-16 wangli
***********************************************/
#pragma once
#ifndef  TYPE_DEF_H
#define  TYPE_DEF_H
/*Heard Files 头文件 ---------------------------------------*/
#include <stdio.h>

/*Macro Define 宏定义 ---------------------------------------*/
#define  PI  (3.1415)

/*struct&union 结构体&union等定义 --------------------------*/
typedef unsigned char   u8  ;
typedef signed char     s8  ;
typedef unsigned short  u16 ;
typedef signed short    s16 ;
typedef unsigned int    u32 ;
typedef signed int      s32 ;
typedef unsigned long   u64 ;
typedef signed long     s64 ;
typedef float           f32 ;
typedef double          f64 ;



#endif
【C语言实现快速傅里叶变换（FFT）算法】
weixin_50961821的博客
02-26 662
傅里叶变换是一种将信号从时域转换到频域的数学变换。
用c 代码来研究 dft(discrete fourier transform)
最新发布
hjjdebug的专栏
06-24 1004
甲: DFT 的定义： 乙: 下面给出用c代码实现的dft 公式， 验证了手工计算的正确性. 丙：理解还不够深刻? 再来一段程序，专门创建所需要的信号及采样数据. 丁： 利用程序进行试验 试验1: 创建一个1k赫兹的频率信号,数据格式S16,幅度{-30000,30000}用16k赫兹的采用频率采样. 试验2: 用上边数据(1khz信号，16k采样频率)，取16个点进行dft 运算，查看其频谱输出 试验3: 仍然用1khz,16k采样频率,但窗口size取32点，计算其dft, 此时频率分辨率是0.5khz
DFT源代码程序
07-23
DFT源代码程序，可以直接使用和根据自己的修改使用
用C语言实现DFT算法
热门推荐
姚明明的博客
01-22 1万+
一. 简介 离散傅里叶变换（Discrete Fourier Transform，缩写为DFT），是傅里叶变换在时域和频域上都呈离散的形式，将信号的时域采样变换为其DTFT的频域采样。在形式上，变换两端（时域和频域上）的序列是有限长的，而实际上这两组序列都应当被认为是离散周期信号的主值序列。即使对有限长的离散信号作DFT，也应当将其看作其周期延拓的变换。 X（k）=∑n=0N−1x(n)exp(−...
《C》C语言实现DFT算法
杨贵安的博客
01-20 9460
一、什么是DFT？ 在计算机机上实现信号的频谱分析及其他方面的处理工作时，对型号的要求是：在时域和频域都应是离散的，且都应是有限长。由于e(±j2πNnk)e(\pm j \frac{2\pi}{N} nk)e(±jN2π​nk)相对n和k都是以N为周期的，X(k)和x(n)为傅里叶变化对，即DFT。 DFT并不是一个新的傅里叶变换形式，它实际上来自于DFS，只不过仅在时域频域各取一个周期而已，由...
离散傅里叶变换(DFT) C代码
07-31
是《数字信号处理C语言程序集》的DFT的C语言源代码，已测试！
fft-dft-opencl:在OpenCL中实现DFT和FFT
05-13
在OpenCL中实现离散傅立叶变换（DFT）和快速傅立叶变换（FFT）是一项关键的技术，尤其对于那些需要在FPGA（Field-Programmable Gate Array）上进行高效并行计算的应用。OpenCL是一种开放标准的并行编程框架，允许...
FFT的C语言实现代码
02-24
快速傅里叶变换 (fast Fourier transform), 即利用计算机计算离散傅里叶变换（DFT)的高效、快速计算方法的统称，简称FFT。本程序以C语言为平台，实现了按时间抽取的基-2FFT算法（蝶形算法）。具体见...
fft.rar_C语言FFt 优化_FFT源码_fft 优化处理
09-24
快速傅立叶变换（Fast Fourier Transform，简称FFT）是一种高效的计算离散傅立叶变换（Discrete Fourier Transform，DFT）及其逆变换的方法。在数字信号处理、图像处理、音频处理等领域有着广泛应用。C语言实现的FFT...
FFT-Analysis.rar_fft c语言
09-22
根据压缩包子文件的文件名称"FFT Analysis.doc"，我们可以推测这可能是一个文档，详细介绍了FFT的理论基础、实现步骤，或者是对提供的C语言源码的解释和分析。通常，这样的文档会包含FFT的基本概念，如DFT（离散...
fft.rar_fft的C语言代码
09-14
**快速傅里叶变换(FFT)是数字信号处理领域中的一种高效算法，用于计算离散傅里叶变换(DFT)及其逆变换。FFT算法通过分解问题的大小来减少计算复杂度，从DFT的O(n^2)降低到O(n log n)。** 在C语言中实现FFT，主要涉及...
C语言DFT计算
04-01
C语言实现计算DFT的程序，有部分注释，子函数与主函数分布
FFT源代码，C语言编写
04-01
快速傅里叶变换源代码，自己编写，实现了DIT和DIF两种算法。时间复杂度O(nlogn)。
DFT FFT 的C语言实现方法及程序
09-17
用C语言实现DFT FFT 变化及计算相位谱和频谱！
FFT源码
03-17
FFT 源码，C语言实现，信号处理中有用！
c语言编写的dft idft fft ifft，自然序，绝对可以用。
09-16
一分钱一分货。我编写fft和ifft的时候，下载了好多，结果都不能用。花了几十币。
FFT源代码
jwy2014的专栏
07-15 2516
 源码表示编辑 在C环境下的源码 源码（1）： 注：亲测，这个版本无法运行，作者删改了重要内容[1] 请参考源码（2） //快速傅立叶变换 // 入口参数： // l: l=0, 傅立叶变换;l=1, 逆傅立叶变换 // il: il=0,不计算傅立叶变换或逆变换模和幅角；il=1,计算模和幅角 // n: 输入的点数，为偶数，一般为32，64，128，...,1024等
C++实现简单的离散傅里叶变换（DFT），附源代码
qq_20115319的博客
12-30 2571
MyDFT.h #pragma once #include <complex> #include <vector> using namespace std; //Copyright (c) 2020 FuZhixiang class DFT { public: static void dft(std::vector<std::complex<double> >& vec, bool inverse); private: static std::ve
c语言 fft程序,FFT算法的使用说明与C语言版实现源码
weixin_29358811的博客
05-17 1086
/*********************************************************************快速福利叶变换C程序包函数简介：此程序包是通用的快速傅里叶变换C语言函数，移植性强，以下部分不依赖硬件。此程序包采用联合体的形式表示一个复数，输入为自然顺序的复数(输入实数是可令复数虚部为0)，输出为经过FFT变换的自然顺序的复数.此程序包可在初始化时调用cr...
FFT-C快速傅里叶变换C语言源码解读
快速傅里叶变换（Fast Fourier Transform，简称FFT）是一种高效的计算离散傅里叶变换（Discrete Fourier Transform，简称DFT）及其逆变换的算法。FFT的出现极大地提高了傅里叶变换的计算效率，从而使得复杂的信号...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值