How to Calculate the nth Root of a Number in C++?

You can calculate the nth root of a number in C++ using the pow() function or, for better precision with fractional exponents, or by implementing a numerical method like binary search.

1. Using the pow() function

The simplest way is to use the pow() function from the <cmath> library. This function raises a number to a given power. To find the nth root of a number x, you raise x to the power of 1/n.

#include <iostream>
#include <cmath>

int main() {
  double x = 27.0; // The number
  double n = 3.0;  // The root (e.g., 3 for cube root)

  double nth_root = pow(x, 1.0 / n);

  std::cout << "The " << n << "th root of " << x << " is: " << nth_root << std::endl;

  return 0;
}

Explanation:

• #include <cmath>: Includes the necessary header file for the pow() function.
• pow(x, 1.0 / n): Calculates x raised to the power of (1/n), which is the nth root of x. It's important to use 1.0 to ensure floating-point division.

2. Using Binary Search (for positive numbers)

For increased precision, especially when dealing with very large numbers or high-degree roots, or when you want more control over the tolerance, a binary search approach can be used. This method avoids potential issues with the pow() function and certain exponent combinations. This approach also guarantees a better control over the precision

#include <iostream>
#include <cmath>
#include <iomanip> // For setting precision

double nthRootBinarySearch(double number, int n, double epsilon = 0.00001) {
    if (number < 0 && n % 2 == 0) {
        std::cerr << "Error: Cannot calculate even root of a negative number." << std::endl;
        return NAN; // Not a Number
    }

    if (number < 0) {
        // Handle negative numbers for odd roots
        return -nthRootBinarySearch(-number, n, epsilon);
    }

    double low = 0;
    double high = std::max(1.0, number); // Ensure high is at least 1

    double root = 0;
    while (high - low > epsilon) {
        double mid = (low + high) / 2;
        double power = 1.0;
        for (int i = 0; i < n; ++i) {
            power *= mid;
        }

        if (power > number) {
            high = mid;
        } else {
            low = mid;
            root = mid;  //Update root in else case for better approximation
        }
    }

    return root;
}

int main() {
    double number = 27;
    int n = 3;
    double result = nthRootBinarySearch(number, n);

    std::cout << std::fixed << std::setprecision(5) << "The " << n << "th root of " << number << " is: " << result << std::endl;

    number = 81;
    n = 4;
    result = nthRootBinarySearch(number, n);
    std::cout << std::fixed << std::setprecision(5) << "The " << n << "th root of " << number << " is: " << result << std::endl;
    return 0;
}

Explanation:

• The nthRootBinarySearch function takes the number, the root n, and an optional epsilon value for precision as input.
• It initializes low to 0 and high to the maximum of 1 and the number. This ensures the initial range contains the root.
• The while loop continues as long as the difference between high and low is greater than epsilon.
• mid is calculated as the average of low and high.
• power calculates mid raised to the power of n.
• If power is greater than the number, high is set to mid; otherwise, low is set to mid and root is set to mid.
• The loop continues until the desired precision is reached.
• Negative number edge case is properly handled.

Choosing the Right Method

• For most general-purpose calculations, the pow() function is sufficient and easier to use.
• For situations requiring high precision or when dealing with very large exponents or numbers, the binary search method provides more control and potentially better results. Additionally, for odd roots, the binary search is better for negative numbers.
• Consider the performance implications. pow() is generally optimized but can sometimes be less precise. Binary search requires iteration.