Hide Math function implementations in a closure.

src/third_party/fdlibm/fdlibm.js

 // The following is adapted from fdlibm (http://www.netlib.org/fdlibm),
 //
 // ====================================================
 // Copyright (C) 1993-2004 by Sun Microsystems, Inc. All rights reserved.
 //
 // Developed at SunSoft, a Sun Microsystems, Inc. business.
 // Permission to use, copy, modify, and distribute this
 // software is freely granted, provided that this notice
 // is preserved.
 // ====================================================
@@ skipping 10 matching lines @@
 // from decimal to binary accurately enough to produce the intended values.
 // kMath is initialized to a Float64Array during genesis and not writable.
 // rempio2result is used as a container for return values of %RemPiO2. It is
 // initialized to a two-element Float64Array during genesis.
 
 "use strict";
 
 var kMath;
 var rempio2result;
 
+(function() {
+
 const INVPIO2 = kMath[0];
 const PIO2_1  = kMath[1];
 const PIO2_1T = kMath[2];
 const PIO2_2  = kMath[3];
 const PIO2_2T = kMath[4];
 const PIO2_3  = kMath[5];
 const PIO2_3T = kMath[6];
 const PIO4    = kMath[32];
 const PIO4LO  = kMath[33];
 
@@ skipping 31 matching lines @@
       } else {
         // near pi/2, use 33+33+53 bit pi
         z += PIO2_2;
         y0 = z + PIO2_2T;
         y1 = (z - y0) + PIO2_2T;
       }
       n = -1;
     }
   } else if (ix <= 0x413921fb) {
     // |X| ~<= 2^19*(pi/2), medium size
-    var t = MathAbs(X);
+    var t = $abs(X);
     n = (t * INVPIO2 + 0.5) | 0;
     var r = t - n * PIO2_1;
     var w = n * PIO2_1T;
     // First round good to 85 bit
     y0 = r - w;
     if (ix - (%_DoubleHi(y0) & 0x7ff00000) > 0x1000000) {
       // 2nd iteration needed, good to 118
       t = r;
       w = n * PIO2_2;
       r = t - w;
@@ skipping 157 matching lines @@
 
 function KernelTan(x, y, returnTan) {
   var z;
   var w;
   var hx = %_DoubleHi(x);
   var ix = hx & 0x7fffffff;
 
   if (ix < 0x3e300000) {  // |x| < 2^-28
     if (((ix | %_DoubleLo(x)) | (returnTan + 1)) == 0) {
       // x == 0 && returnTan = -1
-      return 1 / MathAbs(x);
+      return 1 / $abs(x);
     } else {
       if (returnTan == 1) {
         return x;
       } else {
         // Compute -1/(x + y) carefully
         var w = x + y;
         var z = %_ConstructDouble(%_DoubleHi(w), 0);
         var v = y - (z - x);
         var a = -1 / w;
         var t = %_ConstructDouble(%_DoubleHi(a), 0);
@@ skipping 467 matching lines @@
 //      only sinh(0)=0 is exact for finite x.
 //
 const KSINH_OVERFLOW = kMath[51];
 const TWO_M28 = 3.725290298461914e-9;  // 2^-28, empty lower half
 const LOG_MAXD = 709.7822265625;  // 0x40862e42 00000000, empty lower half
 
 function MathSinh(x) {
   x = x * 1;  // Convert to number.
   var h = (x < 0) ? -0.5 : 0.5;
   // |x| in [0, 22]. return sign(x)*0.5*(E+E/(E+1))
-  var ax = MathAbs(x);
+  var ax = $abs(x);
   if (ax < 22) {
     // For |x| < 2^-28, sinh(x) = x
     if (ax < TWO_M28) return x;
     var t = MathExpm1(ax);
     if (ax < 1) return h * (2 * t - t * t / (t + 1));
     return h * (t + t / (t + 1));
   }
   // |x| in [22, log(maxdouble)], return 0.5 * exp(|x|)
-  if (ax < LOG_MAXD) return h * MathExp(ax);
+  if (ax < LOG_MAXD) return h * $exp(ax);
   // |x| in [log(maxdouble), overflowthreshold]
   // overflowthreshold = 710.4758600739426
   if (ax <= KSINH_OVERFLOW) {
-    var w = MathExp(0.5 * ax);
+    var w = $exp(0.5 * ax);
     var t = h * w;
     return t * w;
   }
   // |x| > overflowthreshold or is NaN.
   // Return Infinity of the appropriate sign or NaN.
   return x * INFINITY;
 }
 
 
 // ES6 draft 09-27-13, section 20.2.2.12.
@@ skipping 17 matching lines @@
 //      cosh(x) is |x| if x is +INF, -INF, or NaN.
 //      only cosh(0)=1 is exact for finite x.
 //
 const KCOSH_OVERFLOW = kMath[51];
 
 function MathCosh(x) {
   x = x * 1;  // Convert to number.
   var ix = %_DoubleHi(x) & 0x7fffffff;
   // |x| in [0,0.5*log2], return 1+expm1(|x|)^2/(2*exp(|x|))
   if (ix < 0x3fd62e43) {
-    var t = MathExpm1(MathAbs(x));
+    var t = MathExpm1($abs(x));
     var w = 1 + t;
     // For |x| < 2^-55, cosh(x) = 1
     if (ix < 0x3c800000) return w;
     return 1 + (t * t) / (w + w);
   }
   // |x| in [0.5*log2, 22], return (exp(|x|)+1/exp(|x|)/2
   if (ix < 0x40360000) {
-    var t = MathExp(MathAbs(x));
+    var t = $exp($abs(x));
     return 0.5 * t + 0.5 / t;
   }
   // |x| in [22, log(maxdouble)], return half*exp(|x|)
-  if (ix < 0x40862e42) return 0.5 * MathExp(MathAbs(x));
+  if (ix < 0x40862e42) return 0.5 * $exp($abs(x));
   // |x| in [log(maxdouble), overflowthreshold]
-  if (MathAbs(x) <= KCOSH_OVERFLOW) {
-    var w = MathExp(0.5 * MathAbs(x));
+  if ($abs(x) <= KCOSH_OVERFLOW) {
+    var w = $exp(0.5 * $abs(x));
     var t = 0.5 * w;
     return t * w;
   }
   if (NUMBER_IS_NAN(x)) return x;
   // |x| > overflowthreshold.
   return INFINITY;
 }
 
 // ES6 draft 09-27-13, section 20.2.2.21.
 // Return the base 10 logarithm of x
@@ skipping 47 matching lines @@
 
   // Infinity or NaN.
   if (hx >= 0x7ff00000) return x;
 
   k += (hx >> 20) - 1023;
   i = (k & 0x80000000) >> 31;
   hx = (hx & 0x000fffff) | ((0x3ff - i) << 20);
   y = k + i;
   x = %_ConstructDouble(hx, lx);
 
-  z = y * LOG10_2LO + IVLN10 * MathLog(x);
+  z = y * LOG10_2LO + IVLN10 * %_MathLogRT(x);
   return z + y * LOG10_2HI;
 }
 
 
 // ES6 draft 09-27-13, section 20.2.2.22.
 // Return the base 2 logarithm of x
 //
 // fdlibm does not have an explicit log2 function, but fdlibm's pow
 // function does implement an accurate log2 function as part of the
 // pow implementation.  This extracts the core parts of that as a
@@ skipping 14 matching lines @@
 
 // cp = 2/(3*ln(2)). Note that cp_h + cp_l is cp, but with more accuracy.
 const CP = kMath[61];
 const CP_H = kMath[62];
 const CP_L = kMath[63];
 // 2^53
 const TWO53 = 9007199254740992; 
 
 function MathLog2(x) {
   x = x * 1;  // Convert to number.
-  var ax = MathAbs(x);
+  var ax = $abs(x);
   var hx = %_DoubleHi(x);
   var lx = %_DoubleLo(x);
   var ix = hx & 0x7fffffff;
 
   // Handle special cases.
   // log2(+/- 0) = -Infinity
   if ((ix | lx) == 0) return -INFINITY;
 
   // log(x) = NaN, if x < 0
   if (hx < 0) return NAN;
@@ skipping 62 matching lines @@
   z_l = CP_L * p_h + p_l * CP + dp_l;
 
   // log2(ax) = (ss + ...) * 2 / (3 * log(2)) = n + dp_h + z_h + z_l
   var t = n;
   var t1 = %_ConstructDouble(%_DoubleHi(((z_h + z_l) + dp_h) + t), 0);
   var t2 = z_l - (((t1 - t) - dp_h) - z_h);
 
   // t1 + t2 = log2(ax), sum up because we do not care about extra precision.
   return t1 + t2;
 }
+
+InstallFunctions($Math, DONT_ENUM, $Array(
+  "cos", MathCos,
+  "sin", MathSin,
+  "tan", MathTan,
+  "sinh", MathSinh,
+  "cosh", MathCosh,
+  "log10", MathLog10,
+  "log2", MathLog2,
+  "log1p", MathLog1p,
+  "expm1", MathExpm1
+));
+
+%SetInlineBuiltinFlag(MathSin);
+%SetInlineBuiltinFlag(MathCos);
+
+})();