iamhrithikraj/numerical-algorithm

In numerical analysis, a numerical method is a mathematical tool designed to solve numerical problems. The implementation of a numerical method with an appropriate convergence check in a programming language is called a numerical algorithm

Numerical-Algorithm

In numerical analysis, a numerical method is a mathematical tool designed to solve numerical problems. The implementation of a numerical method with an appropriate convergence check in a programming language is called a numerical algorithm

numerical-algorithm's Issues

ANOTHER METHOD TO SOLVE BISECTION METHOD IN C++

#include
#include
#include

// Function definition to calculate the value of the function at a given point
double get_fun(double res) {
return (res * res * res - 4 * res - 9);
}

// Function to perform the bisection method
double bisect(double int_st, double int_end, double err_all, int mx_iter_cnt) {
double mid_pt = (int_st + int_end) / 2;
int iter_cnt = 0;
std::cout << std::fixed << std::setprecision(6);
while (iter_cnt < mx_iter_cnt && fabs(int_st - int_end) > err_all) {
mid_pt = (int_st + int_end) / 2;
std::cout << "Iteration " << iter_cnt + 1 << ": " << mid_pt << std::endl;
if (get_fun(int_st) * get_fun(mid_pt) < 0) {
int_end = mid_pt;
} else {
int_st = mid_pt;
}
++iter_cnt;
}
return mid_pt;
}

int main() {
double int_st, int_end, err_all;
int mx_iter_cnt;
std::cout << "Enter the first starting point: ";
std::cin >> int_st;
std::cout << "Enter the second ending point: ";
std::cin >> int_end;
std::cout << "Enter the maximum iterations to be allowed: ";
std::cin >> mx_iter_cnt;
std::cout << "Input the number of allowed error points: ";
std::cin >> err_all;
double root = bisect(int_st, int_end, err_all, mx_iter_cnt);
std::cout << "The approximate root is: " << root << std::endl;
return 0;
}

ANOTHER METHOD TO SOLVE NEWGTON RHAPSON METHOD IN C++

#include
#include

// Function to compute f(x) = x^2 - 2
double f(double x) {
return x * x * x + x - 1 ;
}

// Function to compute f'(x) = 2x
double f_prime(double x) {
return 3* x + 1 ;
}

int main() {
// Initial values
double x0 = 1.0; // initial guess
double epsilon = 1e-6; // tolerance
int maxIter = 100; // maximum number of iterations

// Initialize variables
double x = x0;
double fx, f_prime_x, x_next;
int iter = 0;

// Newton Raphson method
while (iter < maxIter) {
    // Compute f(x) and f'(x)
    fx = f(x);
    f_prime_x = f_prime(x);

    // Compute x_next
    x_next = x - fx / f_prime_x;

    // Print iteration details
    std::cout << "Iteration " << iter << ": x = " << x << ", f(x) = " << fx << ", f'(x) = " << f_prime_x << ", x_next = " << x_next << std::endl;

    // Check for convergence
    if (std::abs(x_next - x) < epsilon) {
        std::cout << "Converged! The root is approximately " << x_next << std::endl;
        break;
    }

    // Update x
    x = x_next;
    iter++;
}

return 0;

}