Math.pow() not giving precise answer

Question

I've used Math.pow() to calculate the exponential value in my project.

Now, For specific values like Math.pow(3,40), it returns 12157665459056929000.

But when i tried the same value using a scientific Calculator, it returns 12157665459056928801.

Then i tried to traverse the loop till the exponential value :

  function calculateExpo(base,power){
    base = parseInt(base);
    power = parseInt(power);
    var output = 1;
    gameObj.OutPutString = '';  //base + '^' + power + ' = ';
    for(var i=0;i<power;i++){
      output *= base;
      gameObj.OutPutString += base + ' x ';
    }
    // to remove the last comma 
    gameObj.OutPutString = gameObj.OutPutString.substring(0,gameObj.OutPutString.lastIndexOf('x'));
    gameObj.OutPutString += ' =  ' + output;
    return output;
  }

This also returns 12157665459056929000. Is there any restriction to Int type in JS ?

Answer 1

This behavior is highly dependent on the platform you are running this code at. Interestingly even the browser matters even on the same very machine.

<script>
document.write(Math.pow(3,40));
</script>

On my 64-bit machine Here are the results:

IE11: 12157665459056928000

FF25: 12157665459056929000

CH31: 12157665459056929000

SAFARI: 12157665459056929000

Answer 2

52 bits of JavaScript's 64-bit double-precision number values are used to store the "fraction" part of a number (the main part of the calculations performed), while 11 bits are used to store the "exponent" (basically, the position of the decimal point), and the 64th bit is used for the sign. (Update: see this illustration: http://en.wikipedia.org/wiki/File:IEEE_754_Double_Floating_Point_Format.svg)

There are slightly more than 63 bits worth of significant figures in the base-two expansion of 3^40 (63.3985... in a continuous sense, and 64 in a discrete sense), so hence it cannot be accurately computed using Math.pow(3, 40) in JavaScript. Only numbers with 52 or fewer significant figures in their base-two expansion (and a similar restriction on their order of magnitude fitting within 11 bits) have a chance to be represented accurately by a double-precision floating point value.

Take note that how large the number is does not matter as much as how many significant figures are used to represent it in base two. There are many numbers as large or larger than 3^40 which can be represented accurately by JavaScript's 64-bit double-precision number values.

Note:

3^40 = 1010100010111000101101000101001000101001000111111110100000100001 (base two)

(The length of the largest substring beginning and ending with a 1 is the number of base-two significant figures, which in this case is the entire string of 64 digits.)