OpenSoure_Repos/TheAlgorithms-C-Plus-Plus
1
0
Fork 0
mirror of https://hub.njuu.cf/TheAlgorithms/C-Plus-Plus.git synced 2023-10-11 13:05:55 +08:00
Code Issues Packages Projects Releases Wiki Activity

clang-format and clang-tidy fixes for a6594c85

Browse Source
This commit is contained in:
github-actions 2021-10-18 18:26:29 +00:00
parent a6594c85c0
commit a8a3f7c6fc
1 changed files with 77 additions and 73 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

150
numerical_methods/fast_fourier_transform.cpp
View File

@ -1,70 +1,75 @@
/**
* @file
* @brief [A fast Fourier transform (FFT)](https://medium.com/@aiswaryamathur/understanding-fast-fouriertransform-from-scratch-to-solve-polynomial-multiplication-8018d511162f) is an algorithm that computes the
* discrete Fourier transform (DFT) of a sequence , or its inverse (IDFT) , this algorithm
* has application in use case scenario where a user wants to find points of a function
* in short period time by just using the coefficents of the polynomial function.
* @brief [A fast Fourier transform
(FFT)](https://medium.com/@aiswaryamathur/understanding-fast-fouriertransform-from-scratch-to-solve-polynomial-multiplication-8018d511162f)
is an algorithm that computes the
* discrete Fourier transform (DFT) of a sequence , or its inverse (IDFT) , this
algorithm
* has application in use case scenario where a user wants to find points of a
function
* in short period time by just using the coefficents of the polynomial
function.
* @details
* https://medium.com/@aiswaryamathur/understanding-fast-fourier-transform-from-scratch-to
-solve-polynomial-multiplication-8018d511162f
* @author [Ameya Chawla](https://github.com/ameyachawlaggsipu)
*/
#include <iostream> /// for IO operations
#include<cmath> /// for mathematical-related functions
#include <complex> /// for storing points and coefficents
#include <cassert> /// for assert
#include <vector> /// for storing test cases
#include <cassert> /// for assert
#include <cmath> /// for mathematical-related functions
#include <complex> /// for storing points and coefficents
#include <iostream> /// for IO operations
#include <vector> /// for storing test cases
/**
* @brief FastFourierTransform is a recursive function which returns list of complex numbers
* @brief FastFourierTransform is a recursive function which returns list of
* complex numbers
* @param p List of Coefficents in form of complex numbers
* @param n Count of elements in list p
* @returns p if n==1
* @returns y if n!=1
*/
std::complex<double>* FastFourierTransform(std::complex<double>*p ,uint64_t n)
{
double pi = 2*asin(1.0);///Declaring value of pi
if(n==1) return p; ///Base Case To return
std::complex<double> *FastFourierTransform(std::complex<double> *p,
uint64_t n) {
double pi = 2 * asin(1.0); /// Declaring value of pi
std::complex<double> om=std::complex<double>(cos(2*pi/n),sin(2*pi/n)); ///Calculating value of omega
if (n == 1)
return p; /// Base Case To return
std::complex<double> *pe= new std::complex<double>[n/2]; /// Coefficents of even power
std::complex<double> om = std::complex<double>(
cos(2 * pi / n), sin(2 * pi / n)); /// Calculating value of omega
std::complex<double> *po= new std::complex<double>[n/2]; ///Coefficents of odd power
auto *pe = new std::complex<double>[n / 2]; /// Coefficents of even power
uint64_t k1=0,k2=0;
for(uint64_t j=0;j<n;j++)
{
if(j%2==0){
pe[k1++]=p[j]; ///Assigning values of even coefficents
auto *po = new std::complex<double>[n / 2]; /// Coefficents of odd power
}
else po[k2++]=p[j]; ///Assigning value of odd coefficents
uint64_t k1 = 0, k2 = 0;
for (uint64_t j = 0; j < n; j++) {
if (j % 2 == 0) {
pe[k1++] = p[j]; /// Assigning values of even coefficents
} else
po[k2++] = p[j]; /// Assigning value of odd coefficents
}
}
std::complex<double> *ye =
FastFourierTransform(pe, n / 2); /// Recursive Call
std::complex<double>*ye=FastFourierTransform(pe,n/2);///Recursive Call
std::complex<double>*yo=FastFourierTransform(po,n/2);///Recursive Call
std::complex<double> *yo =
FastFourierTransform(po, n / 2); /// Recursive Call
std::complex<double>*y=new std::complex<double>[n];///Final value representation list
auto *y = new std::complex<double>[n]; /// Final value representation list
for(uint64_t i=0;i<n/2;i++)
{
y[i]=ye[i]+pow(om,i)*yo[i]; ///Updating the first n/2 elements
y[i+n/2]=ye[i]-pow(om,i)*yo[i];///Updating the last n/2 elements
}
for (uint64_t i = 0; i < n / 2; i++) {
y[i] = ye[i] + pow(om, i) * yo[i]; /// Updating the first n/2 elements
y[i + n / 2] =
ye[i] - pow(om, i) * yo[i]; /// Updating the last n/2 elements
}
delete[] ye;
delete[] yo;
delete[] pe;
delete[] po;
return y;///Returns the list
return y; /// Returns the list
}
/**
@ -75,49 +80,49 @@ std::complex<double>* FastFourierTransform(std::complex<double>*p ,uint64_t n)
*/
static void test() {
/* descriptions of the following test */
std::complex<double> *t1= new std::complex<double>[2];///Test case 1
t1[0]={1,0};
t1[1]={2,0};
std::complex<double> *t2=new std::complex<double>[4];///Test case 2
t2[0]={1,0};
t2[1]={2,0};
t2[2]={3,0};
t2[3]={4,0};
auto *t1 = new std::complex<double>[2]; /// Test case 1
t1[0] = {1, 0};
t1[1] = {2, 0};
uint8_t n1=sizeof(t1)/sizeof(std::complex<double>);
uint8_t n2=sizeof(t2)/sizeof(std::complex<double>);
auto *t2 = new std::complex<double>[4]; /// Test case 2
t2[0] = {1, 0};
t2[1] = {2, 0};
t2[2] = {3, 0};
t2[3] = {4, 0};
std::vector<std::complex<double>> r1={{3,0},{-1,0} };///True Answer for test case 1
std::vector<std::complex<double>> r2={{10,0},{-2,-2},{-2,0},{-2,2} };///True Answer for test case 2
uint8_t n1 = sizeof(t1) / sizeof(std::complex<double>);
uint8_t n2 = sizeof(t2) / sizeof(std::complex<double>);
std::complex<double> *o1=FastFourierTransform(t1,n1);
std::complex<double> *o2=FastFourierTransform(t2,n2);
for(uint8_t i=0;i<n1;i++)
{
assert((r1[i].real()-o1->real()<0.000000000001 ) && (r1[i].imag()-o1->imag()<0.000000000001 ));/// Comparing for both real and imaginary values for test case 1
std::vector<std::complex<double>> r1 = {
{3, 0}, {-1, 0}}; /// True Answer for test case 1
std::vector<std::complex<double>> r2 = {
{10, 0}, {-2, -2}, {-2, 0}, {-2, 2}}; /// True Answer for test case 2
std::complex<double> *o1 = FastFourierTransform(t1, n1);
std::complex<double> *o2 = FastFourierTransform(t2, n2);
for (uint8_t i = 0; i < n1; i++) {
assert((r1[i].real() - o1->real() < 0.000000000001) &&
(r1[i].imag() - o1->imag() <
0.000000000001)); /// Comparing for both real and imaginary
/// values for test case 1
o1++;
}
for(uint8_t i=0;i<n2;i++)
{
assert((r2[i].real()-o2->real()<0.000000000001 ) && ( r2[i].imag()-o2->imag()<0.000000000001 ));/// Comparing for both real and imaginary values for test case 2
for (uint8_t i = 0; i < n2; i++) {
assert((r2[i].real() - o2->real() < 0.000000000001) &&
(r2[i].imag() - o2->imag() <
0.000000000001)); /// Comparing for both real and imaginary
/// values for test case 2
o2++;
}
delete[] o1;
delete[] o2;
delete[] t1;
delete[] t2;
}
/**
@ -127,8 +132,7 @@ static void test() {
* calls automated test function to test the working of fast fourier transform.
* @returns 0 on exit
*/
int main(int argc, char const *argv[])
{
test(); // run self-test implementations
return 0;
int main(int argc, char const *argv[]) {
test(); // run self-test implementations
return 0;
}