Babylonian Method to find Square Root in C++

You might need to quickly calculate square roots in your work as a software engineer or data scientist. The Babylonian algorithm is a well-liked approach to approximate square roots. In this post, we will examine the Babylonian algorithm for square roots in C++ and talk about how to implement it without becoming stuck in an endless loop.

A Brief Description of the Babylonian Algorithm:

The Heron's approach is commonly referred to as the Babylonian algorithm. It is an iterative technique for approximating the square root of a positive number. The algorithm begins with a rough approximation and iteratively improves it until it reaches the desired level of accuracy.

The steps of the Babylonian algorithm are as follows:

It starts by estimating the square root of the input number with the initial guess, x0. Any positive number might be used as this hunch.
Using the equation: x1 = (x0 + (number / x0)) / 2, determine an improved guess, x1.
Continue performing step 2 until the gap between successive guesses, |x1 - x0|, is less than a predetermined threshold.
The final guess, x, roughly corresponds to the input number's square root.

C++ implementation of the Babylonian algorithm:

The input number and the required level of accuracy can be passed as parameters to a function that we can use to construct the Babylonian technique for square roots in C++. Here is an illustration of its use:

#include <iostream>
#include <cmath>

double babylonianSquareRoot(double number, double epsilon) {
    double guess = number; // Initial guess

    while (true) {
        double newGuess = 0.5 * (guess + number / guess); // Improved guess

        if (std::abs(newGuess - guess) < epsilon) {
            return newGuess; // Desired level of accuracy reached
        }

        guess = newGuess; // Update guess
    }
}

int main() {
    double inputNumber = 25.0; // The number for which we want to calculate the square root
    double accuracy = 0.00001; // The desired level of accuracy

    double squareRoot = babylonianSquareRoot(inputNumber, accuracy);

std::cout<< "Square root of " <<inputNumber<< " is approximately " <<squareRoot<< std::endl;

    return 0;
}

Output:

Square root of 25 is approximately 5

Explanation:

In this example, we begin with a hunch that is equal to the input value. The algorithm iteratively improves the guess until the difference between successive guesses is less than the specified accuracy threshold.

How to Avoid Infinite Loops?

The Babylonian algorithm can occasionally get stuck in an infinite loop despite the fact that it normally works well for approximating square roots. It may occur if the initial estimate of the square root is too far off or if the desired level of accuracy is not possible.

Establishing a stopping condition based on the difference between successive predictions is crucial to preventing infinite loops. In the code shown above as an illustration, we determine whether the absolute difference between the current guess and the prior guess is less than the given epsilon. If this criterion is true, we return the approximate square root of the current guess.

Picking a decent first guess is also crucial. Starting with a prediction that is close to the actual square root can speed up convergence and lessen the chance of running into infinite loops.

Conclusion:

This article explored the Babylonian approach for C++'s approximate square root approximation. We went over the algorithm's steps and showed an example implementation. We also emphasized the significance of selecting an appropriate beginning guess and creating a stopping condition to prevent infinite cycles.

The Babylonian algorithm provides a quick way to compute square roots with the specified level of precision. By comprehending and correctly applying this algorithm, you can add a useful tool to your data science or software engineering toolbox.

Next TopicConcentric Rectangular Pattern in C++

← prev next →