Line data Source code
1 : // Copyright 2016 the V8 project authors. All rights reserved.
2 : // Use of this source code is governed by a BSD-style license that can be
3 : // found in the LICENSE file.
4 :
5 : #include <limits>
6 :
7 : #include "src/base/ieee754.h"
8 : #include "src/base/macros.h"
9 : #include "src/base/overflowing-math.h"
10 : #include "testing/gmock-support.h"
11 : #include "testing/gtest-support.h"
12 :
13 : using testing::BitEq;
14 : using testing::IsNaN;
15 :
16 : namespace v8 {
17 : namespace base {
18 : namespace ieee754 {
19 :
20 : namespace {
21 :
22 : double const kE = 2.718281828459045;
23 : double const kPI = 3.141592653589793;
24 : double const kTwo120 = 1.329227995784916e+36;
25 : double const kInfinity = std::numeric_limits<double>::infinity();
26 : double const kQNaN = std::numeric_limits<double>::quiet_NaN();
27 : double const kSNaN = std::numeric_limits<double>::signaling_NaN();
28 :
29 : } // namespace
30 :
31 15188 : TEST(Ieee754, Acos) {
32 1 : EXPECT_THAT(acos(kInfinity), IsNaN());
33 1 : EXPECT_THAT(acos(-kInfinity), IsNaN());
34 1 : EXPECT_THAT(acos(kQNaN), IsNaN());
35 1 : EXPECT_THAT(acos(kSNaN), IsNaN());
36 :
37 2 : EXPECT_EQ(0.0, acos(1.0));
38 1 : }
39 :
40 15188 : TEST(Ieee754, Acosh) {
41 : // Tests for acosh for exceptional values
42 2 : EXPECT_EQ(kInfinity, acosh(kInfinity));
43 1 : EXPECT_THAT(acosh(-kInfinity), IsNaN());
44 1 : EXPECT_THAT(acosh(kQNaN), IsNaN());
45 1 : EXPECT_THAT(acosh(kSNaN), IsNaN());
46 1 : EXPECT_THAT(acosh(0.9), IsNaN());
47 :
48 : // Test basic acosh functionality
49 2 : EXPECT_EQ(0.0, acosh(1.0));
50 : // acosh(1.5) = log((sqrt(5)+3)/2), case 1 < x < 2
51 2 : EXPECT_EQ(0.9624236501192069e0, acosh(1.5));
52 : // acosh(4) = log(sqrt(15)+4), case 2 < x < 2^28
53 2 : EXPECT_EQ(2.0634370688955608e0, acosh(4.0));
54 : // acosh(2^50), case 2^28 < x
55 2 : EXPECT_EQ(35.35050620855721e0, acosh(1125899906842624.0));
56 : // acosh(most-positive-float), no overflow
57 2 : EXPECT_EQ(710.4758600739439e0, acosh(1.7976931348623157e308));
58 1 : }
59 :
60 15188 : TEST(Ieee754, Asin) {
61 1 : EXPECT_THAT(asin(kInfinity), IsNaN());
62 1 : EXPECT_THAT(asin(-kInfinity), IsNaN());
63 1 : EXPECT_THAT(asin(kQNaN), IsNaN());
64 1 : EXPECT_THAT(asin(kSNaN), IsNaN());
65 :
66 1 : EXPECT_THAT(asin(0.0), BitEq(0.0));
67 1 : EXPECT_THAT(asin(-0.0), BitEq(-0.0));
68 1 : }
69 :
70 15188 : TEST(Ieee754, Asinh) {
71 : // Tests for asinh for exceptional values
72 2 : EXPECT_EQ(kInfinity, asinh(kInfinity));
73 2 : EXPECT_EQ(-kInfinity, asinh(-kInfinity));
74 1 : EXPECT_THAT(asin(kQNaN), IsNaN());
75 1 : EXPECT_THAT(asin(kSNaN), IsNaN());
76 :
77 : // Test basic asinh functionality
78 1 : EXPECT_THAT(asinh(0.0), BitEq(0.0));
79 1 : EXPECT_THAT(asinh(-0.0), BitEq(-0.0));
80 : // asinh(2^-29) = 2^-29, case |x| < 2^-28, where acosh(x) = x
81 2 : EXPECT_EQ(1.862645149230957e-9, asinh(1.862645149230957e-9));
82 : // asinh(-2^-29) = -2^-29, case |x| < 2^-28, where acosh(x) = x
83 2 : EXPECT_EQ(-1.862645149230957e-9, asinh(-1.862645149230957e-9));
84 : // asinh(2^-28), case 2 > |x| >= 2^-28
85 2 : EXPECT_EQ(3.725290298461914e-9, asinh(3.725290298461914e-9));
86 : // asinh(-2^-28), case 2 > |x| >= 2^-28
87 2 : EXPECT_EQ(-3.725290298461914e-9, asinh(-3.725290298461914e-9));
88 : // asinh(1), case 2 > |x| > 2^-28
89 2 : EXPECT_EQ(0.881373587019543e0, asinh(1.0));
90 : // asinh(-1), case 2 > |x| > 2^-28
91 2 : EXPECT_EQ(-0.881373587019543e0, asinh(-1.0));
92 : // asinh(5), case 2^28 > |x| > 2
93 2 : EXPECT_EQ(2.3124383412727525e0, asinh(5.0));
94 : // asinh(-5), case 2^28 > |x| > 2
95 2 : EXPECT_EQ(-2.3124383412727525e0, asinh(-5.0));
96 : // asinh(2^28), case 2^28 > |x|
97 2 : EXPECT_EQ(20.101268236238415e0, asinh(268435456.0));
98 : // asinh(-2^28), case 2^28 > |x|
99 2 : EXPECT_EQ(-20.101268236238415e0, asinh(-268435456.0));
100 : // asinh(<most-positive-float>), no overflow
101 2 : EXPECT_EQ(710.4758600739439e0, asinh(1.7976931348623157e308));
102 : // asinh(-<most-positive-float>), no overflow
103 2 : EXPECT_EQ(-710.4758600739439e0, asinh(-1.7976931348623157e308));
104 1 : }
105 :
106 15188 : TEST(Ieee754, Atan) {
107 1 : EXPECT_THAT(atan(kQNaN), IsNaN());
108 1 : EXPECT_THAT(atan(kSNaN), IsNaN());
109 1 : EXPECT_THAT(atan(-0.0), BitEq(-0.0));
110 1 : EXPECT_THAT(atan(0.0), BitEq(0.0));
111 1 : EXPECT_DOUBLE_EQ(1.5707963267948966, atan(kInfinity));
112 1 : EXPECT_DOUBLE_EQ(-1.5707963267948966, atan(-kInfinity));
113 1 : }
114 :
115 15188 : TEST(Ieee754, Atan2) {
116 1 : EXPECT_THAT(atan2(kQNaN, kQNaN), IsNaN());
117 1 : EXPECT_THAT(atan2(kQNaN, kSNaN), IsNaN());
118 1 : EXPECT_THAT(atan2(kSNaN, kQNaN), IsNaN());
119 1 : EXPECT_THAT(atan2(kSNaN, kSNaN), IsNaN());
120 1 : EXPECT_DOUBLE_EQ(0.7853981633974483, atan2(kInfinity, kInfinity));
121 1 : EXPECT_DOUBLE_EQ(2.356194490192345, atan2(kInfinity, -kInfinity));
122 1 : EXPECT_DOUBLE_EQ(-0.7853981633974483, atan2(-kInfinity, kInfinity));
123 1 : EXPECT_DOUBLE_EQ(-2.356194490192345, atan2(-kInfinity, -kInfinity));
124 1 : }
125 :
126 15188 : TEST(Ieee754, Atanh) {
127 1 : EXPECT_THAT(atanh(kQNaN), IsNaN());
128 1 : EXPECT_THAT(atanh(kSNaN), IsNaN());
129 1 : EXPECT_THAT(atanh(kInfinity), IsNaN());
130 2 : EXPECT_EQ(kInfinity, atanh(1));
131 2 : EXPECT_EQ(-kInfinity, atanh(-1));
132 1 : EXPECT_DOUBLE_EQ(0.54930614433405478, atanh(0.5));
133 1 : }
134 :
135 15188 : TEST(Ieee754, Cos) {
136 : // Test values mentioned in the EcmaScript spec.
137 1 : EXPECT_THAT(cos(kQNaN), IsNaN());
138 1 : EXPECT_THAT(cos(kSNaN), IsNaN());
139 1 : EXPECT_THAT(cos(kInfinity), IsNaN());
140 1 : EXPECT_THAT(cos(-kInfinity), IsNaN());
141 :
142 : // Tests for cos for |x| < pi/4
143 2 : EXPECT_EQ(1.0, 1 / cos(-0.0));
144 2 : EXPECT_EQ(1.0, 1 / cos(0.0));
145 : // cos(x) = 1 for |x| < 2^-27
146 2 : EXPECT_EQ(1, cos(2.3283064365386963e-10));
147 2 : EXPECT_EQ(1, cos(-2.3283064365386963e-10));
148 : // Test KERNELCOS for |x| < 0.3.
149 : // cos(pi/20) = sqrt(sqrt(2)*sqrt(sqrt(5)+5)+4)/2^(3/2)
150 2 : EXPECT_EQ(0.9876883405951378, cos(0.15707963267948966));
151 : // Test KERNELCOS for x ~= 0.78125
152 2 : EXPECT_EQ(0.7100335477927638, cos(0.7812504768371582));
153 2 : EXPECT_EQ(0.7100338835660797, cos(0.78125));
154 : // Test KERNELCOS for |x| > 0.3.
155 : // cos(pi/8) = sqrt(sqrt(2)+1)/2^(3/4)
156 2 : EXPECT_EQ(0.9238795325112867, cos(0.39269908169872414));
157 : // Test KERNELTAN for |x| < 0.67434.
158 2 : EXPECT_EQ(0.9238795325112867, cos(-0.39269908169872414));
159 :
160 : // Tests for cos.
161 2 : EXPECT_EQ(1, cos(3.725290298461914e-9));
162 : // Cover different code paths in KERNELCOS.
163 2 : EXPECT_EQ(0.9689124217106447, cos(0.25));
164 2 : EXPECT_EQ(0.8775825618903728, cos(0.5));
165 2 : EXPECT_EQ(0.7073882691671998, cos(0.785));
166 : // Test that cos(Math.PI/2) != 0 since Math.PI is not exact.
167 2 : EXPECT_EQ(6.123233995736766e-17, cos(1.5707963267948966));
168 : // Test cos for various phases.
169 2 : EXPECT_EQ(0.7071067811865474, cos(7.0 / 4 * kPI));
170 2 : EXPECT_EQ(0.7071067811865477, cos(9.0 / 4 * kPI));
171 2 : EXPECT_EQ(-0.7071067811865467, cos(11.0 / 4 * kPI));
172 2 : EXPECT_EQ(-0.7071067811865471, cos(13.0 / 4 * kPI));
173 2 : EXPECT_EQ(0.9367521275331447, cos(1000000.0));
174 2 : EXPECT_EQ(-3.435757038074824e-12, cos(1048575.0 / 2 * kPI));
175 :
176 : // Test Hayne-Panek reduction.
177 2 : EXPECT_EQ(-0.9258790228548379e0, cos(kTwo120));
178 2 : EXPECT_EQ(-0.9258790228548379e0, cos(-kTwo120));
179 1 : }
180 :
181 15188 : TEST(Ieee754, Cosh) {
182 : // Test values mentioned in the EcmaScript spec.
183 1 : EXPECT_THAT(cosh(kQNaN), IsNaN());
184 1 : EXPECT_THAT(cosh(kSNaN), IsNaN());
185 0 : EXPECT_THAT(cosh(kInfinity), kInfinity);
186 1 : EXPECT_THAT(cosh(-kInfinity), kInfinity);
187 2 : EXPECT_EQ(1, cosh(0.0));
188 2 : EXPECT_EQ(1, cosh(-0.0));
189 1 : }
190 :
191 15188 : TEST(Ieee754, Exp) {
192 1 : EXPECT_THAT(exp(kQNaN), IsNaN());
193 1 : EXPECT_THAT(exp(kSNaN), IsNaN());
194 2 : EXPECT_EQ(0.0, exp(-kInfinity));
195 2 : EXPECT_EQ(0.0, exp(-1000));
196 2 : EXPECT_EQ(0.0, exp(-745.1332191019412));
197 2 : EXPECT_EQ(2.2250738585072626e-308, exp(-708.39641853226408));
198 2 : EXPECT_EQ(3.307553003638408e-308, exp(-708.0));
199 2 : EXPECT_EQ(4.9406564584124654e-324, exp(-7.45133219101941108420e+02));
200 2 : EXPECT_EQ(0.36787944117144233, exp(-1.0));
201 2 : EXPECT_EQ(1.0, exp(-0.0));
202 2 : EXPECT_EQ(1.0, exp(0.0));
203 2 : EXPECT_EQ(1.0, exp(2.2250738585072014e-308));
204 :
205 : // Test that exp(x) is monotonic near 1.
206 1 : EXPECT_GE(exp(1.0), exp(0.9999999999999999));
207 1 : EXPECT_LE(exp(1.0), exp(1.0000000000000002));
208 :
209 : // Test that we produce the correctly rounded result for 1.
210 2 : EXPECT_EQ(kE, exp(1.0));
211 :
212 2 : EXPECT_EQ(7.38905609893065e0, exp(2.0));
213 2 : EXPECT_EQ(1.7976931348622732e308, exp(7.09782712893383973096e+02));
214 2 : EXPECT_EQ(2.6881171418161356e+43, exp(100.0));
215 2 : EXPECT_EQ(8.218407461554972e+307, exp(709.0));
216 2 : EXPECT_EQ(1.7968190737295725e308, exp(709.7822265625e0));
217 2 : EXPECT_EQ(kInfinity, exp(709.7827128933841e0));
218 2 : EXPECT_EQ(kInfinity, exp(710.0));
219 2 : EXPECT_EQ(kInfinity, exp(1000.0));
220 2 : EXPECT_EQ(kInfinity, exp(kInfinity));
221 1 : }
222 :
223 15188 : TEST(Ieee754, Expm1) {
224 1 : EXPECT_THAT(expm1(kQNaN), IsNaN());
225 1 : EXPECT_THAT(expm1(kSNaN), IsNaN());
226 2 : EXPECT_EQ(-1.0, expm1(-kInfinity));
227 2 : EXPECT_EQ(kInfinity, expm1(kInfinity));
228 2 : EXPECT_EQ(0.0, expm1(-0.0));
229 2 : EXPECT_EQ(0.0, expm1(0.0));
230 2 : EXPECT_EQ(1.718281828459045, expm1(1.0));
231 2 : EXPECT_EQ(2.6881171418161356e+43, expm1(100.0));
232 2 : EXPECT_EQ(8.218407461554972e+307, expm1(709.0));
233 2 : EXPECT_EQ(kInfinity, expm1(710.0));
234 1 : }
235 :
236 15188 : TEST(Ieee754, Log) {
237 1 : EXPECT_THAT(log(kQNaN), IsNaN());
238 1 : EXPECT_THAT(log(kSNaN), IsNaN());
239 1 : EXPECT_THAT(log(-kInfinity), IsNaN());
240 1 : EXPECT_THAT(log(-1.0), IsNaN());
241 2 : EXPECT_EQ(-kInfinity, log(-0.0));
242 2 : EXPECT_EQ(-kInfinity, log(0.0));
243 2 : EXPECT_EQ(0.0, log(1.0));
244 2 : EXPECT_EQ(kInfinity, log(kInfinity));
245 :
246 : // Test that log(E) produces the correctly rounded result.
247 2 : EXPECT_EQ(1.0, log(kE));
248 1 : }
249 :
250 15188 : TEST(Ieee754, Log1p) {
251 1 : EXPECT_THAT(log1p(kQNaN), IsNaN());
252 1 : EXPECT_THAT(log1p(kSNaN), IsNaN());
253 1 : EXPECT_THAT(log1p(-kInfinity), IsNaN());
254 2 : EXPECT_EQ(-kInfinity, log1p(-1.0));
255 2 : EXPECT_EQ(0.0, log1p(0.0));
256 2 : EXPECT_EQ(-0.0, log1p(-0.0));
257 2 : EXPECT_EQ(kInfinity, log1p(kInfinity));
258 2 : EXPECT_EQ(6.9756137364252422e-03, log1p(0.007));
259 2 : EXPECT_EQ(709.782712893384, log1p(1.7976931348623157e308));
260 2 : EXPECT_EQ(2.7755575615628914e-17, log1p(2.7755575615628914e-17));
261 2 : EXPECT_EQ(9.313225741817976e-10, log1p(9.313225746154785e-10));
262 2 : EXPECT_EQ(-0.2876820724517809, log1p(-0.25));
263 2 : EXPECT_EQ(0.22314355131420976, log1p(0.25));
264 2 : EXPECT_EQ(2.3978952727983707, log1p(10));
265 2 : EXPECT_EQ(36.841361487904734, log1p(10e15));
266 2 : EXPECT_EQ(37.08337388996168, log1p(12738099905822720));
267 2 : EXPECT_EQ(37.08336444902049, log1p(12737979646738432));
268 2 : EXPECT_EQ(1.3862943611198906, log1p(3));
269 2 : EXPECT_EQ(1.3862945995384413, log1p(3 + 9.5367431640625e-7));
270 2 : EXPECT_EQ(0.5596157879354227, log1p(0.75));
271 2 : EXPECT_EQ(0.8109302162163288, log1p(1.25));
272 1 : }
273 :
274 15188 : TEST(Ieee754, Log2) {
275 1 : EXPECT_THAT(log2(kQNaN), IsNaN());
276 1 : EXPECT_THAT(log2(kSNaN), IsNaN());
277 1 : EXPECT_THAT(log2(-kInfinity), IsNaN());
278 1 : EXPECT_THAT(log2(-1.0), IsNaN());
279 2 : EXPECT_EQ(-kInfinity, log2(0.0));
280 2 : EXPECT_EQ(-kInfinity, log2(-0.0));
281 2 : EXPECT_EQ(kInfinity, log2(kInfinity));
282 1 : }
283 :
284 15188 : TEST(Ieee754, Log10) {
285 1 : EXPECT_THAT(log10(kQNaN), IsNaN());
286 1 : EXPECT_THAT(log10(kSNaN), IsNaN());
287 1 : EXPECT_THAT(log10(-kInfinity), IsNaN());
288 1 : EXPECT_THAT(log10(-1.0), IsNaN());
289 2 : EXPECT_EQ(-kInfinity, log10(0.0));
290 2 : EXPECT_EQ(-kInfinity, log10(-0.0));
291 2 : EXPECT_EQ(kInfinity, log10(kInfinity));
292 2 : EXPECT_EQ(3.0, log10(1000.0));
293 2 : EXPECT_EQ(14.0, log10(100000000000000)); // log10(10 ^ 14)
294 2 : EXPECT_EQ(3.7389561269540406, log10(5482.2158));
295 2 : EXPECT_EQ(14.661551142893833, log10(458723662312872.125782332587));
296 2 : EXPECT_EQ(-0.9083828622192334, log10(0.12348583358871));
297 2 : EXPECT_EQ(5.0, log10(100000.0));
298 1 : }
299 :
300 15188 : TEST(Ieee754, Cbrt) {
301 1 : EXPECT_THAT(cbrt(kQNaN), IsNaN());
302 1 : EXPECT_THAT(cbrt(kSNaN), IsNaN());
303 2 : EXPECT_EQ(kInfinity, cbrt(kInfinity));
304 2 : EXPECT_EQ(-kInfinity, cbrt(-kInfinity));
305 2 : EXPECT_EQ(1.4422495703074083, cbrt(3));
306 2 : EXPECT_EQ(100, cbrt(100 * 100 * 100));
307 2 : EXPECT_EQ(46.415888336127786, cbrt(100000));
308 1 : }
309 :
310 15188 : TEST(Ieee754, Sin) {
311 : // Test values mentioned in the EcmaScript spec.
312 1 : EXPECT_THAT(sin(kQNaN), IsNaN());
313 1 : EXPECT_THAT(sin(kSNaN), IsNaN());
314 1 : EXPECT_THAT(sin(kInfinity), IsNaN());
315 1 : EXPECT_THAT(sin(-kInfinity), IsNaN());
316 :
317 : // Tests for sin for |x| < pi/4
318 2 : EXPECT_EQ(-kInfinity, Divide(1.0, sin(-0.0)));
319 2 : EXPECT_EQ(kInfinity, Divide(1.0, sin(0.0)));
320 : // sin(x) = x for x < 2^-27
321 2 : EXPECT_EQ(2.3283064365386963e-10, sin(2.3283064365386963e-10));
322 2 : EXPECT_EQ(-2.3283064365386963e-10, sin(-2.3283064365386963e-10));
323 : // sin(pi/8) = sqrt(sqrt(2)-1)/2^(3/4)
324 2 : EXPECT_EQ(0.3826834323650898, sin(0.39269908169872414));
325 2 : EXPECT_EQ(-0.3826834323650898, sin(-0.39269908169872414));
326 :
327 : // Tests for sin.
328 2 : EXPECT_EQ(0.479425538604203, sin(0.5));
329 2 : EXPECT_EQ(-0.479425538604203, sin(-0.5));
330 2 : EXPECT_EQ(1, sin(kPI / 2.0));
331 2 : EXPECT_EQ(-1, sin(-kPI / 2.0));
332 : // Test that sin(Math.PI) != 0 since Math.PI is not exact.
333 2 : EXPECT_EQ(1.2246467991473532e-16, sin(kPI));
334 2 : EXPECT_EQ(-7.047032979958965e-14, sin(2200.0 * kPI));
335 : // Test sin for various phases.
336 2 : EXPECT_EQ(-0.7071067811865477, sin(7.0 / 4.0 * kPI));
337 2 : EXPECT_EQ(0.7071067811865474, sin(9.0 / 4.0 * kPI));
338 2 : EXPECT_EQ(0.7071067811865483, sin(11.0 / 4.0 * kPI));
339 2 : EXPECT_EQ(-0.7071067811865479, sin(13.0 / 4.0 * kPI));
340 2 : EXPECT_EQ(-3.2103381051568376e-11, sin(1048576.0 / 4 * kPI));
341 :
342 : // Test Hayne-Panek reduction.
343 2 : EXPECT_EQ(0.377820109360752e0, sin(kTwo120));
344 2 : EXPECT_EQ(-0.377820109360752e0, sin(-kTwo120));
345 1 : }
346 :
347 15188 : TEST(Ieee754, Sinh) {
348 : // Test values mentioned in the EcmaScript spec.
349 1 : EXPECT_THAT(sinh(kQNaN), IsNaN());
350 1 : EXPECT_THAT(sinh(kSNaN), IsNaN());
351 1 : EXPECT_THAT(sinh(kInfinity), kInfinity);
352 1 : EXPECT_THAT(sinh(-kInfinity), -kInfinity);
353 2 : EXPECT_EQ(0.0, sinh(0.0));
354 2 : EXPECT_EQ(-0.0, sinh(-0.0));
355 1 : }
356 :
357 15188 : TEST(Ieee754, Tan) {
358 : // Test values mentioned in the EcmaScript spec.
359 1 : EXPECT_THAT(tan(kQNaN), IsNaN());
360 1 : EXPECT_THAT(tan(kSNaN), IsNaN());
361 1 : EXPECT_THAT(tan(kInfinity), IsNaN());
362 1 : EXPECT_THAT(tan(-kInfinity), IsNaN());
363 :
364 : // Tests for tan for |x| < pi/4
365 2 : EXPECT_EQ(kInfinity, Divide(1.0, tan(0.0)));
366 2 : EXPECT_EQ(-kInfinity, Divide(1.0, tan(-0.0)));
367 : // tan(x) = x for |x| < 2^-28
368 2 : EXPECT_EQ(2.3283064365386963e-10, tan(2.3283064365386963e-10));
369 2 : EXPECT_EQ(-2.3283064365386963e-10, tan(-2.3283064365386963e-10));
370 : // Test KERNELTAN for |x| > 0.67434.
371 2 : EXPECT_EQ(0.8211418015898941, tan(11.0 / 16.0));
372 2 : EXPECT_EQ(-0.8211418015898941, tan(-11.0 / 16.0));
373 2 : EXPECT_EQ(0.41421356237309503, tan(0.39269908169872414));
374 : // crbug/427468
375 2 : EXPECT_EQ(0.7993357819992383, tan(0.6743358));
376 :
377 : // Tests for tan.
378 2 : EXPECT_EQ(3.725290298461914e-9, tan(3.725290298461914e-9));
379 : // Test that tan(PI/2) != Infinity since PI is not exact.
380 2 : EXPECT_EQ(1.633123935319537e16, tan(kPI / 2));
381 : // Cover different code paths in KERNELTAN (tangent and cotangent)
382 2 : EXPECT_EQ(0.5463024898437905, tan(0.5));
383 2 : EXPECT_EQ(2.0000000000000027, tan(1.107148717794091));
384 2 : EXPECT_EQ(-1.0000000000000004, tan(7.0 / 4.0 * kPI));
385 2 : EXPECT_EQ(0.9999999999999994, tan(9.0 / 4.0 * kPI));
386 2 : EXPECT_EQ(-6.420676210313675e-11, tan(1048576.0 / 2.0 * kPI));
387 2 : EXPECT_EQ(2.910566692924059e11, tan(1048575.0 / 2.0 * kPI));
388 :
389 : // Test Hayne-Panek reduction.
390 2 : EXPECT_EQ(-0.40806638884180424e0, tan(kTwo120));
391 2 : EXPECT_EQ(0.40806638884180424e0, tan(-kTwo120));
392 1 : }
393 :
394 15188 : TEST(Ieee754, Tanh) {
395 : // Test values mentioned in the EcmaScript spec.
396 1 : EXPECT_THAT(tanh(kQNaN), IsNaN());
397 1 : EXPECT_THAT(tanh(kSNaN), IsNaN());
398 1 : EXPECT_THAT(tanh(kInfinity), 1);
399 1 : EXPECT_THAT(tanh(-kInfinity), -1);
400 2 : EXPECT_EQ(0.0, tanh(0.0));
401 2 : EXPECT_EQ(-0.0, tanh(-0.0));
402 1 : }
403 :
404 : } // namespace ieee754
405 : } // namespace base
406 9111 : } // namespace v8
|
