JavaScript: Berechnen Sie die n-te Wurzel einer Zahl

Ich versuche, die n-te Wurzel einer Zahl mithilfe von JavaScript zu ermitteln, sehe jedoch keine Möglichkeit, dies mithilfe des integrierten MathObjekts zu tun . Übersehe ich etwas?
Wenn nicht...

Gibt es eine Mathematikbibliothek, die diese Funktionalität bietet?
Wenn nicht...

Was ist der beste Algorithmus, um dies selbst zu tun?

Kannst du so etwas benutzen?

Math.pow(n, 1/root);

z.B.

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

Die nth Wurzel von xist die gleiche wie xdie Kraft von 1/n. Sie können einfach verwenden Math.pow:

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

Verwenden Sie Math.pow ()

Beachten Sie, dass Negative nicht gut behandelt werden - hier ist eine Diskussion und ein Code, der dies tut

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

Du könntest benutzen

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

Die n-te Wurzel von xist eine Zahl r, die rzur Potenz von 1/nist x.

In reellen Zahlen gibt es einige Unterfälle:

• Es gibt zwei Lösungen (gleicher Wert mit entgegengesetztem Vorzeichen), wenn sie xpositiv und rgerade sind.
• Es gibt eine positive Lösung, wenn sie xpositiv und rungerade ist.
• Es gibt eine negative Lösung, wenn sie xnegativ und rungerade ist.
• Es gibt keine Lösung, wenn xnegativ und gerade rist.

Da Math.poweine negative Basis mit einem nicht ganzzahligen Exponenten nicht gefällt, können Sie verwenden

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

Beispiele:

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)

Für die besonderen Fälle von quadratischen und kubischen Wurzel, dann ist es am besten , die nativen Funktionen zu nutzen Math.sqrtund Math.cbrtjeweils.

Ab ES7 kann der Exponentiationsoperator** verwendet werden, um die n- te Wurzel als ¹ / _n- te Potenz einer nicht negativen Basis zu berechnen :

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

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

Dies funktioniert jedoch nicht mit negativen Basen.

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

Hier ist eine Funktion, die versucht, die imaginäre Zahl zurückzugeben. Es wird auch zuerst nach ein paar häufigen Dingen gesucht, z. B.: Wenn Sie eine Quadratwurzel von 0 oder 1 oder eine 0. Wurzel von Zahl x erhalten

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

Nun, ich weiß, das ist eine alte Frage. Basierend auf der Antwort von SwiftNinjaPro habe ich die Funktion vereinfacht und einige NaN-Probleme behoben. Hinweis: Diese Funktion verwendete die ES6-Funktion, die Pfeilfunktion und Vorlagenzeichenfolgen sowie die Exponentation. In älteren Browsern funktioniert dies möglicherweise nicht:

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

Beispiel:

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

Beispiel (imaginäres Zahlenergebnis):

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

Ich habe einen Algorithmus geschrieben, aber er ist langsam, wenn Sie nach dem Punkt viele Zahlen benötigen:

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

NRoot(orginal, nthRoot, base, numbersAfterPoint);

Die Funktion gibt eine Zeichenfolge zurück.

Z.B

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