Implement trigonometric functions using a fdlibm port.

test/mjsunit/sin-cos.js

 // Copyright 2011 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 139 matching lines @@
 }
 
 var err_rms = Math.sqrt(squares[0] / test_inputs.length / 2);
 assertEqualsDelta(0, err_rms, 1E-14);
 
 assertEquals(-1, Math.cos({ valueOf: function() { return Math.PI; } }));
 assertEquals(0, Math.sin("0x00000"));
 assertEquals(1, Math.cos("0x00000"));
 assertTrue(isNaN(Math.sin(Infinity)));
 assertTrue(isNaN(Math.cos("-Infinity")));
-assertEquals("Infinity", String(Math.tan(Math.PI/2)));
-assertEquals("-Infinity", String(Math.tan(-Math.PI/2)));
+assertTrue(Math.tan(Math.PI/2) > 1e16);
+assertTrue(Math.tan(-Math.PI/2) < -1e16);
 assertEquals("-Infinity", String(1/Math.sin("-0")));
 
 // Assert that the remainder after division by pi is reasonably precise.
 function assertError(expected, x, epsilon) {
   assertTrue(Math.abs(x - expected) < epsilon);
 }
 
 assertEqualsDelta(0.9367521275331447,  Math.cos(1e06),  1e-15);
 assertEqualsDelta(0.8731196226768560,  Math.cos(1e10),  1e-08);
 assertEqualsDelta(0.9367521275331447,  Math.cos(-1e06), 1e-15);
 assertEqualsDelta(0.8731196226768560,  Math.cos(-1e10), 1e-08);
 assertEqualsDelta(-0.3499935021712929, Math.sin(1e06),  1e-15);
 assertEqualsDelta(-0.4875060250875106, Math.sin(1e10),  1e-08);
 assertEqualsDelta(0.3499935021712929,  Math.sin(-1e06), 1e-15);
 assertEqualsDelta(0.4875060250875106,  Math.sin(-1e10), 1e-08);
 assertEqualsDelta(0.7796880066069787,  Math.sin(1e16),  1e-05);
 assertEqualsDelta(-0.6261681981330861, Math.cos(1e16),  1e-05);
 
 // Assert that remainder calculation terminates.
 for (var i = -1024; i < 1024; i++) {
   assertFalse(isNaN(Math.sin(Math.pow(2, i))));
 }
 
 assertFalse(isNaN(Math.cos(1.57079632679489700)));
 assertFalse(isNaN(Math.cos(-1e-100)));
 assertFalse(isNaN(Math.cos(-1e-323)));
+
+// Tests for specific values expected from the fdlibm implementation.
+
+var two_32 = Math.pow(2, -32);
+var two_28 = Math.pow(2, -28);
+
+// Tests for Math.sin for |x| < pi/4

[Raymond Toy, 2014/07/24 16:51:12]

I think you should add more comments on what these tests are trying to test.
Otherwise, they look like just random numbers pulled out of a hat. Some are, but
most are not. The tests are trying to get coverage of all of the branches in the
routines.

It's probably easiest to pull the comments from the original test suite in
www/~rtoy/V8/tests.js.

[Raymond Toy, 2014/07/24 22:41:50]

The spec also lists specific values for various arguments. You should add tests
for these as well.

+assertEquals(Infinity, 1/Math.sin(+0.0));
+assertEquals(-Infinity, 1/Math.sin(-0.0));
+assertEquals(two_32, Math.sin(two_32));

[Raymond Toy, 2014/07/24 16:51:12]

The two_32 and two_28 tests are to verify that sin(x) = x, exactly.  It's really
hard to guess that from just these two tests.

[Yang, 2014/07/28 11:29:00]

Done.

+assertEquals(-two_32, Math.sin(-two_32));
+assertEquals(0.3826834323650898, Math.sin(Math.PI/8));
+assertEquals(-0.3826834323650898, -Math.sin(Math.PI/8));

[Raymond Toy, 2014/07/24 16:51:12]

I think these 2 tests are intended to test case of sin(x) for x < pi/4, which is
one of the branches in MathSin

[Yang, 2014/07/28 11:29:00]

Done.

+
+// Tests for Math.cos for |x| < pi/4
+assertEquals(1, Math.cos(two_32));
+assertEquals(1, Math.cos(-two_32));

[Raymond Toy, 2014/07/24 16:51:12]

These two are for verifying cos(x) = 1 exactly for |x| < 2^-27.

[Yang, 2014/07/28 11:29:00]

Done.

