为什么Java语言的Math.pow（）与C语言中的相同，似乎返回一个四舍五入的值？

Question

My understanding is that both C's double and Javascript's numbers are IEEE 754 64 bit floating point numbers. I am trying to port some code from C to Nodejs, and I am running into what appears to be a rounding error in Javascript's Math.pow() .

Here is my C program:

#include "stdio.h"
#include "math.h"

int main(int argc, char *argv[]) {
  double shared = 729;
  double exponent = 15;
  double prime = 1500450271;
  double power = pow(shared, exponent);
  double mod = fmod(power, prime);
  int intResult = (int) mod;
  printf("shared: %lf, exponent: %lf, prime: %lf, pow: %lf, mod: %lf, result: %i\n",
      shared, exponent, prime, power, mod, intResult); 
}

The output of which is:

shared: 729.000000, exponent: 15.000000, prime: 1500450271.000000, pow: 8727963568087711970669458465954849888403456.000000, mod: 1488486878.000000, result: 1488486878

Interestingly, when I try to perform this calculation in Javascript (tested in node, Chrome, Firefox)

I get the following result:

> Math.pow( 729, 15)
8.727963568087713e+42
> Math.pow( 729, 15 ) % 1500450271;
93655693

In addition, when I store the power result from C in a Javascript number:

> 8727963568087711970669458465954849888403456.0
8.727963568087712e+42

Note the difference -> 8.727963568087713e+42 !== 8.727963568087712e+42 , so understandably the modulo operation fails to produce the same result.

I've had a look at the source for v8's implementation of Math.pow, but the masm macros look like greek to me atm.

Any help here is appreciated.

Answer 1

ECMAScript ("JavaScript") doesn't make any guarantees about the precision of the pow function. ECMA-262 says :

Returns an implementation-dependent approximation to the result of raising x to the power y.

Neither does the C language. Only the optional Annex F of the C99 spec refers to IEC 60559 (same as IEEE 754), but pow isn't one of the basic operations for which there are precision guarantees.

In your case, the result you get from Node.js is slighty more inaccurate than the result from your C program, but this doesn't violate the spec. You simply have to live with this kind of differences. Calling fmod on huge floating point numbers is foolish anyway.

Edit: The reason for the discrepancy is probably excess precision of the x87 80-bit "double extended" format. Take the following program:

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

int main(int argc, char *argv[]) {
    int base = atoi(argv[1]);
    int exp  = atoi(argv[2]);
    printf("pow: %.15e\n", pow(base, exp));
    return 0;
}

Compiled with gcc and no special options:

$ gcc -Wall -O2 pow.c -lm -o pow
$ ./pow 729 15
pow: 8.727963568087712e+42

Compiled with -mpc64 :

$ gcc -mpc64 -Wall -O2 pow.c -lm -o pow
$ ./pow 729 15
pow: 8.727963568087713e+42