Square Root in Javascript Calculator

What is a Square Root?

The square root of a number is a value that, when multiplied by itself, gives the original number. For example, the square root of 9 is 3 because 3 × 3 = 9. Mathematically, the square root of a number x is written as √x.

Square roots have several important properties:

• The square root of a negative number is not a real number (it's an imaginary number)
• The square root of 0 is 0
• The square root of 1 is 1
• Square roots of perfect squares are integers (e.g., √16 = 4)

JavaScript Implementation

JavaScript provides several ways to calculate square roots:

Using Math.sqrt()

The simplest way to calculate a square root in JavaScript is to use the built-in Math.sqrt() method:

let number = 25;
let squareRoot = Math.sqrt(number);
console.log(squareRoot); // Output: 5

Custom Square Root Function

For educational purposes, you can implement your own square root function using the Babylonian method (also known as Heron's method):

function customSqrt(number, precision = 1e-10) {
    if (number < 0) return NaN;
    if (number === 0) return 0;

    let guess = number;
    let prevGuess;

    do {
        prevGuess = guess;
        guess = (guess + number / guess) / 2;
    } while (Math.abs(guess - prevGuess) > precision);

    return guess;
}

console.log(customSqrt(25)); // Output: 5

This custom implementation provides more control over the precision and handles edge cases like negative numbers.

Practical Examples

Here are some practical examples of square root calculations in JavaScript:

Example 1: Simple Square Root

let result = Math.sqrt(144);
console.log(result); // Output: 12

Example 2: Square Root of a Negative Number

let result = Math.sqrt(-1);
console.log(result); // Output: NaN

Example 3: Using the Custom Function

let result = customSqrt(100, 1e-15);
console.log(result); // Output: 10

Example 4: Square Root in an Array

let numbers = [9, 16, 25, 36];
let squareRoots = numbers.map(num => Math.sqrt(num));
console.log(squareRoots); // Output: [3, 4, 5, 6]

Common Mistakes

When working with square roots in JavaScript, be aware of these common pitfalls:

1. Forgetting to Handle Negative Numbers

The Math.sqrt() function returns NaN for negative numbers. Always check for negative inputs if they might occur in your application.

2. Precision Issues

Floating-point arithmetic can lead to precision errors. For example, Math.sqrt(2) * Math.sqrt(2) might not equal exactly 2 due to floating-point representation.

3. Using Square Root for Non-Mathematical Purposes

Square roots are mathematical operations and should not be used for non-mathematical purposes like string manipulation or data transformation.