numerical_methods Namespace Reference

for io operations More...

Functions
std::complex< double > *	FastFourierTransform (std::complex< double > *p, uint8_t n)
	FastFourierTransform is a recursive function which returns list of complex numbers. More...

Detailed Description

for io operations

Numerical Methods.

for std::map container

for std::vector

for math operations

Numerical methods

for assert for mathematical-related functions for storing points and coefficents for IO operations

Numerical algorithms/methods

for assert for math functions for integer allocation for std::atof for std::function for IO operations

Numerical algorithms/methods

Function Documentation

FastFourierTransform()

std::complex< double > * numerical_methods::FastFourierTransform	(	std::complex< double > *	p,
		uint8_t	n
	)

FastFourierTransform is a recursive function which returns list of complex numbers.

Parameters

p	List of Coefficents in form of complex numbers
n	Count of elements in list p

Returns

p if n==1

y if n!=1

Base Case To return

Declaring value of pi

Calculating value of omega

Coefficients of even power

Coefficients of odd power

Assigning values of even Coefficients

Assigning value of odd Coefficients

Recursive Call

Recursive Call

Final value representation list

Updating the first n/2 elements

Updating the last n/2 elements

Deleting dynamic array ye

Deleting dynamic array yo

                                                                           {
    if (n == 1) {
        return p;  /// Base Case To return
    }
 
    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
 
    auto *pe = new std::complex<double>[n / 2];  /// Coefficients of even power
 
    auto *po = new std::complex<double>[n / 2];  /// Coefficients of odd power
 
    int k1 = 0, k2 = 0;
    for (int j = 0; j < n; j++) {
        if (j % 2 == 0) {
            pe[k1++] = p[j];  /// Assigning values of even Coefficients
 
        } else
            po[k2++] = p[j];  /// Assigning value of odd Coefficients
    }
 
    std::complex<double> *ye =
        FastFourierTransform(pe, n / 2);  /// Recursive Call
 
    std::complex<double> *yo =
        FastFourierTransform(po, n / 2);  /// Recursive Call
 
    auto *y = new std::complex<double>[n];  /// Final value representation list
 
    k1 = 0, k2 = 0;
 
    for (int i = 0; i < n / 2; i++) {
        y[i] =
            ye[k1] + pow(om, i) * yo[k2];  /// Updating the first n/2 elements
        y[i + n / 2] =
            ye[k1] - pow(om, i) * yo[k2];  /// Updating the last n/2 elements
 
        k1++;
        k2++;
    }
 
    if(n!=2){
     
        delete[] pe;
        delete[] po;
        
    }
 
    delete[] ye;  /// Deleting dynamic array ye
    delete[] yo;  /// Deleting dynamic array yo
    return y;
}

Here is the call graph for this function: