Java中实现快速傅里叶变换FFT

最新推荐文章于 2024-07-24 17:27:32 发布
最新推荐文章于 2024-07-24 17:27:32 发布
阅读量4.4k 收藏 32
点赞数 7
分类专栏： 电子信息 文章标签： java 算法 数字信号处理 信号处理 快速傅立叶变换
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LeeDuoZuiShuai/article/details/105603121
版权

Java中实现快速傅里叶变换FFT

一.概述

1.傅里叶变换(FT)

      傅里叶变换是将一个满足条件的函数表示成三角函数或其积分的线性组合。
      实际应用中，将一个随时间变化的信号，经过傅里叶变换，可以得到这个信号的频率组成，实现从时域到频域的变换，进而研究其频谱结构和变化规律。
      傅里叶变换表明：一个信号可以表示成多个不同频率的正弦波的叠加。

2.离散傅里叶变换(DFT)

      对一个连续的时域信号以一定的频率进行采样，可以得到这个信号时域的一组采样点，通过对这些采样点进行离散傅里叶变换，可以得到这个信号对应频域的一组采样点。
在这里插入图片描述
由公式可以得出离散傅里叶变换的时间复杂度为O(n2)。

3.快速傅里叶变换(FFT)

      快速傅里叶变换是对离散傅里叶变换进行快速计算的一种方法。可以将时间复杂度降低到O(nlog2n)，因此称为快速傅里叶变换。

1）单位根

      在一个复平面内将单位圆平均分成n份，这n个点表示的复数称为n次单位根。
在这里插入图片描述
其中k = 0，1，2，…n-1，方向逆时针。
在这里插入图片描述
单位根的性质：
在这里插入图片描述

2）快速傅里叶变换的思想

      将DFT公式的求和符号去掉，变成相加的多项式A。用单位根替换旋转因子，将展开式中的项分成奇数项展开式A1和偶数项展开式A0，通过利用单位根的性质，可以将奇数项展开式A1和偶数项展开式A0化简为相同的单位根和x(n)相乘的形式，通过将奇数项展开式A1和偶数项展开式A0中的x(n)分别和单位根相乘，最后再将两部分相加，可以求出X(K)的值。
      进一步，可以将奇数项展开式A1再分成奇数项展开式A11和偶数项展开式A10，偶数项展开式A0也再分成奇数项展开式A01和偶数项展开式A00，一直向下分，最后分成只包含两项的展开式，使问题的规模变小，最后向上计算，求出X(K)。
      因此快速傅里叶变换的时间复杂度为O(nlog2n)。
eg：设对于某个信号的一组16点采样值为 0，1，2，3，4，5，6，7，8，9，10，11，12，13，14，15。
第一次奇偶分组：0，2，4，6，8，10，12，14 | 1，3，5，7，9，11，13，15
第二次奇偶分组：0，4，8，12 | 2，6，10，14 | 1，5，9，13 | 3，7，11，15
第三次奇偶分组：0，8 | 4，12 | 2，10 | 6，14 | 1，9 | 5，13 | 3，11 | 7，15

设对于某个信号的一组8点采样值为 0，1，2，3，4，5，6，7，8。
第一次奇偶分组：0，2，4，6 | 1，3，5，7
第二次奇偶分组：0，4 | 2，6 | 1，5 | 3，7

      通过观察可以发现，对采样点对应位置的索引的二进制形式进行镜像操作，再还原成十进制形式，可以获得采样点在奇偶分组后的位置。

原位置二进制表示镜像表示分组后位置
00000000
10011004
20100102
30111106
41000011
51011015
61100113
71111117

3）蝶形图

      将奇数项和偶数项的展开式从下向上计算的过程，可以通过画图来表示，由于该图形似蝴蝶，故称为蝶形图。

快速傅里叶变换：
在这里插入图片描述

