जावास्क्रिप्ट: किसी संख्या की nth रूट की गणना करें

Question 1

मैं जावास्क्रिप्ट का उपयोग करके एक नंबर की nth रूट प्राप्त करने की कोशिश कर रहा हूं, लेकिन मुझे बिल्ट इन Mathऑब्जेक्ट का उपयोग करने का कोई तरीका नहीं दिखता है । क्या मैं कुछ देख रहा हूँ?
अगर नहीं...

क्या एक गणित पुस्तकालय है जिसका मैं उपयोग कर सकता हूं जिसमें यह कार्यक्षमता है?
अगर नहीं...

यह स्वयं करने के लिए सबसे अच्छा एल्गोरिथ्म क्या है?

Question 2

क्या आप ऐसा कुछ इस्तेमाल कर सकते हैं?

Math.pow(n, 1/root);

जैसे।

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

Question 3

की nजड़ xउसी xकी शक्ति के समान है 1/n। आप बस का उपयोग कर सकते हैं Math.pow:

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

Question 4

Math.pow () का उपयोग करें

ध्यान दें कि यह नकारात्मक रूप से संभाल नहीं करता है - यहां एक चर्चा और कुछ कोड है जो करता है

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

Question 5

आप उपयोग कर सकते हैं

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

Question 6

की n-th जड़ xएक संख्या है r, जो rकी शक्ति 1/nहै x।

वास्तविक संख्या में, कुछ उप-मामले हैं:

xसकारात्मक होने पर दो समाधान (विपरीत संकेत के साथ समान मूल्य) हैं और rयहां तक कि है।
सकारात्मक होने पर एक सकारात्मक समाधान xहै और rविषम है।
ऋणात्मक होने पर एक ऋणात्मक हल होता xहै और rविषम होता है।
जब xनकारात्मक है और rयहां तक कि कोई समाधान नहीं है।

चूंकि Math.powएक गैर-पूर्णांक प्रतिपादक के साथ एक नकारात्मक आधार पसंद नहीं है, आप उपयोग कर सकते हैं

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

उदाहरण:

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)

Question 7

वर्ग और क्यूबिक रूट के विशेष मामलों के लिए, देशी कार्यों का उपयोग करना सबसे अच्छा है Math.sqrtऔरMath.cbrt क्रमशः ।

ES7 के रूप में, घातांक ऑपरेटर** का उपयोग n वें रूट की गणना करने के लिए किया जा सकता है क्योंकि गैर-नकारात्मक मूल्य का ¹ / _n वें शक्ति:

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

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

यह नकारात्मक ठिकानों के साथ काम नहीं करता है, हालांकि।

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

Question 8

यहां एक फ़ंक्शन है जो काल्पनिक संख्या को वापस करने की कोशिश करता है। यह पहले कुछ सामान्य चीजों की भी जांच करता है, पूर्व: यदि 0 या 1 का वर्गमूल प्राप्त करना है, या संख्या x की 0 वीं जड़ प्राप्त करना है

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

Question 9

वैसे, मुझे पता है कि यह एक पुराना सवाल है। लेकिन, SwiftNinjaPro के उत्तर के आधार पर, मैंने फ़ंक्शन को सरल बनाया और कुछ NaN मुद्दे तय किए। नोट: इस फंक्शन में ES6 फीचर, एरो फंक्शन और टेम्प्लेट स्ट्रिंग्स और एक्सप्रेशन का इस्तेमाल किया गया है। इसलिए, यह पुराने ब्राउज़रों में काम नहीं कर सकता है:

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

उदाहरण:

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

उदाहरण (काल्पनिक संख्या परिणाम):

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

Question 10

मैंने एक एल्गोरिथ्म लिखा है, लेकिन यह धीमा है जब आपको बिंदु के बाद कई नंबरों की आवश्यकता होती है:

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

NRoot(orginal, nthRoot, base, numbersAfterPoint);

फ़ंक्शन एक स्ट्रिंग लौटाता है।

उदाहरण के लिए

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