third_party/fdlibm/fdlibm.js - platform/external/chromium_org/v8 - Git at Google

 // The following is adapted from fdlibm (http://www.netlib.org/fdlibm),
 //
 // ====================================================
 // Copyright (C) 1993 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.
 // ====================================================
 //
 // The original source code covered by the above license above has been
 // modified significantly by Google Inc.
 // Copyright 2014 the V8 project authors. All rights reserved.
 //
 // The following is a straightforward translation of fdlibm routines for
 // sin, cos, and tan, by Raymond Toy (rtoy@google.com).


 var kTrig;  // Initialized to a Float64Array during genesis and is not writable.

 const INVPIO2 = kTrig[0];
 const PIO2_1  = kTrig[1];
 const PIO2_1T = kTrig[2];
 const PIO2_2  = kTrig[3];
 const PIO2_2T = kTrig[4];
 const PIO2_3  = kTrig[5];
 const PIO2_3T = kTrig[6];
 const PIO4    = kTrig[32];
 const PIO4LO  = kTrig[33];

 // Compute k and r such that x - k*pi/2 = r where |r| < pi/4. For
 // precision, r is returned as two values y0 and y1 such that r = y0 + y1
 // to more than double precision.
 macro REMPIO2(X)
   var n, y0, y1;
   var hx = %_DoubleHi(X);
   var ix = hx & 0x7fffffff;

   if (ix < 0x4002d97c) {
     // |X| ~< 3*pi/4, special case with n = +/- 1
     if (hx > 0) {
       var z = X - PIO2_1;
       if (ix != 0x3ff921fb) {
         // 33+53 bit pi is good enough
         y0 = z - PIO2_1T;
         y1 = (z - y0) - PIO2_1T;
       } 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 {
       // Negative X
       var z = X + PIO2_1;
       if (ix != 0x3ff921fb) {
         // 33+53 bit pi is good enough
         y0 = z + PIO2_1T;
         y1 = (z - y0) + PIO2_1T;
       } 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);
     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;
       w = n * PIO2_2T - ((t - r) - w);
       y0 = r - w;
       if (ix - (%_DoubleHi(y0) & 0x7ff00000) > 0x3100000) {
         // 3rd iteration needed. 151 bits accuracy
         t = r;
         w = n * PIO2_3;
         r = t - w;
         w = n * PIO2_3T - ((t - r) - w);
         y0 = r - w;
       }
     }
     y1 = (r - y0) - w;
     if (hx < 0) {
       n = -n;
       y0 = -y0;
       y1 = -y1;
     }
   } else {
     // Need to do full Payne-Hanek reduction here.
     var r = %RemPiO2(X);
     n = r[0];
     y0 = r[1];
     y1 = r[2];
   }
 endmacro


 // __kernel_sin(X, Y, IY)
 // kernel sin function on [-pi/4, pi/4], pi/4 ~ 0.7854
 // 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_sin(-x) = -ieee_sin(x), we need only to consider positive x.
 //  2. ieee_sin(x) is approximated by a polynomial of degree 13 on
 //     [0,pi/4]
 //                           3            13
 //          sin(x) ~ x + S1*x + ... + S6*x
 //     where
 //
 //    |ieee_sin(x)    2     4     6     8     10     12  |     -58
 //    |----- - (1+S1*x +S2*x +S3*x +S4*x +S5*x  +S6*x   )| <= 2
 //    |  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)
 kTrig[7+x]
 endmacro

 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;
 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
 //     [0,pi/4]
 //                                   4            14
 //          cos(x) ~ 1 - x*x/2 + C1*x + ... + C6*x
 //     where the remez error is
 //
 //  |                   2     4     6     8     10    12     14 |     -58
 //  |ieee_cos(x)-(1-.5*x +C1*x +C2*x +C3*x +C4*x +C5*x  +C6*x  )| <= 2
 //  |                                                           |
 //
 //                 4     6     8     10    12     14
 //  3. let r = C1*x +C2*x +C3*x +C4*x +C5*x  +C6*x  , then
 //         ieee_cos(x) = 1 - x*x/2 + r
 //     since ieee_cos(X+Y) ~ ieee_cos(X) - ieee_sin(X)*Y
 //                    ~ ieee_cos(X) - X*Y,
 //     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)
 kTrig[13+x]
 endmacro

 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))))));
   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;
     return (1 - qx - (hz - (z * r - X * Y))) SIGN;
   }
 endmacro

 // kernel tan function on [-pi/4, pi/4], pi/4 ~ 0.7854
 // Input x is assumed to be bounded by ~pi/4 in magnitude.
 // Input y is the tail of x.
 // Input k indicates whether ieee_tan (if k = 1) or -1/tan (if k = -1)
 // is returned.
 //
 // Algorithm
 //  1. Since ieee_tan(-x) = -ieee_tan(x), we need only to consider positive x.
 //  2. if x < 2^-28 (hx<0x3e300000 0), return x with inexact if x!=0.
 //  3. ieee_tan(x) is approximated by a odd polynomial of degree 27 on
 //     [0,0.67434]
 //                           3             27
 //          tan(x) ~ x + T1*x + ... + T13*x
 //     where
 //
 //     |ieee_tan(x)    2     4            26   |     -59.2
 //     |----- - (1+T1*x +T2*x +.... +T13*x    )| <= 2
 //     |  x                                    |
 //
 //     Note: ieee_tan(x+y) = ieee_tan(x) + tan'(x)*y
 //                    ~ ieee_tan(x) + (1+x*x)*y
 //     Therefore, for better accuracy in computing ieee_tan(x+y), let
 //               3      2      2       2       2
 //          r = x *(T2+x *(T3+x *(...+x *(T12+x *T13))))
 //     then
 //                              3    2
 //          tan(x+y) = x + (T1*x + (x *(r+y)+y))
 //
 //  4. For x in [0.67434,pi/4],  let y = pi/4 - x, then
 //          tan(x) = ieee_tan(pi/4-y) = (1-ieee_tan(y))/(1+ieee_tan(y))
 //                 = 1 - 2*(ieee_tan(y) - (ieee_tan(y)^2)/(1+ieee_tan(y)))
 //
 // Set returnTan to 1 for tan; -1 for cot.  Anything else is illegal
 // and will cause incorrect results.
 //
 macro KTAN(x)
 kTrig[19+x]
 endmacro

 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);
     } 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);
         var s = 1 + t * z;
         return t + a * (s + t * v);
       }
     }
   }
   if (ix >= 0x3fe59429) {  // |x| > .6744
     if (x < 0) {
       x = -x;
       y = -y;
     }
     z = PIO4 - x;
     w = PIO4LO - y;
     x = z + w;
     y = 0;
   }
   z = x * x;
   w = z * z;

   // Break x^5 * (T1 + x^2*T2 + ...) into
   // x^5 * (T1 + x^4*T3 + ... + x^20*T11) +
   // x^5 * (x^2 * (T2 + x^4*T4 + ... + x^22*T12))
   var r = KTAN(1) + w * (KTAN(3) + w * (KTAN(5) +
                     w * (KTAN(7) + w * (KTAN(9) + w * KTAN(11)))));
   var v = z * (KTAN(2) + w * (KTAN(4) + w * (KTAN(6) +
                          w * (KTAN(8) + w * (KTAN(10) + w * KTAN(12))))));
   var s = z * x;
   r = y + z * (s * (r + v) + y);
   r = r + KTAN(0) * s;
   w = x + r;
   if (ix >= 0x3fe59428) {
     return (1 - ((hx >> 30) & 2)) *
       (returnTan - 2.0 * (x - (w * w / (w + returnTan) - r)));
   }
   if (returnTan == 1) {
     return w;
   } else {
     z = %_ConstructDouble(%_DoubleHi(w), 0);
     v = r - (z - x);
     var a = -1 / w;
     var t = %_ConstructDouble(%_DoubleHi(a), 0);
     s = 1 + t * z;
     return t + a * (s + t * v);
   }
 }

 function MathSinSlow(x) {
   REMPIO2(x);
   var sign = 1 - (n & 2);
   if (n & 1) {
     RETURN_KERNELCOS(y0, y1, * sign);
   } else {
     RETURN_KERNELSIN(y0, y1, * sign);
   }
 }

 function MathCosSlow(x) {
   REMPIO2(x);
   if (n & 1) {
     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.
   if ((%_DoubleHi(x) & 0x7fffffff) <= 0x3fe921fb) {
     // |x| < pi/4, approximately.  No reduction needed.
     RETURN_KERNELSIN(x, 0, /* empty */);
   }
   return MathSinSlow(x);
 }

 // ECMA 262 - 15.8.2.7
 function MathCos(x) {
   x = x * 1;  // Convert to number.
   if ((%_DoubleHi(x) & 0x7fffffff) <= 0x3fe921fb) {
     // |x| < pi/4, approximately.  No reduction needed.
     RETURN_KERNELCOS(x, 0, /* empty */);
   }
   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);
   return KernelTan(y0, y1, (n & 1) ? -1 : 1);
 }
	// The following is adapted from fdlibm (http://www.netlib.org/fdlibm),
	//
	// ====================================================
	// Copyright (C) 1993 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.
	// ====================================================
	//
	// The original source code covered by the above license above has been
	// modified significantly by Google Inc.
	// Copyright 2014 the V8 project authors. All rights reserved.
	//
	// The following is a straightforward translation of fdlibm routines for
	// sin, cos, and tan, by Raymond Toy (rtoy@google.com).


	var kTrig; // Initialized to a Float64Array during genesis and is not writable.

	const INVPIO2 = kTrig[0];
	const PIO2_1 = kTrig[1];
	const PIO2_1T = kTrig[2];
	const PIO2_2 = kTrig[3];
	const PIO2_2T = kTrig[4];
	const PIO2_3 = kTrig[5];
	const PIO2_3T = kTrig[6];
	const PIO4 = kTrig[32];
	const PIO4LO = kTrig[33];

	// Compute k and r such that x - k*pi/2 = r where \|r\| < pi/4. For
	// precision, r is returned as two values y0 and y1 such that r = y0 + y1
	// to more than double precision.
	macro REMPIO2(X)
	var n, y0, y1;
	var hx = %_DoubleHi(X);
	var ix = hx & 0x7fffffff;

	if (ix < 0x4002d97c) {
	// \|X\| ~< 3*pi/4, special case with n = +/- 1
	if (hx > 0) {
	var z = X - PIO2_1;
	if (ix != 0x3ff921fb) {
	// 33+53 bit pi is good enough
	y0 = z - PIO2_1T;
	y1 = (z - y0) - PIO2_1T;
	} 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 {
	// Negative X
	var z = X + PIO2_1;
	if (ix != 0x3ff921fb) {
	// 33+53 bit pi is good enough
	y0 = z + PIO2_1T;
	y1 = (z - y0) + PIO2_1T;
	} 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);
	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;
	w = n * PIO2_2T - ((t - r) - w);
	y0 = r - w;
	if (ix - (%_DoubleHi(y0) & 0x7ff00000) > 0x3100000) {
	// 3rd iteration needed. 151 bits accuracy
	t = r;
	w = n * PIO2_3;
	r = t - w;
	w = n * PIO2_3T - ((t - r) - w);
	y0 = r - w;
	}
	}
	y1 = (r - y0) - w;
	if (hx < 0) {
	n = -n;
	y0 = -y0;
	y1 = -y1;
	}
	} else {
	// Need to do full Payne-Hanek reduction here.
	var r = %RemPiO2(X);
	n = r[0];
	y0 = r[1];
	y1 = r[2];
	}
	endmacro


	// __kernel_sin(X, Y, IY)
	// kernel sin function on [-pi/4, pi/4], pi/4 ~ 0.7854
	// 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_sin(-x) = -ieee_sin(x), we need only to consider positive x.
	// 2. ieee_sin(x) is approximated by a polynomial of degree 13 on
	// [0,pi/4]
	// 3 13
	// sin(x) ~ x + S1x + ... + S6x
	// where
	//
	// \|ieee_sin(x) 2 4 6 8 10 12 \| -58
	// \|----- - (1+S1x +S2x +S3x +S4x +S5x +S6x )\| <= 2
	// \| x \|
	//
	// 3. ieee_sin(X+Y) = ieee_sin(X) + sin'(X')*Y
	// ~ ieee_sin(X) + (1-XX/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 + (S1X + (X (r-Y/2)+Y))
	//
	macro KSIN(x)
	kTrig[7+x]
	endmacro

	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;
	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
	// [0,pi/4]
	// 4 14
	// cos(x) ~ 1 - xx/2 + C1x + ... + C6*x
	// where the remez error is
	//
	// \| 2 4 6 8 10 12 14 \| -58
	// \|ieee_cos(x)-(1-.5x +C1x +C2x +C3x +C4x +C5x +C6*x )\| <= 2
	// \| \|
	//
	// 4 6 8 10 12 14
	// 3. let r = C1x +C2x +C3x +C4x +C5x +C6x , then
	// ieee_cos(x) = 1 - x*x/2 + r
	// since ieee_cos(X+Y) ~ ieee_cos(X) - ieee_sin(X)*Y
	// ~ ieee_cos(X) - X*Y,
	// a correction term is necessary in ieee_cos(x) and hence
	// cos(X+Y) = 1 - (XX/2 - (r - XY))
	// 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) - ((XX/2-qx) - (r-XY)).
	// 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)
	kTrig[13+x]
	endmacro

	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))))));
	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;
	return (1 - qx - (hz - (z * r - X * Y))) SIGN;
	}
	endmacro

	// kernel tan function on [-pi/4, pi/4], pi/4 ~ 0.7854
	// Input x is assumed to be bounded by ~pi/4 in magnitude.
	// Input y is the tail of x.
	// Input k indicates whether ieee_tan (if k = 1) or -1/tan (if k = -1)
	// is returned.
	//
	// Algorithm
	// 1. Since ieee_tan(-x) = -ieee_tan(x), we need only to consider positive x.
	// 2. if x < 2^-28 (hx<0x3e300000 0), return x with inexact if x!=0.
	// 3. ieee_tan(x) is approximated by a odd polynomial of degree 27 on
	// [0,0.67434]
	// 3 27
	// tan(x) ~ x + T1x + ... + T13x
	// where
	//
	// \|ieee_tan(x) 2 4 26 \| -59.2
	// \|----- - (1+T1x +T2x +.... +T13*x )\| <= 2
	// \| x \|
	//
	// Note: ieee_tan(x+y) = ieee_tan(x) + tan'(x)*y
	// ~ ieee_tan(x) + (1+xx)y
	// Therefore, for better accuracy in computing ieee_tan(x+y), let
	// 3 2 2 2 2
	// r = x (T2+x (T3+x (...+x (T12+x *T13))))
	// then
	// 3 2
	// tan(x+y) = x + (T1x + (x (r+y)+y))
	//
	// 4. For x in [0.67434,pi/4], let y = pi/4 - x, then
	// tan(x) = ieee_tan(pi/4-y) = (1-ieee_tan(y))/(1+ieee_tan(y))
	// = 1 - 2*(ieee_tan(y) - (ieee_tan(y)^2)/(1+ieee_tan(y)))
	//
	// Set returnTan to 1 for tan; -1 for cot. Anything else is illegal
	// and will cause incorrect results.
	//
	macro KTAN(x)
	kTrig[19+x]
	endmacro

	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);
	} 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);
	var s = 1 + t * z;
	return t + a * (s + t * v);
	}
	}
	}
	if (ix >= 0x3fe59429) { // \|x\| > .6744
	if (x < 0) {
	x = -x;
	y = -y;
	}
	z = PIO4 - x;
	w = PIO4LO - y;
	x = z + w;
	y = 0;
	}
	z = x * x;
	w = z * z;

	// Break x^5 * (T1 + x^2*T2 + ...) into
	// x^5 * (T1 + x^4T3 + ... + x^20T11) +
	// x^5 * (x^2 * (T2 + x^4T4 + ... + x^22T12))
	var r = KTAN(1) + w * (KTAN(3) + w * (KTAN(5) +
	w * (KTAN(7) + w * (KTAN(9) + w * KTAN(11)))));
	var v = z * (KTAN(2) + w * (KTAN(4) + w * (KTAN(6) +
	w * (KTAN(8) + w * (KTAN(10) + w * KTAN(12))))));
	var s = z * x;
	r = y + z * (s * (r + v) + y);
	r = r + KTAN(0) * s;
	w = x + r;
	if (ix >= 0x3fe59428) {
	return (1 - ((hx >> 30) & 2)) *
	(returnTan - 2.0 * (x - (w * w / (w + returnTan) - r)));
	}
	if (returnTan == 1) {
	return w;
	} else {
	z = %_ConstructDouble(%_DoubleHi(w), 0);
	v = r - (z - x);
	var a = -1 / w;
	var t = %_ConstructDouble(%_DoubleHi(a), 0);
	s = 1 + t * z;
	return t + a * (s + t * v);
	}
	}

	function MathSinSlow(x) {
	REMPIO2(x);
	var sign = 1 - (n & 2);
	if (n & 1) {
	RETURN_KERNELCOS(y0, y1, * sign);
	} else {
	RETURN_KERNELSIN(y0, y1, * sign);
	}
	}

	function MathCosSlow(x) {
	REMPIO2(x);
	if (n & 1) {
	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.
	if ((%_DoubleHi(x) & 0x7fffffff) <= 0x3fe921fb) {
	// \|x\| < pi/4, approximately. No reduction needed.
	RETURN_KERNELSIN(x, 0, /* empty */);
	}
	return MathSinSlow(x);
	}

	// ECMA 262 - 15.8.2.7
	function MathCos(x) {
	x = x * 1; // Convert to number.
	if ((%_DoubleHi(x) & 0x7fffffff) <= 0x3fe921fb) {
	// \|x\| < pi/4, approximately. No reduction needed.
	RETURN_KERNELCOS(x, 0, /* empty */);
	}
	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);
	return KernelTan(y0, y1, (n & 1) ? -1 : 1);
	}