web-dev-qa-db-fra.com

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

J'essaie d'obtenir la nième racine d'un nombre en utilisant JavaScript, mais je ne vois pas de moyen de le faire en utilisant l'objet Math intégré. Suis-je en train d'oublier quelque chose?
Si non...

Y a-t-il une bibliothèque mathématique que je peux utiliser qui a cette fonctionnalité?
Si non...

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

algorithmmathjavascript
69
Nathan

Pouvez-vous utiliser quelque chose comme ça?

Math.pow(n, 1/root);

par exemple.

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

La racine de nth de x est la même que x à la puissance de 1/n. Vous pouvez simplement utiliser Math.pow:

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

Utilisez Math.pow ()

Notez qu'il ne gère pas bien les négatifs - voici une discussion et du code qui ne

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

Vous pourriez utiliser

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

n- e racine de x est un nombre r tel que r à la puissance de 1/n est x.

En nombre réel, il existe quelques sous-cas:

  • Il existe deux solutions (même valeur avec le signe opposé) lorsque x est positif et r est pair.
  • Il existe une solution positive lorsque x est positif et r est impair.
  • Il existe une solution négative lorsque x est négatif et r est impair.
  • Il n'y a pas de solution lorsque x est négatif et r est pair.

Puisque Math.pow n'aime pas une base négative avec un exposant non entier, vous pouvez utiliser

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

Exemples:

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)
3
Oriol

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

Depuis ES7, le opérateur d'exponentiation ** peut être utilisé pour calculer la racine n e comme 1/ n 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

Cependant, cela ne fonctionne pas avec des bases négatives.

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

Voici une fonction qui essaie de renvoyer le nombre imaginaire. Il vérifie également d'abord quelques éléments communs, par exemple: si vous obtenez la racine carrée de 0 ou 1, ou si vous obtenez 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;
    }
0
SwiftNinjaPro