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