How to Find the Square Root Without Using the SQRT Function in C++

1. Find Square Roots in C++ Without Using the sqrt Function: Newton’s Method
2. Find Square Roots in C++ Without Using the sqrt Function: Binary Search Method
3. Find Square Roots in C++ Without Using the sqrt Function: Babylonian (Heron’s) Method
4. Find Square Roots in C++ Without Using the sqrt Function: Exponential Function Method
5. Conclusion

The sqrt() function is a built-in C++ function that calculates the square root of a number. It accepts one argument, n, and returns the square root of n.

But did you know that we can find the square root of a number in C++ without using the sqrt() function? In this article, we will explain four distinct approaches: Newton’s Method, Binary Search, Babylonian (Heron’s) Method, and the Exponential Function Method.

Find Square Roots in C++ Without Using the sqrt Function: Newton’s Method

Another elegant numerical method for finding square roots is Newton’s Method. Also known as the Newton-Raphson method, this is an iterative numerical technique for finding the roots of real-valued functions.

The basic idea behind Newton’s Method is to start with an initial guess and iteratively refine that guess until it converges to the actual square root.

Here’s a breakdown of Newton’s Method algorithm for finding square roots in C++:

Let’s implement Newton’s Method for finding square roots in C++:

#include <iostream>

double squareRoot(double n) {
    double x = n;
    double epsilon = 0.000001;

    while ((x * x - n) > epsilon) {
        x = 0.5 * (x + n / x);
    }

    return x;
}

int main() {
    double number;
    std::cout << "Enter a number: ";
    std::cin >> number;

    std::cout << "Square root: " << squareRoot(number) << std::endl;

    return 0;
}

Output:

Enter a number: 5
Square root: 2.23607

In this example, we were prompted to enter a number, and in this case, we input 5. The program then calculates the square root of 5 using Newton’s Method.

The result, approximately 2.23607, is then displayed.

It’s important to note that the precision of the result depends on the chosen value of epsilon. A smaller epsilon will yield a more accurate result but might require more iterations.

This method is sensitive to the initial guess. Choosing a good initial guess can lead to faster convergence.

Find Square Roots in C++ Without Using the sqrt Function: Binary Search Method

Binary search is a well-known algorithm primarily used for finding an element in a sorted array. Surprisingly, it can also be adapted to find square roots.

The core idea involves performing a binary search within a specified range, systematically narrowing down possibilities until the square root is found within the desired precision.

Let’s delve into the implementation of the Binary Search method for finding square roots in C++:

Here is the complete implementation:

#include <iostream>

double squareRoot(double n) {
    double low = 0.0;
    double high = n;
    double mid, guess;

    double epsilon = 0.000001;  // Set your desired precision

    while ((high - low) > epsilon) {
        mid = (low + high) / 2;
        guess = mid * mid;

        if (guess > n) {
            high = mid;
        } else {
            low = mid;
        }
    }

    return low;
}

int main() {
    double number;
    std::cout << "Enter a number: ";
    std::cin >> number;

    std::cout << "Square root: " << squareRoot(number) << std::endl;

    return 0;
}

For instance, let’s consider an input of 5:

Enter a number: 5
Square root: 2.23607

In this example, the program prompts the user to enter a number (5). The algorithm then utilizes Binary Search to calculate the square root, yielding a result of approximately 2.23607.

Ensure the initial range (low and high) encapsulates the potential square root. The adjustment of the search range based on the comparison with the target number is crucial for the algorithm’s success.

Find Square Roots in C++ Without Using the sqrt Function: Babylonian (Heron’s) Method

When it comes to calculating square roots in C++ without relying on the built-in square root function, the Babylonian Method, also known as Heron’s Method, is also a powerful iterative technique.

Named after the ancient Babylonian mathematicians and the Greek mathematician Heron of Alexandria, this method provides an efficient and accurate approach to finding square roots.

The Babylonian Method is an iterative algorithm based on the principle of refining an initial guess until it converges to the true square root. It’s particularly effective due to its simplicity and rapid convergence.

Let’s implement the Babylonian (Heron’s) Method for finding square roots in C++:

#include <iostream>

double squareRoot(double n) {
    double x = n;
    double epsilon = 0.000001;  // Set your desired precision

    while ((x * x - n) > epsilon) {
        x = 0.5 * (x + n / x);
    }

    return x;
}

int main() {
    double number;
    std::cout << "Enter a number: ";
    std::cin >> number;

    std::cout << "Square root: " << squareRoot(number) << std::endl;

    return 0;
}

For instance, let’s consider an input of 5:

Enter a number: 5
Square root: 2.23607

In this example, the program prompts the user to enter a number (5). The Babylonian Method is then applied to calculate the square root, resulting in a precision of approximately 2.23607.

The precision of the result depends on the chosen value of epsilon. A smaller epsilon will yield a more accurate result but might require more iterations.

While the method is robust, choosing a good initial guess can influence the convergence speed.

Find Square Roots in C++ Without Using the sqrt Function: Exponential Function Method

The Exponential Function Method exploits the fact that the square root of a number n can be expressed as n^(1/2) or, equivalently, exp(0.5 * log(n)) in terms of the exponential and logarithmic functions. Leveraging these mathematical relationships, we can bypass the direct use of square root functions in C++.

Let’s implement the Exponential Function Method for finding square roots in C++:

#include <iostream>
#include <cmath>

double squareRoot(double n) {
    return exp(0.5 * log(n));
}

int main() {
    double number;
    std::cout << "Enter a number: ";
    std::cin >> number;

    std::cout << "Square root: " << squareRoot(number) << std::endl;

    return 0;
}

Consider an input of 5:

Enter a number: 5
Square root: 2.23607

In this example, the program prompts the user to enter a number (5). The Exponential Function Method is then applied to calculate the square root, resulting in a precision of approximately 2.23607.

Note that the method relies on the <cmath> library for mathematical functions, so ensure proper inclusion.

While elegant, the Exponential Function Method may have limitations for extremely large or small numbers due to limitations in numerical precision.

Conclusion

This article explored various methods for calculating square roots in C++ without relying on the built-in sqrt function. Each method—Newton’s Method, Binary Search, Babylonian (Heron’s) Method, and the Exponential Function Method—offers a unique approach to iteratively refine guesses until convergence to the actual square root is achieved.

It’s important to note that the precision of these methods depends on the chosen epsilon value, and the efficiency may vary based on the nature of the input and the selected algorithm. These methods not only present viable alternatives to the sqrt function but also offer a deeper understanding of numerical methods, algorithmic principles, and the interplay between mathematics and programming.