package com.maths;

import java.util.ArrayList;

/**
 * Class for circular convolution of two discrete signals using the convolution theorem.
 *
 * @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());
        }
    }

    /**
     * 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);

        /* 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)

        FFTBluestein.fftBluestein(convolved, true);          //IFFT

        return convolved;
    }
}