algorithm - studio - JavaScript: calcula la enésima raíz de un número

sintaxis raiz cuadrada en java

Question

Estoy tratando de obtener la enésima raíz de un número usando JavaScript, pero no veo la manera de hacerlo utilizando el objeto Math incorporado. ¿Estoy pasando por alto algo?
Si no...

¿Hay una biblioteca de matemáticas que pueda usar que tenga esta funcionalidad?
Si no...

¿Cuál es el mejor algoritmo para hacer esto yo mismo?

Answer 1

¿Puedes usar algo como esto?

Math.pow(n, 1/root);

p.ej.

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

Answer 2

La raíz n -ésima de x es un número r tal que r a la potencia de 1/n es x .

En números reales, hay algunos subcampos:

• Hay dos soluciones (el mismo valor con signo opuesto) cuando x es positivo y r es par.
• Hay una solución positiva cuando x es positivo r es impar.
• Hay una solución negativa cuando x es negativo r es impar.
• No hay solución cuando x es negativo y r es par.

Como a Math.pow no le gusta una base negativa con un exponente no entero, puede usar

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);
}

Ejemplos:

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)

Answer 3

La raíz n de x es la misma que x para la potencia de 1/n . Simplemente puede usar Math.pow :

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

Answer 4

Para los casos especiales de raíz cuadrada y cúbica, es mejor usar las funciones nativas Math.sqrt y Math.cbrt respectivamente.

A partir de ES7, el operador de exponenciación ** se puede usar para calcular la raíz enésima como la potencia ¹ / _n th de una base no negativa:

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

Sin embargo, esto no funciona con bases negativas.

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

Answer 5

Podrías usar

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

Answer 6

Use Math.pow ()

Tenga en cuenta que no maneja negativamente bien - aquí hay una discusión y algún código que hace

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){}
}