return MathCosImpl(x);

return MathSinImpl(x);

return MathSinImpl(x) / MathCosImpl(x);

var MathSinImpl = function(x) {

InitTrigonometricFunctions();

return MathSinImpl(x);

var MathCosImpl = function(x) {

InitTrigonometricFunctions();

return MathCosImpl(x);

var InitTrigonometricFunctions;

function SetupTrigonometricFunctions() {

var samples = 1800; // Table size. Do not change arbitrarily.

var inverse_pi_half = 0.636619772367581343; // 2 / pi

var inverse_pi_half_s_26 = 9.48637384723993156e-9; // 2 / pi / (2^26)

var s_26 = 1 << 26;

var two_step_threshold = 1 << 27;

var index_convert = 1145.915590261646418; // samples / (pi / 2)

// pi / 2 rounded up

var pi_half = 1.570796326794896780; // 0x192d4454fb21f93f

// We use two parts for pi/2 to emulate a higher precision.

// pi_half_1 only has 26 significant bits for mantissa.

// Note that pi_half > pi_half_1 + pi_half_2

var pi_half_1 = 1.570796325802803040; // 0x00000054fb21f93f

var pi_half_2 = 9.920935796805404252e-10; // 0x3326a611460b113e

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.

// Note that we try to use only 26 instead of 52 significant bits for

// mantissa to avoid rounding errors when multiplying. For very large

// input we therefore have additional steps.

// 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, phase) {

if (x < 0 || x > pi_half) {

var multiple;

while (x < -two_step_threshold || x > two_step_threshold) {

// Let's assume this loop does not terminate.

// All numbers x in each loop forms a set S.

// (1) abs(x) > 2^27 for all x in S.

// (2) abs(multiple) != 0 since (2^27 * inverse_pi_half_s26) > 1

// (3) multiple is rounded down in 2^26 steps, so the rounding error is

// at most max(ulp, 2^26).

// (4) so for x > 2^27, we subtract at most (1+pi/4)x and at least

// (1-pi/4)x

// (5) The subtraction results in x' so that abs(x') <= abs(x)*pi/4.

// Note that this difference cannot be simply rounded off.

// Set S cannot exist since (5) violates (1). Loop must terminate.

multiple = MathFloor(x * inverse_pi_half_s_26) * s_26;

x = x - multiple * pi_half_1 - multiple * pi_half_2;

}

multiple = MathFloor(x * inverse_pi_half);

x = x - multiple * pi_half_1 - multiple * pi_half_2;

phase += multiple;

var double_index = x * index_convert;

if (phase & 1) double_index = samples - double_index;

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))

* (1 - (phase & 2)) + 0;

}

var MathSinInterpolation = function(x) {

x = x * 1; // Convert to number and deal with -0.

if (%_IsMinusZero(x)) return x;

return Interpolation(x, 0);

}

// Cosine is sine with a phase offset.

var MathCosInterpolation = function(x) {

x = MathAbs(x); // Convert to number and get rid of -0.

return Interpolation(x, 1);

};

%SetInlineBuiltinFlag(Interpolation);

%SetInlineBuiltinFlag(MathSinInterpolation);

%SetInlineBuiltinFlag(MathCosInterpolation);

InitTrigonometricFunctions = function() {

table_sin = new global.Float64Array(samples + 2);

table_cos_interval = new global.Float64Array(samples + 2);

%PopulateTrigonometricTable(table_sin, table_cos_interval, samples);

MathSinImpl = MathSinInterpolation;

MathCosImpl = MathCosInterpolation;

RUNTIME_FUNCTION(MaybeObject*, Runtime_PopulateTrigonometricTable) {

HandleScope scope(isolate);

ASSERT(args.length() == 3);

CONVERT_ARG_HANDLE_CHECKED(JSTypedArray, sin_table, 0);

CONVERT_ARG_HANDLE_CHECKED(JSTypedArray, cos_table, 1);

CONVERT_SMI_ARG_CHECKED(samples, 2);

RUNTIME_ASSERT(sin_table->type() == kExternalDoubleArray);

RUNTIME_ASSERT(cos_table->type() == kExternalDoubleArray);

double* sin_buffer = reinterpret_cast<double*>(

JSArrayBuffer::cast(sin_table->buffer())->backing_store());

double* cos_buffer = reinterpret_cast<double*>(

JSArrayBuffer::cast(cos_table->buffer())->backing_store());

static const double pi_half = 3.1415926535897932 / 2;

double interval = pi_half / samples;

for (int i = 0; i < samples + 1; i++) {

double sample = sin(i * interval);

sin_buffer[i] = sample;

cos_buffer[samples - i] = sample * interval;

}

// Fill this to catch out of bound accesses when calculating Math.sin(pi/2).

sin_buffer[samples + 1] = sin(pi_half + interval);

cos_buffer[samples + 1] = cos(pi_half + interval) * interval;

return isolate->heap()->undefined_value();

}

F(PopulateTrigonometricTable, 3, 1) \