algorithm/Java
1
0
Fork 0
mirror of https://github.com/TheAlgorithms/Java.git synced 2025-07-23 20:44:39 +08:00
Code Issues Packages Projects Releases Wiki Activity

Formatted with Google Java Formatter

Browse Source
This commit is contained in:
github-actions
2021-02-26 19:22:37 +00:00
parent 4264e0f045
commit ca2e20707f
5 changed files with 384 additions and 436 deletions
Download Patch File Download Diff File Expand all files Collapse all files

106
Maths/FFTBluestein.java
View File

@ -3,67 +3,59 @@ package com.maths;
import java.util.ArrayList;
/**
* Class for calculating the Fast Fourier Transform (FFT) of a discrete signal using the Bluestein's algorithm.
* Class for calculating the Fast Fourier Transform (FFT) of a discrete signal using the Bluestein's
* algorithm.
*
* @author Ioannis Karavitsis
* @version 1.0
* */
public class FFTBluestein
{
/**
* Bluestein's FFT Algorithm.
*
* More info:
* https://en.wikipedia.org/wiki/Chirp_Z-transform#Bluestein.27s_algorithm
* http://tka4.org/materials/lib/Articles-Books/Numerical%20Algorithms/Hartley_Trasform/Bluestein%27s%20FFT%20algorithm%20-%20Wikipedia,%20the%20free%20encyclopedia.htm
*
* @param x The discrete signal which is then converted to the FFT or the IFFT of signal x.
* @param inverse True if you want to find the inverse FFT.
* */
public static void fftBluestein(ArrayList<FFT.Complex> x, boolean inverse)
{
int N = x.size();
int bnSize = 2*N - 1;
int direction = inverse ? -1 : 1;
ArrayList<FFT.Complex> an = new ArrayList<>();
ArrayList<FFT.Complex> bn = new ArrayList<>();
*/
public class FFTBluestein {
/**
* Bluestein's FFT Algorithm.
*
* <p>More info: https://en.wikipedia.org/wiki/Chirp_Z-transform#Bluestein.27s_algorithm
* http://tka4.org/materials/lib/Articles-Books/Numerical%20Algorithms/Hartley_Trasform/Bluestein%27s%20FFT%20algorithm%20-%20Wikipedia,%20the%20free%20encyclopedia.htm
*
* @param x The discrete signal which is then converted to the FFT or the IFFT of signal x.
* @param inverse True if you want to find the inverse FFT.
*/
public static void fftBluestein(ArrayList<FFT.Complex> x, boolean inverse) {
int N = x.size();
int bnSize = 2 * N - 1;
int direction = inverse ? -1 : 1;
ArrayList<FFT.Complex> an = new ArrayList<>();
ArrayList<FFT.Complex> bn = new ArrayList<>();
/* Initialization of the b(n) sequence (see Wikipedia's article above for the symbols used)*/
for(int i = 0; i < bnSize; i++)
bn.add(new FFT.Complex());
/* Initialization of the b(n) sequence (see Wikipedia's article above for the symbols used)*/
for (int i = 0; i < bnSize; i++) bn.add(new FFT.Complex());
for(int i = 0; i < N; i++)
{
double angle = (i - N + 1) * (i - N + 1) * Math.PI / N * direction;
bn.set(i, new FFT.Complex(Math.cos(angle), Math.sin(angle)));
bn.set(bnSize - i - 1, new FFT.Complex(Math.cos(angle), Math.sin(angle)));
}
/* Initialization of the a(n) sequence */
for(int i = 0; i < N; i++)
{
double angle = -i * i * Math.PI / N * direction;
an.add(x.get(i).multiply(new FFT.Complex(Math.cos(angle), Math.sin(angle))));
}
ArrayList<FFT.Complex> convolution = ConvolutionFFT.convolutionFFT(an, bn);
/* The final multiplication of the convolution with the b*(k) factor */
for(int i = 0; i < N; i++)
{
double angle = -1 * i * i * Math.PI / N * direction;
FFT.Complex bk = new FFT.Complex(Math.cos(angle), Math.sin(angle));
x.set(i, bk.multiply(convolution.get(i + N - 1)));
}
/* Divide by N if we want the inverse FFT */
if(inverse)
{
for (int i = 0; i < N; i++)
{
FFT.Complex z = x.get(i);
x.set(i, z.divide(N));
}
}
for (int i = 0; i < N; i++) {
double angle = (i - N + 1) * (i - N + 1) * Math.PI / N * direction;
bn.set(i, new FFT.Complex(Math.cos(angle), Math.sin(angle)));
bn.set(bnSize - i - 1, new FFT.Complex(Math.cos(angle), Math.sin(angle)));
}
/* Initialization of the a(n) sequence */
for (int i = 0; i < N; i++) {
double angle = -i * i * Math.PI / N * direction;
an.add(x.get(i).multiply(new FFT.Complex(Math.cos(angle), Math.sin(angle))));
}
ArrayList<FFT.Complex> convolution = ConvolutionFFT.convolutionFFT(an, bn);
/* The final multiplication of the convolution with the b*(k) factor */
for (int i = 0; i < N; i++) {
double angle = -1 * i * i * Math.PI / N * direction;
FFT.Complex bk = new FFT.Complex(Math.cos(angle), Math.sin(angle));
x.set(i, bk.multiply(convolution.get(i + N - 1)));
}
/* Divide by N if we want the inverse FFT */
if (inverse) {
for (int i = 0; i < N; i++) {
FFT.Complex z = x.get(i);
x.set(i, z.divide(N));
}
}
}
}