Write A Program to Calculate Square Root

Introduction

The square root of a number is a value that, when multiplied by itself, gives the original number. For example, the square root of 16 is 4 because 4 × 4 = 16. Calculating square roots is essential in geometry, physics, finance, and many other areas.

There are several methods to calculate square roots programmatically, including using built-in functions, implementing mathematical algorithms, and using iterative approaches. This guide covers these methods and provides code examples in Python and JavaScript.

Methods to Calculate Square Root

There are three primary methods to calculate square roots programmatically:

1. Built-in functions: Most programming languages provide built-in functions to calculate square roots.
2. Mathematical algorithms: Implementing algorithms like the Newton-Raphson method.
3. Iterative approaches: Using loops to approximate the square root.

Each method has its advantages and trade-offs in terms of accuracy, speed, and complexity.

Python Implementation

Python provides several ways to calculate square roots. The simplest method is using the math.sqrt() function from the math module.

Here's a Python example using the built-in function:

import math

def calculate_square_root(x):
    if x < 0:
        return "Error: Cannot calculate square root of a negative number"
    return math.sqrt(x)

# Example usage
number = 25
result = calculate_square_root(number)
print(f"The square root of {number} is {result}")

For more control, you can implement the Newton-Raphson method:

def newton_sqrt(x, tolerance=1e-10, max_iterations=100):
    if x < 0:
        return "Error: Cannot calculate square root of a negative number"
    if x == 0:
        return 0

    guess = x / 2.0
    for _ in range(max_iterations):
        new_guess = (guess + x / guess) / 2.0
        if abs(new_guess - guess) < tolerance:
            return new_guess
        guess = new_guess
    return guess

# Example usage
number = 25
result = newton_sqrt(number)
print(f"The square root of {number} is approximately {result}")

JavaScript Implementation

JavaScript provides the Math.sqrt() function to calculate square roots. Here's an example:

function calculateSquareRoot(x) {
    if (x < 0) {
        return "Error: Cannot calculate square root of a negative number";
    }
    return Math.sqrt(x);
}

// Example usage
const number = 25;
const result = calculateSquareRoot(number);
console.log(`The square root of ${number} is ${result}`);

For a more educational approach, you can implement the Babylonian method (similar to Newton-Raphson):

function babylonianSqrt(x, tolerance=1e-10, maxIterations=100) {
    if (x < 0) {
        return "Error: Cannot calculate square root of a negative number";
    }
    if (x === 0) {
        return 0;
    }

    let guess = x / 2.0;
    for (let i = 0; i < maxIterations; i++) {
        const newGuess = (guess + x / guess) / 2.0;
        if (Math.abs(newGuess - guess) < tolerance) {
            return newGuess;
        }
        guess = newGuess;
    }
    return guess;
}

// Example usage
const number = 25;
const result = babylonianSqrt(number);
console.log(`The square root of ${number} is approximately ${result}`);

Comparison of Methods

The following table compares the three methods for calculating square roots:

The built-in function is generally the best choice for most applications due to its speed and accuracy. The algorithmic approaches are useful for educational purposes or when you need more control over the calculation process.