?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Improve Register Setup
[llvm-core.git] / unittests / ADT / APFloatTest.cpp
blob1212b45fb575d6dd0b8b2b92e6b63bb66f16adc1
1 //===- llvm/unittest/ADT/APFloat.cpp - APFloat unit tests ---------------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9
10 #include "llvm/ADT/APFloat.h"
11 #include "llvm/ADT/APSInt.h"
12 #include "llvm/ADT/Hashing.h"
13 #include "llvm/ADT/SmallVector.h"
14 #include "llvm/Support/FormatVariadic.h"
15 #include "llvm/Support/raw_ostream.h"
16 #include "gtest/gtest.h"
17 #include <cmath>
18 #include <ostream>
19 #include <string>
20 #include <tuple>
21
22 using namespace llvm;
23
24 static double convertToDoubleFromString(const char *Str) {
25 llvm::APFloat F(0.0);
26 F.convertFromString(Str, llvm::APFloat::rmNearestTiesToEven);
27 return F.convertToDouble();
28 }
29
30 static std::string convertToString(double d, unsigned Prec, unsigned Pad,
31 bool Tr = true) {
32 llvm::SmallVector<char, 100> Buffer;
33 llvm::APFloat F(d);
34 F.toString(Buffer, Prec, Pad, Tr);
35 return std::string(Buffer.data(), Buffer.size());
36 }
37
38 namespace {
39
40 TEST(APFloatTest, isSignaling) {
41 // We test qNaN, -qNaN, +sNaN, -sNaN with and without payloads. *NOTE* The
42 // positive/negative distinction is included only since the getQNaN/getSNaN
43 // API provides the option.
44 APInt payload = APInt::getOneBitSet(4, 2);
45 EXPECT_FALSE(APFloat::getQNaN(APFloat::IEEEsingle(), false).isSignaling());
46 EXPECT_FALSE(APFloat::getQNaN(APFloat::IEEEsingle(), true).isSignaling());
47 EXPECT_FALSE(APFloat::getQNaN(APFloat::IEEEsingle(), false, &payload).isSignaling());
48 EXPECT_FALSE(APFloat::getQNaN(APFloat::IEEEsingle(), true, &payload).isSignaling());
49 EXPECT_TRUE(APFloat::getSNaN(APFloat::IEEEsingle(), false).isSignaling());
50 EXPECT_TRUE(APFloat::getSNaN(APFloat::IEEEsingle(), true).isSignaling());
51 EXPECT_TRUE(APFloat::getSNaN(APFloat::IEEEsingle(), false, &payload).isSignaling());
52 EXPECT_TRUE(APFloat::getSNaN(APFloat::IEEEsingle(), true, &payload).isSignaling());
53 }
54
55 TEST(APFloatTest, next) {
56
57 APFloat test(APFloat::IEEEquad(), APFloat::uninitialized);
58 APFloat expected(APFloat::IEEEquad(), APFloat::uninitialized);
59
60 // 1. Test Special Cases Values.
61 //
62 // Test all special values for nextUp and nextDown perscribed by IEEE-754R
63 // 2008. These are:
64 // 1. +inf
65 // 2. -inf
66 // 3. getLargest()
67 // 4. -getLargest()
68 // 5. getSmallest()
69 // 6. -getSmallest()
70 // 7. qNaN
71 // 8. sNaN
72 // 9. +0
73 // 10. -0
74
75 // nextUp(+inf) = +inf.
76 test = APFloat::getInf(APFloat::IEEEquad(), false);
77 expected = APFloat::getInf(APFloat::IEEEquad(), false);
78 EXPECT_EQ(test.next(false), APFloat::opOK);
79 EXPECT_TRUE(test.isInfinity());
80 EXPECT_TRUE(!test.isNegative());
81 EXPECT_TRUE(test.bitwiseIsEqual(expected));
82
83 // nextDown(+inf) = -nextUp(-inf) = -(-getLargest()) = getLargest()
84 test = APFloat::getInf(APFloat::IEEEquad(), false);
85 expected = APFloat::getLargest(APFloat::IEEEquad(), false);
86 EXPECT_EQ(test.next(true), APFloat::opOK);
87 EXPECT_TRUE(!test.isNegative());
88 EXPECT_TRUE(test.bitwiseIsEqual(expected));
89
90 // nextUp(-inf) = -getLargest()
91 test = APFloat::getInf(APFloat::IEEEquad(), true);
92 expected = APFloat::getLargest(APFloat::IEEEquad(), true);
93 EXPECT_EQ(test.next(false), APFloat::opOK);
94 EXPECT_TRUE(test.isNegative());
95 EXPECT_TRUE(test.bitwiseIsEqual(expected));
96
97 // nextDown(-inf) = -nextUp(+inf) = -(+inf) = -inf.
98 test = APFloat::getInf(APFloat::IEEEquad(), true);
99 expected = APFloat::getInf(APFloat::IEEEquad(), true);
100 EXPECT_EQ(test.next(true), APFloat::opOK);
101 EXPECT_TRUE(test.isInfinity() && test.isNegative());
102 EXPECT_TRUE(test.bitwiseIsEqual(expected));
103
104 // nextUp(getLargest()) = +inf
105 test = APFloat::getLargest(APFloat::IEEEquad(), false);
106 expected = APFloat::getInf(APFloat::IEEEquad(), false);
107 EXPECT_EQ(test.next(false), APFloat::opOK);
108 EXPECT_TRUE(test.isInfinity() && !test.isNegative());
109 EXPECT_TRUE(test.bitwiseIsEqual(expected));
110
111 // nextDown(getLargest()) = -nextUp(-getLargest())
112 // = -(-getLargest() + inc)
113 // = getLargest() - inc.
114 test = APFloat::getLargest(APFloat::IEEEquad(), false);
115 expected = APFloat(APFloat::IEEEquad(),
116 "0x1.fffffffffffffffffffffffffffep+16383");
117 EXPECT_EQ(test.next(true), APFloat::opOK);
118 EXPECT_TRUE(!test.isInfinity() && !test.isNegative());
119 EXPECT_TRUE(test.bitwiseIsEqual(expected));
120
121 // nextUp(-getLargest()) = -getLargest() + inc.
122 test = APFloat::getLargest(APFloat::IEEEquad(), true);
123 expected = APFloat(APFloat::IEEEquad(),
124 "-0x1.fffffffffffffffffffffffffffep+16383");
125 EXPECT_EQ(test.next(false), APFloat::opOK);
126 EXPECT_TRUE(test.bitwiseIsEqual(expected));
127
128 // nextDown(-getLargest()) = -nextUp(getLargest()) = -(inf) = -inf.
129 test = APFloat::getLargest(APFloat::IEEEquad(), true);
130 expected = APFloat::getInf(APFloat::IEEEquad(), true);
131 EXPECT_EQ(test.next(true), APFloat::opOK);
132 EXPECT_TRUE(test.isInfinity() && test.isNegative());
133 EXPECT_TRUE(test.bitwiseIsEqual(expected));
134
135 // nextUp(getSmallest()) = getSmallest() + inc.
136 test = APFloat(APFloat::IEEEquad(), "0x0.0000000000000000000000000001p-16382");
137 expected = APFloat(APFloat::IEEEquad(),
138 "0x0.0000000000000000000000000002p-16382");
139 EXPECT_EQ(test.next(false), APFloat::opOK);
140 EXPECT_TRUE(test.bitwiseIsEqual(expected));
141
142 // nextDown(getSmallest()) = -nextUp(-getSmallest()) = -(-0) = +0.
143 test = APFloat(APFloat::IEEEquad(), "0x0.0000000000000000000000000001p-16382");
144 expected = APFloat::getZero(APFloat::IEEEquad(), false);
145 EXPECT_EQ(test.next(true), APFloat::opOK);
146 EXPECT_TRUE(test.isPosZero());
147 EXPECT_TRUE(test.bitwiseIsEqual(expected));
148
149 // nextUp(-getSmallest()) = -0.
150 test = APFloat(APFloat::IEEEquad(), "-0x0.0000000000000000000000000001p-16382");
151 expected = APFloat::getZero(APFloat::IEEEquad(), true);
152 EXPECT_EQ(test.next(false), APFloat::opOK);
153 EXPECT_TRUE(test.isNegZero());
154 EXPECT_TRUE(test.bitwiseIsEqual(expected));
155
156 // nextDown(-getSmallest()) = -nextUp(getSmallest()) = -getSmallest() - inc.
157 test = APFloat(APFloat::IEEEquad(), "-0x0.0000000000000000000000000001p-16382");
158 expected = APFloat(APFloat::IEEEquad(),
159 "-0x0.0000000000000000000000000002p-16382");
160 EXPECT_EQ(test.next(true), APFloat::opOK);
161 EXPECT_TRUE(test.bitwiseIsEqual(expected));
162
163 // nextUp(qNaN) = qNaN
164 test = APFloat::getQNaN(APFloat::IEEEquad(), false);
165 expected = APFloat::getQNaN(APFloat::IEEEquad(), false);
166 EXPECT_EQ(test.next(false), APFloat::opOK);
167 EXPECT_TRUE(test.bitwiseIsEqual(expected));
168
169 // nextDown(qNaN) = qNaN
170 test = APFloat::getQNaN(APFloat::IEEEquad(), false);
171 expected = APFloat::getQNaN(APFloat::IEEEquad(), false);
172 EXPECT_EQ(test.next(true), APFloat::opOK);
173 EXPECT_TRUE(test.bitwiseIsEqual(expected));
174
175 // nextUp(sNaN) = qNaN
176 test = APFloat::getSNaN(APFloat::IEEEquad(), false);
177 expected = APFloat::getQNaN(APFloat::IEEEquad(), false);
178 EXPECT_EQ(test.next(false), APFloat::opInvalidOp);
179 EXPECT_TRUE(test.bitwiseIsEqual(expected));
180
181 // nextDown(sNaN) = qNaN
182 test = APFloat::getSNaN(APFloat::IEEEquad(), false);
183 expected = APFloat::getQNaN(APFloat::IEEEquad(), false);
184 EXPECT_EQ(test.next(true), APFloat::opInvalidOp);
185 EXPECT_TRUE(test.bitwiseIsEqual(expected));
186
187 // nextUp(+0) = +getSmallest()
188 test = APFloat::getZero(APFloat::IEEEquad(), false);
189 expected = APFloat::getSmallest(APFloat::IEEEquad(), false);
190 EXPECT_EQ(test.next(false), APFloat::opOK);
191 EXPECT_TRUE(test.bitwiseIsEqual(expected));
192
193 // nextDown(+0) = -nextUp(-0) = -getSmallest()
194 test = APFloat::getZero(APFloat::IEEEquad(), false);
195 expected = APFloat::getSmallest(APFloat::IEEEquad(), true);
196 EXPECT_EQ(test.next(true), APFloat::opOK);
197 EXPECT_TRUE(test.bitwiseIsEqual(expected));
198
199 // nextUp(-0) = +getSmallest()
200 test = APFloat::getZero(APFloat::IEEEquad(), true);
201 expected = APFloat::getSmallest(APFloat::IEEEquad(), false);
202 EXPECT_EQ(test.next(false), APFloat::opOK);
203 EXPECT_TRUE(test.bitwiseIsEqual(expected));
204
205 // nextDown(-0) = -nextUp(0) = -getSmallest()
206 test = APFloat::getZero(APFloat::IEEEquad(), true);
207 expected = APFloat::getSmallest(APFloat::IEEEquad(), true);
208 EXPECT_EQ(test.next(true), APFloat::opOK);
209 EXPECT_TRUE(test.bitwiseIsEqual(expected));
210
211 // 2. Binade Boundary Tests.
212
213 // 2a. Test denormal <-> normal binade boundaries.
214 // * nextUp(+Largest Denormal) -> +Smallest Normal.
215 // * nextDown(-Largest Denormal) -> -Smallest Normal.
216 // * nextUp(-Smallest Normal) -> -Largest Denormal.
217 // * nextDown(+Smallest Normal) -> +Largest Denormal.
218
219 // nextUp(+Largest Denormal) -> +Smallest Normal.
220 test = APFloat(APFloat::IEEEquad(), "0x0.ffffffffffffffffffffffffffffp-16382");
221 expected = APFloat(APFloat::IEEEquad(),
222 "0x1.0000000000000000000000000000p-16382");
223 EXPECT_EQ(test.next(false), APFloat::opOK);
224 EXPECT_FALSE(test.isDenormal());
225 EXPECT_TRUE(test.bitwiseIsEqual(expected));
226
227 // nextDown(-Largest Denormal) -> -Smallest Normal.
228 test = APFloat(APFloat::IEEEquad(),
229 "-0x0.ffffffffffffffffffffffffffffp-16382");
230 expected = APFloat(APFloat::IEEEquad(),
231 "-0x1.0000000000000000000000000000p-16382");
232 EXPECT_EQ(test.next(true), APFloat::opOK);
233 EXPECT_FALSE(test.isDenormal());
234 EXPECT_TRUE(test.bitwiseIsEqual(expected));
235
236 // nextUp(-Smallest Normal) -> -LargestDenormal.
237 test = APFloat(APFloat::IEEEquad(),
238 "-0x1.0000000000000000000000000000p-16382");
239 expected = APFloat(APFloat::IEEEquad(),
240 "-0x0.ffffffffffffffffffffffffffffp-16382");
241 EXPECT_EQ(test.next(false), APFloat::opOK);
242 EXPECT_TRUE(test.isDenormal());
243 EXPECT_TRUE(test.bitwiseIsEqual(expected));
244
245 // nextDown(+Smallest Normal) -> +Largest Denormal.
246 test = APFloat(APFloat::IEEEquad(),
247 "+0x1.0000000000000000000000000000p-16382");
248 expected = APFloat(APFloat::IEEEquad(),
249 "+0x0.ffffffffffffffffffffffffffffp-16382");
250 EXPECT_EQ(test.next(true), APFloat::opOK);
251 EXPECT_TRUE(test.isDenormal());
252 EXPECT_TRUE(test.bitwiseIsEqual(expected));
253
254 // 2b. Test normal <-> normal binade boundaries.
255 // * nextUp(-Normal Binade Boundary) -> -Normal Binade Boundary + 1.
256 // * nextDown(+Normal Binade Boundary) -> +Normal Binade Boundary - 1.
257 // * nextUp(+Normal Binade Boundary - 1) -> +Normal Binade Boundary.
258 // * nextDown(-Normal Binade Boundary + 1) -> -Normal Binade Boundary.
259
260 // nextUp(-Normal Binade Boundary) -> -Normal Binade Boundary + 1.
261 test = APFloat(APFloat::IEEEquad(), "-0x1p+1");
262 expected = APFloat(APFloat::IEEEquad(),
263 "-0x1.ffffffffffffffffffffffffffffp+0");
264 EXPECT_EQ(test.next(false), APFloat::opOK);
265 EXPECT_TRUE(test.bitwiseIsEqual(expected));
266
267 // nextDown(+Normal Binade Boundary) -> +Normal Binade Boundary - 1.
268 test = APFloat(APFloat::IEEEquad(), "0x1p+1");
269 expected = APFloat(APFloat::IEEEquad(), "0x1.ffffffffffffffffffffffffffffp+0");
270 EXPECT_EQ(test.next(true), APFloat::opOK);
271 EXPECT_TRUE(test.bitwiseIsEqual(expected));
272
273 // nextUp(+Normal Binade Boundary - 1) -> +Normal Binade Boundary.
274 test = APFloat(APFloat::IEEEquad(), "0x1.ffffffffffffffffffffffffffffp+0");
275 expected = APFloat(APFloat::IEEEquad(), "0x1p+1");
276 EXPECT_EQ(test.next(false), APFloat::opOK);
277 EXPECT_TRUE(test.bitwiseIsEqual(expected));
278
279 // nextDown(-Normal Binade Boundary + 1) -> -Normal Binade Boundary.
280 test = APFloat(APFloat::IEEEquad(), "-0x1.ffffffffffffffffffffffffffffp+0");
281 expected = APFloat(APFloat::IEEEquad(), "-0x1p+1");
282 EXPECT_EQ(test.next(true), APFloat::opOK);
283 EXPECT_TRUE(test.bitwiseIsEqual(expected));
284
285 // 2c. Test using next at binade boundaries with a direction away from the
286 // binade boundary. Away from denormal <-> normal boundaries.
287 //
288 // This is to make sure that even though we are at a binade boundary, since
289 // we are rounding away, we do not trigger the binade boundary code. Thus we
290 // test:
291 // * nextUp(-Largest Denormal) -> -Largest Denormal + inc.
292 // * nextDown(+Largest Denormal) -> +Largest Denormal - inc.
293 // * nextUp(+Smallest Normal) -> +Smallest Normal + inc.
294 // * nextDown(-Smallest Normal) -> -Smallest Normal - inc.
295
296 // nextUp(-Largest Denormal) -> -Largest Denormal + inc.
297 test = APFloat(APFloat::IEEEquad(), "-0x0.ffffffffffffffffffffffffffffp-16382");
298 expected = APFloat(APFloat::IEEEquad(),
299 "-0x0.fffffffffffffffffffffffffffep-16382");
300 EXPECT_EQ(test.next(false), APFloat::opOK);
301 EXPECT_TRUE(test.isDenormal());
302 EXPECT_TRUE(test.isNegative());
303 EXPECT_TRUE(test.bitwiseIsEqual(expected));
304
305 // nextDown(+Largest Denormal) -> +Largest Denormal - inc.
306 test = APFloat(APFloat::IEEEquad(), "0x0.ffffffffffffffffffffffffffffp-16382");
307 expected = APFloat(APFloat::IEEEquad(),
308 "0x0.fffffffffffffffffffffffffffep-16382");
309 EXPECT_EQ(test.next(true), APFloat::opOK);
310 EXPECT_TRUE(test.isDenormal());
311 EXPECT_TRUE(!test.isNegative());
312 EXPECT_TRUE(test.bitwiseIsEqual(expected));
313
314 // nextUp(+Smallest Normal) -> +Smallest Normal + inc.
315 test = APFloat(APFloat::IEEEquad(), "0x1.0000000000000000000000000000p-16382");
316 expected = APFloat(APFloat::IEEEquad(),
317 "0x1.0000000000000000000000000001p-16382");
318 EXPECT_EQ(test.next(false), APFloat::opOK);
319 EXPECT_TRUE(!test.isDenormal());
320 EXPECT_TRUE(!test.isNegative());
321 EXPECT_TRUE(test.bitwiseIsEqual(expected));
322
323 // nextDown(-Smallest Normal) -> -Smallest Normal - inc.
324 test = APFloat(APFloat::IEEEquad(), "-0x1.0000000000000000000000000000p-16382");
325 expected = APFloat(APFloat::IEEEquad(),
326 "-0x1.0000000000000000000000000001p-16382");
327 EXPECT_EQ(test.next(true), APFloat::opOK);
328 EXPECT_TRUE(!test.isDenormal());
329 EXPECT_TRUE(test.isNegative());
330 EXPECT_TRUE(test.bitwiseIsEqual(expected));
331
332 // 2d. Test values which cause our exponent to go to min exponent. This
333 // is to ensure that guards in the code to check for min exponent
334 // trigger properly.
335 // * nextUp(-0x1p-16381) -> -0x1.ffffffffffffffffffffffffffffp-16382
336 // * nextDown(-0x1.ffffffffffffffffffffffffffffp-16382) ->
337 // -0x1p-16381
338 // * nextUp(0x1.ffffffffffffffffffffffffffffp-16382) -> 0x1p-16382
339 // * nextDown(0x1p-16382) -> 0x1.ffffffffffffffffffffffffffffp-16382
340
341 // nextUp(-0x1p-16381) -> -0x1.ffffffffffffffffffffffffffffp-16382
342 test = APFloat(APFloat::IEEEquad(), "-0x1p-16381");
343 expected = APFloat(APFloat::IEEEquad(),
344 "-0x1.ffffffffffffffffffffffffffffp-16382");
345 EXPECT_EQ(test.next(false), APFloat::opOK);
346 EXPECT_TRUE(test.bitwiseIsEqual(expected));
347
348 // nextDown(-0x1.ffffffffffffffffffffffffffffp-16382) ->
349 // -0x1p-16381
350 test = APFloat(APFloat::IEEEquad(), "-0x1.ffffffffffffffffffffffffffffp-16382");
351 expected = APFloat(APFloat::IEEEquad(), "-0x1p-16381");
352 EXPECT_EQ(test.next(true), APFloat::opOK);
353 EXPECT_TRUE(test.bitwiseIsEqual(expected));
354
355 // nextUp(0x1.ffffffffffffffffffffffffffffp-16382) -> 0x1p-16381
356 test = APFloat(APFloat::IEEEquad(), "0x1.ffffffffffffffffffffffffffffp-16382");
357 expected = APFloat(APFloat::IEEEquad(), "0x1p-16381");
358 EXPECT_EQ(test.next(false), APFloat::opOK);
359 EXPECT_TRUE(test.bitwiseIsEqual(expected));
360
361 // nextDown(0x1p-16381) -> 0x1.ffffffffffffffffffffffffffffp-16382
362 test = APFloat(APFloat::IEEEquad(), "0x1p-16381");
363 expected = APFloat(APFloat::IEEEquad(),
364 "0x1.ffffffffffffffffffffffffffffp-16382");
365 EXPECT_EQ(test.next(true), APFloat::opOK);
366 EXPECT_TRUE(test.bitwiseIsEqual(expected));
367
368 // 3. Now we test both denormal/normal computation which will not cause us
369 // to go across binade boundaries. Specifically we test:
370 // * nextUp(+Denormal) -> +Denormal.
371 // * nextDown(+Denormal) -> +Denormal.
372 // * nextUp(-Denormal) -> -Denormal.
373 // * nextDown(-Denormal) -> -Denormal.
374 // * nextUp(+Normal) -> +Normal.
375 // * nextDown(+Normal) -> +Normal.
376 // * nextUp(-Normal) -> -Normal.
377 // * nextDown(-Normal) -> -Normal.
378
379 // nextUp(+Denormal) -> +Denormal.
380 test = APFloat(APFloat::IEEEquad(),
381 "0x0.ffffffffffffffffffffffff000cp-16382");
382 expected = APFloat(APFloat::IEEEquad(),
383 "0x0.ffffffffffffffffffffffff000dp-16382");
384 EXPECT_EQ(test.next(false), APFloat::opOK);
385 EXPECT_TRUE(test.isDenormal());
386 EXPECT_TRUE(!test.isNegative());
387 EXPECT_TRUE(test.bitwiseIsEqual(expected));
388
389 // nextDown(+Denormal) -> +Denormal.
390 test = APFloat(APFloat::IEEEquad(),
391 "0x0.ffffffffffffffffffffffff000cp-16382");
392 expected = APFloat(APFloat::IEEEquad(),
393 "0x0.ffffffffffffffffffffffff000bp-16382");
394 EXPECT_EQ(test.next(true), APFloat::opOK);
395 EXPECT_TRUE(test.isDenormal());
396 EXPECT_TRUE(!test.isNegative());
397 EXPECT_TRUE(test.bitwiseIsEqual(expected));
398
399 // nextUp(-Denormal) -> -Denormal.
400 test = APFloat(APFloat::IEEEquad(),
401 "-0x0.ffffffffffffffffffffffff000cp-16382");
402 expected = APFloat(APFloat::IEEEquad(),
403 "-0x0.ffffffffffffffffffffffff000bp-16382");
404 EXPECT_EQ(test.next(false), APFloat::opOK);
405 EXPECT_TRUE(test.isDenormal());
406 EXPECT_TRUE(test.isNegative());
407 EXPECT_TRUE(test.bitwiseIsEqual(expected));
408
409 // nextDown(-Denormal) -> -Denormal
410 test = APFloat(APFloat::IEEEquad(),
411 "-0x0.ffffffffffffffffffffffff000cp-16382");
412 expected = APFloat(APFloat::IEEEquad(),
413 "-0x0.ffffffffffffffffffffffff000dp-16382");
414 EXPECT_EQ(test.next(true), APFloat::opOK);
415 EXPECT_TRUE(test.isDenormal());
416 EXPECT_TRUE(test.isNegative());
417 EXPECT_TRUE(test.bitwiseIsEqual(expected));
418
419 // nextUp(+Normal) -> +Normal.
420 test = APFloat(APFloat::IEEEquad(),
421 "0x1.ffffffffffffffffffffffff000cp-16000");
422 expected = APFloat(APFloat::IEEEquad(),
423 "0x1.ffffffffffffffffffffffff000dp-16000");
424 EXPECT_EQ(test.next(false), APFloat::opOK);
425 EXPECT_TRUE(!test.isDenormal());
426 EXPECT_TRUE(!test.isNegative());
427 EXPECT_TRUE(test.bitwiseIsEqual(expected));
428
429 // nextDown(+Normal) -> +Normal.
430 test = APFloat(APFloat::IEEEquad(),
431 "0x1.ffffffffffffffffffffffff000cp-16000");
432 expected = APFloat(APFloat::IEEEquad(),
433 "0x1.ffffffffffffffffffffffff000bp-16000");
434 EXPECT_EQ(test.next(true), APFloat::opOK);
435 EXPECT_TRUE(!test.isDenormal());
436 EXPECT_TRUE(!test.isNegative());
437 EXPECT_TRUE(test.bitwiseIsEqual(expected));
438
439 // nextUp(-Normal) -> -Normal.
440 test = APFloat(APFloat::IEEEquad(),
441 "-0x1.ffffffffffffffffffffffff000cp-16000");
442 expected = APFloat(APFloat::IEEEquad(),
443 "-0x1.ffffffffffffffffffffffff000bp-16000");
444 EXPECT_EQ(test.next(false), APFloat::opOK);
445 EXPECT_TRUE(!test.isDenormal());
446 EXPECT_TRUE(test.isNegative());
447 EXPECT_TRUE(test.bitwiseIsEqual(expected));
448
449 // nextDown(-Normal) -> -Normal.
450 test = APFloat(APFloat::IEEEquad(),
451 "-0x1.ffffffffffffffffffffffff000cp-16000");
452 expected = APFloat(APFloat::IEEEquad(),
453 "-0x1.ffffffffffffffffffffffff000dp-16000");
454 EXPECT_EQ(test.next(true), APFloat::opOK);
455 EXPECT_TRUE(!test.isDenormal());
456 EXPECT_TRUE(test.isNegative());
457 EXPECT_TRUE(test.bitwiseIsEqual(expected));
458 }
459
460 TEST(APFloatTest, FMA) {
461 APFloat::roundingMode rdmd = APFloat::rmNearestTiesToEven;
462
463 {
464 APFloat f1(14.5f);
465 APFloat f2(-14.5f);
466 APFloat f3(225.0f);
467 f1.fusedMultiplyAdd(f2, f3, APFloat::rmNearestTiesToEven);
468 EXPECT_EQ(14.75f, f1.convertToFloat());
469 }
470
471 {
472 APFloat Val2(2.0f);
473 APFloat f1((float)1.17549435e-38F);
474 APFloat f2((float)1.17549435e-38F);
475 f1.divide(Val2, rdmd);
476 f2.divide(Val2, rdmd);
477 APFloat f3(12.0f);
478 f1.fusedMultiplyAdd(f2, f3, APFloat::rmNearestTiesToEven);
479 EXPECT_EQ(12.0f, f1.convertToFloat());
480 }
481
482 // Test for correct zero sign when answer is exactly zero.
483 // fma(1.0, -1.0, 1.0) -> +ve 0.
484 {
485 APFloat f1(1.0);
486 APFloat f2(-1.0);
487 APFloat f3(1.0);
488 f1.fusedMultiplyAdd(f2, f3, APFloat::rmNearestTiesToEven);
489 EXPECT_TRUE(!f1.isNegative() && f1.isZero());
490 }
491
492 // Test for correct zero sign when answer is exactly zero and rounding towards
493 // negative.
494 // fma(1.0, -1.0, 1.0) -> +ve 0.
495 {
496 APFloat f1(1.0);
497 APFloat f2(-1.0);
498 APFloat f3(1.0);
499 f1.fusedMultiplyAdd(f2, f3, APFloat::rmTowardNegative);
500 EXPECT_TRUE(f1.isNegative() && f1.isZero());
501 }
502
503 // Test for correct (in this case -ve) sign when adding like signed zeros.
504 // Test fma(0.0, -0.0, -0.0) -> -ve 0.
505 {
506 APFloat f1(0.0);
507 APFloat f2(-0.0);
508 APFloat f3(-0.0);
509 f1.fusedMultiplyAdd(f2, f3, APFloat::rmNearestTiesToEven);
510 EXPECT_TRUE(f1.isNegative() && f1.isZero());
511 }
512
513 // Test -ve sign preservation when small negative results underflow.
514 {
515 APFloat f1(APFloat::IEEEdouble(), "-0x1p-1074");
516 APFloat f2(APFloat::IEEEdouble(), "+0x1p-1074");
517 APFloat f3(0.0);
518 f1.fusedMultiplyAdd(f2, f3, APFloat::rmNearestTiesToEven);
519 EXPECT_TRUE(f1.isNegative() && f1.isZero());
520 }
521
522 // Test x87 extended precision case from http://llvm.org/PR20728.
523 {
524 APFloat M1(APFloat::x87DoubleExtended(), 1.0);
525 APFloat M2(APFloat::x87DoubleExtended(), 1.0);
526 APFloat A(APFloat::x87DoubleExtended(), 3.0);
527
528 bool losesInfo = false;
529 M1.fusedMultiplyAdd(M1, A, APFloat::rmNearestTiesToEven);
530 M1.convert(APFloat::IEEEsingle(), APFloat::rmNearestTiesToEven, &losesInfo);
531 EXPECT_FALSE(losesInfo);
532 EXPECT_EQ(4.0f, M1.convertToFloat());
533 }
534 }
535
536 TEST(APFloatTest, MinNum) {
537 APFloat f1(1.0);
538 APFloat f2(2.0);
539 APFloat nan = APFloat::getNaN(APFloat::IEEEdouble());
540
541 EXPECT_EQ(1.0, minnum(f1, f2).convertToDouble());
542 EXPECT_EQ(1.0, minnum(f2, f1).convertToDouble());
543 EXPECT_EQ(1.0, minnum(f1, nan).convertToDouble());
544 EXPECT_EQ(1.0, minnum(nan, f1).convertToDouble());
545 }
546
547 TEST(APFloatTest, MaxNum) {
548 APFloat f1(1.0);
549 APFloat f2(2.0);
550 APFloat nan = APFloat::getNaN(APFloat::IEEEdouble());
551
552 EXPECT_EQ(2.0, maxnum(f1, f2).convertToDouble());
553 EXPECT_EQ(2.0, maxnum(f2, f1).convertToDouble());
554 EXPECT_EQ(1.0, maxnum(f1, nan).convertToDouble());
555 EXPECT_EQ(1.0, maxnum(nan, f1).convertToDouble());
556 }
557
558 TEST(APFloatTest, Denormal) {
559 APFloat::roundingMode rdmd = APFloat::rmNearestTiesToEven;
560
561 // Test single precision
562 {
563 const char *MinNormalStr = "1.17549435082228750797e-38";
564 EXPECT_FALSE(APFloat(APFloat::IEEEsingle(), MinNormalStr).isDenormal());
565 EXPECT_FALSE(APFloat(APFloat::IEEEsingle(), 0.0).isDenormal());
566
567 APFloat Val2(APFloat::IEEEsingle(), 2.0e0);
568 APFloat T(APFloat::IEEEsingle(), MinNormalStr);
569 T.divide(Val2, rdmd);
570 EXPECT_TRUE(T.isDenormal());
571 }
572
573 // Test double precision
574 {
575 const char *MinNormalStr = "2.22507385850720138309e-308";
576 EXPECT_FALSE(APFloat(APFloat::IEEEdouble(), MinNormalStr).isDenormal());
577 EXPECT_FALSE(APFloat(APFloat::IEEEdouble(), 0.0).isDenormal());
578
579 APFloat Val2(APFloat::IEEEdouble(), 2.0e0);
580 APFloat T(APFloat::IEEEdouble(), MinNormalStr);
581 T.divide(Val2, rdmd);
582 EXPECT_TRUE(T.isDenormal());
583 }
584
585 // Test Intel double-ext
586 {
587 const char *MinNormalStr = "3.36210314311209350626e-4932";
588 EXPECT_FALSE(APFloat(APFloat::x87DoubleExtended(), MinNormalStr).isDenormal());
589 EXPECT_FALSE(APFloat(APFloat::x87DoubleExtended(), 0.0).isDenormal());
590
591 APFloat Val2(APFloat::x87DoubleExtended(), 2.0e0);
592 APFloat T(APFloat::x87DoubleExtended(), MinNormalStr);
593 T.divide(Val2, rdmd);
594 EXPECT_TRUE(T.isDenormal());
595 }
596
597 // Test quadruple precision
598 {
599 const char *MinNormalStr = "3.36210314311209350626267781732175260e-4932";
600 EXPECT_FALSE(APFloat(APFloat::IEEEquad(), MinNormalStr).isDenormal());
601 EXPECT_FALSE(APFloat(APFloat::IEEEquad(), 0.0).isDenormal());
602
603 APFloat Val2(APFloat::IEEEquad(), 2.0e0);
604 APFloat T(APFloat::IEEEquad(), MinNormalStr);
605 T.divide(Val2, rdmd);
606 EXPECT_TRUE(T.isDenormal());
607 }
608 }
609
610 TEST(APFloatTest, Zero) {
611 EXPECT_EQ(0.0f, APFloat(0.0f).convertToFloat());
612 EXPECT_EQ(-0.0f, APFloat(-0.0f).convertToFloat());
613 EXPECT_TRUE(APFloat(-0.0f).isNegative());
614
615 EXPECT_EQ(0.0, APFloat(0.0).convertToDouble());
616 EXPECT_EQ(-0.0, APFloat(-0.0).convertToDouble());
617 EXPECT_TRUE(APFloat(-0.0).isNegative());
618 }
619
620 TEST(APFloatTest, DecimalStringsWithoutNullTerminators) {
621 // Make sure that we can parse strings without null terminators.
622 // rdar://14323230.
623 APFloat Val(APFloat::IEEEdouble());
624 Val.convertFromString(StringRef("0.00", 3),
625 llvm::APFloat::rmNearestTiesToEven);
626 EXPECT_EQ(Val.convertToDouble(), 0.0);
627 Val.convertFromString(StringRef("0.01", 3),
628 llvm::APFloat::rmNearestTiesToEven);
629 EXPECT_EQ(Val.convertToDouble(), 0.0);
630 Val.convertFromString(StringRef("0.09", 3),
631 llvm::APFloat::rmNearestTiesToEven);
632 EXPECT_EQ(Val.convertToDouble(), 0.0);
633 Val.convertFromString(StringRef("0.095", 4),
634 llvm::APFloat::rmNearestTiesToEven);
635 EXPECT_EQ(Val.convertToDouble(), 0.09);
636 Val.convertFromString(StringRef("0.00e+3", 7),
637 llvm::APFloat::rmNearestTiesToEven);
638 EXPECT_EQ(Val.convertToDouble(), 0.00);
639 Val.convertFromString(StringRef("0e+3", 4),
640 llvm::APFloat::rmNearestTiesToEven);
641 EXPECT_EQ(Val.convertToDouble(), 0.00);
642
643 }
644
645 TEST(APFloatTest, fromZeroDecimalString) {
646 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0").convertToDouble());
647 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0").convertToDouble());
648 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0").convertToDouble());
649
650 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0.").convertToDouble());
651 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0.").convertToDouble());
652 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0.").convertToDouble());
653
654 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), ".0").convertToDouble());
655 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+.0").convertToDouble());
656 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-.0").convertToDouble());
657
658 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0.0").convertToDouble());
659 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0.0").convertToDouble());
660 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0.0").convertToDouble());
661
662 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "00000.").convertToDouble());
663 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+00000.").convertToDouble());
664 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-00000.").convertToDouble());
665
666 EXPECT_EQ(0.0, APFloat(APFloat::IEEEdouble(), ".00000").convertToDouble());
667 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+.00000").convertToDouble());
668 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-.00000").convertToDouble());
669
670 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0000.00000").convertToDouble());
671 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0000.00000").convertToDouble());
672 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0000.00000").convertToDouble());
673 }
674
675 TEST(APFloatTest, fromZeroDecimalSingleExponentString) {
676 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0e1").convertToDouble());
677 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0e1").convertToDouble());
678 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0e1").convertToDouble());
679
680 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0e+1").convertToDouble());
681 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0e+1").convertToDouble());
682 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0e+1").convertToDouble());
683
684 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0e-1").convertToDouble());
685 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0e-1").convertToDouble());
686 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0e-1").convertToDouble());
687
688
689 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0.e1").convertToDouble());
690 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0.e1").convertToDouble());
691 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0.e1").convertToDouble());
692
693 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0.e+1").convertToDouble());
694 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0.e+1").convertToDouble());
695 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0.e+1").convertToDouble());
696
697 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0.e-1").convertToDouble());
698 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0.e-1").convertToDouble());
699 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0.e-1").convertToDouble());
700
701 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), ".0e1").convertToDouble());
702 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+.0e1").convertToDouble());
703 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-.0e1").convertToDouble());
704
705 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), ".0e+1").convertToDouble());
706 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+.0e+1").convertToDouble());
707 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-.0e+1").convertToDouble());
708
709 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), ".0e-1").convertToDouble());
710 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+.0e-1").convertToDouble());
711 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-.0e-1").convertToDouble());
712
713
714 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0.0e1").convertToDouble());
715 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0.0e1").convertToDouble());
716 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0.0e1").convertToDouble());
717
718 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0.0e+1").convertToDouble());
719 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0.0e+1").convertToDouble());
720 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0.0e+1").convertToDouble());
721
722 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0.0e-1").convertToDouble());
723 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0.0e-1").convertToDouble());
724 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0.0e-1").convertToDouble());
725
726
727 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "000.0000e1").convertToDouble());
728 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+000.0000e+1").convertToDouble());
729 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-000.0000e+1").convertToDouble());
730 }
731
732 TEST(APFloatTest, fromZeroDecimalLargeExponentString) {
733 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0e1234").convertToDouble());
734 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0e1234").convertToDouble());
735 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0e1234").convertToDouble());
736
737 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0e+1234").convertToDouble());
738 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0e+1234").convertToDouble());
739 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0e+1234").convertToDouble());
740
741 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0e-1234").convertToDouble());
742 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0e-1234").convertToDouble());
743 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0e-1234").convertToDouble());
744
745 EXPECT_EQ(0.0, APFloat(APFloat::IEEEdouble(), "000.0000e1234").convertToDouble());
746 EXPECT_EQ(0.0, APFloat(APFloat::IEEEdouble(), "000.0000e-1234").convertToDouble());
747
748 EXPECT_EQ(0.0, APFloat(APFloat::IEEEdouble(), StringRef("0e1234" "\0" "2", 6)).convertToDouble());
749 }
750
751 TEST(APFloatTest, fromZeroHexadecimalString) {
752 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x0p1").convertToDouble());
753 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0x0p1").convertToDouble());
754 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0x0p1").convertToDouble());
755
756 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x0p+1").convertToDouble());
757 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0x0p+1").convertToDouble());
758 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0x0p+1").convertToDouble());
759
760 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x0p-1").convertToDouble());
761 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0x0p-1").convertToDouble());
762 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0x0p-1").convertToDouble());
763
764
765 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x0.p1").convertToDouble());
766 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0x0.p1").convertToDouble());
767 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0x0.p1").convertToDouble());
768
769 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x0.p+1").convertToDouble());
770 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0x0.p+1").convertToDouble());
771 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0x0.p+1").convertToDouble());
772
773 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x0.p-1").convertToDouble());
774 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0x0.p-1").convertToDouble());
775 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0x0.p-1").convertToDouble());
776
777
778 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x.0p1").convertToDouble());
779 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0x.0p1").convertToDouble());
780 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0x.0p1").convertToDouble());
781
782 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x.0p+1").convertToDouble());
783 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0x.0p+1").convertToDouble());
784 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0x.0p+1").convertToDouble());
785
786 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x.0p-1").convertToDouble());
787 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0x.0p-1").convertToDouble());
788 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0x.0p-1").convertToDouble());
789
790
791 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x0.0p1").convertToDouble());
792 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0x0.0p1").convertToDouble());
793 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0x0.0p1").convertToDouble());
794
795 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x0.0p+1").convertToDouble());
796 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0x0.0p+1").convertToDouble());
797 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0x0.0p+1").convertToDouble());
798
799 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x0.0p-1").convertToDouble());
800 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0x0.0p-1").convertToDouble());
801 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0x0.0p-1").convertToDouble());
802
803
804 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x00000.p1").convertToDouble());
805 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x0000.00000p1").convertToDouble());
806 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x.00000p1").convertToDouble());
807 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x0.p1").convertToDouble());
808 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x0p1234").convertToDouble());
809 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0x0p1234").convertToDouble());
810 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x00000.p1234").convertToDouble());
811 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x0000.00000p1234").convertToDouble());
812 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x.00000p1234").convertToDouble());
813 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x0.p1234").convertToDouble());
814 }
815
816 TEST(APFloatTest, fromDecimalString) {
817 EXPECT_EQ(1.0, APFloat(APFloat::IEEEdouble(), "1").convertToDouble());
818 EXPECT_EQ(2.0, APFloat(APFloat::IEEEdouble(), "2.").convertToDouble());
819 EXPECT_EQ(0.5, APFloat(APFloat::IEEEdouble(), ".5").convertToDouble());
820 EXPECT_EQ(1.0, APFloat(APFloat::IEEEdouble(), "1.0").convertToDouble());
821 EXPECT_EQ(-2.0, APFloat(APFloat::IEEEdouble(), "-2").convertToDouble());
822 EXPECT_EQ(-4.0, APFloat(APFloat::IEEEdouble(), "-4.").convertToDouble());
823 EXPECT_EQ(-0.5, APFloat(APFloat::IEEEdouble(), "-.5").convertToDouble());
824 EXPECT_EQ(-1.5, APFloat(APFloat::IEEEdouble(), "-1.5").convertToDouble());
825 EXPECT_EQ(1.25e12, APFloat(APFloat::IEEEdouble(), "1.25e12").convertToDouble());
826 EXPECT_EQ(1.25e+12, APFloat(APFloat::IEEEdouble(), "1.25e+12").convertToDouble());
827 EXPECT_EQ(1.25e-12, APFloat(APFloat::IEEEdouble(), "1.25e-12").convertToDouble());
828 EXPECT_EQ(1024.0, APFloat(APFloat::IEEEdouble(), "1024.").convertToDouble());
829 EXPECT_EQ(1024.05, APFloat(APFloat::IEEEdouble(), "1024.05000").convertToDouble());
830 EXPECT_EQ(0.05, APFloat(APFloat::IEEEdouble(), ".05000").convertToDouble());
831 EXPECT_EQ(2.0, APFloat(APFloat::IEEEdouble(), "2.").convertToDouble());
832 EXPECT_EQ(2.0e2, APFloat(APFloat::IEEEdouble(), "2.e2").convertToDouble());
833 EXPECT_EQ(2.0e+2, APFloat(APFloat::IEEEdouble(), "2.e+2").convertToDouble());
834 EXPECT_EQ(2.0e-2, APFloat(APFloat::IEEEdouble(), "2.e-2").convertToDouble());
835 EXPECT_EQ(2.05e2, APFloat(APFloat::IEEEdouble(), "002.05000e2").convertToDouble());
836 EXPECT_EQ(2.05e+2, APFloat(APFloat::IEEEdouble(), "002.05000e+2").convertToDouble());
837 EXPECT_EQ(2.05e-2, APFloat(APFloat::IEEEdouble(), "002.05000e-2").convertToDouble());
838 EXPECT_EQ(2.05e12, APFloat(APFloat::IEEEdouble(), "002.05000e12").convertToDouble());
839 EXPECT_EQ(2.05e+12, APFloat(APFloat::IEEEdouble(), "002.05000e+12").convertToDouble());
840 EXPECT_EQ(2.05e-12, APFloat(APFloat::IEEEdouble(), "002.05000e-12").convertToDouble());
841
842 // These are "carefully selected" to overflow the fast log-base
843 // calculations in APFloat.cpp
844 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "99e99999").isInfinity());
845 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "-99e99999").isInfinity());
846 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "1e-99999").isPosZero());
847 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "-1e-99999").isNegZero());
848
849 EXPECT_EQ(2.71828, convertToDoubleFromString("2.71828"));
850 }
851
852 TEST(APFloatTest, fromToStringSpecials) {
853 auto expects = [] (const char *first, const char *second) {
854 std::string roundtrip = convertToString(convertToDoubleFromString(second), 0, 3);
855 EXPECT_STREQ(first, roundtrip.c_str());
856 };
857 expects("+Inf", "+Inf");
858 expects("+Inf", "INFINITY");
859 expects("+Inf", "inf");
860 expects("-Inf", "-Inf");
861 expects("-Inf", "-INFINITY");
862 expects("-Inf", "-inf");
863 expects("NaN", "NaN");
864 expects("NaN", "nan");
865 expects("NaN", "-NaN");
866 expects("NaN", "-nan");
867 }
868
869 TEST(APFloatTest, fromHexadecimalString) {
870 EXPECT_EQ( 1.0, APFloat(APFloat::IEEEdouble(), "0x1p0").convertToDouble());
871 EXPECT_EQ(+1.0, APFloat(APFloat::IEEEdouble(), "+0x1p0").convertToDouble());
872 EXPECT_EQ(-1.0, APFloat(APFloat::IEEEdouble(), "-0x1p0").convertToDouble());
873
874 EXPECT_EQ( 1.0, APFloat(APFloat::IEEEdouble(), "0x1p+0").convertToDouble());
875 EXPECT_EQ(+1.0, APFloat(APFloat::IEEEdouble(), "+0x1p+0").convertToDouble());
876 EXPECT_EQ(-1.0, APFloat(APFloat::IEEEdouble(), "-0x1p+0").convertToDouble());
877
878 EXPECT_EQ( 1.0, APFloat(APFloat::IEEEdouble(), "0x1p-0").convertToDouble());
879 EXPECT_EQ(+1.0, APFloat(APFloat::IEEEdouble(), "+0x1p-0").convertToDouble());
880 EXPECT_EQ(-1.0, APFloat(APFloat::IEEEdouble(), "-0x1p-0").convertToDouble());
881
882
883 EXPECT_EQ( 2.0, APFloat(APFloat::IEEEdouble(), "0x1p1").convertToDouble());
884 EXPECT_EQ(+2.0, APFloat(APFloat::IEEEdouble(), "+0x1p1").convertToDouble());
885 EXPECT_EQ(-2.0, APFloat(APFloat::IEEEdouble(), "-0x1p1").convertToDouble());
886
887 EXPECT_EQ( 2.0, APFloat(APFloat::IEEEdouble(), "0x1p+1").convertToDouble());
888 EXPECT_EQ(+2.0, APFloat(APFloat::IEEEdouble(), "+0x1p+1").convertToDouble());
889 EXPECT_EQ(-2.0, APFloat(APFloat::IEEEdouble(), "-0x1p+1").convertToDouble());
890
891 EXPECT_EQ( 0.5, APFloat(APFloat::IEEEdouble(), "0x1p-1").convertToDouble());
892 EXPECT_EQ(+0.5, APFloat(APFloat::IEEEdouble(), "+0x1p-1").convertToDouble());
893 EXPECT_EQ(-0.5, APFloat(APFloat::IEEEdouble(), "-0x1p-1").convertToDouble());
894
895
896 EXPECT_EQ( 3.0, APFloat(APFloat::IEEEdouble(), "0x1.8p1").convertToDouble());
897 EXPECT_EQ(+3.0, APFloat(APFloat::IEEEdouble(), "+0x1.8p1").convertToDouble());
898 EXPECT_EQ(-3.0, APFloat(APFloat::IEEEdouble(), "-0x1.8p1").convertToDouble());
899
900 EXPECT_EQ( 3.0, APFloat(APFloat::IEEEdouble(), "0x1.8p+1").convertToDouble());
901 EXPECT_EQ(+3.0, APFloat(APFloat::IEEEdouble(), "+0x1.8p+1").convertToDouble());
902 EXPECT_EQ(-3.0, APFloat(APFloat::IEEEdouble(), "-0x1.8p+1").convertToDouble());
903
904 EXPECT_EQ( 0.75, APFloat(APFloat::IEEEdouble(), "0x1.8p-1").convertToDouble());
905 EXPECT_EQ(+0.75, APFloat(APFloat::IEEEdouble(), "+0x1.8p-1").convertToDouble());
906 EXPECT_EQ(-0.75, APFloat(APFloat::IEEEdouble(), "-0x1.8p-1").convertToDouble());
907
908
909 EXPECT_EQ( 8192.0, APFloat(APFloat::IEEEdouble(), "0x1000.000p1").convertToDouble());
910 EXPECT_EQ(+8192.0, APFloat(APFloat::IEEEdouble(), "+0x1000.000p1").convertToDouble());
911 EXPECT_EQ(-8192.0, APFloat(APFloat::IEEEdouble(), "-0x1000.000p1").convertToDouble());
912
913 EXPECT_EQ( 8192.0, APFloat(APFloat::IEEEdouble(), "0x1000.000p+1").convertToDouble());
914 EXPECT_EQ(+8192.0, APFloat(APFloat::IEEEdouble(), "+0x1000.000p+1").convertToDouble());
915 EXPECT_EQ(-8192.0, APFloat(APFloat::IEEEdouble(), "-0x1000.000p+1").convertToDouble());
916
917 EXPECT_EQ( 2048.0, APFloat(APFloat::IEEEdouble(), "0x1000.000p-1").convertToDouble());
918 EXPECT_EQ(+2048.0, APFloat(APFloat::IEEEdouble(), "+0x1000.000p-1").convertToDouble());
919 EXPECT_EQ(-2048.0, APFloat(APFloat::IEEEdouble(), "-0x1000.000p-1").convertToDouble());
920
921
922 EXPECT_EQ( 8192.0, APFloat(APFloat::IEEEdouble(), "0x1000p1").convertToDouble());
923 EXPECT_EQ(+8192.0, APFloat(APFloat::IEEEdouble(), "+0x1000p1").convertToDouble());
924 EXPECT_EQ(-8192.0, APFloat(APFloat::IEEEdouble(), "-0x1000p1").convertToDouble());
925
926 EXPECT_EQ( 8192.0, APFloat(APFloat::IEEEdouble(), "0x1000p+1").convertToDouble());
927 EXPECT_EQ(+8192.0, APFloat(APFloat::IEEEdouble(), "+0x1000p+1").convertToDouble());
928 EXPECT_EQ(-8192.0, APFloat(APFloat::IEEEdouble(), "-0x1000p+1").convertToDouble());
929
930 EXPECT_EQ( 2048.0, APFloat(APFloat::IEEEdouble(), "0x1000p-1").convertToDouble());
931 EXPECT_EQ(+2048.0, APFloat(APFloat::IEEEdouble(), "+0x1000p-1").convertToDouble());
932 EXPECT_EQ(-2048.0, APFloat(APFloat::IEEEdouble(), "-0x1000p-1").convertToDouble());
933
934
935 EXPECT_EQ( 16384.0, APFloat(APFloat::IEEEdouble(), "0x10p10").convertToDouble());
936 EXPECT_EQ(+16384.0, APFloat(APFloat::IEEEdouble(), "+0x10p10").convertToDouble());
937 EXPECT_EQ(-16384.0, APFloat(APFloat::IEEEdouble(), "-0x10p10").convertToDouble());
938
939 EXPECT_EQ( 16384.0, APFloat(APFloat::IEEEdouble(), "0x10p+10").convertToDouble());
940 EXPECT_EQ(+16384.0, APFloat(APFloat::IEEEdouble(), "+0x10p+10").convertToDouble());
941 EXPECT_EQ(-16384.0, APFloat(APFloat::IEEEdouble(), "-0x10p+10").convertToDouble());
942
943 EXPECT_EQ( 0.015625, APFloat(APFloat::IEEEdouble(), "0x10p-10").convertToDouble());
944 EXPECT_EQ(+0.015625, APFloat(APFloat::IEEEdouble(), "+0x10p-10").convertToDouble());
945 EXPECT_EQ(-0.015625, APFloat(APFloat::IEEEdouble(), "-0x10p-10").convertToDouble());
946
947 EXPECT_EQ(1.0625, APFloat(APFloat::IEEEdouble(), "0x1.1p0").convertToDouble());
948 EXPECT_EQ(1.0, APFloat(APFloat::IEEEdouble(), "0x1p0").convertToDouble());
949
950 EXPECT_EQ(convertToDoubleFromString("0x1p-150"),
951 convertToDoubleFromString("+0x800000000000000001.p-221"));
952 EXPECT_EQ(2251799813685248.5,
953 convertToDoubleFromString("0x80000000000004000000.010p-28"));
954 }
955
956 TEST(APFloatTest, toString) {
957 ASSERT_EQ("10", convertToString(10.0, 6, 3));
958 ASSERT_EQ("1.0E+1", convertToString(10.0, 6, 0));
959 ASSERT_EQ("10100", convertToString(1.01E+4, 5, 2));
960 ASSERT_EQ("1.01E+4", convertToString(1.01E+4, 4, 2));
961 ASSERT_EQ("1.01E+4", convertToString(1.01E+4, 5, 1));
962 ASSERT_EQ("0.0101", convertToString(1.01E-2, 5, 2));
963 ASSERT_EQ("0.0101", convertToString(1.01E-2, 4, 2));
964 ASSERT_EQ("1.01E-2", convertToString(1.01E-2, 5, 1));
965 ASSERT_EQ("0.78539816339744828", convertToString(0.78539816339744830961, 0, 3));
966 ASSERT_EQ("4.9406564584124654E-324", convertToString(4.9406564584124654e-324, 0, 3));
967 ASSERT_EQ("873.18340000000001", convertToString(873.1834, 0, 1));
968 ASSERT_EQ("8.7318340000000001E+2", convertToString(873.1834, 0, 0));
969 ASSERT_EQ("1.7976931348623157E+308", convertToString(1.7976931348623157E+308, 0, 0));
970 ASSERT_EQ("10", convertToString(10.0, 6, 3, false));
971 ASSERT_EQ("1.000000e+01", convertToString(10.0, 6, 0, false));
972 ASSERT_EQ("10100", convertToString(1.01E+4, 5, 2, false));
973 ASSERT_EQ("1.0100e+04", convertToString(1.01E+4, 4, 2, false));
974 ASSERT_EQ("1.01000e+04", convertToString(1.01E+4, 5, 1, false));
975 ASSERT_EQ("0.0101", convertToString(1.01E-2, 5, 2, false));
976 ASSERT_EQ("0.0101", convertToString(1.01E-2, 4, 2, false));
977 ASSERT_EQ("1.01000e-02", convertToString(1.01E-2, 5, 1, false));
978 ASSERT_EQ("0.78539816339744828",
979 convertToString(0.78539816339744830961, 0, 3, false));
980 ASSERT_EQ("4.94065645841246540e-324",
981 convertToString(4.9406564584124654e-324, 0, 3, false));
982 ASSERT_EQ("873.18340000000001", convertToString(873.1834, 0, 1, false));
983 ASSERT_EQ("8.73183400000000010e+02", convertToString(873.1834, 0, 0, false));
984 ASSERT_EQ("1.79769313486231570e+308",
985 convertToString(1.7976931348623157E+308, 0, 0, false));
986
987 {
988 SmallString<64> Str;
989 APFloat UnnormalZero(APFloat::x87DoubleExtended(), APInt(80, {0, 1}));
990 UnnormalZero.toString(Str);
991 ASSERT_EQ("NaN", Str);
992 }
993 }
994
995 TEST(APFloatTest, toInteger) {
996 bool isExact = false;
997 APSInt result(5, /*isUnsigned=*/true);
998
999 EXPECT_EQ(APFloat::opOK,
1000 APFloat(APFloat::IEEEdouble(), "10")
1001 .convertToInteger(result, APFloat::rmTowardZero, &isExact));
1002 EXPECT_TRUE(isExact);
1003 EXPECT_EQ(APSInt(APInt(5, 10), true), result);
1004
1005 EXPECT_EQ(APFloat::opInvalidOp,
1006 APFloat(APFloat::IEEEdouble(), "-10")
1007 .convertToInteger(result, APFloat::rmTowardZero, &isExact));
1008 EXPECT_FALSE(isExact);
1009 EXPECT_EQ(APSInt::getMinValue(5, true), result);
1010
1011 EXPECT_EQ(APFloat::opInvalidOp,
1012 APFloat(APFloat::IEEEdouble(), "32")
1013 .convertToInteger(result, APFloat::rmTowardZero, &isExact));
1014 EXPECT_FALSE(isExact);
1015 EXPECT_EQ(APSInt::getMaxValue(5, true), result);
1016
1017 EXPECT_EQ(APFloat::opInexact,
1018 APFloat(APFloat::IEEEdouble(), "7.9")
1019 .convertToInteger(result, APFloat::rmTowardZero, &isExact));
1020 EXPECT_FALSE(isExact);
1021 EXPECT_EQ(APSInt(APInt(5, 7), true), result);
1022
1023 result.setIsUnsigned(false);
1024 EXPECT_EQ(APFloat::opOK,
1025 APFloat(APFloat::IEEEdouble(), "-10")
1026 .convertToInteger(result, APFloat::rmTowardZero, &isExact));
1027 EXPECT_TRUE(isExact);
1028 EXPECT_EQ(APSInt(APInt(5, -10, true), false), result);
1029
1030 EXPECT_EQ(APFloat::opInvalidOp,
1031 APFloat(APFloat::IEEEdouble(), "-17")
1032 .convertToInteger(result, APFloat::rmTowardZero, &isExact));
1033 EXPECT_FALSE(isExact);
1034 EXPECT_EQ(APSInt::getMinValue(5, false), result);
1035
1036 EXPECT_EQ(APFloat::opInvalidOp,
1037 APFloat(APFloat::IEEEdouble(), "16")
1038 .convertToInteger(result, APFloat::rmTowardZero, &isExact));
1039 EXPECT_FALSE(isExact);
1040 EXPECT_EQ(APSInt::getMaxValue(5, false), result);
1041 }
1042
1043 static APInt nanbits(const fltSemantics &Sem,
1044 bool SNaN, bool Negative, uint64_t fill) {
1045 APInt apfill(64, fill);
1046 if (SNaN)
1047 return APFloat::getSNaN(Sem, Negative, &apfill).bitcastToAPInt();
1048 else
1049 return APFloat::getQNaN(Sem, Negative, &apfill).bitcastToAPInt();
1050 }
1051
1052 TEST(APFloatTest, makeNaN) {
1053 ASSERT_EQ(0x7fc00000, nanbits(APFloat::IEEEsingle(), false, false, 0));
1054 ASSERT_EQ(0xffc00000, nanbits(APFloat::IEEEsingle(), false, true, 0));
1055 ASSERT_EQ(0x7fc0ae72, nanbits(APFloat::IEEEsingle(), false, false, 0xae72));
1056 ASSERT_EQ(0x7fffae72, nanbits(APFloat::IEEEsingle(), false, false, 0xffffae72));
1057 ASSERT_EQ(0x7fa00000, nanbits(APFloat::IEEEsingle(), true, false, 0));
1058 ASSERT_EQ(0xffa00000, nanbits(APFloat::IEEEsingle(), true, true, 0));
1059 ASSERT_EQ(0x7f80ae72, nanbits(APFloat::IEEEsingle(), true, false, 0xae72));
1060 ASSERT_EQ(0x7fbfae72, nanbits(APFloat::IEEEsingle(), true, false, 0xffffae72));
1061
1062 ASSERT_EQ(0x7ff8000000000000ULL, nanbits(APFloat::IEEEdouble(), false, false, 0));
1063 ASSERT_EQ(0xfff8000000000000ULL, nanbits(APFloat::IEEEdouble(), false, true, 0));
1064 ASSERT_EQ(0x7ff800000000ae72ULL, nanbits(APFloat::IEEEdouble(), false, false, 0xae72));
1065 ASSERT_EQ(0x7fffffffffffae72ULL, nanbits(APFloat::IEEEdouble(), false, false, 0xffffffffffffae72ULL));
1066 ASSERT_EQ(0x7ff4000000000000ULL, nanbits(APFloat::IEEEdouble(), true, false, 0));
1067 ASSERT_EQ(0xfff4000000000000ULL, nanbits(APFloat::IEEEdouble(), true, true, 0));
1068 ASSERT_EQ(0x7ff000000000ae72ULL, nanbits(APFloat::IEEEdouble(), true, false, 0xae72));
1069 ASSERT_EQ(0x7ff7ffffffffae72ULL, nanbits(APFloat::IEEEdouble(), true, false, 0xffffffffffffae72ULL));
1070 }
1071
1072 #ifdef GTEST_HAS_DEATH_TEST
1073 #ifndef NDEBUG
1074 TEST(APFloatTest, SemanticsDeath) {
1075 EXPECT_DEATH(APFloat(APFloat::IEEEsingle(), 0.0f).convertToDouble(), "Float semantics are not IEEEdouble");
1076 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), 0.0 ).convertToFloat(), "Float semantics are not IEEEsingle");
1077 }
1078
1079 TEST(APFloatTest, StringDecimalDeath) {
1080 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), ""), "Invalid string length");
1081 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "+"), "String has no digits");
1082 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "-"), "String has no digits");
1083
1084 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), StringRef("\0", 1)), "Invalid character in significand");
1085 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), StringRef("1\0", 2)), "Invalid character in significand");
1086 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), StringRef("1" "\0" "2", 3)), "Invalid character in significand");
1087 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), StringRef("1" "\0" "2e1", 5)), "Invalid character in significand");
1088 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), StringRef("1e\0", 3)), "Invalid character in exponent");
1089 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), StringRef("1e1\0", 4)), "Invalid character in exponent");
1090 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), StringRef("1e1" "\0" "2", 5)), "Invalid character in exponent");
1091
1092 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "1.0f"), "Invalid character in significand");
1093
1094 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), ".."), "String contains multiple dots");
1095 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "..0"), "String contains multiple dots");
1096 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "1.0.0"), "String contains multiple dots");
1097 }
1098
1099 TEST(APFloatTest, StringDecimalSignificandDeath) {
1100 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "."), "Significand has no digits");
1101 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "+."), "Significand has no digits");
1102 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "-."), "Significand has no digits");
1103
1104
1105 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "e"), "Significand has no digits");
1106 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "+e"), "Significand has no digits");
1107 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "-e"), "Significand has no digits");
1108
1109 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "e1"), "Significand has no digits");
1110 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "+e1"), "Significand has no digits");
1111 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "-e1"), "Significand has no digits");
1112
1113 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), ".e1"), "Significand has no digits");
1114 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "+.e1"), "Significand has no digits");
1115 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "-.e1"), "Significand has no digits");
1116
1117
1118 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), ".e"), "Significand has no digits");
1119 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "+.e"), "Significand has no digits");
1120 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "-.e"), "Significand has no digits");
1121 }
1122
1123 TEST(APFloatTest, StringDecimalExponentDeath) {
1124 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "1e"), "Exponent has no digits");
1125 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "+1e"), "Exponent has no digits");
1126 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "-1e"), "Exponent has no digits");
1127
1128 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "1.e"), "Exponent has no digits");
1129 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "+1.e"), "Exponent has no digits");
1130 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "-1.e"), "Exponent has no digits");
1131
1132 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), ".1e"), "Exponent has no digits");
1133 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "+.1e"), "Exponent has no digits");
1134 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "-.1e"), "Exponent has no digits");
1135
1136 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "1.1e"), "Exponent has no digits");
1137 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "+1.1e"), "Exponent has no digits");
1138 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "-1.1e"), "Exponent has no digits");
1139
1140
1141 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "1e+"), "Exponent has no digits");
1142 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "1e-"), "Exponent has no digits");
1143
1144 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), ".1e"), "Exponent has no digits");
1145 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), ".1e+"), "Exponent has no digits");
1146 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), ".1e-"), "Exponent has no digits");
1147
1148 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "1.0e"), "Exponent has no digits");
1149 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "1.0e+"), "Exponent has no digits");
1150 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "1.0e-"), "Exponent has no digits");
1151 }
1152
1153 TEST(APFloatTest, StringHexadecimalDeath) {
1154 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "0x"), "Invalid string");
1155 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "+0x"), "Invalid string");
1156 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "-0x"), "Invalid string");
1157
1158 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "0x0"), "Hex strings require an exponent");
1159 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "+0x0"), "Hex strings require an exponent");
1160 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "-0x0"), "Hex strings require an exponent");
1161
1162 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "0x0."), "Hex strings require an exponent");
1163 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "+0x0."), "Hex strings require an exponent");
1164 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "-0x0."), "Hex strings require an exponent");
1165
1166 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "0x.0"), "Hex strings require an exponent");
1167 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "+0x.0"), "Hex strings require an exponent");
1168 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "-0x.0"), "Hex strings require an exponent");
1169
1170 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "0x0.0"), "Hex strings require an exponent");
1171 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "+0x0.0"), "Hex strings require an exponent");
1172 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "-0x0.0"), "Hex strings require an exponent");
1173
1174 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), StringRef("0x\0", 3)), "Invalid character in significand");
1175 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), StringRef("0x1\0", 4)), "Invalid character in significand");
1176 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), StringRef("0x1" "\0" "2", 5)), "Invalid character in significand");
1177 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), StringRef("0x1" "\0" "2p1", 7)), "Invalid character in significand");
1178 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), StringRef("0x1p\0", 5)), "Invalid character in exponent");
1179 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), StringRef("0x1p1\0", 6)), "Invalid character in exponent");
1180 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), StringRef("0x1p1" "\0" "2", 7)), "Invalid character in exponent");
1181
1182 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "0x1p0f"), "Invalid character in exponent");
1183
1184 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "0x..p1"), "String contains multiple dots");
1185 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "0x..0p1"), "String contains multiple dots");
1186 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "0x1.0.0p1"), "String contains multiple dots");
1187 }
1188
1189 TEST(APFloatTest, StringHexadecimalSignificandDeath) {
1190 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "0x."), "Significand has no digits");
1191 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "+0x."), "Significand has no digits");
1192 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "-0x."), "Significand has no digits");
1193
1194 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "0xp"), "Significand has no digits");
1195 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "+0xp"), "Significand has no digits");
1196 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "-0xp"), "Significand has no digits");
1197
1198 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "0xp+"), "Significand has no digits");
1199 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "+0xp+"), "Significand has no digits");
1200 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "-0xp+"), "Significand has no digits");
1201
1202 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "0xp-"), "Significand has no digits");
1203 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "+0xp-"), "Significand has no digits");
1204 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "-0xp-"), "Significand has no digits");
1205
1206
1207 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "0x.p"), "Significand has no digits");
1208 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "+0x.p"), "Significand has no digits");
1209 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "-0x.p"), "Significand has no digits");
1210
1211 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "0x.p+"), "Significand has no digits");
1212 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "+0x.p+"), "Significand has no digits");
1213 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "-0x.p+"), "Significand has no digits");
1214
1215 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "0x.p-"), "Significand has no digits");
1216 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "+0x.p-"), "Significand has no digits");
1217 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "-0x.p-"), "Significand has no digits");
1218 }
1219
1220 TEST(APFloatTest, StringHexadecimalExponentDeath) {
1221 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "0x1p"), "Exponent has no digits");
1222 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "+0x1p"), "Exponent has no digits");
1223 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "-0x1p"), "Exponent has no digits");
1224
1225 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "0x1p+"), "Exponent has no digits");
1226 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "+0x1p+"), "Exponent has no digits");
1227 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "-0x1p+"), "Exponent has no digits");
1228
1229 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "0x1p-"), "Exponent has no digits");
1230 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "+0x1p-"), "Exponent has no digits");
1231 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "-0x1p-"), "Exponent has no digits");
1232
1233
1234 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "0x1.p"), "Exponent has no digits");
1235 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "+0x1.p"), "Exponent has no digits");
1236 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "-0x1.p"), "Exponent has no digits");
1237
1238 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "0x1.p+"), "Exponent has no digits");
1239 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "+0x1.p+"), "Exponent has no digits");
1240 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "-0x1.p+"), "Exponent has no digits");
1241
1242 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "0x1.p-"), "Exponent has no digits");
1243 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "+0x1.p-"), "Exponent has no digits");
1244 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "-0x1.p-"), "Exponent has no digits");
1245
1246
1247 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "0x.1p"), "Exponent has no digits");
1248 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "+0x.1p"), "Exponent has no digits");
1249 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "-0x.1p"), "Exponent has no digits");
1250
1251 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "0x.1p+"), "Exponent has no digits");
1252 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "+0x.1p+"), "Exponent has no digits");
1253 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "-0x.1p+"), "Exponent has no digits");
1254
1255 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "0x.1p-"), "Exponent has no digits");
1256 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "+0x.1p-"), "Exponent has no digits");
1257 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "-0x.1p-"), "Exponent has no digits");
1258
1259
1260 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "0x1.1p"), "Exponent has no digits");
1261 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "+0x1.1p"), "Exponent has no digits");
1262 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "-0x1.1p"), "Exponent has no digits");
1263
1264 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "0x1.1p+"), "Exponent has no digits");
1265 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "+0x1.1p+"), "Exponent has no digits");
1266 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "-0x1.1p+"), "Exponent has no digits");
1267
1268 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "0x1.1p-"), "Exponent has no digits");
1269 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "+0x1.1p-"), "Exponent has no digits");
1270 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "-0x1.1p-"), "Exponent has no digits");
1271 }
1272 #endif
1273 #endif
1274
1275 TEST(APFloatTest, exactInverse) {
1276 APFloat inv(0.0f);
1277
1278 // Trivial operation.
1279 EXPECT_TRUE(APFloat(2.0).getExactInverse(&inv));
1280 EXPECT_TRUE(inv.bitwiseIsEqual(APFloat(0.5)));
1281 EXPECT_TRUE(APFloat(2.0f).getExactInverse(&inv));
1282 EXPECT_TRUE(inv.bitwiseIsEqual(APFloat(0.5f)));
1283 EXPECT_TRUE(APFloat(APFloat::IEEEquad(), "2.0").getExactInverse(&inv));
1284 EXPECT_TRUE(inv.bitwiseIsEqual(APFloat(APFloat::IEEEquad(), "0.5")));
1285 EXPECT_TRUE(APFloat(APFloat::PPCDoubleDouble(), "2.0").getExactInverse(&inv));
1286 EXPECT_TRUE(inv.bitwiseIsEqual(APFloat(APFloat::PPCDoubleDouble(), "0.5")));
1287 EXPECT_TRUE(APFloat(APFloat::x87DoubleExtended(), "2.0").getExactInverse(&inv));
1288 EXPECT_TRUE(inv.bitwiseIsEqual(APFloat(APFloat::x87DoubleExtended(), "0.5")));
1289
1290 // FLT_MIN
1291 EXPECT_TRUE(APFloat(1.17549435e-38f).getExactInverse(&inv));
1292 EXPECT_TRUE(inv.bitwiseIsEqual(APFloat(8.5070592e+37f)));
1293
1294 // Large float, inverse is a denormal.
1295 EXPECT_FALSE(APFloat(1.7014118e38f).getExactInverse(nullptr));
1296 // Zero
1297 EXPECT_FALSE(APFloat(0.0).getExactInverse(nullptr));
1298 // Denormalized float
1299 EXPECT_FALSE(APFloat(1.40129846e-45f).getExactInverse(nullptr));
1300 }
1301
1302 TEST(APFloatTest, roundToIntegral) {
1303 APFloat T(-0.5), S(3.14), R(APFloat::getLargest(APFloat::IEEEdouble())), P(0.0);
1304
1305 P = T;
1306 P.roundToIntegral(APFloat::rmTowardZero);
1307 EXPECT_EQ(-0.0, P.convertToDouble());
1308 P = T;
1309 P.roundToIntegral(APFloat::rmTowardNegative);
1310 EXPECT_EQ(-1.0, P.convertToDouble());
1311 P = T;
1312 P.roundToIntegral(APFloat::rmTowardPositive);
1313 EXPECT_EQ(-0.0, P.convertToDouble());
1314 P = T;
1315 P.roundToIntegral(APFloat::rmNearestTiesToEven);
1316 EXPECT_EQ(-0.0, P.convertToDouble());
1317
1318 P = S;
1319 P.roundToIntegral(APFloat::rmTowardZero);
1320 EXPECT_EQ(3.0, P.convertToDouble());
1321 P = S;
1322 P.roundToIntegral(APFloat::rmTowardNegative);
1323 EXPECT_EQ(3.0, P.convertToDouble());
1324 P = S;
1325 P.roundToIntegral(APFloat::rmTowardPositive);
1326 EXPECT_EQ(4.0, P.convertToDouble());
1327 P = S;
1328 P.roundToIntegral(APFloat::rmNearestTiesToEven);
1329 EXPECT_EQ(3.0, P.convertToDouble());
1330
1331 P = R;
1332 P.roundToIntegral(APFloat::rmTowardZero);
1333 EXPECT_EQ(R.convertToDouble(), P.convertToDouble());
1334 P = R;
1335 P.roundToIntegral(APFloat::rmTowardNegative);
1336 EXPECT_EQ(R.convertToDouble(), P.convertToDouble());
1337 P = R;
1338 P.roundToIntegral(APFloat::rmTowardPositive);
1339 EXPECT_EQ(R.convertToDouble(), P.convertToDouble());
1340 P = R;
1341 P.roundToIntegral(APFloat::rmNearestTiesToEven);
1342 EXPECT_EQ(R.convertToDouble(), P.convertToDouble());
1343
1344 P = APFloat::getZero(APFloat::IEEEdouble());
1345 P.roundToIntegral(APFloat::rmTowardZero);
1346 EXPECT_EQ(0.0, P.convertToDouble());
1347 P = APFloat::getZero(APFloat::IEEEdouble(), true);
1348 P.roundToIntegral(APFloat::rmTowardZero);
1349 EXPECT_EQ(-0.0, P.convertToDouble());
1350 P = APFloat::getNaN(APFloat::IEEEdouble());
1351 P.roundToIntegral(APFloat::rmTowardZero);
1352 EXPECT_TRUE(std::isnan(P.convertToDouble()));
1353 P = APFloat::getInf(APFloat::IEEEdouble());
1354 P.roundToIntegral(APFloat::rmTowardZero);
1355 EXPECT_TRUE(std::isinf(P.convertToDouble()) && P.convertToDouble() > 0.0);
1356 P = APFloat::getInf(APFloat::IEEEdouble(), true);
1357 P.roundToIntegral(APFloat::rmTowardZero);
1358 EXPECT_TRUE(std::isinf(P.convertToDouble()) && P.convertToDouble() < 0.0);
1359 }
1360
1361 TEST(APFloatTest, isInteger) {
1362 APFloat T(-0.0);
1363 EXPECT_TRUE(T.isInteger());
1364 T = APFloat(3.14159);
1365 EXPECT_FALSE(T.isInteger());
1366 T = APFloat::getNaN(APFloat::IEEEdouble());
1367 EXPECT_FALSE(T.isInteger());
1368 T = APFloat::getInf(APFloat::IEEEdouble());
1369 EXPECT_FALSE(T.isInteger());
1370 T = APFloat::getInf(APFloat::IEEEdouble(), true);
1371 EXPECT_FALSE(T.isInteger());
1372 T = APFloat::getLargest(APFloat::IEEEdouble());
1373 EXPECT_TRUE(T.isInteger());
1374 }
1375
1376 TEST(DoubleAPFloatTest, isInteger) {
1377 APFloat F1(-0.0);
1378 APFloat F2(-0.0);
1379 llvm::detail::DoubleAPFloat T(APFloat::PPCDoubleDouble(), std::move(F1),
1380 std::move(F2));
1381 EXPECT_TRUE(T.isInteger());
1382 APFloat F3(3.14159);
1383 APFloat F4(-0.0);
1384 llvm::detail::DoubleAPFloat T2(APFloat::PPCDoubleDouble(), std::move(F3),
1385 std::move(F4));
1386 EXPECT_FALSE(T2.isInteger());
1387 APFloat F5(-0.0);
1388 APFloat F6(3.14159);
1389 llvm::detail::DoubleAPFloat T3(APFloat::PPCDoubleDouble(), std::move(F5),
1390 std::move(F6));
1391 EXPECT_FALSE(T3.isInteger());
1392 }
1393
1394 TEST(APFloatTest, getLargest) {
1395 EXPECT_EQ(3.402823466e+38f, APFloat::getLargest(APFloat::IEEEsingle()).convertToFloat());
1396 EXPECT_EQ(1.7976931348623158e+308, APFloat::getLargest(APFloat::IEEEdouble()).convertToDouble());
1397 }
1398
1399 TEST(APFloatTest, getSmallest) {
1400 APFloat test = APFloat::getSmallest(APFloat::IEEEsingle(), false);
1401 APFloat expected = APFloat(APFloat::IEEEsingle(), "0x0.000002p-126");
1402 EXPECT_FALSE(test.isNegative());
1403 EXPECT_TRUE(test.isFiniteNonZero());
1404 EXPECT_TRUE(test.isDenormal());
1405 EXPECT_TRUE(test.bitwiseIsEqual(expected));
1406
1407 test = APFloat::getSmallest(APFloat::IEEEsingle(), true);
1408 expected = APFloat(APFloat::IEEEsingle(), "-0x0.000002p-126");
1409 EXPECT_TRUE(test.isNegative());
1410 EXPECT_TRUE(test.isFiniteNonZero());
1411 EXPECT_TRUE(test.isDenormal());
1412 EXPECT_TRUE(test.bitwiseIsEqual(expected));
1413
1414 test = APFloat::getSmallest(APFloat::IEEEquad(), false);
1415 expected = APFloat(APFloat::IEEEquad(), "0x0.0000000000000000000000000001p-16382");
1416 EXPECT_FALSE(test.isNegative());
1417 EXPECT_TRUE(test.isFiniteNonZero());
1418 EXPECT_TRUE(test.isDenormal());
1419 EXPECT_TRUE(test.bitwiseIsEqual(expected));
1420
1421 test = APFloat::getSmallest(APFloat::IEEEquad(), true);
1422 expected = APFloat(APFloat::IEEEquad(), "-0x0.0000000000000000000000000001p-16382");
1423 EXPECT_TRUE(test.isNegative());
1424 EXPECT_TRUE(test.isFiniteNonZero());
1425 EXPECT_TRUE(test.isDenormal());
1426 EXPECT_TRUE(test.bitwiseIsEqual(expected));
1427 }
1428
1429 TEST(APFloatTest, getSmallestNormalized) {
1430 APFloat test = APFloat::getSmallestNormalized(APFloat::IEEEsingle(), false);
1431 APFloat expected = APFloat(APFloat::IEEEsingle(), "0x1p-126");
1432 EXPECT_FALSE(test.isNegative());
1433 EXPECT_TRUE(test.isFiniteNonZero());
1434 EXPECT_FALSE(test.isDenormal());
1435 EXPECT_TRUE(test.bitwiseIsEqual(expected));
1436
1437 test = APFloat::getSmallestNormalized(APFloat::IEEEsingle(), true);
1438 expected = APFloat(APFloat::IEEEsingle(), "-0x1p-126");
1439 EXPECT_TRUE(test.isNegative());
1440 EXPECT_TRUE(test.isFiniteNonZero());
1441 EXPECT_FALSE(test.isDenormal());
1442 EXPECT_TRUE(test.bitwiseIsEqual(expected));
1443
1444 test = APFloat::getSmallestNormalized(APFloat::IEEEquad(), false);
1445 expected = APFloat(APFloat::IEEEquad(), "0x1p-16382");
1446 EXPECT_FALSE(test.isNegative());
1447 EXPECT_TRUE(test.isFiniteNonZero());
1448 EXPECT_FALSE(test.isDenormal());
1449 EXPECT_TRUE(test.bitwiseIsEqual(expected));
1450
1451 test = APFloat::getSmallestNormalized(APFloat::IEEEquad(), true);
1452 expected = APFloat(APFloat::IEEEquad(), "-0x1p-16382");
1453 EXPECT_TRUE(test.isNegative());
1454 EXPECT_TRUE(test.isFiniteNonZero());
1455 EXPECT_FALSE(test.isDenormal());
1456 EXPECT_TRUE(test.bitwiseIsEqual(expected));
1457 }
1458
1459 TEST(APFloatTest, getZero) {
1460 struct {
1461 const fltSemantics *semantics;
1462 const bool sign;
1463 const unsigned long long bitPattern[2];
1464 const unsigned bitPatternLength;
1465 } const GetZeroTest[] = {
1466 { &APFloat::IEEEhalf(), false, {0, 0}, 1},
1467 { &APFloat::IEEEhalf(), true, {0x8000ULL, 0}, 1},
1468 { &APFloat::IEEEsingle(), false, {0, 0}, 1},
1469 { &APFloat::IEEEsingle(), true, {0x80000000ULL, 0}, 1},
1470 { &APFloat::IEEEdouble(), false, {0, 0}, 1},
1471 { &APFloat::IEEEdouble(), true, {0x8000000000000000ULL, 0}, 1},
1472 { &APFloat::IEEEquad(), false, {0, 0}, 2},
1473 { &APFloat::IEEEquad(), true, {0, 0x8000000000000000ULL}, 2},
1474 { &APFloat::PPCDoubleDouble(), false, {0, 0}, 2},
1475 { &APFloat::PPCDoubleDouble(), true, {0x8000000000000000ULL, 0}, 2},
1476 { &APFloat::x87DoubleExtended(), false, {0, 0}, 2},
1477 { &APFloat::x87DoubleExtended(), true, {0, 0x8000ULL}, 2},
1478 };
1479 const unsigned NumGetZeroTests = 12;
1480 for (unsigned i = 0; i < NumGetZeroTests; ++i) {
1481 APFloat test = APFloat::getZero(*GetZeroTest[i].semantics,
1482 GetZeroTest[i].sign);
1483 const char *pattern = GetZeroTest[i].sign? "-0x0p+0" : "0x0p+0";
1484 APFloat expected = APFloat(*GetZeroTest[i].semantics,
1485 pattern);
1486 EXPECT_TRUE(test.isZero());
1487 EXPECT_TRUE(GetZeroTest[i].sign? test.isNegative() : !test.isNegative());
1488 EXPECT_TRUE(test.bitwiseIsEqual(expected));
1489 for (unsigned j = 0, je = GetZeroTest[i].bitPatternLength; j < je; ++j) {
1490 EXPECT_EQ(GetZeroTest[i].bitPattern[j],
1491 test.bitcastToAPInt().getRawData()[j]);
1492 }
1493 }
1494 }
1495
1496 TEST(APFloatTest, copySign) {
1497 EXPECT_TRUE(APFloat(-42.0).bitwiseIsEqual(
1498 APFloat::copySign(APFloat(42.0), APFloat(-1.0))));
1499 EXPECT_TRUE(APFloat(42.0).bitwiseIsEqual(
1500 APFloat::copySign(APFloat(-42.0), APFloat(1.0))));
1501 EXPECT_TRUE(APFloat(-42.0).bitwiseIsEqual(
1502 APFloat::copySign(APFloat(-42.0), APFloat(-1.0))));
1503 EXPECT_TRUE(APFloat(42.0).bitwiseIsEqual(
1504 APFloat::copySign(APFloat(42.0), APFloat(1.0))));
1505 }
1506
1507 TEST(APFloatTest, convert) {
1508 bool losesInfo;
1509 APFloat test(APFloat::IEEEdouble(), "1.0");
1510 test.convert(APFloat::IEEEsingle(), APFloat::rmNearestTiesToEven, &losesInfo);
1511 EXPECT_EQ(1.0f, test.convertToFloat());
1512 EXPECT_FALSE(losesInfo);
1513
1514 test = APFloat(APFloat::x87DoubleExtended(), "0x1p-53");
1515 test.add(APFloat(APFloat::x87DoubleExtended(), "1.0"), APFloat::rmNearestTiesToEven);
1516 test.convert(APFloat::IEEEdouble(), APFloat::rmNearestTiesToEven, &losesInfo);
1517 EXPECT_EQ(1.0, test.convertToDouble());
1518 EXPECT_TRUE(losesInfo);
1519
1520 test = APFloat(APFloat::IEEEquad(), "0x1p-53");
1521 test.add(APFloat(APFloat::IEEEquad(), "1.0"), APFloat::rmNearestTiesToEven);
1522 test.convert(APFloat::IEEEdouble(), APFloat::rmNearestTiesToEven, &losesInfo);
1523 EXPECT_EQ(1.0, test.convertToDouble());
1524 EXPECT_TRUE(losesInfo);
1525
1526 test = APFloat(APFloat::x87DoubleExtended(), "0xf.fffffffp+28");
1527 test.convert(APFloat::IEEEdouble(), APFloat::rmNearestTiesToEven, &losesInfo);
1528 EXPECT_EQ(4294967295.0, test.convertToDouble());
1529 EXPECT_FALSE(losesInfo);
1530
1531 test = APFloat::getSNaN(APFloat::IEEEsingle());
1532 APFloat X87SNaN = APFloat::getSNaN(APFloat::x87DoubleExtended());
1533 test.convert(APFloat::x87DoubleExtended(), APFloat::rmNearestTiesToEven,
1534 &losesInfo);
1535 EXPECT_TRUE(test.bitwiseIsEqual(X87SNaN));
1536 EXPECT_FALSE(losesInfo);
1537
1538 test = APFloat::getQNaN(APFloat::IEEEsingle());
1539 APFloat X87QNaN = APFloat::getQNaN(APFloat::x87DoubleExtended());
1540 test.convert(APFloat::x87DoubleExtended(), APFloat::rmNearestTiesToEven,
1541 &losesInfo);
1542 EXPECT_TRUE(test.bitwiseIsEqual(X87QNaN));
1543 EXPECT_FALSE(losesInfo);
1544
1545 test = APFloat::getSNaN(APFloat::x87DoubleExtended());
1546 test.convert(APFloat::x87DoubleExtended(), APFloat::rmNearestTiesToEven,
1547 &losesInfo);
1548 EXPECT_TRUE(test.bitwiseIsEqual(X87SNaN));
1549 EXPECT_FALSE(losesInfo);
1550
1551 test = APFloat::getQNaN(APFloat::x87DoubleExtended());
1552 test.convert(APFloat::x87DoubleExtended(), APFloat::rmNearestTiesToEven,
1553 &losesInfo);
1554 EXPECT_TRUE(test.bitwiseIsEqual(X87QNaN));
1555 EXPECT_FALSE(losesInfo);
1556 }
1557
1558 TEST(APFloatTest, PPCDoubleDouble) {
1559 APFloat test(APFloat::PPCDoubleDouble(), "1.0");
1560 EXPECT_EQ(0x3ff0000000000000ull, test.bitcastToAPInt().getRawData()[0]);
1561 EXPECT_EQ(0x0000000000000000ull, test.bitcastToAPInt().getRawData()[1]);
1562
1563 // LDBL_MAX
1564 test = APFloat(APFloat::PPCDoubleDouble(), "1.79769313486231580793728971405301e+308");
1565 EXPECT_EQ(0x7fefffffffffffffull, test.bitcastToAPInt().getRawData()[0]);
1566 EXPECT_EQ(0x7c8ffffffffffffeull, test.bitcastToAPInt().getRawData()[1]);
1567
1568 // LDBL_MIN
1569 test = APFloat(APFloat::PPCDoubleDouble(), "2.00416836000897277799610805135016e-292");
1570 EXPECT_EQ(0x0360000000000000ull, test.bitcastToAPInt().getRawData()[0]);
1571 EXPECT_EQ(0x0000000000000000ull, test.bitcastToAPInt().getRawData()[1]);
1572
1573 // PR30869
1574 {
1575 auto Result = APFloat(APFloat::PPCDoubleDouble(), "1.0") +
1576 APFloat(APFloat::PPCDoubleDouble(), "1.0");
1577 EXPECT_EQ(&APFloat::PPCDoubleDouble(), &Result.getSemantics());
1578
1579 Result = APFloat(APFloat::PPCDoubleDouble(), "1.0") -
1580 APFloat(APFloat::PPCDoubleDouble(), "1.0");
1581 EXPECT_EQ(&APFloat::PPCDoubleDouble(), &Result.getSemantics());
1582
1583 Result = APFloat(APFloat::PPCDoubleDouble(), "1.0") *
1584 APFloat(APFloat::PPCDoubleDouble(), "1.0");
1585 EXPECT_EQ(&APFloat::PPCDoubleDouble(), &Result.getSemantics());
1586
1587 Result = APFloat(APFloat::PPCDoubleDouble(), "1.0") /
1588 APFloat(APFloat::PPCDoubleDouble(), "1.0");
1589 EXPECT_EQ(&APFloat::PPCDoubleDouble(), &Result.getSemantics());
1590
1591 int Exp;
1592 Result = frexp(APFloat(APFloat::PPCDoubleDouble(), "1.0"), Exp,
1593 APFloat::rmNearestTiesToEven);
1594 EXPECT_EQ(&APFloat::PPCDoubleDouble(), &Result.getSemantics());
1595
1596 Result = scalbn(APFloat(APFloat::PPCDoubleDouble(), "1.0"), 1,
1597 APFloat::rmNearestTiesToEven);
1598 EXPECT_EQ(&APFloat::PPCDoubleDouble(), &Result.getSemantics());
1599 }
1600 }
1601
1602 TEST(APFloatTest, isNegative) {
1603 APFloat t(APFloat::IEEEsingle(), "0x1p+0");
1604 EXPECT_FALSE(t.isNegative());
1605 t = APFloat(APFloat::IEEEsingle(), "-0x1p+0");
1606 EXPECT_TRUE(t.isNegative());
1607
1608 EXPECT_FALSE(APFloat::getInf(APFloat::IEEEsingle(), false).isNegative());
1609 EXPECT_TRUE(APFloat::getInf(APFloat::IEEEsingle(), true).isNegative());
1610
1611 EXPECT_FALSE(APFloat::getZero(APFloat::IEEEsingle(), false).isNegative());
1612 EXPECT_TRUE(APFloat::getZero(APFloat::IEEEsingle(), true).isNegative());
1613
1614 EXPECT_FALSE(APFloat::getNaN(APFloat::IEEEsingle(), false).isNegative());
1615 EXPECT_TRUE(APFloat::getNaN(APFloat::IEEEsingle(), true).isNegative());
1616
1617 EXPECT_FALSE(APFloat::getSNaN(APFloat::IEEEsingle(), false).isNegative());
1618 EXPECT_TRUE(APFloat::getSNaN(APFloat::IEEEsingle(), true).isNegative());
1619 }
1620
1621 TEST(APFloatTest, isNormal) {
1622 APFloat t(APFloat::IEEEsingle(), "0x1p+0");
1623 EXPECT_TRUE(t.isNormal());
1624
1625 EXPECT_FALSE(APFloat::getInf(APFloat::IEEEsingle(), false).isNormal());
1626 EXPECT_FALSE(APFloat::getZero(APFloat::IEEEsingle(), false).isNormal());
1627 EXPECT_FALSE(APFloat::getNaN(APFloat::IEEEsingle(), false).isNormal());
1628 EXPECT_FALSE(APFloat::getSNaN(APFloat::IEEEsingle(), false).isNormal());
1629 EXPECT_FALSE(APFloat(APFloat::IEEEsingle(), "0x1p-149").isNormal());
1630 }
1631
1632 TEST(APFloatTest, isFinite) {
1633 APFloat t(APFloat::IEEEsingle(), "0x1p+0");
1634 EXPECT_TRUE(t.isFinite());
1635 EXPECT_FALSE(APFloat::getInf(APFloat::IEEEsingle(), false).isFinite());
1636 EXPECT_TRUE(APFloat::getZero(APFloat::IEEEsingle(), false).isFinite());
1637 EXPECT_FALSE(APFloat::getNaN(APFloat::IEEEsingle(), false).isFinite());
1638 EXPECT_FALSE(APFloat::getSNaN(APFloat::IEEEsingle(), false).isFinite());
1639 EXPECT_TRUE(APFloat(APFloat::IEEEsingle(), "0x1p-149").isFinite());
1640 }
1641
1642 TEST(APFloatTest, isInfinity) {
1643 APFloat t(APFloat::IEEEsingle(), "0x1p+0");
1644 EXPECT_FALSE(t.isInfinity());
1645 EXPECT_TRUE(APFloat::getInf(APFloat::IEEEsingle(), false).isInfinity());
1646 EXPECT_FALSE(APFloat::getZero(APFloat::IEEEsingle(), false).isInfinity());
1647 EXPECT_FALSE(APFloat::getNaN(APFloat::IEEEsingle(), false).isInfinity());
1648 EXPECT_FALSE(APFloat::getSNaN(APFloat::IEEEsingle(), false).isInfinity());
1649 EXPECT_FALSE(APFloat(APFloat::IEEEsingle(), "0x1p-149").isInfinity());
1650 }
1651
1652 TEST(APFloatTest, isNaN) {
1653 APFloat t(APFloat::IEEEsingle(), "0x1p+0");
1654 EXPECT_FALSE(t.isNaN());
1655 EXPECT_FALSE(APFloat::getInf(APFloat::IEEEsingle(), false).isNaN());
1656 EXPECT_FALSE(APFloat::getZero(APFloat::IEEEsingle(), false).isNaN());
1657 EXPECT_TRUE(APFloat::getNaN(APFloat::IEEEsingle(), false).isNaN());
1658 EXPECT_TRUE(APFloat::getSNaN(APFloat::IEEEsingle(), false).isNaN());
1659 EXPECT_FALSE(APFloat(APFloat::IEEEsingle(), "0x1p-149").isNaN());
1660 }
1661
1662 TEST(APFloatTest, isFiniteNonZero) {
1663 // Test positive/negative normal value.
1664 EXPECT_TRUE(APFloat(APFloat::IEEEsingle(), "0x1p+0").isFiniteNonZero());
1665 EXPECT_TRUE(APFloat(APFloat::IEEEsingle(), "-0x1p+0").isFiniteNonZero());
1666
1667 // Test positive/negative denormal value.
1668 EXPECT_TRUE(APFloat(APFloat::IEEEsingle(), "0x1p-149").isFiniteNonZero());
1669 EXPECT_TRUE(APFloat(APFloat::IEEEsingle(), "-0x1p-149").isFiniteNonZero());
1670
1671 // Test +/- Infinity.
1672 EXPECT_FALSE(APFloat::getInf(APFloat::IEEEsingle(), false).isFiniteNonZero());
1673 EXPECT_FALSE(APFloat::getInf(APFloat::IEEEsingle(), true).isFiniteNonZero());
1674
1675 // Test +/- Zero.
1676 EXPECT_FALSE(APFloat::getZero(APFloat::IEEEsingle(), false).isFiniteNonZero());
1677 EXPECT_FALSE(APFloat::getZero(APFloat::IEEEsingle(), true).isFiniteNonZero());
1678
1679 // Test +/- qNaN. +/- dont mean anything with qNaN but paranoia can't hurt in
1680 // this instance.
1681 EXPECT_FALSE(APFloat::getNaN(APFloat::IEEEsingle(), false).isFiniteNonZero());
1682 EXPECT_FALSE(APFloat::getNaN(APFloat::IEEEsingle(), true).isFiniteNonZero());
1683
1684 // Test +/- sNaN. +/- dont mean anything with sNaN but paranoia can't hurt in
1685 // this instance.
1686 EXPECT_FALSE(APFloat::getSNaN(APFloat::IEEEsingle(), false).isFiniteNonZero());
1687 EXPECT_FALSE(APFloat::getSNaN(APFloat::IEEEsingle(), true).isFiniteNonZero());
1688 }
1689
1690 TEST(APFloatTest, add) {
1691 // Test Special Cases against each other and normal values.
1692
1693 // TODOS/NOTES:
1694 // 1. Since we perform only default exception handling all operations with
1695 // signaling NaNs should have a result that is a quiet NaN. Currently they
1696 // return sNaN.
1697
1698 APFloat PInf = APFloat::getInf(APFloat::IEEEsingle(), false);
1699 APFloat MInf = APFloat::getInf(APFloat::IEEEsingle(), true);
1700 APFloat PZero = APFloat::getZero(APFloat::IEEEsingle(), false);
1701 APFloat MZero = APFloat::getZero(APFloat::IEEEsingle(), true);
1702 APFloat QNaN = APFloat::getNaN(APFloat::IEEEsingle(), false);
1703 APFloat SNaN = APFloat::getSNaN(APFloat::IEEEsingle(), false);
1704 APFloat PNormalValue = APFloat(APFloat::IEEEsingle(), "0x1p+0");
1705 APFloat MNormalValue = APFloat(APFloat::IEEEsingle(), "-0x1p+0");
1706 APFloat PLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), false);
1707 APFloat MLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), true);
1708 APFloat PSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), false);
1709 APFloat MSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), true);
1710 APFloat PSmallestNormalized =
1711 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), false);
1712 APFloat MSmallestNormalized =
1713 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), true);
1714
1715 const int OverflowStatus = APFloat::opOverflow | APFloat::opInexact;
1716
1717 const unsigned NumTests = 169;
1718 struct {
1719 APFloat x;
1720 APFloat y;
1721 const char *result;
1722 int status;
1723 int category;
1724 } SpecialCaseTests[NumTests] = {
1725 { PInf, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1726 { PInf, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1727 { PInf, PZero, "inf", APFloat::opOK, APFloat::fcInfinity },
1728 { PInf, MZero, "inf", APFloat::opOK, APFloat::fcInfinity },
1729 { PInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1730 #if 0
1731 // See Note 1.
1732 { PInf, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1733 #endif
1734 { PInf, PNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
1735 { PInf, MNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
1736 { PInf, PLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
1737 { PInf, MLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
1738 { PInf, PSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
1739 { PInf, MSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
1740 { PInf, PSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity },
1741 { PInf, MSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity },
1742 { MInf, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1743 { MInf, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1744 { MInf, PZero, "-inf", APFloat::opOK, APFloat::fcInfinity },
1745 { MInf, MZero, "-inf", APFloat::opOK, APFloat::fcInfinity },
1746 { MInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1747 #if 0
1748 // See Note 1.
1749 { MInf, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1750 #endif
1751 { MInf, PNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
1752 { MInf, MNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
1753 { MInf, PLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
1754 { MInf, MLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
1755 { MInf, PSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
1756 { MInf, MSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
1757 { MInf, PSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity },
1758 { MInf, MSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity },
1759 { PZero, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1760 { PZero, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1761 { PZero, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1762 { PZero, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1763 { PZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1764 #if 0
1765 // See Note 1.
1766 { PZero, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1767 #endif
1768 { PZero, PNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
1769 { PZero, MNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
1770 { PZero, PLargestValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
1771 { PZero, MLargestValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
1772 { PZero, PSmallestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
1773 { PZero, MSmallestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
1774 { PZero, PSmallestNormalized, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
1775 { PZero, MSmallestNormalized, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
1776 { MZero, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1777 { MZero, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1778 { MZero, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1779 { MZero, MZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
1780 { MZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1781 #if 0
1782 // See Note 1.
1783 { MZero, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1784 #endif
1785 { MZero, PNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
1786 { MZero, MNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
1787 { MZero, PLargestValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
1788 { MZero, MLargestValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
1789 { MZero, PSmallestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
1790 { MZero, MSmallestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
1791 { MZero, PSmallestNormalized, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
1792 { MZero, MSmallestNormalized, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
1793 { QNaN, PInf, "nan", APFloat::opOK, APFloat::fcNaN },
1794 { QNaN, MInf, "nan", APFloat::opOK, APFloat::fcNaN },
1795 { QNaN, PZero, "nan", APFloat::opOK, APFloat::fcNaN },
1796 { QNaN, MZero, "nan", APFloat::opOK, APFloat::fcNaN },
1797 { QNaN, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1798 #if 0
1799 // See Note 1.
1800 { QNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1801 #endif
1802 { QNaN, PNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
1803 { QNaN, MNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
1804 { QNaN, PLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
1805 { QNaN, MLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
1806 { QNaN, PSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
1807 { QNaN, MSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
1808 { QNaN, PSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
1809 { QNaN, MSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
1810 #if 0
1811 // See Note 1.
1812 { SNaN, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1813 { SNaN, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1814 { SNaN, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1815 { SNaN, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1816 { SNaN, QNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1817 { SNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1818 { SNaN, PNormalValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1819 { SNaN, MNormalValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1820 { SNaN, PLargestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1821 { SNaN, MLargestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1822 { SNaN, PSmallestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1823 { SNaN, MSmallestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1824 { SNaN, PSmallestNormalized, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1825 { SNaN, MSmallestNormalized, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1826 #endif
1827 { PNormalValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1828 { PNormalValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1829 { PNormalValue, PZero, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
1830 { PNormalValue, MZero, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
1831 { PNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1832 #if 0
1833 // See Note 1.
1834 { PNormalValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1835 #endif
1836 { PNormalValue, PNormalValue, "0x1p+1", APFloat::opOK, APFloat::fcNormal },
1837 { PNormalValue, MNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1838 { PNormalValue, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1839 { PNormalValue, MLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1840 { PNormalValue, PSmallestValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1841 { PNormalValue, MSmallestValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1842 { PNormalValue, PSmallestNormalized, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1843 { PNormalValue, MSmallestNormalized, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1844 { MNormalValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1845 { MNormalValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1846 { MNormalValue, PZero, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
1847 { MNormalValue, MZero, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
1848 { MNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1849 #if 0
1850 // See Note 1.
1851 { MNormalValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1852 #endif
1853 { MNormalValue, PNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1854 { MNormalValue, MNormalValue, "-0x1p+1", APFloat::opOK, APFloat::fcNormal },
1855 { MNormalValue, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1856 { MNormalValue, MLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1857 { MNormalValue, PSmallestValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1858 { MNormalValue, MSmallestValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1859 { MNormalValue, PSmallestNormalized, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1860 { MNormalValue, MSmallestNormalized, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1861 { PLargestValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1862 { PLargestValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1863 { PLargestValue, PZero, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
1864 { PLargestValue, MZero, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
1865 { PLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1866 #if 0
1867 // See Note 1.
1868 { PLargestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1869 #endif
1870 { PLargestValue, PNormalValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1871 { PLargestValue, MNormalValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1872 { PLargestValue, PLargestValue, "inf", OverflowStatus, APFloat::fcInfinity },
1873 { PLargestValue, MLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1874 { PLargestValue, PSmallestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1875 { PLargestValue, MSmallestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1876 { PLargestValue, PSmallestNormalized, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1877 { PLargestValue, MSmallestNormalized, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1878 { MLargestValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1879 { MLargestValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1880 { MLargestValue, PZero, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
1881 { MLargestValue, MZero, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
1882 { MLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1883 #if 0
1884 // See Note 1.
1885 { MLargestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1886 #endif
1887 { MLargestValue, PNormalValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1888 { MLargestValue, MNormalValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1889 { MLargestValue, PLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1890 { MLargestValue, MLargestValue, "-inf", OverflowStatus, APFloat::fcInfinity },
1891 { MLargestValue, PSmallestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1892 { MLargestValue, MSmallestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1893 { MLargestValue, PSmallestNormalized, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1894 { MLargestValue, MSmallestNormalized, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1895 { PSmallestValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1896 { PSmallestValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1897 { PSmallestValue, PZero, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
1898 { PSmallestValue, MZero, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
1899 { PSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1900 #if 0
1901 // See Note 1.
1902 { PSmallestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1903 #endif
1904 { PSmallestValue, PNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1905 { PSmallestValue, MNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1906 { PSmallestValue, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1907 { PSmallestValue, MLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1908 { PSmallestValue, PSmallestValue, "0x1p-148", APFloat::opOK, APFloat::fcNormal },
1909 { PSmallestValue, MSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1910 { PSmallestValue, PSmallestNormalized, "0x1.000002p-126", APFloat::opOK, APFloat::fcNormal },
1911 { PSmallestValue, MSmallestNormalized, "-0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal },
1912 { MSmallestValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1913 { MSmallestValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1914 { MSmallestValue, PZero, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
1915 { MSmallestValue, MZero, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
1916 { MSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1917 #if 0
1918 // See Note 1.
1919 { MSmallestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1920 #endif
1921 { MSmallestValue, PNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1922 { MSmallestValue, MNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1923 { MSmallestValue, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1924 { MSmallestValue, MLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1925 { MSmallestValue, PSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1926 { MSmallestValue, MSmallestValue, "-0x1p-148", APFloat::opOK, APFloat::fcNormal },
1927 { MSmallestValue, PSmallestNormalized, "0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal },
1928 { MSmallestValue, MSmallestNormalized, "-0x1.000002p-126", APFloat::opOK, APFloat::fcNormal },
1929 { PSmallestNormalized, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1930 { PSmallestNormalized, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1931 { PSmallestNormalized, PZero, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
1932 { PSmallestNormalized, MZero, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
1933 { PSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1934 #if 0
1935 // See Note 1.
1936 { PSmallestNormalized, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1937 #endif
1938 { PSmallestNormalized, PNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1939 { PSmallestNormalized, MNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1940 { PSmallestNormalized, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1941 { PSmallestNormalized, MLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1942 { PSmallestNormalized, PSmallestValue, "0x1.000002p-126", APFloat::opOK, APFloat::fcNormal },
1943 { PSmallestNormalized, MSmallestValue, "0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal },
1944 { PSmallestNormalized, PSmallestNormalized, "0x1p-125", APFloat::opOK, APFloat::fcNormal },
1945 { PSmallestNormalized, MSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1946 { MSmallestNormalized, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1947 { MSmallestNormalized, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1948 { MSmallestNormalized, PZero, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
1949 { MSmallestNormalized, MZero, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
1950 { MSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1951 #if 0
1952 // See Note 1.
1953 { MSmallestNormalized, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1954 #endif
1955 { MSmallestNormalized, PNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1956 { MSmallestNormalized, MNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1957 { MSmallestNormalized, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1958 { MSmallestNormalized, MLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1959 { MSmallestNormalized, PSmallestValue, "-0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal },
1960 { MSmallestNormalized, MSmallestValue, "-0x1.000002p-126", APFloat::opOK, APFloat::fcNormal },
1961 { MSmallestNormalized, PSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1962 { MSmallestNormalized, MSmallestNormalized, "-0x1p-125", APFloat::opOK, APFloat::fcNormal }
1963 };
1964
1965 for (size_t i = 0; i < NumTests; ++i) {
1966 APFloat x(SpecialCaseTests[i].x);
1967 APFloat y(SpecialCaseTests[i].y);
1968 APFloat::opStatus status = x.add(y, APFloat::rmNearestTiesToEven);
1969
1970 APFloat result(APFloat::IEEEsingle(), SpecialCaseTests[i].result);
1971
1972 EXPECT_TRUE(result.bitwiseIsEqual(x));
1973 EXPECT_TRUE((int)status == SpecialCaseTests[i].status);
1974 EXPECT_TRUE((int)x.getCategory() == SpecialCaseTests[i].category);
1975 }
1976 }
1977
1978 TEST(APFloatTest, subtract) {
1979 // Test Special Cases against each other and normal values.
1980
1981 // TODOS/NOTES:
1982 // 1. Since we perform only default exception handling all operations with
1983 // signaling NaNs should have a result that is a quiet NaN. Currently they
1984 // return sNaN.
1985
1986 APFloat PInf = APFloat::getInf(APFloat::IEEEsingle(), false);
1987 APFloat MInf = APFloat::getInf(APFloat::IEEEsingle(), true);
1988 APFloat PZero = APFloat::getZero(APFloat::IEEEsingle(), false);
1989 APFloat MZero = APFloat::getZero(APFloat::IEEEsingle(), true);
1990 APFloat QNaN = APFloat::getNaN(APFloat::IEEEsingle(), false);
1991 APFloat SNaN = APFloat::getSNaN(APFloat::IEEEsingle(), false);
1992 APFloat PNormalValue = APFloat(APFloat::IEEEsingle(), "0x1p+0");
1993 APFloat MNormalValue = APFloat(APFloat::IEEEsingle(), "-0x1p+0");
1994 APFloat PLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), false);
1995 APFloat MLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), true);
1996 APFloat PSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), false);
1997 APFloat MSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), true);
1998 APFloat PSmallestNormalized =
1999 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), false);
2000 APFloat MSmallestNormalized =
2001 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), true);
2002
2003 const int OverflowStatus = APFloat::opOverflow | APFloat::opInexact;
2004
2005 const unsigned NumTests = 169;
2006 struct {
2007 APFloat x;
2008 APFloat y;
2009 const char *result;
2010 int status;
2011 int category;
2012 } SpecialCaseTests[NumTests] = {
2013 { PInf, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2014 { PInf, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2015 { PInf, PZero, "inf", APFloat::opOK, APFloat::fcInfinity },
2016 { PInf, MZero, "inf", APFloat::opOK, APFloat::fcInfinity },
2017 { PInf, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
2018 #if 0
2019 // See Note 1.
2020 { PInf, SNaN, "-nan", APFloat::opInvalidOp, APFloat::fcNaN },
2021 #endif
2022 { PInf, PNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2023 { PInf, MNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2024 { PInf, PLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2025 { PInf, MLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2026 { PInf, PSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2027 { PInf, MSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2028 { PInf, PSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity },
2029 { PInf, MSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity },
2030 { MInf, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2031 { MInf, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2032 { MInf, PZero, "-inf", APFloat::opOK, APFloat::fcInfinity },
2033 { MInf, MZero, "-inf", APFloat::opOK, APFloat::fcInfinity },
2034 { MInf, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
2035 #if 0
2036 // See Note 1.
2037 { MInf, SNaN, "-nan", APFloat::opInvalidOp, APFloat::fcNaN },
2038 #endif
2039 { MInf, PNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2040 { MInf, MNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2041 { MInf, PLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2042 { MInf, MLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2043 { MInf, PSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2044 { MInf, MSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2045 { MInf, PSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity },
2046 { MInf, MSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity },
2047 { PZero, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2048 { PZero, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2049 { PZero, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2050 { PZero, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2051 { PZero, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
2052 #if 0
2053 // See Note 1.
2054 { PZero, SNaN, "-nan", APFloat::opInvalidOp, APFloat::fcNaN },
2055 #endif
2056 { PZero, PNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2057 { PZero, MNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2058 { PZero, PLargestValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2059 { PZero, MLargestValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2060 { PZero, PSmallestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2061 { PZero, MSmallestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2062 { PZero, PSmallestNormalized, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2063 { PZero, MSmallestNormalized, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2064 { MZero, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2065 { MZero, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2066 { MZero, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2067 { MZero, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2068 { MZero, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
2069 #if 0
2070 // See Note 1.
2071 { MZero, SNaN, "-nan", APFloat::opInvalidOp, APFloat::fcNaN },
2072 #endif
2073 { MZero, PNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2074 { MZero, MNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2075 { MZero, PLargestValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2076 { MZero, MLargestValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2077 { MZero, PSmallestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2078 { MZero, MSmallestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2079 { MZero, PSmallestNormalized, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2080 { MZero, MSmallestNormalized, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2081 { QNaN, PInf, "nan", APFloat::opOK, APFloat::fcNaN },
2082 { QNaN, MInf, "nan", APFloat::opOK, APFloat::fcNaN },
2083 { QNaN, PZero, "nan", APFloat::opOK, APFloat::fcNaN },
2084 { QNaN, MZero, "nan", APFloat::opOK, APFloat::fcNaN },
2085 { QNaN, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2086 #if 0
2087 // See Note 1.
2088 { QNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2089 #endif
2090 { QNaN, PNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
2091 { QNaN, MNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
2092 { QNaN, PLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2093 { QNaN, MLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2094 { QNaN, PSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2095 { QNaN, MSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2096 { QNaN, PSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
2097 { QNaN, MSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
2098 #if 0
2099 // See Note 1.
2100 { SNaN, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2101 { SNaN, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2102 { SNaN, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2103 { SNaN, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2104 { SNaN, QNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2105 { SNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2106 { SNaN, PNormalValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2107 { SNaN, MNormalValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2108 { SNaN, PLargestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2109 { SNaN, MLargestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2110 { SNaN, PSmallestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2111 { SNaN, MSmallestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2112 { SNaN, PSmallestNormalized, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2113 { SNaN, MSmallestNormalized, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2114 #endif
2115 { PNormalValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2116 { PNormalValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2117 { PNormalValue, PZero, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2118 { PNormalValue, MZero, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2119 { PNormalValue, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
2120 #if 0
2121 // See Note 1.
2122 { PNormalValue, SNaN, "-nan", APFloat::opInvalidOp, APFloat::fcNaN },
2123 #endif
2124 { PNormalValue, PNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2125 { PNormalValue, MNormalValue, "0x1p+1", APFloat::opOK, APFloat::fcNormal },
2126 { PNormalValue, PLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2127 { PNormalValue, MLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2128 { PNormalValue, PSmallestValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2129 { PNormalValue, MSmallestValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2130 { PNormalValue, PSmallestNormalized, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2131 { PNormalValue, MSmallestNormalized, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2132 { MNormalValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2133 { MNormalValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2134 { MNormalValue, PZero, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2135 { MNormalValue, MZero, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2136 { MNormalValue, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
2137 #if 0
2138 // See Note 1.
2139 { MNormalValue, SNaN, "-nan", APFloat::opInvalidOp, APFloat::fcNaN },
2140 #endif
2141 { MNormalValue, PNormalValue, "-0x1p+1", APFloat::opOK, APFloat::fcNormal },
2142 { MNormalValue, MNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2143 { MNormalValue, PLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2144 { MNormalValue, MLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2145 { MNormalValue, PSmallestValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2146 { MNormalValue, MSmallestValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2147 { MNormalValue, PSmallestNormalized, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2148 { MNormalValue, MSmallestNormalized, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2149 { PLargestValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2150 { PLargestValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2151 { PLargestValue, PZero, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2152 { PLargestValue, MZero, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2153 { PLargestValue, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
2154 #if 0
2155 // See Note 1.
2156 { PLargestValue, SNaN, "-nan", APFloat::opInvalidOp, APFloat::fcNaN },
2157 #endif
2158 { PLargestValue, PNormalValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2159 { PLargestValue, MNormalValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2160 { PLargestValue, PLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2161 { PLargestValue, MLargestValue, "inf", OverflowStatus, APFloat::fcInfinity },
2162 { PLargestValue, PSmallestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2163 { PLargestValue, MSmallestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2164 { PLargestValue, PSmallestNormalized, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2165 { PLargestValue, MSmallestNormalized, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2166 { MLargestValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2167 { MLargestValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2168 { MLargestValue, PZero, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2169 { MLargestValue, MZero, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2170 { MLargestValue, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
2171 #if 0
2172 // See Note 1.
2173 { MLargestValue, SNaN, "-nan", APFloat::opInvalidOp, APFloat::fcNaN },
2174 #endif
2175 { MLargestValue, PNormalValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2176 { MLargestValue, MNormalValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2177 { MLargestValue, PLargestValue, "-inf", OverflowStatus, APFloat::fcInfinity },
2178 { MLargestValue, MLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2179 { MLargestValue, PSmallestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2180 { MLargestValue, MSmallestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2181 { MLargestValue, PSmallestNormalized, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2182 { MLargestValue, MSmallestNormalized, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2183 { PSmallestValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2184 { PSmallestValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2185 { PSmallestValue, PZero, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2186 { PSmallestValue, MZero, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2187 { PSmallestValue, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
2188 #if 0
2189 // See Note 1.
2190 { PSmallestValue, SNaN, "-nan", APFloat::opInvalidOp, APFloat::fcNaN },
2191 #endif
2192 { PSmallestValue, PNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2193 { PSmallestValue, MNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2194 { PSmallestValue, PLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2195 { PSmallestValue, MLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2196 { PSmallestValue, PSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2197 { PSmallestValue, MSmallestValue, "0x1p-148", APFloat::opOK, APFloat::fcNormal },
2198 { PSmallestValue, PSmallestNormalized, "-0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal },
2199 { PSmallestValue, MSmallestNormalized, "0x1.000002p-126", APFloat::opOK, APFloat::fcNormal },
2200 { MSmallestValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2201 { MSmallestValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2202 { MSmallestValue, PZero, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2203 { MSmallestValue, MZero, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2204 { MSmallestValue, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
2205 #if 0
2206 // See Note 1.
2207 { MSmallestValue, SNaN, "-nan", APFloat::opInvalidOp, APFloat::fcNaN },
2208 #endif
2209 { MSmallestValue, PNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2210 { MSmallestValue, MNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2211 { MSmallestValue, PLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2212 { MSmallestValue, MLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2213 { MSmallestValue, PSmallestValue, "-0x1p-148", APFloat::opOK, APFloat::fcNormal },
2214 { MSmallestValue, MSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2215 { MSmallestValue, PSmallestNormalized, "-0x1.000002p-126", APFloat::opOK, APFloat::fcNormal },
2216 { MSmallestValue, MSmallestNormalized, "0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal },
2217 { PSmallestNormalized, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2218 { PSmallestNormalized, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2219 { PSmallestNormalized, PZero, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2220 { PSmallestNormalized, MZero, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2221 { PSmallestNormalized, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
2222 #if 0
2223 // See Note 1.
2224 { PSmallestNormalized, SNaN, "-nan", APFloat::opInvalidOp, APFloat::fcNaN },
2225 #endif
2226 { PSmallestNormalized, PNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2227 { PSmallestNormalized, MNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2228 { PSmallestNormalized, PLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2229 { PSmallestNormalized, MLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2230 { PSmallestNormalized, PSmallestValue, "0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal },
2231 { PSmallestNormalized, MSmallestValue, "0x1.000002p-126", APFloat::opOK, APFloat::fcNormal },
2232 { PSmallestNormalized, PSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2233 { PSmallestNormalized, MSmallestNormalized, "0x1p-125", APFloat::opOK, APFloat::fcNormal },
2234 { MSmallestNormalized, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2235 { MSmallestNormalized, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2236 { MSmallestNormalized, PZero, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2237 { MSmallestNormalized, MZero, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2238 { MSmallestNormalized, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
2239 #if 0
2240 // See Note 1.
2241 { MSmallestNormalized, SNaN, "-nan", APFloat::opInvalidOp, APFloat::fcNaN },
2242 #endif
2243 { MSmallestNormalized, PNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2244 { MSmallestNormalized, MNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2245 { MSmallestNormalized, PLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2246 { MSmallestNormalized, MLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2247 { MSmallestNormalized, PSmallestValue, "-0x1.000002p-126", APFloat::opOK, APFloat::fcNormal },
2248 { MSmallestNormalized, MSmallestValue, "-0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal },
2249 { MSmallestNormalized, PSmallestNormalized, "-0x1p-125", APFloat::opOK, APFloat::fcNormal },
2250 { MSmallestNormalized, MSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero }
2251 };
2252
2253 for (size_t i = 0; i < NumTests; ++i) {
2254 APFloat x(SpecialCaseTests[i].x);
2255 APFloat y(SpecialCaseTests[i].y);
2256 APFloat::opStatus status = x.subtract(y, APFloat::rmNearestTiesToEven);
2257
2258 APFloat result(APFloat::IEEEsingle(), SpecialCaseTests[i].result);
2259
2260 EXPECT_TRUE(result.bitwiseIsEqual(x));
2261 EXPECT_TRUE((int)status == SpecialCaseTests[i].status);
2262 EXPECT_TRUE((int)x.getCategory() == SpecialCaseTests[i].category);
2263 }
2264 }
2265
2266 TEST(APFloatTest, multiply) {
2267 // Test Special Cases against each other and normal values.
2268
2269 // TODOS/NOTES:
2270 // 1. Since we perform only default exception handling all operations with
2271 // signaling NaNs should have a result that is a quiet NaN. Currently they
2272 // return sNaN.
2273
2274 APFloat PInf = APFloat::getInf(APFloat::IEEEsingle(), false);
2275 APFloat MInf = APFloat::getInf(APFloat::IEEEsingle(), true);
2276 APFloat PZero = APFloat::getZero(APFloat::IEEEsingle(), false);
2277 APFloat MZero = APFloat::getZero(APFloat::IEEEsingle(), true);
2278 APFloat QNaN = APFloat::getNaN(APFloat::IEEEsingle(), false);
2279 APFloat SNaN = APFloat::getSNaN(APFloat::IEEEsingle(), false);
2280 APFloat PNormalValue = APFloat(APFloat::IEEEsingle(), "0x1p+0");
2281 APFloat MNormalValue = APFloat(APFloat::IEEEsingle(), "-0x1p+0");
2282 APFloat PLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), false);
2283 APFloat MLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), true);
2284 APFloat PSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), false);
2285 APFloat MSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), true);
2286 APFloat PSmallestNormalized =
2287 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), false);
2288 APFloat MSmallestNormalized =
2289 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), true);
2290
2291 const int OverflowStatus = APFloat::opOverflow | APFloat::opInexact;
2292 const int UnderflowStatus = APFloat::opUnderflow | APFloat::opInexact;
2293
2294 const unsigned NumTests = 169;
2295 struct {
2296 APFloat x;
2297 APFloat y;
2298 const char *result;
2299 int status;
2300 int category;
2301 } SpecialCaseTests[NumTests] = {
2302 { PInf, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2303 { PInf, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2304 { PInf, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2305 { PInf, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2306 { PInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2307 #if 0
2308 // See Note 1.
2309 { PInf, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2310 #endif
2311 { PInf, PNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2312 { PInf, MNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2313 { PInf, PLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2314 { PInf, MLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2315 { PInf, PSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2316 { PInf, MSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2317 { PInf, PSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity },
2318 { PInf, MSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity },
2319 { MInf, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2320 { MInf, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2321 { MInf, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2322 { MInf, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2323 { MInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2324 #if 0
2325 // See Note 1.
2326 { MInf, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2327 #endif
2328 { MInf, PNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2329 { MInf, MNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2330 { MInf, PLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2331 { MInf, MLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2332 { MInf, PSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2333 { MInf, MSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2334 { MInf, PSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity },
2335 { MInf, MSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity },
2336 { PZero, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2337 { PZero, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2338 { PZero, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2339 { PZero, MZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2340 { PZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2341 #if 0
2342 // See Note 1.
2343 { PZero, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2344 #endif
2345 { PZero, PNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2346 { PZero, MNormalValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2347 { PZero, PLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2348 { PZero, MLargestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2349 { PZero, PSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2350 { PZero, MSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2351 { PZero, PSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2352 { PZero, MSmallestNormalized, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2353 { MZero, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2354 { MZero, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2355 { MZero, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2356 { MZero, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2357 { MZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2358 #if 0
2359 // See Note 1.
2360 { MZero, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2361 #endif
2362 { MZero, PNormalValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2363 { MZero, MNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2364 { MZero, PLargestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2365 { MZero, MLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2366 { MZero, PSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2367 { MZero, MSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2368 { MZero, PSmallestNormalized, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2369 { MZero, MSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2370 { QNaN, PInf, "nan", APFloat::opOK, APFloat::fcNaN },
2371 { QNaN, MInf, "nan", APFloat::opOK, APFloat::fcNaN },
2372 { QNaN, PZero, "nan", APFloat::opOK, APFloat::fcNaN },
2373 { QNaN, MZero, "nan", APFloat::opOK, APFloat::fcNaN },
2374 { QNaN, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2375 #if 0
2376 // See Note 1.
2377 { QNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2378 #endif
2379 { QNaN, PNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
2380 { QNaN, MNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
2381 { QNaN, PLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2382 { QNaN, MLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2383 { QNaN, PSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2384 { QNaN, MSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2385 { QNaN, PSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
2386 { QNaN, MSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
2387 #if 0
2388 // See Note 1.
2389 { SNaN, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2390 { SNaN, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2391 { SNaN, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2392 { SNaN, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2393 { SNaN, QNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2394 { SNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2395 { SNaN, PNormalValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2396 { SNaN, MNormalValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2397 { SNaN, PLargestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2398 { SNaN, MLargestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2399 { SNaN, PSmallestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2400 { SNaN, MSmallestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2401 { SNaN, PSmallestNormalized, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2402 { SNaN, MSmallestNormalized, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2403 #endif
2404 { PNormalValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2405 { PNormalValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2406 { PNormalValue, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2407 { PNormalValue, MZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2408 { PNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2409 #if 0
2410 // See Note 1.
2411 { PNormalValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2412 #endif
2413 { PNormalValue, PNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2414 { PNormalValue, MNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2415 { PNormalValue, PLargestValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2416 { PNormalValue, MLargestValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2417 { PNormalValue, PSmallestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2418 { PNormalValue, MSmallestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2419 { PNormalValue, PSmallestNormalized, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2420 { PNormalValue, MSmallestNormalized, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2421 { MNormalValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2422 { MNormalValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2423 { MNormalValue, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2424 { MNormalValue, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2425 { MNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2426 #if 0
2427 // See Note 1.
2428 { MNormalValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2429 #endif
2430 { MNormalValue, PNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2431 { MNormalValue, MNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2432 { MNormalValue, PLargestValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2433 { MNormalValue, MLargestValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2434 { MNormalValue, PSmallestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2435 { MNormalValue, MSmallestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2436 { MNormalValue, PSmallestNormalized, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2437 { MNormalValue, MSmallestNormalized, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2438 { PLargestValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2439 { PLargestValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2440 { PLargestValue, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2441 { PLargestValue, MZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2442 { PLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2443 #if 0
2444 // See Note 1.
2445 { PLargestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2446 #endif
2447 { PLargestValue, PNormalValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2448 { PLargestValue, MNormalValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2449 { PLargestValue, PLargestValue, "inf", OverflowStatus, APFloat::fcInfinity },
2450 { PLargestValue, MLargestValue, "-inf", OverflowStatus, APFloat::fcInfinity },
2451 { PLargestValue, PSmallestValue, "0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal },
2452 { PLargestValue, MSmallestValue, "-0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal },
2453 { PLargestValue, PSmallestNormalized, "0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal },
2454 { PLargestValue, MSmallestNormalized, "-0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal },
2455 { MLargestValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2456 { MLargestValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2457 { MLargestValue, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2458 { MLargestValue, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2459 { MLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2460 #if 0
2461 // See Note 1.
2462 { MLargestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2463 #endif
2464 { MLargestValue, PNormalValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2465 { MLargestValue, MNormalValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2466 { MLargestValue, PLargestValue, "-inf", OverflowStatus, APFloat::fcInfinity },
2467 { MLargestValue, MLargestValue, "inf", OverflowStatus, APFloat::fcInfinity },
2468 { MLargestValue, PSmallestValue, "-0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal },
2469 { MLargestValue, MSmallestValue, "0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal },
2470 { MLargestValue, PSmallestNormalized, "-0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal },
2471 { MLargestValue, MSmallestNormalized, "0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal },
2472 { PSmallestValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2473 { PSmallestValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2474 { PSmallestValue, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2475 { PSmallestValue, MZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2476 { PSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2477 #if 0
2478 // See Note 1.
2479 { PSmallestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2480 #endif
2481 { PSmallestValue, PNormalValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2482 { PSmallestValue, MNormalValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2483 { PSmallestValue, PLargestValue, "0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal },
2484 { PSmallestValue, MLargestValue, "-0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal },
2485 { PSmallestValue, PSmallestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero },
2486 { PSmallestValue, MSmallestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2487 { PSmallestValue, PSmallestNormalized, "0x0p+0", UnderflowStatus, APFloat::fcZero },
2488 { PSmallestValue, MSmallestNormalized, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2489 { MSmallestValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2490 { MSmallestValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2491 { MSmallestValue, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2492 { MSmallestValue, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2493 { MSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2494 #if 0
2495 // See Note 1.
2496 { MSmallestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2497 #endif
2498 { MSmallestValue, PNormalValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2499 { MSmallestValue, MNormalValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2500 { MSmallestValue, PLargestValue, "-0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal },
2501 { MSmallestValue, MLargestValue, "0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal },
2502 { MSmallestValue, PSmallestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2503 { MSmallestValue, MSmallestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero },
2504 { MSmallestValue, PSmallestNormalized, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2505 { MSmallestValue, MSmallestNormalized, "0x0p+0", UnderflowStatus, APFloat::fcZero },
2506 { PSmallestNormalized, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2507 { PSmallestNormalized, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2508 { PSmallestNormalized, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2509 { PSmallestNormalized, MZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2510 { PSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2511 #if 0
2512 // See Note 1.
2513 { PSmallestNormalized, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2514 #endif
2515 { PSmallestNormalized, PNormalValue, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2516 { PSmallestNormalized, MNormalValue, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2517 { PSmallestNormalized, PLargestValue, "0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal },
2518 { PSmallestNormalized, MLargestValue, "-0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal },
2519 { PSmallestNormalized, PSmallestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero },
2520 { PSmallestNormalized, MSmallestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2521 { PSmallestNormalized, PSmallestNormalized, "0x0p+0", UnderflowStatus, APFloat::fcZero },
2522 { PSmallestNormalized, MSmallestNormalized, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2523 { MSmallestNormalized, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2524 { MSmallestNormalized, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2525 { MSmallestNormalized, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2526 { MSmallestNormalized, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2527 { MSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2528 #if 0
2529 // See Note 1.
2530 { MSmallestNormalized, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2531 #endif
2532 { MSmallestNormalized, PNormalValue, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2533 { MSmallestNormalized, MNormalValue, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2534 { MSmallestNormalized, PLargestValue, "-0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal },
2535 { MSmallestNormalized, MLargestValue, "0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal },
2536 { MSmallestNormalized, PSmallestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2537 { MSmallestNormalized, MSmallestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero },
2538 { MSmallestNormalized, PSmallestNormalized, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2539 { MSmallestNormalized, MSmallestNormalized, "0x0p+0", UnderflowStatus, APFloat::fcZero }
2540 };
2541
2542 for (size_t i = 0; i < NumTests; ++i) {
2543 APFloat x(SpecialCaseTests[i].x);
2544 APFloat y(SpecialCaseTests[i].y);
2545 APFloat::opStatus status = x.multiply(y, APFloat::rmNearestTiesToEven);
2546
2547 APFloat result(APFloat::IEEEsingle(), SpecialCaseTests[i].result);
2548
2549 EXPECT_TRUE(result.bitwiseIsEqual(x));
2550 EXPECT_TRUE((int)status == SpecialCaseTests[i].status);
2551 EXPECT_TRUE((int)x.getCategory() == SpecialCaseTests[i].category);
2552 }
2553 }
2554
2555 TEST(APFloatTest, divide) {
2556 // Test Special Cases against each other and normal values.
2557
2558 // TODOS/NOTES:
2559 // 1. Since we perform only default exception handling all operations with
2560 // signaling NaNs should have a result that is a quiet NaN. Currently they
2561 // return sNaN.
2562
2563 APFloat PInf = APFloat::getInf(APFloat::IEEEsingle(), false);
2564 APFloat MInf = APFloat::getInf(APFloat::IEEEsingle(), true);
2565 APFloat PZero = APFloat::getZero(APFloat::IEEEsingle(), false);
2566 APFloat MZero = APFloat::getZero(APFloat::IEEEsingle(), true);
2567 APFloat QNaN = APFloat::getNaN(APFloat::IEEEsingle(), false);
2568 APFloat SNaN = APFloat::getSNaN(APFloat::IEEEsingle(), false);
2569 APFloat PNormalValue = APFloat(APFloat::IEEEsingle(), "0x1p+0");
2570 APFloat MNormalValue = APFloat(APFloat::IEEEsingle(), "-0x1p+0");
2571 APFloat PLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), false);
2572 APFloat MLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), true);
2573 APFloat PSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), false);
2574 APFloat MSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), true);
2575 APFloat PSmallestNormalized =
2576 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), false);
2577 APFloat MSmallestNormalized =
2578 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), true);
2579
2580 const int OverflowStatus = APFloat::opOverflow | APFloat::opInexact;
2581 const int UnderflowStatus = APFloat::opUnderflow | APFloat::opInexact;
2582
2583 const unsigned NumTests = 169;
2584 struct {
2585 APFloat x;
2586 APFloat y;
2587 const char *result;
2588 int status;
2589 int category;
2590 } SpecialCaseTests[NumTests] = {
2591 { PInf, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2592 { PInf, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2593 { PInf, PZero, "inf", APFloat::opOK, APFloat::fcInfinity },
2594 { PInf, MZero, "-inf", APFloat::opOK, APFloat::fcInfinity },
2595 { PInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2596 #if 0
2597 // See Note 1.
2598 { PInf, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2599 #endif
2600 { PInf, PNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2601 { PInf, MNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2602 { PInf, PLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2603 { PInf, MLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2604 { PInf, PSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2605 { PInf, MSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2606 { PInf, PSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity },
2607 { PInf, MSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity },
2608 { MInf, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2609 { MInf, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2610 { MInf, PZero, "-inf", APFloat::opOK, APFloat::fcInfinity },
2611 { MInf, MZero, "inf", APFloat::opOK, APFloat::fcInfinity },
2612 { MInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2613 #if 0
2614 // See Note 1.
2615 { MInf, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2616 #endif
2617 { MInf, PNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2618 { MInf, MNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2619 { MInf, PLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2620 { MInf, MLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2621 { MInf, PSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2622 { MInf, MSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2623 { MInf, PSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity },
2624 { MInf, MSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity },
2625 { PZero, PInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2626 { PZero, MInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2627 { PZero, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2628 { PZero, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2629 { PZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2630 #if 0
2631 // See Note 1.
2632 { PZero, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2633 #endif
2634 { PZero, PNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2635 { PZero, MNormalValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2636 { PZero, PLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2637 { PZero, MLargestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2638 { PZero, PSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2639 { PZero, MSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2640 { PZero, PSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2641 { PZero, MSmallestNormalized, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2642 { MZero, PInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2643 { MZero, MInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2644 { MZero, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2645 { MZero, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2646 { MZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2647 #if 0
2648 // See Note 1.
2649 { MZero, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2650 #endif
2651 { MZero, PNormalValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2652 { MZero, MNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2653 { MZero, PLargestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2654 { MZero, MLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2655 { MZero, PSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2656 { MZero, MSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2657 { MZero, PSmallestNormalized, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2658 { MZero, MSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2659 { QNaN, PInf, "nan", APFloat::opOK, APFloat::fcNaN },
2660 { QNaN, MInf, "nan", APFloat::opOK, APFloat::fcNaN },
2661 { QNaN, PZero, "nan", APFloat::opOK, APFloat::fcNaN },
2662 { QNaN, MZero, "nan", APFloat::opOK, APFloat::fcNaN },
2663 { QNaN, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2664 #if 0
2665 // See Note 1.
2666 { QNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2667 #endif
2668 { QNaN, PNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
2669 { QNaN, MNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
2670 { QNaN, PLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2671 { QNaN, MLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2672 { QNaN, PSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2673 { QNaN, MSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2674 { QNaN, PSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
2675 { QNaN, MSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
2676 #if 0
2677 // See Note 1.
2678 { SNaN, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2679 { SNaN, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2680 { SNaN, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2681 { SNaN, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2682 { SNaN, QNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2683 { SNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2684 { SNaN, PNormalValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2685 { SNaN, MNormalValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2686 { SNaN, PLargestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2687 { SNaN, MLargestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2688 { SNaN, PSmallestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2689 { SNaN, MSmallestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2690 { SNaN, PSmallestNormalized, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2691 { SNaN, MSmallestNormalized, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2692 #endif
2693 { PNormalValue, PInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2694 { PNormalValue, MInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2695 { PNormalValue, PZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
2696 { PNormalValue, MZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
2697 { PNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2698 #if 0
2699 // See Note 1.
2700 { PNormalValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2701 #endif
2702 { PNormalValue, PNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2703 { PNormalValue, MNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2704 { PNormalValue, PLargestValue, "0x1p-128", UnderflowStatus, APFloat::fcNormal },
2705 { PNormalValue, MLargestValue, "-0x1p-128", UnderflowStatus, APFloat::fcNormal },
2706 { PNormalValue, PSmallestValue, "inf", OverflowStatus, APFloat::fcInfinity },
2707 { PNormalValue, MSmallestValue, "-inf", OverflowStatus, APFloat::fcInfinity },
2708 { PNormalValue, PSmallestNormalized, "0x1p+126", APFloat::opOK, APFloat::fcNormal },
2709 { PNormalValue, MSmallestNormalized, "-0x1p+126", APFloat::opOK, APFloat::fcNormal },
2710 { MNormalValue, PInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2711 { MNormalValue, MInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2712 { MNormalValue, PZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
2713 { MNormalValue, MZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
2714 { MNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2715 #if 0
2716 // See Note 1.
2717 { MNormalValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2718 #endif
2719 { MNormalValue, PNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2720 { MNormalValue, MNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2721 { MNormalValue, PLargestValue, "-0x1p-128", UnderflowStatus, APFloat::fcNormal },
2722 { MNormalValue, MLargestValue, "0x1p-128", UnderflowStatus, APFloat::fcNormal },
2723 { MNormalValue, PSmallestValue, "-inf", OverflowStatus, APFloat::fcInfinity },
2724 { MNormalValue, MSmallestValue, "inf", OverflowStatus, APFloat::fcInfinity },
2725 { MNormalValue, PSmallestNormalized, "-0x1p+126", APFloat::opOK, APFloat::fcNormal },
2726 { MNormalValue, MSmallestNormalized, "0x1p+126", APFloat::opOK, APFloat::fcNormal },
2727 { PLargestValue, PInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2728 { PLargestValue, MInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2729 { PLargestValue, PZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
2730 { PLargestValue, MZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
2731 { PLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2732 #if 0
2733 // See Note 1.
2734 { PLargestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2735 #endif
2736 { PLargestValue, PNormalValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2737 { PLargestValue, MNormalValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2738 { PLargestValue, PLargestValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2739 { PLargestValue, MLargestValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2740 { PLargestValue, PSmallestValue, "inf", OverflowStatus, APFloat::fcInfinity },
2741 { PLargestValue, MSmallestValue, "-inf", OverflowStatus, APFloat::fcInfinity },
2742 { PLargestValue, PSmallestNormalized, "inf", OverflowStatus, APFloat::fcInfinity },
2743 { PLargestValue, MSmallestNormalized, "-inf", OverflowStatus, APFloat::fcInfinity },
2744 { MLargestValue, PInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2745 { MLargestValue, MInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2746 { MLargestValue, PZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
2747 { MLargestValue, MZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
2748 { MLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2749 #if 0
2750 // See Note 1.
2751 { MLargestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2752 #endif
2753 { MLargestValue, PNormalValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2754 { MLargestValue, MNormalValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2755 { MLargestValue, PLargestValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2756 { MLargestValue, MLargestValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2757 { MLargestValue, PSmallestValue, "-inf", OverflowStatus, APFloat::fcInfinity },
2758 { MLargestValue, MSmallestValue, "inf", OverflowStatus, APFloat::fcInfinity },
2759 { MLargestValue, PSmallestNormalized, "-inf", OverflowStatus, APFloat::fcInfinity },
2760 { MLargestValue, MSmallestNormalized, "inf", OverflowStatus, APFloat::fcInfinity },
2761 { PSmallestValue, PInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2762 { PSmallestValue, MInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2763 { PSmallestValue, PZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
2764 { PSmallestValue, MZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
2765 { PSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2766 #if 0
2767 // See Note 1.
2768 { PSmallestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2769 #endif
2770 { PSmallestValue, PNormalValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2771 { PSmallestValue, MNormalValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2772 { PSmallestValue, PLargestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero },
2773 { PSmallestValue, MLargestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2774 { PSmallestValue, PSmallestValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2775 { PSmallestValue, MSmallestValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2776 { PSmallestValue, PSmallestNormalized, "0x1p-23", APFloat::opOK, APFloat::fcNormal },
2777 { PSmallestValue, MSmallestNormalized, "-0x1p-23", APFloat::opOK, APFloat::fcNormal },
2778 { MSmallestValue, PInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2779 { MSmallestValue, MInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2780 { MSmallestValue, PZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
2781 { MSmallestValue, MZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
2782 { MSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2783 #if 0
2784 // See Note 1.
2785 { MSmallestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2786 #endif
2787 { MSmallestValue, PNormalValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2788 { MSmallestValue, MNormalValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2789 { MSmallestValue, PLargestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2790 { MSmallestValue, MLargestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero },
2791 { MSmallestValue, PSmallestValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2792 { MSmallestValue, MSmallestValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2793 { MSmallestValue, PSmallestNormalized, "-0x1p-23", APFloat::opOK, APFloat::fcNormal },
2794 { MSmallestValue, MSmallestNormalized, "0x1p-23", APFloat::opOK, APFloat::fcNormal },
2795 { PSmallestNormalized, PInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2796 { PSmallestNormalized, MInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2797 { PSmallestNormalized, PZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
2798 { PSmallestNormalized, MZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
2799 { PSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2800 #if 0
2801 // See Note 1.
2802 { PSmallestNormalized, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2803 #endif
2804 { PSmallestNormalized, PNormalValue, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2805 { PSmallestNormalized, MNormalValue, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2806 { PSmallestNormalized, PLargestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero },
2807 { PSmallestNormalized, MLargestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2808 { PSmallestNormalized, PSmallestValue, "0x1p+23", APFloat::opOK, APFloat::fcNormal },
2809 { PSmallestNormalized, MSmallestValue, "-0x1p+23", APFloat::opOK, APFloat::fcNormal },
2810 { PSmallestNormalized, PSmallestNormalized, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2811 { PSmallestNormalized, MSmallestNormalized, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2812 { MSmallestNormalized, PInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2813 { MSmallestNormalized, MInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2814 { MSmallestNormalized, PZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
2815 { MSmallestNormalized, MZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
2816 { MSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2817 #if 0
2818 // See Note 1.
2819 { MSmallestNormalized, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2820 #endif
2821 { MSmallestNormalized, PNormalValue, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2822 { MSmallestNormalized, MNormalValue, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2823 { MSmallestNormalized, PLargestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2824 { MSmallestNormalized, MLargestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero },
2825 { MSmallestNormalized, PSmallestValue, "-0x1p+23", APFloat::opOK, APFloat::fcNormal },
2826 { MSmallestNormalized, MSmallestValue, "0x1p+23", APFloat::opOK, APFloat::fcNormal },
2827 { MSmallestNormalized, PSmallestNormalized, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2828 { MSmallestNormalized, MSmallestNormalized, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2829 };
2830
2831 for (size_t i = 0; i < NumTests; ++i) {
2832 APFloat x(SpecialCaseTests[i].x);
2833 APFloat y(SpecialCaseTests[i].y);
2834 APFloat::opStatus status = x.divide(y, APFloat::rmNearestTiesToEven);
2835
2836 APFloat result(APFloat::IEEEsingle(), SpecialCaseTests[i].result);
2837
2838 EXPECT_TRUE(result.bitwiseIsEqual(x));
2839 EXPECT_TRUE((int)status == SpecialCaseTests[i].status);
2840 EXPECT_TRUE((int)x.getCategory() == SpecialCaseTests[i].category);
2841 }
2842 }
2843
2844 TEST(APFloatTest, operatorOverloads) {
2845 // This is mostly testing that these operator overloads compile.
2846 APFloat One = APFloat(APFloat::IEEEsingle(), "0x1p+0");
2847 APFloat Two = APFloat(APFloat::IEEEsingle(), "0x2p+0");
2848 EXPECT_TRUE(Two.bitwiseIsEqual(One + One));
2849 EXPECT_TRUE(One.bitwiseIsEqual(Two - One));
2850 EXPECT_TRUE(Two.bitwiseIsEqual(One * Two));
2851 EXPECT_TRUE(One.bitwiseIsEqual(Two / Two));
2852 }
2853
2854 TEST(APFloatTest, abs) {
2855 APFloat PInf = APFloat::getInf(APFloat::IEEEsingle(), false);
2856 APFloat MInf = APFloat::getInf(APFloat::IEEEsingle(), true);
2857 APFloat PZero = APFloat::getZero(APFloat::IEEEsingle(), false);
2858 APFloat MZero = APFloat::getZero(APFloat::IEEEsingle(), true);
2859 APFloat PQNaN = APFloat::getNaN(APFloat::IEEEsingle(), false);
2860 APFloat MQNaN = APFloat::getNaN(APFloat::IEEEsingle(), true);
2861 APFloat PSNaN = APFloat::getSNaN(APFloat::IEEEsingle(), false);
2862 APFloat MSNaN = APFloat::getSNaN(APFloat::IEEEsingle(), true);
2863 APFloat PNormalValue = APFloat(APFloat::IEEEsingle(), "0x1p+0");
2864 APFloat MNormalValue = APFloat(APFloat::IEEEsingle(), "-0x1p+0");
2865 APFloat PLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), false);
2866 APFloat MLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), true);
2867 APFloat PSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), false);
2868 APFloat MSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), true);
2869 APFloat PSmallestNormalized =
2870 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), false);
2871 APFloat MSmallestNormalized =
2872 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), true);
2873
2874 EXPECT_TRUE(PInf.bitwiseIsEqual(abs(PInf)));
2875 EXPECT_TRUE(PInf.bitwiseIsEqual(abs(MInf)));
2876 EXPECT_TRUE(PZero.bitwiseIsEqual(abs(PZero)));
2877 EXPECT_TRUE(PZero.bitwiseIsEqual(abs(MZero)));
2878 EXPECT_TRUE(PQNaN.bitwiseIsEqual(abs(PQNaN)));
2879 EXPECT_TRUE(PQNaN.bitwiseIsEqual(abs(MQNaN)));
2880 EXPECT_TRUE(PSNaN.bitwiseIsEqual(abs(PSNaN)));
2881 EXPECT_TRUE(PSNaN.bitwiseIsEqual(abs(MSNaN)));
2882 EXPECT_TRUE(PNormalValue.bitwiseIsEqual(abs(PNormalValue)));
2883 EXPECT_TRUE(PNormalValue.bitwiseIsEqual(abs(MNormalValue)));
2884 EXPECT_TRUE(PLargestValue.bitwiseIsEqual(abs(PLargestValue)));
2885 EXPECT_TRUE(PLargestValue.bitwiseIsEqual(abs(MLargestValue)));
2886 EXPECT_TRUE(PSmallestValue.bitwiseIsEqual(abs(PSmallestValue)));
2887 EXPECT_TRUE(PSmallestValue.bitwiseIsEqual(abs(MSmallestValue)));
2888 EXPECT_TRUE(PSmallestNormalized.bitwiseIsEqual(abs(PSmallestNormalized)));
2889 EXPECT_TRUE(PSmallestNormalized.bitwiseIsEqual(abs(MSmallestNormalized)));
2890 }
2891
2892 TEST(APFloatTest, neg) {
2893 APFloat One = APFloat(APFloat::IEEEsingle(), "1.0");
2894 APFloat NegOne = APFloat(APFloat::IEEEsingle(), "-1.0");
2895 APFloat Zero = APFloat::getZero(APFloat::IEEEsingle(), false);
2896 APFloat NegZero = APFloat::getZero(APFloat::IEEEsingle(), true);
2897 APFloat Inf = APFloat::getInf(APFloat::IEEEsingle(), false);
2898 APFloat NegInf = APFloat::getInf(APFloat::IEEEsingle(), true);
2899 APFloat QNaN = APFloat::getNaN(APFloat::IEEEsingle(), false);
2900 APFloat NegQNaN = APFloat::getNaN(APFloat::IEEEsingle(), true);
2901
2902 EXPECT_TRUE(NegOne.bitwiseIsEqual(neg(One)));
2903 EXPECT_TRUE(One.bitwiseIsEqual(neg(NegOne)));
2904 EXPECT_TRUE(NegZero.bitwiseIsEqual(neg(Zero)));
2905 EXPECT_TRUE(Zero.bitwiseIsEqual(neg(NegZero)));
2906 EXPECT_TRUE(NegInf.bitwiseIsEqual(neg(Inf)));
2907 EXPECT_TRUE(Inf.bitwiseIsEqual(neg(NegInf)));
2908 EXPECT_TRUE(NegInf.bitwiseIsEqual(neg(Inf)));
2909 EXPECT_TRUE(Inf.bitwiseIsEqual(neg(NegInf)));
2910 EXPECT_TRUE(NegQNaN.bitwiseIsEqual(neg(QNaN)));
2911 EXPECT_TRUE(QNaN.bitwiseIsEqual(neg(NegQNaN)));
2912 }
2913
2914 TEST(APFloatTest, ilogb) {
2915 EXPECT_EQ(-1074, ilogb(APFloat::getSmallest(APFloat::IEEEdouble(), false)));
2916 EXPECT_EQ(-1074, ilogb(APFloat::getSmallest(APFloat::IEEEdouble(), true)));
2917 EXPECT_EQ(-1023, ilogb(APFloat(APFloat::IEEEdouble(), "0x1.ffffffffffffep-1024")));
2918 EXPECT_EQ(-1023, ilogb(APFloat(APFloat::IEEEdouble(), "0x1.ffffffffffffep-1023")));
2919 EXPECT_EQ(-1023, ilogb(APFloat(APFloat::IEEEdouble(), "-0x1.ffffffffffffep-1023")));
2920 EXPECT_EQ(-51, ilogb(APFloat(APFloat::IEEEdouble(), "0x1p-51")));
2921 EXPECT_EQ(-1023, ilogb(APFloat(APFloat::IEEEdouble(), "0x1.c60f120d9f87cp-1023")));
2922 EXPECT_EQ(-2, ilogb(APFloat(APFloat::IEEEdouble(), "0x0.ffffp-1")));
2923 EXPECT_EQ(-1023, ilogb(APFloat(APFloat::IEEEdouble(), "0x1.fffep-1023")));
2924 EXPECT_EQ(1023, ilogb(APFloat::getLargest(APFloat::IEEEdouble(), false)));
2925 EXPECT_EQ(1023, ilogb(APFloat::getLargest(APFloat::IEEEdouble(), true)));
2926
2927
2928 EXPECT_EQ(0, ilogb(APFloat(APFloat::IEEEsingle(), "0x1p+0")));
2929 EXPECT_EQ(0, ilogb(APFloat(APFloat::IEEEsingle(), "-0x1p+0")));
2930 EXPECT_EQ(42, ilogb(APFloat(APFloat::IEEEsingle(), "0x1p+42")));
2931 EXPECT_EQ(-42, ilogb(APFloat(APFloat::IEEEsingle(), "0x1p-42")));
2932
2933 EXPECT_EQ(APFloat::IEK_Inf,
2934 ilogb(APFloat::getInf(APFloat::IEEEsingle(), false)));
2935 EXPECT_EQ(APFloat::IEK_Inf,
2936 ilogb(APFloat::getInf(APFloat::IEEEsingle(), true)));
2937 EXPECT_EQ(APFloat::IEK_Zero,
2938 ilogb(APFloat::getZero(APFloat::IEEEsingle(), false)));
2939 EXPECT_EQ(APFloat::IEK_Zero,
2940 ilogb(APFloat::getZero(APFloat::IEEEsingle(), true)));
2941 EXPECT_EQ(APFloat::IEK_NaN,
2942 ilogb(APFloat::getNaN(APFloat::IEEEsingle(), false)));
2943 EXPECT_EQ(APFloat::IEK_NaN,
2944 ilogb(APFloat::getSNaN(APFloat::IEEEsingle(), false)));
2945
2946 EXPECT_EQ(127, ilogb(APFloat::getLargest(APFloat::IEEEsingle(), false)));
2947 EXPECT_EQ(127, ilogb(APFloat::getLargest(APFloat::IEEEsingle(), true)));
2948
2949 EXPECT_EQ(-149, ilogb(APFloat::getSmallest(APFloat::IEEEsingle(), false)));
2950 EXPECT_EQ(-149, ilogb(APFloat::getSmallest(APFloat::IEEEsingle(), true)));
2951 EXPECT_EQ(-126,
2952 ilogb(APFloat::getSmallestNormalized(APFloat::IEEEsingle(), false)));
2953 EXPECT_EQ(-126,
2954 ilogb(APFloat::getSmallestNormalized(APFloat::IEEEsingle(), true)));
2955 }
2956
2957 TEST(APFloatTest, scalbn) {
2958
2959 const APFloat::roundingMode RM = APFloat::rmNearestTiesToEven;
2960 EXPECT_TRUE(
2961 APFloat(APFloat::IEEEsingle(), "0x1p+0")
2962 .bitwiseIsEqual(scalbn(APFloat(APFloat::IEEEsingle(), "0x1p+0"), 0, RM)));
2963 EXPECT_TRUE(
2964 APFloat(APFloat::IEEEsingle(), "0x1p+42")
2965 .bitwiseIsEqual(scalbn(APFloat(APFloat::IEEEsingle(), "0x1p+0"), 42, RM)));
2966 EXPECT_TRUE(
2967 APFloat(APFloat::IEEEsingle(), "0x1p-42")
2968 .bitwiseIsEqual(scalbn(APFloat(APFloat::IEEEsingle(), "0x1p+0"), -42, RM)));
2969
2970 APFloat PInf = APFloat::getInf(APFloat::IEEEsingle(), false);
2971 APFloat MInf = APFloat::getInf(APFloat::IEEEsingle(), true);
2972 APFloat PZero = APFloat::getZero(APFloat::IEEEsingle(), false);
2973 APFloat MZero = APFloat::getZero(APFloat::IEEEsingle(), true);
2974 APFloat QPNaN = APFloat::getNaN(APFloat::IEEEsingle(), false);
2975 APFloat QMNaN = APFloat::getNaN(APFloat::IEEEsingle(), true);
2976 APFloat SNaN = APFloat::getSNaN(APFloat::IEEEsingle(), false);
2977
2978 EXPECT_TRUE(PInf.bitwiseIsEqual(scalbn(PInf, 0, RM)));
2979 EXPECT_TRUE(MInf.bitwiseIsEqual(scalbn(MInf, 0, RM)));
2980 EXPECT_TRUE(PZero.bitwiseIsEqual(scalbn(PZero, 0, RM)));
2981 EXPECT_TRUE(MZero.bitwiseIsEqual(scalbn(MZero, 0, RM)));
2982 EXPECT_TRUE(QPNaN.bitwiseIsEqual(scalbn(QPNaN, 0, RM)));
2983 EXPECT_TRUE(QMNaN.bitwiseIsEqual(scalbn(QMNaN, 0, RM)));
2984 EXPECT_FALSE(scalbn(SNaN, 0, RM).isSignaling());
2985
2986 APFloat ScalbnSNaN = scalbn(SNaN, 1, RM);
2987 EXPECT_TRUE(ScalbnSNaN.isNaN() && !ScalbnSNaN.isSignaling());
2988
2989 // Make sure highest bit of payload is preserved.
2990 const APInt Payload(64, (UINT64_C(1) << 50) |
2991 (UINT64_C(1) << 49) |
2992 (UINT64_C(1234) << 32) |
2993 1);
2994
2995 APFloat SNaNWithPayload = APFloat::getSNaN(APFloat::IEEEdouble(), false,
2996 &Payload);
2997 APFloat QuietPayload = scalbn(SNaNWithPayload, 1, RM);
2998 EXPECT_TRUE(QuietPayload.isNaN() && !QuietPayload.isSignaling());
2999 EXPECT_EQ(Payload, QuietPayload.bitcastToAPInt().getLoBits(51));
3000
3001 EXPECT_TRUE(PInf.bitwiseIsEqual(
3002 scalbn(APFloat(APFloat::IEEEsingle(), "0x1p+0"), 128, RM)));
3003 EXPECT_TRUE(MInf.bitwiseIsEqual(
3004 scalbn(APFloat(APFloat::IEEEsingle(), "-0x1p+0"), 128, RM)));
3005 EXPECT_TRUE(PInf.bitwiseIsEqual(
3006 scalbn(APFloat(APFloat::IEEEsingle(), "0x1p+127"), 1, RM)));
3007 EXPECT_TRUE(PZero.bitwiseIsEqual(
3008 scalbn(APFloat(APFloat::IEEEsingle(), "0x1p-127"), -127, RM)));
3009 EXPECT_TRUE(MZero.bitwiseIsEqual(
3010 scalbn(APFloat(APFloat::IEEEsingle(), "-0x1p-127"), -127, RM)));
3011 EXPECT_TRUE(APFloat(APFloat::IEEEsingle(), "-0x1p-149").bitwiseIsEqual(
3012 scalbn(APFloat(APFloat::IEEEsingle(), "-0x1p-127"), -22, RM)));
3013 EXPECT_TRUE(PZero.bitwiseIsEqual(
3014 scalbn(APFloat(APFloat::IEEEsingle(), "0x1p-126"), -24, RM)));
3015
3016
3017 APFloat SmallestF64 = APFloat::getSmallest(APFloat::IEEEdouble(), false);
3018 APFloat NegSmallestF64 = APFloat::getSmallest(APFloat::IEEEdouble(), true);
3019
3020 APFloat LargestF64 = APFloat::getLargest(APFloat::IEEEdouble(), false);
3021 APFloat NegLargestF64 = APFloat::getLargest(APFloat::IEEEdouble(), true);
3022
3023 APFloat SmallestNormalizedF64
3024 = APFloat::getSmallestNormalized(APFloat::IEEEdouble(), false);
3025 APFloat NegSmallestNormalizedF64
3026 = APFloat::getSmallestNormalized(APFloat::IEEEdouble(), true);
3027
3028 APFloat LargestDenormalF64(APFloat::IEEEdouble(), "0x1.ffffffffffffep-1023");
3029 APFloat NegLargestDenormalF64(APFloat::IEEEdouble(), "-0x1.ffffffffffffep-1023");
3030
3031
3032 EXPECT_TRUE(SmallestF64.bitwiseIsEqual(
3033 scalbn(APFloat(APFloat::IEEEdouble(), "0x1p-1074"), 0, RM)));
3034 EXPECT_TRUE(NegSmallestF64.bitwiseIsEqual(
3035 scalbn(APFloat(APFloat::IEEEdouble(), "-0x1p-1074"), 0, RM)));
3036
3037 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1p+1023")
3038 .bitwiseIsEqual(scalbn(SmallestF64, 2097, RM)));
3039
3040 EXPECT_TRUE(scalbn(SmallestF64, -2097, RM).isPosZero());
3041 EXPECT_TRUE(scalbn(SmallestF64, -2098, RM).isPosZero());
3042 EXPECT_TRUE(scalbn(SmallestF64, -2099, RM).isPosZero());
3043 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1p+1022")
3044 .bitwiseIsEqual(scalbn(SmallestF64, 2096, RM)));
3045 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1p+1023")
3046 .bitwiseIsEqual(scalbn(SmallestF64, 2097, RM)));
3047 EXPECT_TRUE(scalbn(SmallestF64, 2098, RM).isInfinity());
3048 EXPECT_TRUE(scalbn(SmallestF64, 2099, RM).isInfinity());
3049
3050 // Test for integer overflows when adding to exponent.
3051 EXPECT_TRUE(scalbn(SmallestF64, -INT_MAX, RM).isPosZero());
3052 EXPECT_TRUE(scalbn(LargestF64, INT_MAX, RM).isInfinity());
3053
3054 EXPECT_TRUE(LargestDenormalF64
3055 .bitwiseIsEqual(scalbn(LargestDenormalF64, 0, RM)));
3056 EXPECT_TRUE(NegLargestDenormalF64
3057 .bitwiseIsEqual(scalbn(NegLargestDenormalF64, 0, RM)));
3058
3059 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.ffffffffffffep-1022")
3060 .bitwiseIsEqual(scalbn(LargestDenormalF64, 1, RM)));
3061 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "-0x1.ffffffffffffep-1021")
3062 .bitwiseIsEqual(scalbn(NegLargestDenormalF64, 2, RM)));
3063
3064 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.ffffffffffffep+1")
3065 .bitwiseIsEqual(scalbn(LargestDenormalF64, 1024, RM)));
3066 EXPECT_TRUE(scalbn(LargestDenormalF64, -1023, RM).isPosZero());
3067 EXPECT_TRUE(scalbn(LargestDenormalF64, -1024, RM).isPosZero());
3068 EXPECT_TRUE(scalbn(LargestDenormalF64, -2048, RM).isPosZero());
3069 EXPECT_TRUE(scalbn(LargestDenormalF64, 2047, RM).isInfinity());
3070 EXPECT_TRUE(scalbn(LargestDenormalF64, 2098, RM).isInfinity());
3071 EXPECT_TRUE(scalbn(LargestDenormalF64, 2099, RM).isInfinity());
3072
3073 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.ffffffffffffep-2")
3074 .bitwiseIsEqual(scalbn(LargestDenormalF64, 1021, RM)));
3075 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.ffffffffffffep-1")
3076 .bitwiseIsEqual(scalbn(LargestDenormalF64, 1022, RM)));
3077 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.ffffffffffffep+0")
3078 .bitwiseIsEqual(scalbn(LargestDenormalF64, 1023, RM)));
3079 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.ffffffffffffep+1023")
3080 .bitwiseIsEqual(scalbn(LargestDenormalF64, 2046, RM)));
3081 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1p+974")
3082 .bitwiseIsEqual(scalbn(SmallestF64, 2048, RM)));
3083
3084 APFloat RandomDenormalF64(APFloat::IEEEdouble(), "0x1.c60f120d9f87cp+51");
3085 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.c60f120d9f87cp-972")
3086 .bitwiseIsEqual(scalbn(RandomDenormalF64, -1023, RM)));
3087 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.c60f120d9f87cp-1")
3088 .bitwiseIsEqual(scalbn(RandomDenormalF64, -52, RM)));
3089 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.c60f120d9f87cp-2")
3090 .bitwiseIsEqual(scalbn(RandomDenormalF64, -53, RM)));
3091 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.c60f120d9f87cp+0")
3092 .bitwiseIsEqual(scalbn(RandomDenormalF64, -51, RM)));
3093
3094 EXPECT_TRUE(scalbn(RandomDenormalF64, -2097, RM).isPosZero());
3095 EXPECT_TRUE(scalbn(RandomDenormalF64, -2090, RM).isPosZero());
3096
3097
3098 EXPECT_TRUE(
3099 APFloat(APFloat::IEEEdouble(), "-0x1p-1073")
3100 .bitwiseIsEqual(scalbn(NegLargestF64, -2097, RM)));
3101
3102 EXPECT_TRUE(
3103 APFloat(APFloat::IEEEdouble(), "-0x1p-1024")
3104 .bitwiseIsEqual(scalbn(NegLargestF64, -2048, RM)));
3105
3106 EXPECT_TRUE(
3107 APFloat(APFloat::IEEEdouble(), "0x1p-1073")
3108 .bitwiseIsEqual(scalbn(LargestF64, -2097, RM)));
3109
3110 EXPECT_TRUE(
3111 APFloat(APFloat::IEEEdouble(), "0x1p-1074")
3112 .bitwiseIsEqual(scalbn(LargestF64, -2098, RM)));
3113 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "-0x1p-1074")
3114 .bitwiseIsEqual(scalbn(NegLargestF64, -2098, RM)));
3115 EXPECT_TRUE(scalbn(NegLargestF64, -2099, RM).isNegZero());
3116 EXPECT_TRUE(scalbn(LargestF64, 1, RM).isInfinity());
3117
3118
3119 EXPECT_TRUE(
3120 APFloat(APFloat::IEEEdouble(), "0x1p+0")
3121 .bitwiseIsEqual(scalbn(APFloat(APFloat::IEEEdouble(), "0x1p+52"), -52, RM)));
3122
3123 EXPECT_TRUE(
3124 APFloat(APFloat::IEEEdouble(), "0x1p-103")
3125 .bitwiseIsEqual(scalbn(APFloat(APFloat::IEEEdouble(), "0x1p-51"), -52, RM)));
3126 }
3127
3128 TEST(APFloatTest, frexp) {
3129 const APFloat::roundingMode RM = APFloat::rmNearestTiesToEven;
3130
3131 APFloat PZero = APFloat::getZero(APFloat::IEEEdouble(), false);
3132 APFloat MZero = APFloat::getZero(APFloat::IEEEdouble(), true);
3133 APFloat One(1.0);
3134 APFloat MOne(-1.0);
3135 APFloat Two(2.0);
3136 APFloat MTwo(-2.0);
3137
3138 APFloat LargestDenormal(APFloat::IEEEdouble(), "0x1.ffffffffffffep-1023");
3139 APFloat NegLargestDenormal(APFloat::IEEEdouble(), "-0x1.ffffffffffffep-1023");
3140
3141 APFloat Smallest = APFloat::getSmallest(APFloat::IEEEdouble(), false);
3142 APFloat NegSmallest = APFloat::getSmallest(APFloat::IEEEdouble(), true);
3143
3144 APFloat Largest = APFloat::getLargest(APFloat::IEEEdouble(), false);
3145 APFloat NegLargest = APFloat::getLargest(APFloat::IEEEdouble(), true);
3146
3147 APFloat PInf = APFloat::getInf(APFloat::IEEEdouble(), false);
3148 APFloat MInf = APFloat::getInf(APFloat::IEEEdouble(), true);
3149
3150 APFloat QPNaN = APFloat::getNaN(APFloat::IEEEdouble(), false);
3151 APFloat QMNaN = APFloat::getNaN(APFloat::IEEEdouble(), true);
3152 APFloat SNaN = APFloat::getSNaN(APFloat::IEEEdouble(), false);
3153
3154 // Make sure highest bit of payload is preserved.
3155 const APInt Payload(64, (UINT64_C(1) << 50) |
3156 (UINT64_C(1) << 49) |
3157 (UINT64_C(1234) << 32) |
3158 1);
3159
3160 APFloat SNaNWithPayload = APFloat::getSNaN(APFloat::IEEEdouble(), false,
3161 &Payload);
3162
3163 APFloat SmallestNormalized
3164 = APFloat::getSmallestNormalized(APFloat::IEEEdouble(), false);
3165 APFloat NegSmallestNormalized
3166 = APFloat::getSmallestNormalized(APFloat::IEEEdouble(), true);
3167
3168 int Exp;
3169 APFloat Frac(APFloat::IEEEdouble());
3170
3171
3172 Frac = frexp(PZero, Exp, RM);
3173 EXPECT_EQ(0, Exp);
3174 EXPECT_TRUE(Frac.isPosZero());
3175
3176 Frac = frexp(MZero, Exp, RM);
3177 EXPECT_EQ(0, Exp);
3178 EXPECT_TRUE(Frac.isNegZero());
3179
3180
3181 Frac = frexp(One, Exp, RM);
3182 EXPECT_EQ(1, Exp);
3183 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1p-1").bitwiseIsEqual(Frac));
3184
3185 Frac = frexp(MOne, Exp, RM);
3186 EXPECT_EQ(1, Exp);
3187 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "-0x1p-1").bitwiseIsEqual(Frac));
3188
3189 Frac = frexp(LargestDenormal, Exp, RM);
3190 EXPECT_EQ(-1022, Exp);
3191 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.ffffffffffffep-1").bitwiseIsEqual(Frac));
3192
3193 Frac = frexp(NegLargestDenormal, Exp, RM);
3194 EXPECT_EQ(-1022, Exp);
3195 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "-0x1.ffffffffffffep-1").bitwiseIsEqual(Frac));
3196
3197
3198 Frac = frexp(Smallest, Exp, RM);
3199 EXPECT_EQ(-1073, Exp);
3200 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1p-1").bitwiseIsEqual(Frac));
3201
3202 Frac = frexp(NegSmallest, Exp, RM);
3203 EXPECT_EQ(-1073, Exp);
3204 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "-0x1p-1").bitwiseIsEqual(Frac));
3205
3206
3207 Frac = frexp(Largest, Exp, RM);
3208 EXPECT_EQ(1024, Exp);
3209 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.fffffffffffffp-1").bitwiseIsEqual(Frac));
3210
3211 Frac = frexp(NegLargest, Exp, RM);
3212 EXPECT_EQ(1024, Exp);
3213 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "-0x1.fffffffffffffp-1").bitwiseIsEqual(Frac));
3214
3215
3216 Frac = frexp(PInf, Exp, RM);
3217 EXPECT_EQ(INT_MAX, Exp);
3218 EXPECT_TRUE(Frac.isInfinity() && !Frac.isNegative());
3219
3220 Frac = frexp(MInf, Exp, RM);
3221 EXPECT_EQ(INT_MAX, Exp);
3222 EXPECT_TRUE(Frac.isInfinity() && Frac.isNegative());
3223
3224 Frac = frexp(QPNaN, Exp, RM);
3225 EXPECT_EQ(INT_MIN, Exp);
3226 EXPECT_TRUE(Frac.isNaN());
3227
3228 Frac = frexp(QMNaN, Exp, RM);
3229 EXPECT_EQ(INT_MIN, Exp);
3230 EXPECT_TRUE(Frac.isNaN());
3231
3232 Frac = frexp(SNaN, Exp, RM);
3233 EXPECT_EQ(INT_MIN, Exp);
3234 EXPECT_TRUE(Frac.isNaN() && !Frac.isSignaling());
3235
3236 Frac = frexp(SNaNWithPayload, Exp, RM);
3237 EXPECT_EQ(INT_MIN, Exp);
3238 EXPECT_TRUE(Frac.isNaN() && !Frac.isSignaling());
3239 EXPECT_EQ(Payload, Frac.bitcastToAPInt().getLoBits(51));
3240
3241 Frac = frexp(APFloat(APFloat::IEEEdouble(), "0x0.ffffp-1"), Exp, RM);
3242 EXPECT_EQ(-1, Exp);
3243 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.fffep-1").bitwiseIsEqual(Frac));
3244
3245 Frac = frexp(APFloat(APFloat::IEEEdouble(), "0x1p-51"), Exp, RM);
3246 EXPECT_EQ(-50, Exp);
3247 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1p-1").bitwiseIsEqual(Frac));
3248
3249 Frac = frexp(APFloat(APFloat::IEEEdouble(), "0x1.c60f120d9f87cp+51"), Exp, RM);
3250 EXPECT_EQ(52, Exp);
3251 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.c60f120d9f87cp-1").bitwiseIsEqual(Frac));
3252 }
3253
3254 TEST(APFloatTest, mod) {
3255 {
3256 APFloat f1(APFloat::IEEEdouble(), "1.5");
3257 APFloat f2(APFloat::IEEEdouble(), "1.0");
3258 APFloat expected(APFloat::IEEEdouble(), "0.5");
3259 EXPECT_EQ(f1.mod(f2), APFloat::opOK);
3260 EXPECT_TRUE(f1.bitwiseIsEqual(expected));
3261 }
3262 {
3263 APFloat f1(APFloat::IEEEdouble(), "0.5");
3264 APFloat f2(APFloat::IEEEdouble(), "1.0");
3265 APFloat expected(APFloat::IEEEdouble(), "0.5");
3266 EXPECT_EQ(f1.mod(f2), APFloat::opOK);
3267 EXPECT_TRUE(f1.bitwiseIsEqual(expected));
3268 }
3269 {
3270 APFloat f1(APFloat::IEEEdouble(), "0x1.3333333333333p-2"); // 0.3
3271 APFloat f2(APFloat::IEEEdouble(), "0x1.47ae147ae147bp-7"); // 0.01
3272 APFloat expected(APFloat::IEEEdouble(),
3273 "0x1.47ae147ae1471p-7"); // 0.009999999999999983
3274 EXPECT_EQ(f1.mod(f2), APFloat::opOK);
3275 EXPECT_TRUE(f1.bitwiseIsEqual(expected));
3276 }
3277 {
3278 APFloat f1(APFloat::IEEEdouble(), "0x1p64"); // 1.8446744073709552e19
3279 APFloat f2(APFloat::IEEEdouble(), "1.5");
3280 APFloat expected(APFloat::IEEEdouble(), "1.0");
3281 EXPECT_EQ(f1.mod(f2), APFloat::opOK);
3282 EXPECT_TRUE(f1.bitwiseIsEqual(expected));
3283 }
3284 {
3285 APFloat f1(APFloat::IEEEdouble(), "0x1p1000");
3286 APFloat f2(APFloat::IEEEdouble(), "0x1p-1000");
3287 APFloat expected(APFloat::IEEEdouble(), "0.0");
3288 EXPECT_EQ(f1.mod(f2), APFloat::opOK);
3289 EXPECT_TRUE(f1.bitwiseIsEqual(expected));
3290 }
3291 {
3292 APFloat f1(APFloat::IEEEdouble(), "0.0");
3293 APFloat f2(APFloat::IEEEdouble(), "1.0");
3294 APFloat expected(APFloat::IEEEdouble(), "0.0");
3295 EXPECT_EQ(f1.mod(f2), APFloat::opOK);
3296 EXPECT_TRUE(f1.bitwiseIsEqual(expected));
3297 }
3298 {
3299 APFloat f1(APFloat::IEEEdouble(), "1.0");
3300 APFloat f2(APFloat::IEEEdouble(), "0.0");
3301 EXPECT_EQ(f1.mod(f2), APFloat::opInvalidOp);
3302 EXPECT_TRUE(f1.isNaN());
3303 }
3304 {
3305 APFloat f1(APFloat::IEEEdouble(), "0.0");
3306 APFloat f2(APFloat::IEEEdouble(), "0.0");
3307 EXPECT_EQ(f1.mod(f2), APFloat::opInvalidOp);
3308 EXPECT_TRUE(f1.isNaN());
3309 }
3310 {
3311 APFloat f1 = APFloat::getInf(APFloat::IEEEdouble(), false);
3312 APFloat f2(APFloat::IEEEdouble(), "1.0");
3313 EXPECT_EQ(f1.mod(f2), APFloat::opInvalidOp);
3314 EXPECT_TRUE(f1.isNaN());
3315 }
3316 {
3317 APFloat f1(APFloat::IEEEdouble(), "-4.0");
3318 APFloat f2(APFloat::IEEEdouble(), "-2.0");
3319 APFloat expected(APFloat::IEEEdouble(), "-0.0");
3320 EXPECT_EQ(f1.mod(f2), APFloat::opOK);
3321 EXPECT_TRUE(f1.bitwiseIsEqual(expected));
3322 }
3323 {
3324 APFloat f1(APFloat::IEEEdouble(), "-4.0");
3325 APFloat f2(APFloat::IEEEdouble(), "2.0");
3326 APFloat expected(APFloat::IEEEdouble(), "-0.0");
3327 EXPECT_EQ(f1.mod(f2), APFloat::opOK);
3328 EXPECT_TRUE(f1.bitwiseIsEqual(expected));
3329 }
3330 }
3331
3332 TEST(APFloatTest, PPCDoubleDoubleAddSpecial) {
3333 using DataType = std::tuple<uint64_t, uint64_t, uint64_t, uint64_t,
3334 APFloat::fltCategory, APFloat::roundingMode>;
3335 DataType Data[] = {
3336 // (1 + 0) + (-1 + 0) = fcZero
3337 std::make_tuple(0x3ff0000000000000ull, 0, 0xbff0000000000000ull, 0,
3338 APFloat::fcZero, APFloat::rmNearestTiesToEven),
3339 // LDBL_MAX + (1.1 >> (1023 - 106) + 0)) = fcInfinity
3340 std::make_tuple(0x7fefffffffffffffull, 0x7c8ffffffffffffeull,
3341 0x7948000000000000ull, 0ull, APFloat::fcInfinity,
3342 APFloat::rmNearestTiesToEven),
3343 // TODO: change the 4th 0x75effffffffffffe to 0x75efffffffffffff when
3344 // semPPCDoubleDoubleLegacy is gone.
3345 // LDBL_MAX + (1.011111... >> (1023 - 106) + (1.1111111...0 >> (1023 -
3346 // 160))) = fcNormal
3347 std::make_tuple(0x7fefffffffffffffull, 0x7c8ffffffffffffeull,
3348 0x7947ffffffffffffull, 0x75effffffffffffeull,
3349 APFloat::fcNormal, APFloat::rmNearestTiesToEven),
3350 // LDBL_MAX + (1.1 >> (1023 - 106) + 0)) = fcInfinity
3351 std::make_tuple(0x7fefffffffffffffull, 0x7c8ffffffffffffeull,
3352 0x7fefffffffffffffull, 0x7c8ffffffffffffeull,
3353 APFloat::fcInfinity, APFloat::rmNearestTiesToEven),
3354 // NaN + (1 + 0) = fcNaN
3355 std::make_tuple(0x7ff8000000000000ull, 0, 0x3ff0000000000000ull, 0,
3356 APFloat::fcNaN, APFloat::rmNearestTiesToEven),
3357 };
3358
3359 for (auto Tp : Data) {
3360 uint64_t Op1[2], Op2[2];
3361 APFloat::fltCategory Expected;
3362 APFloat::roundingMode RM;
3363 std::tie(Op1[0], Op1[1], Op2[0], Op2[1], Expected, RM) = Tp;
3364
3365 {
3366 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
3367 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
3368 A1.add(A2, RM);
3369
3370 EXPECT_EQ(Expected, A1.getCategory())
3371 << formatv("({0:x} + {1:x}) + ({2:x} + {3:x})", Op1[0], Op1[1],
3372 Op2[0], Op2[1])
3373 .str();
3374 }
3375 {
3376 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
3377 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
3378 A2.add(A1, RM);
3379
3380 EXPECT_EQ(Expected, A2.getCategory())
3381 << formatv("({0:x} + {1:x}) + ({2:x} + {3:x})", Op2[0], Op2[1],
3382 Op1[0], Op1[1])
3383 .str();
3384 }
3385 }
3386 }
3387
3388 TEST(APFloatTest, PPCDoubleDoubleAdd) {
3389 using DataType = std::tuple<uint64_t, uint64_t, uint64_t, uint64_t, uint64_t,
3390 uint64_t, APFloat::roundingMode>;
3391 DataType Data[] = {
3392 // (1 + 0) + (1e-105 + 0) = (1 + 1e-105)
3393 std::make_tuple(0x3ff0000000000000ull, 0, 0x3960000000000000ull, 0,
3394 0x3ff0000000000000ull, 0x3960000000000000ull,
3395 APFloat::rmNearestTiesToEven),
3396 // (1 + 0) + (1e-106 + 0) = (1 + 1e-106)
3397 std::make_tuple(0x3ff0000000000000ull, 0, 0x3950000000000000ull, 0,
3398 0x3ff0000000000000ull, 0x3950000000000000ull,
3399 APFloat::rmNearestTiesToEven),
3400 // (1 + 1e-106) + (1e-106 + 0) = (1 + 1e-105)
3401 std::make_tuple(0x3ff0000000000000ull, 0x3950000000000000ull,
3402 0x3950000000000000ull, 0, 0x3ff0000000000000ull,
3403 0x3960000000000000ull, APFloat::rmNearestTiesToEven),
3404 // (1 + 0) + (epsilon + 0) = (1 + epsilon)
3405 std::make_tuple(0x3ff0000000000000ull, 0, 0x0000000000000001ull, 0,
3406 0x3ff0000000000000ull, 0x0000000000000001ull,
3407 APFloat::rmNearestTiesToEven),
3408 // TODO: change 0xf950000000000000 to 0xf940000000000000, when
3409 // semPPCDoubleDoubleLegacy is gone.
3410 // (DBL_MAX - 1 << (1023 - 105)) + (1 << (1023 - 53) + 0) = DBL_MAX +
3411 // 1.11111... << (1023 - 52)
3412 std::make_tuple(0x7fefffffffffffffull, 0xf950000000000000ull,
3413 0x7c90000000000000ull, 0, 0x7fefffffffffffffull,
3414 0x7c8ffffffffffffeull, APFloat::rmNearestTiesToEven),
3415 // TODO: change 0xf950000000000000 to 0xf940000000000000, when
3416 // semPPCDoubleDoubleLegacy is gone.
3417 // (1 << (1023 - 53) + 0) + (DBL_MAX - 1 << (1023 - 105)) = DBL_MAX +
3418 // 1.11111... << (1023 - 52)
3419 std::make_tuple(0x7c90000000000000ull, 0, 0x7fefffffffffffffull,
3420 0xf950000000000000ull, 0x7fefffffffffffffull,
3421 0x7c8ffffffffffffeull, APFloat::rmNearestTiesToEven),
3422 };
3423
3424 for (auto Tp : Data) {
3425 uint64_t Op1[2], Op2[2], Expected[2];
3426 APFloat::roundingMode RM;
3427 std::tie(Op1[0], Op1[1], Op2[0], Op2[1], Expected[0], Expected[1], RM) = Tp;
3428
3429 {
3430 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
3431 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
3432 A1.add(A2, RM);
3433
3434 EXPECT_EQ(Expected[0], A1.bitcastToAPInt().getRawData()[0])
3435 << formatv("({0:x} + {1:x}) + ({2:x} + {3:x})", Op1[0], Op1[1],
3436 Op2[0], Op2[1])
3437 .str();
3438 EXPECT_EQ(Expected[1], A1.bitcastToAPInt().getRawData()[1])
3439 << formatv("({0:x} + {1:x}) + ({2:x} + {3:x})", Op1[0], Op1[1],
3440 Op2[0], Op2[1])
3441 .str();
3442 }
3443 {
3444 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
3445 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
3446 A2.add(A1, RM);
3447
3448 EXPECT_EQ(Expected[0], A2.bitcastToAPInt().getRawData()[0])
3449 << formatv("({0:x} + {1:x}) + ({2:x} + {3:x})", Op2[0], Op2[1],
3450 Op1[0], Op1[1])
3451 .str();
3452 EXPECT_EQ(Expected[1], A2.bitcastToAPInt().getRawData()[1])
3453 << formatv("({0:x} + {1:x}) + ({2:x} + {3:x})", Op2[0], Op2[1],
3454 Op1[0], Op1[1])
3455 .str();
3456 }
3457 }
3458 }
3459
3460 TEST(APFloatTest, PPCDoubleDoubleSubtract) {
3461 using DataType = std::tuple<uint64_t, uint64_t, uint64_t, uint64_t, uint64_t,
3462 uint64_t, APFloat::roundingMode>;
3463 DataType Data[] = {
3464 // (1 + 0) - (-1e-105 + 0) = (1 + 1e-105)
3465 std::make_tuple(0x3ff0000000000000ull, 0, 0xb960000000000000ull, 0,
3466 0x3ff0000000000000ull, 0x3960000000000000ull,
3467 APFloat::rmNearestTiesToEven),
3468 // (1 + 0) - (-1e-106 + 0) = (1 + 1e-106)
3469 std::make_tuple(0x3ff0000000000000ull, 0, 0xb950000000000000ull, 0,
3470 0x3ff0000000000000ull, 0x3950000000000000ull,
3471 APFloat::rmNearestTiesToEven),
3472 };
3473
3474 for (auto Tp : Data) {
3475 uint64_t Op1[2], Op2[2], Expected[2];
3476 APFloat::roundingMode RM;
3477 std::tie(Op1[0], Op1[1], Op2[0], Op2[1], Expected[0], Expected[1], RM) = Tp;
3478
3479 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
3480 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
3481 A1.subtract(A2, RM);
3482
3483 EXPECT_EQ(Expected[0], A1.bitcastToAPInt().getRawData()[0])
3484 << formatv("({0:x} + {1:x}) - ({2:x} + {3:x})", Op1[0], Op1[1], Op2[0],
3485 Op2[1])
3486 .str();
3487 EXPECT_EQ(Expected[1], A1.bitcastToAPInt().getRawData()[1])
3488 << formatv("({0:x} + {1:x}) - ({2:x} + {3:x})", Op1[0], Op1[1], Op2[0],
3489 Op2[1])
3490 .str();
3491 }
3492 }
3493
3494 TEST(APFloatTest, PPCDoubleDoubleMultiplySpecial) {
3495 using DataType = std::tuple<uint64_t, uint64_t, uint64_t, uint64_t,
3496 APFloat::fltCategory, APFloat::roundingMode>;
3497 DataType Data[] = {
3498 // fcNaN * fcNaN = fcNaN
3499 std::make_tuple(0x7ff8000000000000ull, 0, 0x7ff8000000000000ull, 0,
3500 APFloat::fcNaN, APFloat::rmNearestTiesToEven),
3501 // fcNaN * fcZero = fcNaN
3502 std::make_tuple(0x7ff8000000000000ull, 0, 0, 0, APFloat::fcNaN,
3503 APFloat::rmNearestTiesToEven),
3504 // fcNaN * fcInfinity = fcNaN
3505 std::make_tuple(0x7ff8000000000000ull, 0, 0x7ff0000000000000ull, 0,
3506 APFloat::fcNaN, APFloat::rmNearestTiesToEven),
3507 // fcNaN * fcNormal = fcNaN
3508 std::make_tuple(0x7ff8000000000000ull, 0, 0x3ff0000000000000ull, 0,
3509 APFloat::fcNaN, APFloat::rmNearestTiesToEven),
3510 // fcInfinity * fcInfinity = fcInfinity
3511 std::make_tuple(0x7ff0000000000000ull, 0, 0x7ff0000000000000ull, 0,
3512 APFloat::fcInfinity, APFloat::rmNearestTiesToEven),
3513 // fcInfinity * fcZero = fcNaN
3514 std::make_tuple(0x7ff0000000000000ull, 0, 0, 0, APFloat::fcNaN,
3515 APFloat::rmNearestTiesToEven),
3516 // fcInfinity * fcNormal = fcInfinity
3517 std::make_tuple(0x7ff0000000000000ull, 0, 0x3ff0000000000000ull, 0,
3518 APFloat::fcInfinity, APFloat::rmNearestTiesToEven),
3519 // fcZero * fcZero = fcZero
3520 std::make_tuple(0, 0, 0, 0, APFloat::fcZero,
3521 APFloat::rmNearestTiesToEven),
3522 // fcZero * fcNormal = fcZero
3523 std::make_tuple(0, 0, 0x3ff0000000000000ull, 0, APFloat::fcZero,
3524 APFloat::rmNearestTiesToEven),
3525 };
3526
3527 for (auto Tp : Data) {
3528 uint64_t Op1[2], Op2[2];
3529 APFloat::fltCategory Expected;
3530 APFloat::roundingMode RM;
3531 std::tie(Op1[0], Op1[1], Op2[0], Op2[1], Expected, RM) = Tp;
3532
3533 {
3534 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
3535 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
3536 A1.multiply(A2, RM);
3537
3538 EXPECT_EQ(Expected, A1.getCategory())
3539 << formatv("({0:x} + {1:x}) * ({2:x} + {3:x})", Op1[0], Op1[1],
3540 Op2[0], Op2[1])
3541 .str();
3542 }
3543 {
3544 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
3545 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
3546 A2.multiply(A1, RM);
3547
3548 EXPECT_EQ(Expected, A2.getCategory())
3549 << formatv("({0:x} + {1:x}) * ({2:x} + {3:x})", Op2[0], Op2[1],
3550 Op1[0], Op1[1])
3551 .str();
3552 }
3553 }
3554 }
3555
3556 TEST(APFloatTest, PPCDoubleDoubleMultiply) {
3557 using DataType = std::tuple<uint64_t, uint64_t, uint64_t, uint64_t, uint64_t,
3558 uint64_t, APFloat::roundingMode>;
3559 DataType Data[] = {
3560 // 1/3 * 3 = 1.0
3561 std::make_tuple(0x3fd5555555555555ull, 0x3c75555555555556ull,
3562 0x4008000000000000ull, 0, 0x3ff0000000000000ull, 0,
3563 APFloat::rmNearestTiesToEven),
3564 // (1 + epsilon) * (1 + 0) = fcZero
3565 std::make_tuple(0x3ff0000000000000ull, 0x0000000000000001ull,
3566 0x3ff0000000000000ull, 0, 0x3ff0000000000000ull,
3567 0x0000000000000001ull, APFloat::rmNearestTiesToEven),
3568 // (1 + epsilon) * (1 + epsilon) = 1 + 2 * epsilon
3569 std::make_tuple(0x3ff0000000000000ull, 0x0000000000000001ull,
3570 0x3ff0000000000000ull, 0x0000000000000001ull,
3571 0x3ff0000000000000ull, 0x0000000000000002ull,
3572 APFloat::rmNearestTiesToEven),
3573 // -(1 + epsilon) * (1 + epsilon) = -1
3574 std::make_tuple(0xbff0000000000000ull, 0x0000000000000001ull,
3575 0x3ff0000000000000ull, 0x0000000000000001ull,
3576 0xbff0000000000000ull, 0, APFloat::rmNearestTiesToEven),
3577 // (0.5 + 0) * (1 + 2 * epsilon) = 0.5 + epsilon
3578 std::make_tuple(0x3fe0000000000000ull, 0, 0x3ff0000000000000ull,
3579 0x0000000000000002ull, 0x3fe0000000000000ull,
3580 0x0000000000000001ull, APFloat::rmNearestTiesToEven),
3581 // (0.5 + 0) * (1 + epsilon) = 0.5
3582 std::make_tuple(0x3fe0000000000000ull, 0, 0x3ff0000000000000ull,
3583 0x0000000000000001ull, 0x3fe0000000000000ull, 0,
3584 APFloat::rmNearestTiesToEven),
3585 // __LDBL_MAX__ * (1 + 1 << 106) = inf
3586 std::make_tuple(0x7fefffffffffffffull, 0x7c8ffffffffffffeull,
3587 0x3ff0000000000000ull, 0x3950000000000000ull,
3588 0x7ff0000000000000ull, 0, APFloat::rmNearestTiesToEven),
3589 // __LDBL_MAX__ * (1 + 1 << 107) > __LDBL_MAX__, but not inf, yes =_=|||
3590 std::make_tuple(0x7fefffffffffffffull, 0x7c8ffffffffffffeull,
3591 0x3ff0000000000000ull, 0x3940000000000000ull,
3592 0x7fefffffffffffffull, 0x7c8fffffffffffffull,
3593 APFloat::rmNearestTiesToEven),
3594 // __LDBL_MAX__ * (1 + 1 << 108) = __LDBL_MAX__
3595 std::make_tuple(0x7fefffffffffffffull, 0x7c8ffffffffffffeull,
3596 0x3ff0000000000000ull, 0x3930000000000000ull,
3597 0x7fefffffffffffffull, 0x7c8ffffffffffffeull,
3598 APFloat::rmNearestTiesToEven),
3599 };
3600
3601 for (auto Tp : Data) {
3602 uint64_t Op1[2], Op2[2], Expected[2];
3603 APFloat::roundingMode RM;
3604 std::tie(Op1[0], Op1[1], Op2[0], Op2[1], Expected[0], Expected[1], RM) = Tp;
3605
3606 {
3607 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
3608 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
3609 A1.multiply(A2, RM);
3610
3611 EXPECT_EQ(Expected[0], A1.bitcastToAPInt().getRawData()[0])
3612 << formatv("({0:x} + {1:x}) * ({2:x} + {3:x})", Op1[0], Op1[1],
3613 Op2[0], Op2[1])
3614 .str();
3615 EXPECT_EQ(Expected[1], A1.bitcastToAPInt().getRawData()[1])
3616 << formatv("({0:x} + {1:x}) * ({2:x} + {3:x})", Op1[0], Op1[1],
3617 Op2[0], Op2[1])
3618 .str();
3619 }
3620 {
3621 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
3622 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
3623 A2.multiply(A1, RM);
3624
3625 EXPECT_EQ(Expected[0], A2.bitcastToAPInt().getRawData()[0])
3626 << formatv("({0:x} + {1:x}) * ({2:x} + {3:x})", Op2[0], Op2[1],
3627 Op1[0], Op1[1])
3628 .str();
3629 EXPECT_EQ(Expected[1], A2.bitcastToAPInt().getRawData()[1])
3630 << formatv("({0:x} + {1:x}) * ({2:x} + {3:x})", Op2[0], Op2[1],
3631 Op1[0], Op1[1])
3632 .str();
3633 }
3634 }
3635 }
3636
3637 TEST(APFloatTest, PPCDoubleDoubleDivide) {
3638 using DataType = std::tuple<uint64_t, uint64_t, uint64_t, uint64_t, uint64_t,
3639 uint64_t, APFloat::roundingMode>;
3640 // TODO: Only a sanity check for now. Add more edge cases when the
3641 // double-double algorithm is implemented.
3642 DataType Data[] = {
3643 // 1 / 3 = 1/3
3644 std::make_tuple(0x3ff0000000000000ull, 0, 0x4008000000000000ull, 0,
3645 0x3fd5555555555555ull, 0x3c75555555555556ull,
3646 APFloat::rmNearestTiesToEven),
3647 };
3648
3649 for (auto Tp : Data) {
3650 uint64_t Op1[2], Op2[2], Expected[2];
3651 APFloat::roundingMode RM;
3652 std::tie(Op1[0], Op1[1], Op2[0], Op2[1], Expected[0], Expected[1], RM) = Tp;
3653
3654 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
3655 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
3656 A1.divide(A2, RM);
3657
3658 EXPECT_EQ(Expected[0], A1.bitcastToAPInt().getRawData()[0])
3659 << formatv("({0:x} + {1:x}) / ({2:x} + {3:x})", Op1[0], Op1[1], Op2[0],
3660 Op2[1])
3661 .str();
3662 EXPECT_EQ(Expected[1], A1.bitcastToAPInt().getRawData()[1])
3663 << formatv("({0:x} + {1:x}) / ({2:x} + {3:x})", Op1[0], Op1[1], Op2[0],
3664 Op2[1])
3665 .str();
3666 }
3667 }
3668
3669 TEST(APFloatTest, PPCDoubleDoubleRemainder) {
3670 using DataType =
3671 std::tuple<uint64_t, uint64_t, uint64_t, uint64_t, uint64_t, uint64_t>;
3672 DataType Data[] = {
3673 // remainder(3.0 + 3.0 << 53, 1.25 + 1.25 << 53) = (0.5 + 0.5 << 53)
3674 std::make_tuple(0x4008000000000000ull, 0x3cb8000000000000ull,
3675 0x3ff4000000000000ull, 0x3ca4000000000000ull,
3676 0x3fe0000000000000ull, 0x3c90000000000000ull),
3677 // remainder(3.0 + 3.0 << 53, 1.75 + 1.75 << 53) = (-0.5 - 0.5 << 53)
3678 std::make_tuple(0x4008000000000000ull, 0x3cb8000000000000ull,
3679 0x3ffc000000000000ull, 0x3cac000000000000ull,
3680 0xbfe0000000000000ull, 0xbc90000000000000ull),
3681 };
3682
3683 for (auto Tp : Data) {
3684 uint64_t Op1[2], Op2[2], Expected[2];
3685 std::tie(Op1[0], Op1[1], Op2[0], Op2[1], Expected[0], Expected[1]) = Tp;
3686
3687 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
3688 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
3689 A1.remainder(A2);
3690
3691 EXPECT_EQ(Expected[0], A1.bitcastToAPInt().getRawData()[0])
3692 << formatv("remainder({0:x} + {1:x}), ({2:x} + {3:x}))", Op1[0], Op1[1],
3693 Op2[0], Op2[1])
3694 .str();
3695 EXPECT_EQ(Expected[1], A1.bitcastToAPInt().getRawData()[1])
3696 << formatv("remainder(({0:x} + {1:x}), ({2:x} + {3:x}))", Op1[0],
3697 Op1[1], Op2[0], Op2[1])
3698 .str();
3699 }
3700 }
3701
3702 TEST(APFloatTest, PPCDoubleDoubleMod) {
3703 using DataType =
3704 std::tuple<uint64_t, uint64_t, uint64_t, uint64_t, uint64_t, uint64_t>;
3705 DataType Data[] = {
3706 // mod(3.0 + 3.0 << 53, 1.25 + 1.25 << 53) = (0.5 + 0.5 << 53)
3707 std::make_tuple(0x4008000000000000ull, 0x3cb8000000000000ull,
3708 0x3ff4000000000000ull, 0x3ca4000000000000ull,
3709 0x3fe0000000000000ull, 0x3c90000000000000ull),
3710 // mod(3.0 + 3.0 << 53, 1.75 + 1.75 << 53) = (1.25 + 1.25 << 53)
3711 // 0xbc98000000000000 doesn't seem right, but it's what we currently have.
3712 // TODO: investigate
3713 std::make_tuple(0x4008000000000000ull, 0x3cb8000000000000ull,
3714 0x3ffc000000000000ull, 0x3cac000000000000ull,
3715 0x3ff4000000000001ull, 0xbc98000000000000ull),
3716 };
3717
3718 for (auto Tp : Data) {
3719 uint64_t Op1[2], Op2[2], Expected[2];
3720 std::tie(Op1[0], Op1[1], Op2[0], Op2[1], Expected[0], Expected[1]) = Tp;
3721
3722 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
3723 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
3724 A1.mod(A2);
3725
3726 EXPECT_EQ(Expected[0], A1.bitcastToAPInt().getRawData()[0])
3727 << formatv("fmod(({0:x} + {1:x}), ({2:x} + {3:x}))", Op1[0], Op1[1],
3728 Op2[0], Op2[1])
3729 .str();
3730 EXPECT_EQ(Expected[1], A1.bitcastToAPInt().getRawData()[1])
3731 << formatv("fmod(({0:x} + {1:x}), ({2:x} + {3:x}))", Op1[0], Op1[1],
3732 Op2[0], Op2[1])
3733 .str();
3734 }
3735 }
3736
3737 TEST(APFloatTest, PPCDoubleDoubleFMA) {
3738 // Sanity check for now.
3739 APFloat A(APFloat::PPCDoubleDouble(), "2");
3740 A.fusedMultiplyAdd(APFloat(APFloat::PPCDoubleDouble(), "3"),
3741 APFloat(APFloat::PPCDoubleDouble(), "4"),
3742 APFloat::rmNearestTiesToEven);
3743 EXPECT_EQ(APFloat::cmpEqual,
3744 APFloat(APFloat::PPCDoubleDouble(), "10").compare(A));
3745 }
3746
3747 TEST(APFloatTest, PPCDoubleDoubleRoundToIntegral) {
3748 {
3749 APFloat A(APFloat::PPCDoubleDouble(), "1.5");
3750 A.roundToIntegral(APFloat::rmNearestTiesToEven);
3751 EXPECT_EQ(APFloat::cmpEqual,
3752 APFloat(APFloat::PPCDoubleDouble(), "2").compare(A));
3753 }
3754 {
3755 APFloat A(APFloat::PPCDoubleDouble(), "2.5");
3756 A.roundToIntegral(APFloat::rmNearestTiesToEven);
3757 EXPECT_EQ(APFloat::cmpEqual,
3758 APFloat(APFloat::PPCDoubleDouble(), "2").compare(A));
3759 }
3760 }
3761
3762 TEST(APFloatTest, PPCDoubleDoubleCompare) {
3763 using DataType =
3764 std::tuple<uint64_t, uint64_t, uint64_t, uint64_t, APFloat::cmpResult>;
3765
3766 DataType Data[] = {
3767 // (1 + 0) = (1 + 0)
3768 std::make_tuple(0x3ff0000000000000ull, 0, 0x3ff0000000000000ull, 0,
3769 APFloat::cmpEqual),
3770 // (1 + 0) < (1.00...1 + 0)
3771 std::make_tuple(0x3ff0000000000000ull, 0, 0x3ff0000000000001ull, 0,
3772 APFloat::cmpLessThan),
3773 // (1.00...1 + 0) > (1 + 0)
3774 std::make_tuple(0x3ff0000000000001ull, 0, 0x3ff0000000000000ull, 0,
3775 APFloat::cmpGreaterThan),
3776 // (1 + 0) < (1 + epsilon)
3777 std::make_tuple(0x3ff0000000000000ull, 0, 0x3ff0000000000001ull,
3778 0x0000000000000001ull, APFloat::cmpLessThan),
3779 // NaN != NaN
3780 std::make_tuple(0x7ff8000000000000ull, 0, 0x7ff8000000000000ull, 0,
3781 APFloat::cmpUnordered),
3782 // (1 + 0) != NaN
3783 std::make_tuple(0x3ff0000000000000ull, 0, 0x7ff8000000000000ull, 0,
3784 APFloat::cmpUnordered),
3785 // Inf = Inf
3786 std::make_tuple(0x7ff0000000000000ull, 0, 0x7ff0000000000000ull, 0,
3787 APFloat::cmpEqual),
3788 };
3789
3790 for (auto Tp : Data) {
3791 uint64_t Op1[2], Op2[2];
3792 APFloat::cmpResult Expected;
3793 std::tie(Op1[0], Op1[1], Op2[0], Op2[1], Expected) = Tp;
3794
3795 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
3796 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
3797 EXPECT_EQ(Expected, A1.compare(A2))
3798 << formatv("compare(({0:x} + {1:x}), ({2:x} + {3:x}))", Op1[0], Op1[1],
3799 Op2[0], Op2[1])
3800 .str();
3801 }
3802 }
3803
3804 TEST(APFloatTest, PPCDoubleDoubleBitwiseIsEqual) {
3805 using DataType = std::tuple<uint64_t, uint64_t, uint64_t, uint64_t, bool>;
3806
3807 DataType Data[] = {
3808 // (1 + 0) = (1 + 0)
3809 std::make_tuple(0x3ff0000000000000ull, 0, 0x3ff0000000000000ull, 0, true),
3810 // (1 + 0) != (1.00...1 + 0)
3811 std::make_tuple(0x3ff0000000000000ull, 0, 0x3ff0000000000001ull, 0,
3812 false),
3813 // NaN = NaN
3814 std::make_tuple(0x7ff8000000000000ull, 0, 0x7ff8000000000000ull, 0, true),
3815 // NaN != NaN with a different bit pattern
3816 std::make_tuple(0x7ff8000000000000ull, 0, 0x7ff8000000000000ull,
3817 0x3ff0000000000000ull, false),
3818 // Inf = Inf
3819 std::make_tuple(0x7ff0000000000000ull, 0, 0x7ff0000000000000ull, 0, true),
3820 };
3821
3822 for (auto Tp : Data) {
3823 uint64_t Op1[2], Op2[2];
3824 bool Expected;
3825 std::tie(Op1[0], Op1[1], Op2[0], Op2[1], Expected) = Tp;
3826
3827 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
3828 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
3829 EXPECT_EQ(Expected, A1.bitwiseIsEqual(A2))
3830 << formatv("({0:x} + {1:x}) = ({2:x} + {3:x})", Op1[0], Op1[1], Op2[0],
3831 Op2[1])
3832 .str();
3833 }
3834 }
3835
3836 TEST(APFloatTest, PPCDoubleDoubleHashValue) {
3837 uint64_t Data1[] = {0x3ff0000000000001ull, 0x0000000000000001ull};
3838 uint64_t Data2[] = {0x3ff0000000000001ull, 0};
3839 // The hash values are *hopefully* different.
3840 EXPECT_NE(
3841 hash_value(APFloat(APFloat::PPCDoubleDouble(), APInt(128, 2, Data1))),
3842 hash_value(APFloat(APFloat::PPCDoubleDouble(), APInt(128, 2, Data2))));
3843 }
3844
3845 TEST(APFloatTest, PPCDoubleDoubleChangeSign) {
3846 uint64_t Data[] = {
3847 0x400f000000000000ull, 0xbcb0000000000000ull,
3848 };
3849 APFloat Float(APFloat::PPCDoubleDouble(), APInt(128, 2, Data));
3850 {
3851 APFloat Actual =
3852 APFloat::copySign(Float, APFloat(APFloat::IEEEdouble(), "1"));
3853 EXPECT_EQ(0x400f000000000000ull, Actual.bitcastToAPInt().getRawData()[0]);
3854 EXPECT_EQ(0xbcb0000000000000ull, Actual.bitcastToAPInt().getRawData()[1]);
3855 }
3856 {
3857 APFloat Actual =
3858 APFloat::copySign(Float, APFloat(APFloat::IEEEdouble(), "-1"));
3859 EXPECT_EQ(0xc00f000000000000ull, Actual.bitcastToAPInt().getRawData()[0]);
3860 EXPECT_EQ(0x3cb0000000000000ull, Actual.bitcastToAPInt().getRawData()[1]);
3861 }
3862 }
3863
3864 TEST(APFloatTest, PPCDoubleDoubleFactories) {
3865 {
3866 uint64_t Data[] = {
3867 0, 0,
3868 };
3869 EXPECT_EQ(APInt(128, 2, Data),
3870 APFloat::getZero(APFloat::PPCDoubleDouble()).bitcastToAPInt());
3871 }
3872 {
3873 uint64_t Data[] = {
3874 0x7fefffffffffffffull, 0x7c8ffffffffffffeull,
3875 };
3876 EXPECT_EQ(APInt(128, 2, Data),
3877 APFloat::getLargest(APFloat::PPCDoubleDouble()).bitcastToAPInt());
3878 }
3879 {
3880 uint64_t Data[] = {
3881 0x0000000000000001ull, 0,
3882 };
3883 EXPECT_EQ(
3884 APInt(128, 2, Data),
3885 APFloat::getSmallest(APFloat::PPCDoubleDouble()).bitcastToAPInt());
3886 }
3887 {
3888 uint64_t Data[] = {0x0360000000000000ull, 0};
3889 EXPECT_EQ(APInt(128, 2, Data),
3890 APFloat::getSmallestNormalized(APFloat::PPCDoubleDouble())
3891 .bitcastToAPInt());
3892 }
3893 {
3894 uint64_t Data[] = {
3895 0x8000000000000000ull, 0x0000000000000000ull,
3896 };
3897 EXPECT_EQ(
3898 APInt(128, 2, Data),
3899 APFloat::getZero(APFloat::PPCDoubleDouble(), true).bitcastToAPInt());
3900 }
3901 {
3902 uint64_t Data[] = {
3903 0xffefffffffffffffull, 0xfc8ffffffffffffeull,
3904 };
3905 EXPECT_EQ(
3906 APInt(128, 2, Data),
3907 APFloat::getLargest(APFloat::PPCDoubleDouble(), true).bitcastToAPInt());
3908 }
3909 {
3910 uint64_t Data[] = {
3911 0x8000000000000001ull, 0x0000000000000000ull,
3912 };
3913 EXPECT_EQ(APInt(128, 2, Data),
3914 APFloat::getSmallest(APFloat::PPCDoubleDouble(), true)
3915 .bitcastToAPInt());
3916 }
3917 {
3918 uint64_t Data[] = {
3919 0x8360000000000000ull, 0x0000000000000000ull,
3920 };
3921 EXPECT_EQ(APInt(128, 2, Data),
3922 APFloat::getSmallestNormalized(APFloat::PPCDoubleDouble(), true)
3923 .bitcastToAPInt());
3924 }
3925 EXPECT_TRUE(APFloat::getSmallest(APFloat::PPCDoubleDouble()).isSmallest());
3926 EXPECT_TRUE(APFloat::getLargest(APFloat::PPCDoubleDouble()).isLargest());
3927 }
3928
3929 TEST(APFloatTest, PPCDoubleDoubleIsDenormal) {
3930 EXPECT_TRUE(APFloat::getSmallest(APFloat::PPCDoubleDouble()).isDenormal());
3931 EXPECT_FALSE(APFloat::getLargest(APFloat::PPCDoubleDouble()).isDenormal());
3932 EXPECT_FALSE(
3933 APFloat::getSmallestNormalized(APFloat::PPCDoubleDouble()).isDenormal());
3934 {
3935 // (4 + 3) is not normalized
3936 uint64_t Data[] = {
3937 0x4010000000000000ull, 0x4008000000000000ull,
3938 };
3939 EXPECT_TRUE(
3940 APFloat(APFloat::PPCDoubleDouble(), APInt(128, 2, Data)).isDenormal());
3941 }
3942 }
3943
3944 TEST(APFloatTest, PPCDoubleDoubleScalbn) {
3945 // 3.0 + 3.0 << 53
3946 uint64_t Input[] = {
3947 0x4008000000000000ull, 0x3cb8000000000000ull,
3948 };
3949 APFloat Result =
3950 scalbn(APFloat(APFloat::PPCDoubleDouble(), APInt(128, 2, Input)), 1,
3951 APFloat::rmNearestTiesToEven);
3952 // 6.0 + 6.0 << 53
3953 EXPECT_EQ(0x4018000000000000ull, Result.bitcastToAPInt().getRawData()[0]);
3954 EXPECT_EQ(0x3cc8000000000000ull, Result.bitcastToAPInt().getRawData()[1]);
3955 }
3956
3957 TEST(APFloatTest, PPCDoubleDoubleFrexp) {
3958 // 3.0 + 3.0 << 53
3959 uint64_t Input[] = {
3960 0x4008000000000000ull, 0x3cb8000000000000ull,
3961 };
3962 int Exp;
3963 // 0.75 + 0.75 << 53
3964 APFloat Result =
3965 frexp(APFloat(APFloat::PPCDoubleDouble(), APInt(128, 2, Input)), Exp,
3966 APFloat::rmNearestTiesToEven);
3967 EXPECT_EQ(2, Exp);
3968 EXPECT_EQ(0x3fe8000000000000ull, Result.bitcastToAPInt().getRawData()[0]);
3969 EXPECT_EQ(0x3c98000000000000ull, Result.bitcastToAPInt().getRawData()[1]);
3970 }
3971 }
The LLVM Project is a collection of modular and reusable compiler and toolchain technologies.