Further improve Math.sin/cos.

src/math.js

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 199 matching lines @@
 }
 
 
 var InitTrigonometricFunctions;
 
 
 // Define constants and interpolation functions.
 // Also define the initialization function that populates the lookup table
 // and then wires up the function definitions.
 function SetupTrigonometricFunctions() {
-  var samples = 1800;  // Table size.
-  var pi = 3.1415926535897932;
-  var pi_half = pi / 2;
-  var inverse_pi_half = 2 / pi;
-  var two_pi = 2 * pi;
-  var four_pi = 4 * pi;
-  var interval = pi_half / samples;
-  var inverse_interval = samples / pi_half;
+  var samples = 1620;  // Table size.  Do not change arbitrarily.
+  var inverse_pi_half = 0.63661977236758134;
   var table_sin;
   var table_cos_interval;
 
   // This implements sine using the following algorithm.
   // 1) Multiplication takes care of to-number conversion.
   // 2) Reduce x to the first quadrant [0, pi/2].
   //    Conveniently enough, in case of +/-Infinity, we get NaN.
   // 3) Replace x by (pi/2-x) if x was in the 2nd or 4th quadrant.
   // 4) Do a table lookup for the closest samples to the left and right of x.
   // 5) Find the derivatives at those sampling points by table lookup:
   //    dsin(x)/dx = cos(x) = sin(pi/2-x) for x in [0, pi/2].
   // 6) Use cubic spline interpolation to approximate sin(x).
   // 7) Negate the result if x was in the 3rd or 4th quadrant.
   // 8) Get rid of -0 by adding 0.
   var Interpolation = function(x) {
-    var double_index = x * inverse_interval;
+    var double_index = x * samples;
     var index = double_index | 0;
     var t1 = double_index - index;
     var t2 = 1 - t1;
     var y1 = table_sin[index];
     var y2 = table_sin[index + 1];
     var dy = y2 - y1;
     return (t2 * y1 + t1 * y2 +
                 t1 * t2 * ((table_cos_interval[index] - dy) * t2 +
                            (dy - table_cos_interval[index + 1]) * t1));
   }
 
   var MathSinInterpolation = function(x) {
-    // This is to make Sunspider's result verification happy.
-    if (x > four_pi) x -= four_pi;
-    var multiple = MathFloor(x * inverse_pi_half);
-    if (%_IsMinusZero(multiple)) return multiple;
-    x = (multiple & 1) * pi_half +
-        (1 - ((multiple & 1) << 1)) * (x - multiple * pi_half);
+    x = x * inverse_pi_half;
+    var multiple = MathFloor(x);
+    if (%_IsMinusZero(multiple)) return -0;

[Jakob Kummerow, 2013/11/18 13:53:46]

Why this change? "return multiple" might be (ever so slightly) faster.

+    x = (multiple & 1) + (1 - ((multiple & 1) << 1)) * (x - multiple);
     return Interpolation(x) * (1 - (multiple & 2)) + 0;
   }
 
   // Cosine is sine with a phase offset of pi/2.
   var MathCosInterpolation = function(x) {
-    var multiple = MathFloor(x * inverse_pi_half);
+    x = x * inverse_pi_half;
+    var multiple = MathFloor(x);
     var phase = multiple + 1;
-    x = (phase & 1) * pi_half +
-        (1 - ((phase & 1) << 1)) * (x - multiple * pi_half);
+    x = (phase & 1) + (1 - ((phase & 1) << 1)) * (x - multiple);
     return Interpolation(x) * (1 - (phase & 2)) + 0;
   };
 
   %SetInlineBuiltinFlag(Interpolation);
   %SetInlineBuiltinFlag(MathSinInterpolation);
   %SetInlineBuiltinFlag(MathCosInterpolation);
 
   InitTrigonometricFunctions = function() {
     table_sin = new global.Float64Array(samples + 2);
     table_cos_interval = new global.Float64Array(samples + 2);
@@ skipping 78 matching lines @@
     "min", MathMin,
     "imul", MathImul
   ));
 
   %SetInlineBuiltinFlag(MathSin);
   %SetInlineBuiltinFlag(MathCos);
   %SetInlineBuiltinFlag(MathTan);
 }
 
 SetUpMath();