numerical_methods Namespace Reference

for assert More...

Functions
double	babylonian_method (double radicand)
	Babylonian methods is an iterative function which returns square root of radicand.
std::complex< double > *	FastFourierTransform (std::complex< double > *p, uint8_t n)
	FastFourierTransform is a recursive function which returns list of complex numbers.
std::complex< double > *	InverseFastFourierTransform (std::complex< double > *p, uint8_t n)
	InverseFastFourierTransform is a recursive function which returns list of complex numbers.

Detailed Description

for assert

Numerical Methods.

for std::map container

for storing points and coefficents

for io operations

for math functions

for IO operations

Numerical algorithms/methods

for assert for integer allocation for std::atof for std::function for IO operations for std::map container

Numerical algorithms/methods

for math operations

Numerical methods

for assert for mathematical-related functions for IO operations for std::vector

Numerical algorithms/methods

for std::array for assert for fabs

Numerical Methods algorithms

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

Numerical algorithms/methods

Function Documentation

babylonian_method()

double numerical_methods::babylonian_method

(

double

radicand

)

Babylonian methods is an iterative function which returns square root of radicand.

Parameters

radicand

is the radicand

Returns

x1 the square root of radicand

To find initial root or rough approximation

Real Initial value will be i-1 as loop stops on +1 value

Storing previous value for comparison

Storing calculated value for comparison

Temp variable to x0 and x1

Newly calculated root

Returning final root

Definition at line 30 of file babylonian_method.cpp.

                                          {
    int i = 1;  
 
    while (i * i <= radicand) {
        i++;
    }
 
    i--;  
 
    double x0 = i;  
    double x1 =
        (radicand / x0 + x0) / 2;  
    double temp = NAN;             
 
    while (std::max(x0, x1) - std::min(x0, x1) < 0.0001) {
        temp = (radicand / x1 + x1) / 2;  
        x0 = x1;
        x1 = temp;
    }
 
    return x1;  
}

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

Definition at line 42 of file fast_fourier_transform.cpp.

                                                                           {
    if (n == 1) {
        return p;  
    }
 
    double pi = 2 * asin(1.0);  
 
    std::complex<double> om = std::complex<double>(
        cos(2 * pi / n), sin(2 * pi / n));  
 
    auto *pe = new std::complex<double>[n / 2];  
 
    auto *po = new std::complex<double>[n / 2];  
 
    int k1 = 0, k2 = 0;
    for (int j = 0; j < n; j++) {
        if (j % 2 == 0) {
            pe[k1++] = p[j];  
 
        } else {
            po[k2++] = p[j];  
        }
    }
 
    std::complex<double> *ye =
        FastFourierTransform(pe, n / 2);  
 
    std::complex<double> *yo =
        FastFourierTransform(po, n / 2);  
 
    auto *y = new std::complex<double>[n];  
 
    k1 = 0, k2 = 0;
 
    for (int i = 0; i < n / 2; i++) {
        y[i] =
            ye[k1] + pow(om, i) * yo[k2];  
        y[i + n / 2] =
            ye[k1] - pow(om, i) * yo[k2];  
 
        k1++;
        k2++;
    }
 
    if (n != 2) {
        delete[] pe;
        delete[] po;
    }
 
    delete[] ye;  
    delete[] yo;  
    return y;
}

InverseFastFourierTransform()

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

InverseFastFourierTransform 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

One change in comparison with DFT

One change in comparison with DFT

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

Definition at line 34 of file inverse_fast_fourier_transform.cpp.

                                                             {
    if (n == 1) {
        return p;  
    }
 
    double pi = 2 * asin(1.0);  
 
    std::complex<double> om = std::complex<double>(
        cos(2 * pi / n), sin(2 * pi / n));  
 
    om.real(om.real() / n);  
    om.imag(om.imag() / n);  
 
    auto *pe = new std::complex<double>[n / 2];  
 
    auto *po = new std::complex<double>[n / 2];  
 
    int k1 = 0, k2 = 0;
    for (int j = 0; j < n; j++) {
        if (j % 2 == 0) {
            pe[k1++] = p[j];  
 
        } else {
            po[k2++] = p[j];  
        }
    }
 
    std::complex<double> *ye =
        InverseFastFourierTransform(pe, n / 2);  
 
    std::complex<double> *yo =
        InverseFastFourierTransform(po, n / 2);  
 
    auto *y = new std::complex<double>[n];  
 
    k1 = 0, k2 = 0;
 
    for (int i = 0; i < n / 2; i++) {
        y[i] =
            ye[k1] + pow(om, i) * yo[k2];  
        y[i + n / 2] =
            ye[k1] - pow(om, i) * yo[k2];  
 
        k1++;
        k2++;
    }
 
    if (n != 2) {
        delete[] pe;
        delete[] po;
    }
 
    delete[] ye;  
    delete[] yo;  
    return y;
}