4）快速傅里叶变换的逆变换(IFFT)

      对信号频域的采样点进行快速傅里叶变换的逆变换，可以得到信号在时域对应的采样点。
      具体实现就是快速傅里叶变换蝶形计算的逆过程，但是其单位根为快速傅里叶变换单位根的共轭形式，同时，每次计算后结果要除以2。
快速傅里叶变换的逆变换：
在这里插入图片描述

二.代码实现

1.复数的实现

1）复数的表示

private float realPart;
private float imaginaryPart;
	
public ComplexNumber(float realPart, float imaginaryPart) {
	this.realPart = realPart;
	this.imaginaryPart = imaginaryPart;
}

2）复数的运算

      复数的运算包括加、减、乘、除和共轭运算。在实际应用中，两个复数进行运算后的结果可以存储在调用的对象中，但为了防止数据污染，也可能需要存储在一个新的对象中。其它的计算包括计算复数的幅值(模)和相位。

存储在新对象中：

//加法
public ComplexNumber addNew(ComplexNumber addend) {
	if(addend == null) 
		return new ComplexNumber(this.realPart, this.imaginaryPart);
	return new ComplexNumber(this.realPart+addend.realPart, this.imaginaryPart+addend.imaginaryPart);
}

//减法
public ComplexNumber subtractNew(ComplexNumber subtrahend) {
	if(subtrahend == null) 
		return new ComplexNumber(this.realPart, this.imaginaryPart);
	return new ComplexNumber(this.realPart-subtrahend.realPart, this.imaginaryPart-subtrahend.imaginaryPart);
}

//乘法
public ComplexNumber multiplyNew(ComplexNumber multiplier) {
	if(multiplier == null) 
		return new ComplexNumber(this.realPart, this.imaginaryPart);
	float newRealPart = this.realPart*multiplier.realPart - this.imaginaryPart*multiplier.imaginaryPart;
	float newImaginaryPart = this.realPart*multiplier.imaginaryPart + this.imaginaryPart*multiplier.realPart;
	return new ComplexNumber(newRealPart, newImaginaryPart);
}

//除法
public ComplexNumber divideNew(ComplexNumber divisor) {
	if(divisor == null) 
		return new ComplexNumber(this.realPart, this.imaginaryPart);
	float sumBase = (float) (Math.pow(divisor.realPart, 2) + Math.pow(divisor.imaginaryPart, 2));
	float newRealPart = (this.realPart*divisor.realPart + this.imaginaryPart*divisor.imaginaryPart)/sumBase;
	float newImaginaryPart = (this.realPart*divisor.imaginaryPart - this.imaginaryPart*divisor.realPart)/sumBase;
	return new ComplexNumber(newRealPart, newImaginaryPart);
}

//共轭
public ComplexNumber conjugateNew() {
	return new ComplexNumber(this.realPart, -this.imaginaryPart);
}

存储在调用的对象中：

//加法
public ComplexNumber add(ComplexNumber addend) {
	if(addend == null)
		return this;
	this.realPart += addend.realPart;
	this.imaginaryPart += addend.imaginaryPart;
	return this;
}

//减法
public ComplexNumber subtract(ComplexNumber subtrahend) {
	if(subtrahend == null)
		return this;
	this.realPart -= subtrahend.realPart;
	this.imaginaryPart -= subtrahend.imaginaryPart;
	return this;
}

//乘法
public ComplexNumber multiply(ComplexNumber multiplier) {
	if(multiplier == null) 
		return this;
	float newRealPart = this.realPart*multiplier.realPart - this.imaginaryPart*multiplier.imaginaryPart;
	float newImaginaryPart = this.realPart*multiplier.imaginaryPart + this.imaginaryPart*multiplier.realPart;
	this.realPart = newRealPart;
	this.imaginaryPart = newImaginaryPart;
	return this;
}

//除法
public ComplexNumber divide(ComplexNumber divisor) {
	if(divisor == null) 
		return this;
	float sumBase = (float) (Math.pow(divisor.realPart, 2) + Math.pow(divisor.imaginaryPart, 2));
	float newRealPart = (this.realPart*divisor.realPart + this.imaginaryPart*divisor.imaginaryPart)/sumBase;
	float newImaginaryPart = (this.imaginaryPart*divisor.realPart - this.realPart*divisor.imaginaryPart)/sumBase;
	this.realPart = newRealPart;
	this.imaginaryPart = newImaginaryPart;
	return this;
}

