JavaScript : Calculer la nième racine d'un nombre

Question

J'essaye d'obtenir la nième racine d'un nombre en utilisant JavaScript, mais je ne vois pas comment le faire en utilisant le module intégré Math objet. Est-ce que je néglige quelque chose ?
Si ce n'est pas le cas...

Existe-t-il une bibliothèque mathématique que je peux utiliser et qui possède cette fonctionnalité ?
Si ce n'est pas le cas...

Quel est le meilleur algorithme pour le faire moi-même ?

Answer 1

Pour les cas particuliers de racine carrée et cubique, il est préférable d'utiliser les fonctions natives suivantes Math.sqrt y Math.cbrt respectivement.

À partir de ES7, le opérateur d'exponentiation ** peut être utilisé pour calculer le n e racine comme la 1 / _{<em>n </em>} e puissance d'une base non négative :

let root1 = Math.PI ** (1 / 3); // cube root of 

let root2 = 81 ** 0.25;         // 4th root of 81

Cela ne fonctionne pas avec les bases négatives, cependant.

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

Answer 2

Voici une fonction qui essaie de retourner le nombre imaginaire. Elle vérifie également certaines choses courantes, par exemple si elle obtient la racine carrée de 0 ou 1, ou si elle obtient la racine 0 du nombre 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;
    }

Answer 3

Je sais que c'est une vieille question. Mais, en me basant sur la réponse de SwiftNinjaPro, j'ai simplifié la fonction et corrigé quelques problèmes de NaN. Note : Cette fonction utilise la fonctionnalité ES6, la fonction flèche et les chaînes de caractères modèles, ainsi que l'exponentiation. Elle peut donc ne pas fonctionner dans les anciens navigateurs :

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

Exemple :

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

Exemple (résultat d'un nombre imaginaire) :

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

Answer 4

J'ai écrit un algorithme mais il est lent quand on a besoin de nombreux chiffres après le point :

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

NRoot(orginal, nthRoot, base, numbersAfterPoint);

La fonction renvoie une chaîne de caractères.

Par exemple

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