algorithm/Java
1
0
Fork 0
mirror of https://github.com/TheAlgorithms/Java.git synced 2025-07-21 19:14:55 +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

81
Maths/CircularConvolutionFFT.java
View File

@ -7,52 +7,49 @@ import java.util.ArrayList;
*
* @author Ioannis Karavitsis
* @version 1.0
* */
public class CircularConvolutionFFT
{
/**
* This method pads the signal with zeros until it reaches the new size.
*
* @param x The signal to be padded.
* @param newSize The new size of the signal.
* */
private static void padding(ArrayList<FFT.Complex> x, int newSize)
{
if(x.size() < newSize)
{
int diff = newSize - x.size();
for(int i = 0; i < diff; i++)
x.add(new FFT.Complex());
}
*/
public class CircularConvolutionFFT {
/**
* This method pads the signal with zeros until it reaches the new size.
*
* @param x The signal to be padded.
* @param newSize The new size of the signal.
*/
private static void padding(ArrayList<FFT.Complex> x, int newSize) {
if (x.size() < newSize) {
int diff = newSize - x.size();
for (int i = 0; i < diff; i++) x.add(new FFT.Complex());
}
}
/**
* Discrete circular convolution function. It uses the convolution theorem for discrete signals: convolved = IDFT(DFT(a)*DFT(b)).
* Then we use the FFT algorithm for faster calculations of the two DFTs and the final IDFT.
*
* More info:
* https://en.wikipedia.org/wiki/Convolution_theorem
*
* @param a The first signal.
* @param b The other signal.
* @return The convolved signal.
* */
public static ArrayList<FFT.Complex> fftCircularConvolution(ArrayList<FFT.Complex> a, ArrayList<FFT.Complex> b)
{
int convolvedSize = Math.max(a.size(), b.size()); //The two signals must have the same size equal to the bigger one
padding(a, convolvedSize); //Zero padding the smaller signal
padding(b, convolvedSize);
/**
* Discrete circular convolution function. It uses the convolution theorem for discrete signals:
* convolved = IDFT(DFT(a)*DFT(b)). Then we use the FFT algorithm for faster calculations of the
* two DFTs and the final IDFT.
*
* <p>More info: https://en.wikipedia.org/wiki/Convolution_theorem
*
* @param a The first signal.
* @param b The other signal.
* @return The convolved signal.
*/
public static ArrayList<FFT.Complex> fftCircularConvolution(
ArrayList<FFT.Complex> a, ArrayList<FFT.Complex> b) {
int convolvedSize =
Math.max(
a.size(), b.size()); // The two signals must have the same size equal to the bigger one
padding(a, convolvedSize); // Zero padding the smaller signal
padding(b, convolvedSize);
/* Find the FFTs of both signal. Here we use the Bluestein algorithm because we want the FFT to have the same length with the signal and not bigger */
FFTBluestein.fftBluestein(a, false);
FFTBluestein.fftBluestein(b, false);
ArrayList<FFT.Complex> convolved = new ArrayList<>();
/* Find the FFTs of both signal. Here we use the Bluestein algorithm because we want the FFT to have the same length with the signal and not bigger */
FFTBluestein.fftBluestein(a, false);
FFTBluestein.fftBluestein(b, false);
ArrayList<FFT.Complex> convolved = new ArrayList<>();
for(int i = 0; i < a.size(); i++)
convolved.add(a.get(i).multiply(b.get(i))); //FFT(a)*FFT(b)
for (int i = 0; i < a.size(); i++) convolved.add(a.get(i).multiply(b.get(i))); // FFT(a)*FFT(b)
FFTBluestein.fftBluestein(convolved, true); //IFFT
FFTBluestein.fftBluestein(convolved, true); // IFFT
return convolved;
}
return convolved;
}
}