[fdlibm] Inline coefficients for __kernel_sin and __kernel_cos.

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 123 matching lines @@
 //    |  x                                               |
 //
 //  3. ieee_sin(X+Y) = ieee_sin(X) + sin'(X')*Y
 //              ~ ieee_sin(X) + (1-X*X/2)*Y
 //     For better accuracy, let
 //               3      2      2      2      2
 //          r = X *(S2+X *(S3+X *(S4+X *(S5+X *S6))))
 //     then                   3    2
 //          sin(x) = X + (S1*X + (X *(r-Y/2)+Y))
 //
-macro KSIN(x)
-kMath[7+x]
-endmacro
+const S1 = -1.66666666666666324348e-01;
+const S2 = 8.33333333332248946124e-03;
+const S3 = -1.98412698298579493134e-04;
+const S4 = 2.75573137070700676789e-06;
+const S5 = -2.50507602534068634195e-08;
+const S6 = 1.58969099521155010221e-10;
 
 macro RETURN_KERNELSIN(X, Y, SIGN)
   var z = X * X;
   var v = z * X;
-  var r = KSIN(1) + z * (KSIN(2) + z * (KSIN(3) +
-                    z * (KSIN(4) + z * KSIN(5))));
-  return (X - ((z * (0.5 * Y - v * r) - Y) - v * KSIN(0))) SIGN;
+  var r = S2 + z * (S3 + z * (S4 + z * (S5 + z * S6)));
+  return (X - ((z * (0.5 * Y - v * r) - Y) - v * S1)) SIGN;
 endmacro
 
 // __kernel_cos(X, Y)
 // kernel cos function on [-pi/4, pi/4], pi/4 ~ 0.785398164
 // Input X is assumed to be bounded by ~pi/4 in magnitude.
 // Input Y is the tail of X so that x = X + Y.
 //
 // Algorithm
 //  1. Since ieee_cos(-x) = ieee_cos(x), we need only to consider positive x.
 //  2. ieee_cos(x) is approximated by a polynomial of degree 14 on
@@ skipping 14 matching lines @@
 //     a correction term is necessary in ieee_cos(x) and hence
 //         cos(X+Y) = 1 - (X*X/2 - (r - X*Y))
 //     For better accuracy when x > 0.3, let qx = |x|/4 with
 //     the last 32 bits mask off, and if x > 0.78125, let qx = 0.28125.
 //     Then
 //         cos(X+Y) = (1-qx) - ((X*X/2-qx) - (r-X*Y)).
 //     Note that 1-qx and (X*X/2-qx) is EXACT here, and the
 //     magnitude of the latter is at least a quarter of X*X/2,
 //     thus, reducing the rounding error in the subtraction.
 //
-macro KCOS(x)
-kMath[13+x]
-endmacro
+const C1 = 4.16666666666666019037e-02;
+const C2 = -1.38888888888741095749e-03;
+const C3 = 2.48015872894767294178e-05;
+const C4 = -2.75573143513906633035e-07;
+const C5 = 2.08757232129817482790e-09;
+const C6 = -1.13596475577881948265e-11;
 
 macro RETURN_KERNELCOS(X, Y, SIGN)
   var ix = %_DoubleHi(X) & 0x7fffffff;
   var z = X * X;
-  var r = z * (KCOS(0) + z * (KCOS(1) + z * (KCOS(2)+
-          z * (KCOS(3) + z * (KCOS(4) + z * KCOS(5))))));
+  var r = z * (C1 + z * (C2 + z * (C3 + z * (C4 + z * (C5 + z * C6)))));
   if (ix < 0x3fd33333) {  // |x| ~< 0.3
     return (1 - (0.5 * z - (z * r - X * Y))) SIGN;
   } else {
     var qx;
     if (ix > 0x3fe90000) {  // |x| > 0.78125
       qx = 0.28125;
     } else {
       qx = %_ConstructDouble(%_DoubleHi(0.25 * X), 0);
     }
     var hz = 0.5 * z - qx;
@@ skipping 122 matching lines @@
     var sign = (n & 2) - 1;
     RETURN_KERNELSIN(y0, y1, * sign);
   } else {
     var sign = 1 - (n & 2);
     RETURN_KERNELCOS(y0, y1, * sign);
   }
 }
 
 // ECMA 262 - 15.8.2.16
 function MathSin(x) {
-  x = x * 1;  // Convert to number.
+  x = +x;  // Convert to number.
   if ((%_DoubleHi(x) & 0x7fffffff) <= 0x3fe921fb) {
     // |x| < pi/4, approximately.  No reduction needed.
     RETURN_KERNELSIN(x, 0, /* empty */);
   }
-  return MathSinSlow(x);
+  return +MathSinSlow(x);
 }
 
 // ECMA 262 - 15.8.2.7
 function MathCos(x) {
-  x = x * 1;  // Convert to number.
+  x = +x;  // Convert to number.
   if ((%_DoubleHi(x) & 0x7fffffff) <= 0x3fe921fb) {
     // |x| < pi/4, approximately.  No reduction needed.
     RETURN_KERNELCOS(x, 0, /* empty */);
   }
-  return MathCosSlow(x);
+  return +MathCosSlow(x);
 }
 
 // ECMA 262 - 15.8.2.18
 function MathTan(x) {
   x = x * 1;  // Convert to number.
   if ((%_DoubleHi(x) & 0x7fffffff) <= 0x3fe921fb) {
     // |x| < pi/4, approximately.  No reduction needed.
     return KernelTan(x, 0, 1);
   }
   REMPIO2(x);
@@ skipping 625 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;
 }