I'm trying to get the nth root of a number using JavaScript, but I don't see a way to do it using the built in `Math`

object. Am I overlooking something?

If not...

Is there a math library I can use that has this functionality?

If not...

What's the best algorithm to do this myself?

Can you use something like this?

```
Math.pow(n, 1/root);
```

eg.

```
Math.pow(25, 1/2) == 5
```

The `n`

th root of `x`

is the same as `x`

to the power of `1/n`

. You can simply use `Math.pow`

:

```
var original = 1000;
var fourthRoot = Math.pow(original, 1/4);
original == Math.pow(fourthRoot, 4); // (ignoring floating-point error)
```

Use Math.pow()

Note that it does not handle negative nicely - here is a discussion and some code that does

http://cwestblog.com/2011/05/06/cube-root-an-beyond/

```
function nthroot(x, n) {
try {
var negate = n % 2 == 1 && x < 0;
if(negate)
x = -x;
var possible = Math.pow(x, 1 / n);
n = Math.pow(possible, n);
if(Math.abs(x - n) < 1 && (x > 0 == n > 0))
return negate ? -possible : possible;
} catch(e){}
}
```

You could use

```
Math.nthroot = function(x,n) {
//if x is negative function returns NaN
return this.exp((1/n)*this.log(x));
}
//call using Math.nthroot();
```

The `n`

-th root of `x`

is a number `r`

such that `r`

to the power of `1/n`

is `x`

.

In real numbers, there are some subcases:

- There are two solutions (same value with opposite sign) when
`x`

is positive and`r`

is even. - There is one positive solution when
`x`

is positive and`r`

is odd. - There is one negative solution when
`x`

is negative and`r`

is odd. - There is no solution when
`x`

is negative and`r`

is even.

Since `Math.pow`

doesn't like a negative base with a non-integer exponent, you can use

```
function nthRoot(x, n) {
if(x < 0 && n%2 != 1) return NaN; // Not well defined
return (x < 0 ? -1 : 1) * Math.pow(Math.abs(x), 1/n);
}
```

Examples:

```
nthRoot(+4, 2); // 2 (the positive is chosen, but -2 is a solution too)
nthRoot(+8, 3); // 2 (this is the only solution)
nthRoot(-8, 3); // -2 (this is the only solution)
nthRoot(-4, 2); // NaN (there is no solution)
```

For the special cases of square and cubic root, it's best to use the native functions `Math.sqrt`

and `Math.cbrt`

respectively.

As of ES7, the exponentiation operator `**`

can be used to calculate the *n*th root as the ^{1}/_{n}th power of a non-negative base:

```
let root1 = Math.PI ** (1 / 3); // cube root of ?
let root2 = 81 ** 0.25; // 4th root of 81
```

This doesn't work with negative bases, though.

```
let root3 = (-32) ** 5; // NaN
```

Here's a function that tries to return the imaginary number. It also checks for a few common things first, ex: if getting square root of 0 or 1, or getting 0th root of number x

```
function root(x, n){
if(x == 1){
return 1;
}else if(x == 0 && n > 0){
return 0;
}else if(x == 0 && n < 0){
return Infinity;
}else if(n == 1){
return x;
}else if(n == 0 && x > 1){
return Infinity;
}else if(n == 0 && x == 1){
return 1;
}else if(n == 0 && x < 1 && x > -1){
return 0;
}else if(n == 0){
return NaN;
}
var result = false;
var num = x;
var neg = false;
if(num < 0){
//not using Math.abs because I need the function to remember if the number was positive or negative
num = num*-1;
neg = true;
}
if(n == 2){
//better to use square root if we can
result = Math.sqrt(num);
}else if(n == 3){
//better to use cube root if we can
result = Math.cbrt(num);
}else if(n > 3){
//the method Digital Plane suggested
result = Math.pow(num, 1/n);
}else if(n < 0){
//the method Digital Plane suggested
result = Math.pow(num, 1/n);
}
if(neg && n == 2){
//if square root, you can just add the imaginary number "i=?-1" to a string answer
//you should check if the functions return value contains i, before continuing any calculations
result += 'i';
}else if(neg && n % 2 !== 0 && n > 0){
//if the nth root is an odd number, you don't get an imaginary number
//neg*neg=pos, but neg*neg*neg=neg
//so you can simply make an odd nth root of a negative number, a negative number
result = result*-1;
}else if(neg){
//if the nth root is an even number that is not 2, things get more complex
//if someone wants to calculate this further, they can
//i'm just going to stop at *n?-1 (times the nth root of -1)
//you should also check if the functions return value contains * or ?, before continuing any calculations
result += '*'+n+?+'-1';
}
return result;
}
```

Well, I know this is an old question. But, based on SwiftNinjaPro's answer, I simplified the function and fixed some NaN issues. Note: This function used ES6 feature, arrow function and template strings, and exponentation. So, it might not work in older browsers:

```
Math.numberRoot = (x, n) => {
return (((x > 1 || x < -1) && n == 0) ? Infinity : ((x > 0 || x < 0) && n == 0) ? 1 : (x < 0 && n % 2 == 0) ? `${((x < 0 ? -x : x) ** (1 / n))}${"i"}` : (n == 3 && x < 0) ? -Math.cbrt(-x) : (x < 0) ? -((x < 0 ? -x : x) ** (1 / n)) : (n == 3 && x > 0 ? Math.cbrt(x) : (x < 0 ? -x : x) ** (1 / n)));
};
```

Example:

```
Math.numberRoot(-64, 3); // Returns -4
```

Example (Imaginary number result):

```
Math.numberRoot(-729, 6); // Returns a string containing "3i".
```

I have written an algorithm but it is slow when you need many numbers after the point:

https://github.com/am-trouzine/Arithmetic-algorithms-in-different-numeral-systems

```
NRoot(orginal, nthRoot, base, numbersAfterPoint);
```

The function returns a string.

E.g.

```
var original = 1000;
var fourthRoot = NRoot(original, 4, 10, 32);
console.log(fourthRoot);
//5.62341325190349080394951039776481
```

©2020 All rights reserved.