Program for finding nth root of the number without any external library or header like math.h

Question

Is there any way to find nth root of the number without any external library in C? I'm working on a bare metal code so there is no OS. Also, no complete C is there.

Answer 1

You can write a program like this for nth root. This program is for square root.

int floorSqrt(int x)
{
    // Base cases
    if (x == 0 || x == 1)
       return x;

    // Staring from 1, try all numbers until
    // i*i is greater than or equal to x.
    int i = 1, result = 1;
    while (result < x)
    {
       if (result == x)
          return result;
       i++;
       result = i*i;
    }
    return i-1;
}

You can use the same approach for nth root.

Answer 2

Here there is a C implementation of the the nth root algorithm you can find in wikipedia. It needs an exponentiation algorithm, so I also include an implementation of a basic method for exponentiation by squaring that you can find also find in wikipedia.

double npower(double const base, int const n)
{
    if (n < 0) return npower(1/base, -n)
    else if (n == 0) return 1.0;
    else if (n == 1) return base;
    else if (n % 2) return base*npower(base*base, n/2);
    else return npower(base*base, n/2);
}

double nroot(double const base, int const n)
{
    if (n == 1) return base;
    else if (n <= 0 || base < 0) return NAN;
    else {
        double delta, x = base/n;
        do {
            delta = (base/npower(x,n-1)-x)/n;
            x += delta;
        } while (fabs(delta) >= 1e-8);
        return x;
    }
}

Some comments on this:

• The nth root algorithm in wikipedia leaves freedom for the initial guess. In this example I set it up to be base/n, but this was just a guess.
• The macro NAN is usually defined in <math.h>, so you would need to define it to be suitable for your needs.
• Both functions are implemented in a very rough and simple way, and their performance can be greatly improved with careful thought.
• The tolerance in this example is set to 1e-8 and should be changed to something different. It should probably be proportional to the value of the base.

Answer 3

You can try the nth_root C function :

// return a number that, when multiplied by itself nth times, makes N.
unsigned nth_root(const unsigned n, const unsigned nth) {
    unsigned a = n, b, c, r = nth ? n + (n > 1) : n == 1 ;
    for (; a < r; b = a + (nth - 1) * r, a = b / nth)
        for (r = a, a = n, c = nth - 1; c && (a /= r); --c);
    return r;
}

Source