+assertEquals(0.9876883405951378, Math.cos(Math.PI/20));
+assertEquals(0.7100335477927638, Math.cos(0.7812504768371582));
+assertEquals(0.7100338835660797, Math.cos(0.78125));
+assertEquals(0.9238795325112867, Math.cos(Math.PI/8));
+assertEquals(0.9238795325112867, Math.cos(-Math.PI/8));
+
+// Tests for Math.tan for |x| < pi/4
+assertEquals("Infinity", String(1/Math.tan(0.0)));
+assertEquals("-Infinity", String(1/Math.tan(-0.0)));
+assertEquals(two_32, Math.tan(two_32));
+assertEquals(-two_32, Math.tan(-two_32));
+assertEquals(0.8211418015898941, Math.tan(11/16));
+assertEquals(-0.8211418015898941, Math.tan(-11/16));
+assertEquals(0.41421356237309503, Math.tan(Math.PI / 8));
+
+// Tests for Math.sin.
+assertEquals(0.479425538604203, Math.sin(0.5));
+assertEquals(-0.479425538604203, Math.sin(-0.5));
+assertEquals(1, Math.sin(Math.PI/2));
+assertEquals(-1, Math.sin(-Math.PI/2));
+assertEquals(1.2246467991473532e-16, Math.sin(Math.PI));
+assertEquals(-7.047032979958965e-14, Math.sin(2200*Math.PI));
+assertEquals(-0.7071067811865477, Math.sin(7/4 * Math.PI));
+assertEquals(0.7071067811865474, Math.sin(9/4 * Math.PI));
+assertEquals(0.7071067811865483, Math.sin(11/4 * Math.PI));
+assertEquals(-0.7071067811865479, Math.sin(13/4 * Math.PI));
+assertEquals(-3.2103381051568376e-11, Math.sin(1048576/4 * Math.PI));
+
+// Tests for Math.cos.
+assertEquals(1, Math.cos(two_28));
+assertEquals(0.9689124217106447, Math.cos(0.25));
+assertEquals(0.8775825618903728, Math.cos(0.5));
+assertEquals(0.7073882691671998, Math.cos(0.785));
+assertEquals(6.123233995736766e-17, Math.cos(Math.PI/2));
+assertEquals(0.7071067811865474, Math.cos(7/4 * Math.PI));
+assertEquals(0.7071067811865477, Math.cos(9/4 * Math.PI));
+assertEquals(-0.7071067811865467, Math.cos(11/4 * Math.PI));
+assertEquals(-0.7071067811865471, Math.cos(13/4 * Math.PI));
+assertEquals(0.9367521275331447, Math.cos(1000000));
+assertEquals(-3.435757038074824e-12, Math.cos(1048575/2 * Math.PI));
+
+// Tests for Math.tan.
+assertEquals(two_28, Math.tan(two_28));
+assertEquals(1.633123935319537e16, Math.tan(Math.PI/2));
+assertEquals(0.5463024898437905, Math.tan(0.5));
+assertEquals(0.8211418015898941, Math.tan(11/16));
+assertEquals(2.0000000000000027, Math.tan(1.107148717794091));
+assertEquals(-1.0000000000000004, Math.tan(7/4*Math.PI));
+assertEquals(0.9999999999999994, Math.tan(9/4*Math.PI));
+assertEquals(-6.420676210313675e-11, Math.tan(1048576/2*Math.PI));
+assertEquals(2.910566692924059e11, Math.tan(1048575/2*Math.PI));

[Raymond Toy, 2014/07/24 16:51:12]

Now that the full Payne-Hanek reduction is implemented you should add a couple
of tests for that. (My test suite didn't include it because I didn't implement
Payne-Hanek.)

Something like

assertEquals(0.377820109360752e0, Math.sin(Math.pow(2, 120)));
assertEquals(-0.9258790228548379e0, Math.cos(Math.pow(2, 120)));
assertEquals(-0.40806638884180424e0, Math.tan(Math.pow(2 ,120)));

You probably want to test -2^120 as well.

Another interesting test is pi*2^120 and it's negative.

assertEquals(0.9506464744956261e0, Math.PI * Math.sin(Math.pow(2,120)));
assertEquals(-0.310276135932232e0, Math.PI * Math.cos(Math.pow(2, 120)))
assertEquals(-3.063872352410817e0, Math.PI * Math.tan(Math.pow(2, 120)))

Also, tests.js includes some tests of reduction for various multiples of pi/2.
It might be useful to include those as well because they test various branches
on the reduction code where differing number of bits of pi are needed.

[Yang, 2014/07/28 11:29:00]

Done.