//共轭
public ComplexNumber conjugate() {
	this.imaginaryPart = -this.imaginaryPart;
	return this;
}

计算幅值和相位：

//幅度
public float getAmplitude() {
	return (float) Math.sqrt(Math.pow(realPart, 2)+Math.pow(imaginaryPart, 2)); 
}

//相位
public float getPhase() {
	if(realPart == 0) {
		if(imaginaryPart == 0)
			return 0;
		else if(imaginaryPart>0)
			return (float) (Math.PI/2);
		else
			return (float) (-Math.PI/2);
	}else {
		return (float) Math.atan(imaginaryPart/realPart);
	}	
}

3）复数数组

      由于快速傅里叶变换涉及到大量数据的处理，若采用上述定义的复数的数组形式进行数据的存储，会消耗大量的内存，因此需要更高效的数据结构来存储多个复数。
      这里采用两个数组来存复数，一个存储复数的所有实部，另一个存储虚部。

private float[] realArray;
private float[] imaginaryArray;
private int size;

public ComplexNumberArray(int size) {
	if(size<= 0) {
		this.size = 128;
		realArray = new float[this.size];
		imaginaryArray = new float[this.size];
	}else {
		this.size = size;
		realArray = new float[size];
		imaginaryArray = new float[size];
	}
}

      同样的，我们也需要定义复数数组的相关的运算和计算。通过指定对应复数的索引来对数组中的复数进行操作。

2.单位根的实现

1）单位根的计算

private int n;
private List<ComplexNumber> rootList;

private void calculate() {
	for(int k=0;k<=n;k++) {
		float unit = (float) (2 * Math.PI  * k / n);
		rootList.add(new ComplexNumber((float)Math.cos(unit), -(float)Math.sin(unit)));
	}
}

2）获取单位根时的处理

      需要利用单位根的性质。

public ComplexNumber getUnitRoot(int n ,int k) {
	if(this.n == n) {
		return rootList.get(k);
	}else if(this.n>n) {
		int multiple = this.n/n;
		return rootList.get(k*multiple);
	}else if(this.n<n) {
		int multiple = n/this.n;
		return rootList.get(k/multiple);
	}
	return null;
}

3.快速傅里叶变换的实现

1）索引插值

      对于两点采样点分组后位置为：0，1
      对于四点采样点分组后位置为：0，2，1，3
      对于八点采样点分组后位置为：0，4，2，6， 1，5， 3，7
      对于十六点采样点分组后位置为：0，8，4，12，2，10，6，14，1，9，5，13，3，11，7，15

      通过观察可以发现：
      四点为两点在0后和1后进行插值，插的值为前一个值加上2的1次方。
      八点为四点在0、2、1、3后进行插值，插的值为前一个值加上2的2次方。
      十六点同理。
      即：n点采样点分组后位置为n/2点采样点分组后位置每个位置后插入前一个值和2的((√n)-1)次方的和。

//创建奇偶分类后的索引
private int[] createIndex(int n) {
	int[] index = new int[n];
	int left = 0;
	int middle = n/2;
	int right = n;
	index[left] = 0;
	index[middle] = 1;
	createIndexMerge(index,left,middle,1);
	createIndexMerge(index,middle,right,1);
	return index;
}
//递归调用
private void createIndexMerge(int[] index, int left ,int right, int multiple) {
	if(right - left<=1) return;
	int value = (int) Math.pow(2, multiple);
	int middle = (right+left)/2;
	index[middle]=(index[left]+value);
	createIndexMerge(index,left,middle,multiple+1);
	createIndexMerge(index,middle,right,multiple+1);
}

2）数据奇偶分组

      根据上一步产生的位置信息，对数据进行排序。为了不污染原数据，用新的数组来进行排序。

//根据索引内容将数据进行重排序
//用于FFT
private  float[] sortDataByIndexFFT(float[] data) {
	clearArray(sortedFFTData);
	for(int i=0;i<index.length;i++) {
		int p = index[i];
		sortedFFTData[i] = data[p];
	}
	return sortedFFTData;
}

3）确定循环次数

      以八点采样点的快速傅里叶变换为例子，观察蝶形图，需要进行3次大交叉计算，第一个交叉计算涉及2个点，计算2次，一共需要重复4次。第二个交叉计算涉及4个点，计算4次，一共需要重复八次。第三次交叉计算涉及8个点，计算8次，一共需要重复以此。
      即：n点采样点的快速傅里叶变换，需要进行(√n)次计算。k = 1,2,3…,√n。
      第k次交叉计算涉及2的k次方个点，计算2的k次方次，一共需要重复n除以(2的k次方)次。
在这里插入图片描述

4）核心计算

      将每一次计算的数据平均分成上部分和下部分，每次计算分别从上部分和下部分相同次序处各取一个数据，上部分数据对下部分数据与对应单位根的乘积做和，结果存放在当前上部分数据的位置。上部分数据对下部分数据与对应单位根的乘积做差，结果存放在当前下部分数据的位置。

//快速傅里叶变换
public  ComplexNumberArray fft(float[] data) {
	sortedFFTData = sortDataByIndexFFT(data);
	ComplexNumberArray complexNumberArray = createComplexNumberArray(sortedFFTData);
	
	for(int i=1;i<=flyTime;i++) {
		//每次蝶形运算中数据的数量
		int teamSize = (int)(Math.pow(2, i));
		//大蝶形运算中需要计算的组数
		int teams = size/teamSize;
	    for(int j=0;j<teams;j++) {
	    	int start1 = j*teamSize;
	    	int start2 = start1+teamSize/2;
	    	for(int k=0;k<teamSize/2;k++) {
	    		//核心计算
	    		complexNumberArray.multiply(start2, root.getUnitRoot(teamSize, k));
	    		ComplexNumber cNum = complexNumberArray.getComplexNumber(start2);
	    		complexNumberArray.setComplexNumber(start2, complexNumberArray.getRealPart(start1), complexNumberArray.getImaginaryPart(start1));
	    		complexNumberArray.add(start1, cNum);
	    		complexNumberArray.subtract(start2, cNum);

	    		start1++;
	    		start2++;
	    	}
	    }
	}
	return complexNumberArray;
}

三.获取全部代码

      https://github.com/HolyCrazy/FFT/

LeeDuo.
关注
  • 7
    点赞
  • 踩
  • 32
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
推荐使用：高效多线程Java FFT库 - JTransforms
gitblog_00050的博客
05-08 539
推荐使用：高效多线程Java FFT库 - JTransforms 项目地址:https://gitcode.com/wendykierp/JTransforms 1、项目介绍 JTransforms是一个创新的开源项目，它是首个纯Java编写的多线程快速傅里叶变换（FFT）库。该项目不仅提供了快速傅里叶变换，还支持离散余弦变换（DCT）、离散正弦变换（DST）和离散哈特利变换（DHT）。JTra...
卡尔曼滤波 -- 从推导到应用(一)
热门推荐
知行合一
12-30 24万+
前言 卡尔曼滤波器是在估计线性系统状态的过程中，以最小均方差为目的而推导出的几个递推数学等式,也可以从贝叶斯推断的角度来推导。 本文将分为两部分： 第一部分，结合例子，从最小均方差的角度，直观地介绍卡尔曼滤波的原理，并给出较为详细的数学推导。 第二部分，通过两个例子给出卡尔曼滤波的实际应用。其中将详细介绍一个匀加速模型，并直观的对比系统状态模型的建立对滤波的影响。
快速傅里叶变换 FFT (Fast Fourier Transformation)介绍，包含java和C++实现
12-18
快速傅里叶变换 FFT (Fast Fourier Transformation)介绍，包含java和C++实现。快速傅里叶变换 FFT (Fast Fourier Transformation)介绍，包含java和C++实现。快速傅里叶变换 FFT (Fast Fourier Transformation)介绍，包含java和C++实现。快速傅里叶变换 FFT (Fast Fourier Transformation)介绍，包含java和C++实现。
完整java版本的傅里叶变换函数（FFT）
qq_37699867的博客
03-06 4003
本函数完全是基于Java语言及其相关计算工具包完成，已经应用与实际。 众所周知，当我们需要对信号进行分析时，基本都会用到傅里叶变化函数，但是基于Java平台缺少相关的傅里叶函数，或者有的工具包里面虽然有包，但是在实际计算的时候却出现问题。因此需要自己根据傅里叶变换的原理写出相关函数，这样更加靠谱。傅里叶变换作用就是将时域波形转换到频域以观察信号的规律
java频谱计算的工具类
liangshui999的博客
06-12 1801
直接上代码，逻辑还算比较清楚 public class SpectrumHelper { /** * 计算频谱 * @param data 采样数据 * @param samplingInterval 采样间隔,以秒为单位 * @param needFillZero 是否需要补零 * @param flyLen 参与傅里叶变换的长度 ...
java fft_java实现快速傅里叶变换（FFT）
weixin_35959379的博客
02-12 1217
最近做音频信号处理的时候，需要对数据做fft变换。关于fft原理：请参考：FFT算法讲解——麻麻我终于会FFT了！matlab实现fft函数很简单，直接调用fft即可。但java实现起来就有点难了。参考了比较好两篇java实现的博客：A.Java实现算法导论中快速傅里叶变换FFT递归算法B.快速傅里叶变换及java实现通过比对。A博客只实现了数组长度是2的幂次的函数，其他就没有实现，B博客是实现了...
Java/C++实现快速傅里叶变换（FFT）
爱玲姐姐的博客
12-09 4717
快速傅里叶变换不是一种新的变换，而是傅里叶变换的一种快速算法，这个算法可以将普通的离散傅里叶变换（DFT）的时间复杂度O（n*n）降到O（n log n），大大提高了傅里叶变换的速度。快速傅里叶变换算法的提出，使傅里叶变换在通信领域得到了极大地运用和发展。 在ACM中，快速傅里叶变换通常用于大数的乘法。当两个数大到连JAVA的BI都无法承受时，就该使用快速傅里叶算法了。该算法是将...
java实现傅里叶变换FFT
05-25
可以加到项目中，实现傅里叶变换；有一篇关于傅里叶的博客讲的特别好，推荐大家仔细看看https://blog.csdn.net/l494926429/article/details/51818012
快速傅里叶变换-Java代码实现
03-29
本篇文章将详细介绍如何使用Java语言实现快速傅里叶变换，并探讨相关知识点。 一、离散傅里叶变换（DFT） 离散傅里叶变换是连续傅里叶变换在离散时间上的近似，它将一个序列的离散点表示转换为它的频域表示。对于一...
JAVA实现对FFT变换的带通滤波算法
04-18
此代码为博客文中代码，博文地址：https://blog.csdn.net/systemlsy/article/details/89373321，主要实现对JAVA的FFT（快速傅里叶变换）并对其进行带通滤波。
fft:Java 的快速傅里叶余弦变换
06-30
它包含以下纯 Java 实现： 一维快速傅立叶变换 二维快速傅立叶变换 一维快速余弦变换 二维快速余弦变换 一维变换仅对长度为 2 的幂的向量进行操作。 2D 变换仅在大小为 2 的幂的方阵上运行。 建造： $蚂蚁 运行：...
快速傅里叶变换及java实现
mvksfg的博客
06-13 1万+
傅里叶变换是一种线性的积分变换。它的理论依据是：任何连续周期信号都可以由一组适当的正弦曲线组合而成，即使用简单的正弦、余弦函数（如sinx,Acos(ωx+θ)）,可以拟合复杂函数。
JavaScript：实现FFT快速傅立叶变换算法(附完整源码)
希望我的博客，能帮上你解决学习中工作中所遇到的问题
08-01 356
JavaScript：实现FFT快速傅立叶变换算法(附完整源码)
12. Hibernate 模板设计模式
这是一个web全栈开发的博客，取其精华去其糟粕，争取让大家一看就懂，一学就会，一用就成~
07-22 1108
如何运用模板设计模式重构 Hibernate 操作流程；持久化对象与序列化接口；OOP中有一个编码原则 ：写仅写一次。翻译过来就是，不要重复，要重用。答案是：使用模板设计模式进一步封装Hibernate的操作。在真实项目中，Hibernate仅仅只是完成项目中的一部分工作，需要和其它，如Spring等框架联合工作，一起承担整体项目的开发。Spring框架中就提供的有Hibernate模板对象。一个常规的、频繁的操作代码中，大部分代码不需要变动，只有小部分代码需要根据需求变动。
redis+spring面试题
github_36510643的博客
07-21 363
redis+spring面试题
Java-Lambda
lizhiwei21的博客
07-21 425
lambda表达式可以理解为对匿名内部类的一种简化 , 但是本质是有区别的面向对象思想 :强调的是用对象去完成某些功能函数式编程思想 :强调的是结果 , 而不是怎么去做。
Promise 详解（原理篇）
山重水复疑无路，柳暗花明又一村。
07-20 754
Promise 是一种异步编程的解决方案。在异步操作中，callback 会导致回调地狱的问题，Promise 解决了这个问题。一个 Promise对象有以下三种状态:pending：初始状态，既不是成功，也不是失败状态。：意味着操作成功完成。rejected：意味着操作失败。当 new Promise() 被实例化后，即表示 Promise 进入 pending 初始化状态，准备就绪，等待运行。
Java读取文件中多个JSON对象，并且16进制字符串和byte相互转换，将byte转为16进制字符串并写入json文件
最新发布
weixin_43561432的博客
07-24 101
【代码】Java读取文件中多个JSON对象，并且16进制字符串和byte相互转换，将byte转为16进制字符串并写入json文件。
java实现快速傅里叶变换FFT(附完整源码)
06-08
下面是Java实现快速傅里叶变换FFT的完整源码： ```java public class FFT { public static Complex[] fft(Complex[] a) { int n = a.length; // base case if (n == 1) return new Complex[] { a[0] }; // radix 2 Cooley-Tukey FFT if (n % 2 != 0) { throw new IllegalArgumentException("n is not a power of 2"); } // fft of even terms Complex[] even = new Complex[n/2]; for (int k = 0; k < n/2; k++) { even[k] = a[2*k]; } Complex[] q = fft(even); // fft of odd terms Complex[] odd = even; // reuse the array for (int k = 0; k < n/2; k++) { odd[k] = a[2*k + 1]; } Complex[] r = fft(odd); // combine Complex[] y = new Complex[n]; for (int k = 0; k < n/2; k++) { double kth = -2 * k * Math.PI / n; Complex wk = new Complex(Math.cos(kth), Math.sin(kth)); y[k] = q[k].plus(wk.times(r[k])); y[k + n/2] = q[k].minus(wk.times(r[k])); } return y; } } ``` 使用方法： ```java Complex[] a = new Complex[8]; a[0] = new Complex(1, 0); a[1] = new Complex(2, 0); a[2] = new Complex(3, 0); a[3] = new Complex(4, 0); a[4] = new Complex(5, 0); a[5] = new Complex(6, 0); a[6] = new Complex(7, 0); a[7] = new Complex(8, 0); Complex[] b = FFT.fft(a); for (int i = 0; i < b.length; i++) { System.out.println(b[i]); } ``` 其中，Complex类表示复数，可以自己实现或引用Java内置的Complex类。这里的fft方法实现了Cooley-Tukey FFT算法，时间复杂度为O(n log n)。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值