?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[LoongArch] Fix the assertion for atomic store with 'ptr' type
[llvm-project.git] / llvm / unittests / ADT / APFloatTest.cpp
blobd50bdf4a65dcbfa8b47ea1140fedc6a255f9ea36
1 //===- llvm/unittest/ADT/APFloat.cpp - APFloat unit tests ---------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8
9 #include "llvm/ADT/APFloat.h"
10 #include "llvm/ADT/APSInt.h"
11 #include "llvm/ADT/Hashing.h"
12 #include "llvm/ADT/SmallString.h"
13 #include "llvm/ADT/SmallVector.h"
14 #include "llvm/ADT/StringExtras.h"
15 #include "llvm/Support/Error.h"
16 #include "llvm/Support/FormatVariadic.h"
17 #include "gtest/gtest.h"
18 #include <cmath>
19 #include <ostream>
20 #include <string>
21 #include <tuple>
22
23 using namespace llvm;
24
25 static std::string convertToErrorFromString(StringRef Str) {
26 llvm::APFloat F(0.0);
27 auto StatusOrErr =
28 F.convertFromString(Str, llvm::APFloat::rmNearestTiesToEven);
29 EXPECT_TRUE(!StatusOrErr);
30 return toString(StatusOrErr.takeError());
31 }
32
33 static double convertToDoubleFromString(StringRef Str) {
34 llvm::APFloat F(0.0);
35 auto StatusOrErr =
36 F.convertFromString(Str, llvm::APFloat::rmNearestTiesToEven);
37 EXPECT_FALSE(!StatusOrErr);
38 consumeError(StatusOrErr.takeError());
39 return F.convertToDouble();
40 }
41
42 static std::string convertToString(double d, unsigned Prec, unsigned Pad,
43 bool Tr = true) {
44 llvm::SmallVector<char, 100> Buffer;
45 llvm::APFloat F(d);
46 F.toString(Buffer, Prec, Pad, Tr);
47 return std::string(Buffer.data(), Buffer.size());
48 }
49
50 namespace {
51
52 TEST(APFloatTest, isSignaling) {
53 // We test qNaN, -qNaN, +sNaN, -sNaN with and without payloads. *NOTE* The
54 // positive/negative distinction is included only since the getQNaN/getSNaN
55 // API provides the option.
56 APInt payload = APInt::getOneBitSet(4, 2);
57 APFloat QNan = APFloat::getQNaN(APFloat::IEEEsingle(), false);
58 EXPECT_FALSE(QNan.isSignaling());
59 EXPECT_EQ(fcQNan, QNan.classify());
60
61 EXPECT_FALSE(APFloat::getQNaN(APFloat::IEEEsingle(), true).isSignaling());
62 EXPECT_FALSE(APFloat::getQNaN(APFloat::IEEEsingle(), false, &payload).isSignaling());
63 EXPECT_FALSE(APFloat::getQNaN(APFloat::IEEEsingle(), true, &payload).isSignaling());
64
65 APFloat SNan = APFloat::getSNaN(APFloat::IEEEsingle(), false);
66 EXPECT_TRUE(SNan.isSignaling());
67 EXPECT_EQ(fcSNan, SNan.classify());
68
69 EXPECT_TRUE(APFloat::getSNaN(APFloat::IEEEsingle(), true).isSignaling());
70 EXPECT_TRUE(APFloat::getSNaN(APFloat::IEEEsingle(), false, &payload).isSignaling());
71 EXPECT_TRUE(APFloat::getSNaN(APFloat::IEEEsingle(), true, &payload).isSignaling());
72 }
73
74 TEST(APFloatTest, next) {
75
76 APFloat test(APFloat::IEEEquad(), APFloat::uninitialized);
77 APFloat expected(APFloat::IEEEquad(), APFloat::uninitialized);
78
79 // 1. Test Special Cases Values.
80 //
81 // Test all special values for nextUp and nextDown perscribed by IEEE-754R
82 // 2008. These are:
83 // 1. +inf
84 // 2. -inf
85 // 3. getLargest()
86 // 4. -getLargest()
87 // 5. getSmallest()
88 // 6. -getSmallest()
89 // 7. qNaN
90 // 8. sNaN
91 // 9. +0
92 // 10. -0
93
94 // nextUp(+inf) = +inf.
95 test = APFloat::getInf(APFloat::IEEEquad(), false);
96 expected = APFloat::getInf(APFloat::IEEEquad(), false);
97 EXPECT_EQ(test.next(false), APFloat::opOK);
98 EXPECT_TRUE(test.isInfinity());
99 EXPECT_TRUE(!test.isNegative());
100 EXPECT_TRUE(test.bitwiseIsEqual(expected));
101
102 // nextDown(+inf) = -nextUp(-inf) = -(-getLargest()) = getLargest()
103 test = APFloat::getInf(APFloat::IEEEquad(), false);
104 expected = APFloat::getLargest(APFloat::IEEEquad(), false);
105 EXPECT_EQ(test.next(true), APFloat::opOK);
106 EXPECT_TRUE(!test.isNegative());
107 EXPECT_TRUE(test.bitwiseIsEqual(expected));
108
109 // nextUp(-inf) = -getLargest()
110 test = APFloat::getInf(APFloat::IEEEquad(), true);
111 expected = APFloat::getLargest(APFloat::IEEEquad(), true);
112 EXPECT_EQ(test.next(false), APFloat::opOK);
113 EXPECT_TRUE(test.isNegative());
114 EXPECT_TRUE(test.bitwiseIsEqual(expected));
115
116 // nextDown(-inf) = -nextUp(+inf) = -(+inf) = -inf.
117 test = APFloat::getInf(APFloat::IEEEquad(), true);
118 expected = APFloat::getInf(APFloat::IEEEquad(), true);
119 EXPECT_EQ(test.next(true), APFloat::opOK);
120 EXPECT_TRUE(test.isInfinity() && test.isNegative());
121 EXPECT_TRUE(test.bitwiseIsEqual(expected));
122
123 // nextUp(getLargest()) = +inf
124 test = APFloat::getLargest(APFloat::IEEEquad(), false);
125 expected = APFloat::getInf(APFloat::IEEEquad(), false);
126 EXPECT_EQ(test.next(false), APFloat::opOK);
127 EXPECT_TRUE(test.isInfinity() && !test.isNegative());
128 EXPECT_TRUE(test.bitwiseIsEqual(expected));
129
130 // nextDown(getLargest()) = -nextUp(-getLargest())
131 // = -(-getLargest() + inc)
132 // = getLargest() - inc.
133 test = APFloat::getLargest(APFloat::IEEEquad(), false);
134 expected = APFloat(APFloat::IEEEquad(),
135 "0x1.fffffffffffffffffffffffffffep+16383");
136 EXPECT_EQ(test.next(true), APFloat::opOK);
137 EXPECT_TRUE(!test.isInfinity() && !test.isNegative());
138 EXPECT_TRUE(test.bitwiseIsEqual(expected));
139
140 // nextUp(-getLargest()) = -getLargest() + inc.
141 test = APFloat::getLargest(APFloat::IEEEquad(), true);
142 expected = APFloat(APFloat::IEEEquad(),
143 "-0x1.fffffffffffffffffffffffffffep+16383");
144 EXPECT_EQ(test.next(false), APFloat::opOK);
145 EXPECT_TRUE(test.bitwiseIsEqual(expected));
146
147 // nextDown(-getLargest()) = -nextUp(getLargest()) = -(inf) = -inf.
148 test = APFloat::getLargest(APFloat::IEEEquad(), true);
149 expected = APFloat::getInf(APFloat::IEEEquad(), true);
150 EXPECT_EQ(test.next(true), APFloat::opOK);
151 EXPECT_TRUE(test.isInfinity() && test.isNegative());
152 EXPECT_TRUE(test.bitwiseIsEqual(expected));
153
154 // nextUp(getSmallest()) = getSmallest() + inc.
155 test = APFloat(APFloat::IEEEquad(), "0x0.0000000000000000000000000001p-16382");
156 expected = APFloat(APFloat::IEEEquad(),
157 "0x0.0000000000000000000000000002p-16382");
158 EXPECT_EQ(test.next(false), APFloat::opOK);
159 EXPECT_TRUE(test.bitwiseIsEqual(expected));
160
161 // nextDown(getSmallest()) = -nextUp(-getSmallest()) = -(-0) = +0.
162 test = APFloat(APFloat::IEEEquad(), "0x0.0000000000000000000000000001p-16382");
163 expected = APFloat::getZero(APFloat::IEEEquad(), false);
164 EXPECT_EQ(test.next(true), APFloat::opOK);
165 EXPECT_TRUE(test.isPosZero());
166 EXPECT_TRUE(test.bitwiseIsEqual(expected));
167
168 // nextUp(-getSmallest()) = -0.
169 test = APFloat(APFloat::IEEEquad(), "-0x0.0000000000000000000000000001p-16382");
170 expected = APFloat::getZero(APFloat::IEEEquad(), true);
171 EXPECT_EQ(test.next(false), APFloat::opOK);
172 EXPECT_TRUE(test.isNegZero());
173 EXPECT_TRUE(test.bitwiseIsEqual(expected));
174
175 // nextDown(-getSmallest()) = -nextUp(getSmallest()) = -getSmallest() - inc.
176 test = APFloat(APFloat::IEEEquad(), "-0x0.0000000000000000000000000001p-16382");
177 expected = APFloat(APFloat::IEEEquad(),
178 "-0x0.0000000000000000000000000002p-16382");
179 EXPECT_EQ(test.next(true), APFloat::opOK);
180 EXPECT_TRUE(test.bitwiseIsEqual(expected));
181
182 // nextUp(qNaN) = qNaN
183 test = APFloat::getQNaN(APFloat::IEEEquad(), false);
184 expected = APFloat::getQNaN(APFloat::IEEEquad(), false);
185 EXPECT_EQ(test.next(false), APFloat::opOK);
186 EXPECT_TRUE(test.bitwiseIsEqual(expected));
187
188 // nextDown(qNaN) = qNaN
189 test = APFloat::getQNaN(APFloat::IEEEquad(), false);
190 expected = APFloat::getQNaN(APFloat::IEEEquad(), false);
191 EXPECT_EQ(test.next(true), APFloat::opOK);
192 EXPECT_TRUE(test.bitwiseIsEqual(expected));
193
194 // nextUp(sNaN) = qNaN
195 test = APFloat::getSNaN(APFloat::IEEEquad(), false);
196 expected = APFloat::getQNaN(APFloat::IEEEquad(), false);
197 EXPECT_EQ(test.next(false), APFloat::opInvalidOp);
198 EXPECT_TRUE(test.bitwiseIsEqual(expected));
199
200 // nextDown(sNaN) = qNaN
201 test = APFloat::getSNaN(APFloat::IEEEquad(), false);
202 expected = APFloat::getQNaN(APFloat::IEEEquad(), false);
203 EXPECT_EQ(test.next(true), APFloat::opInvalidOp);
204 EXPECT_TRUE(test.bitwiseIsEqual(expected));
205
206 // nextUp(+0) = +getSmallest()
207 test = APFloat::getZero(APFloat::IEEEquad(), false);
208 expected = APFloat::getSmallest(APFloat::IEEEquad(), false);
209 EXPECT_EQ(test.next(false), APFloat::opOK);
210 EXPECT_TRUE(test.bitwiseIsEqual(expected));
211
212 // nextDown(+0) = -nextUp(-0) = -getSmallest()
213 test = APFloat::getZero(APFloat::IEEEquad(), false);
214 expected = APFloat::getSmallest(APFloat::IEEEquad(), true);
215 EXPECT_EQ(test.next(true), APFloat::opOK);
216 EXPECT_TRUE(test.bitwiseIsEqual(expected));
217
218 // nextUp(-0) = +getSmallest()
219 test = APFloat::getZero(APFloat::IEEEquad(), true);
220 expected = APFloat::getSmallest(APFloat::IEEEquad(), false);
221 EXPECT_EQ(test.next(false), APFloat::opOK);
222 EXPECT_TRUE(test.bitwiseIsEqual(expected));
223
224 // nextDown(-0) = -nextUp(0) = -getSmallest()
225 test = APFloat::getZero(APFloat::IEEEquad(), true);
226 expected = APFloat::getSmallest(APFloat::IEEEquad(), true);
227 EXPECT_EQ(test.next(true), APFloat::opOK);
228 EXPECT_TRUE(test.bitwiseIsEqual(expected));
229
230 // 2. Binade Boundary Tests.
231
232 // 2a. Test denormal <-> normal binade boundaries.
233 // * nextUp(+Largest Denormal) -> +Smallest Normal.
234 // * nextDown(-Largest Denormal) -> -Smallest Normal.
235 // * nextUp(-Smallest Normal) -> -Largest Denormal.
236 // * nextDown(+Smallest Normal) -> +Largest Denormal.
237
238 // nextUp(+Largest Denormal) -> +Smallest Normal.
239 test = APFloat(APFloat::IEEEquad(), "0x0.ffffffffffffffffffffffffffffp-16382");
240 expected = APFloat(APFloat::IEEEquad(),
241 "0x1.0000000000000000000000000000p-16382");
242 EXPECT_EQ(test.next(false), APFloat::opOK);
243 EXPECT_FALSE(test.isDenormal());
244 EXPECT_TRUE(test.bitwiseIsEqual(expected));
245
246 // nextDown(-Largest Denormal) -> -Smallest Normal.
247 test = APFloat(APFloat::IEEEquad(),
248 "-0x0.ffffffffffffffffffffffffffffp-16382");
249 expected = APFloat(APFloat::IEEEquad(),
250 "-0x1.0000000000000000000000000000p-16382");
251 EXPECT_EQ(test.next(true), APFloat::opOK);
252 EXPECT_FALSE(test.isDenormal());
253 EXPECT_TRUE(test.bitwiseIsEqual(expected));
254
255 // nextUp(-Smallest Normal) -> -LargestDenormal.
256 test = APFloat(APFloat::IEEEquad(),
257 "-0x1.0000000000000000000000000000p-16382");
258 expected = APFloat(APFloat::IEEEquad(),
259 "-0x0.ffffffffffffffffffffffffffffp-16382");
260 EXPECT_EQ(test.next(false), APFloat::opOK);
261 EXPECT_TRUE(test.isDenormal());
262 EXPECT_TRUE(test.bitwiseIsEqual(expected));
263
264 // nextDown(+Smallest Normal) -> +Largest Denormal.
265 test = APFloat(APFloat::IEEEquad(),
266 "+0x1.0000000000000000000000000000p-16382");
267 expected = APFloat(APFloat::IEEEquad(),
268 "+0x0.ffffffffffffffffffffffffffffp-16382");
269 EXPECT_EQ(test.next(true), APFloat::opOK);
270 EXPECT_TRUE(test.isDenormal());
271 EXPECT_TRUE(test.bitwiseIsEqual(expected));
272
273 // 2b. Test normal <-> normal binade boundaries.
274 // * nextUp(-Normal Binade Boundary) -> -Normal Binade Boundary + 1.
275 // * nextDown(+Normal Binade Boundary) -> +Normal Binade Boundary - 1.
276 // * nextUp(+Normal Binade Boundary - 1) -> +Normal Binade Boundary.
277 // * nextDown(-Normal Binade Boundary + 1) -> -Normal Binade Boundary.
278
279 // nextUp(-Normal Binade Boundary) -> -Normal Binade Boundary + 1.
280 test = APFloat(APFloat::IEEEquad(), "-0x1p+1");
281 expected = APFloat(APFloat::IEEEquad(),
282 "-0x1.ffffffffffffffffffffffffffffp+0");
283 EXPECT_EQ(test.next(false), APFloat::opOK);
284 EXPECT_TRUE(test.bitwiseIsEqual(expected));
285
286 // nextDown(+Normal Binade Boundary) -> +Normal Binade Boundary - 1.
287 test = APFloat(APFloat::IEEEquad(), "0x1p+1");
288 expected = APFloat(APFloat::IEEEquad(), "0x1.ffffffffffffffffffffffffffffp+0");
289 EXPECT_EQ(test.next(true), APFloat::opOK);
290 EXPECT_TRUE(test.bitwiseIsEqual(expected));
291
292 // nextUp(+Normal Binade Boundary - 1) -> +Normal Binade Boundary.
293 test = APFloat(APFloat::IEEEquad(), "0x1.ffffffffffffffffffffffffffffp+0");
294 expected = APFloat(APFloat::IEEEquad(), "0x1p+1");
295 EXPECT_EQ(test.next(false), APFloat::opOK);
296 EXPECT_TRUE(test.bitwiseIsEqual(expected));
297
298 // nextDown(-Normal Binade Boundary + 1) -> -Normal Binade Boundary.
299 test = APFloat(APFloat::IEEEquad(), "-0x1.ffffffffffffffffffffffffffffp+0");
300 expected = APFloat(APFloat::IEEEquad(), "-0x1p+1");
301 EXPECT_EQ(test.next(true), APFloat::opOK);
302 EXPECT_TRUE(test.bitwiseIsEqual(expected));
303
304 // 2c. Test using next at binade boundaries with a direction away from the
305 // binade boundary. Away from denormal <-> normal boundaries.
306 //
307 // This is to make sure that even though we are at a binade boundary, since
308 // we are rounding away, we do not trigger the binade boundary code. Thus we
309 // test:
310 // * nextUp(-Largest Denormal) -> -Largest Denormal + inc.
311 // * nextDown(+Largest Denormal) -> +Largest Denormal - inc.
312 // * nextUp(+Smallest Normal) -> +Smallest Normal + inc.
313 // * nextDown(-Smallest Normal) -> -Smallest Normal - inc.
314
315 // nextUp(-Largest Denormal) -> -Largest Denormal + inc.
316 test = APFloat(APFloat::IEEEquad(), "-0x0.ffffffffffffffffffffffffffffp-16382");
317 expected = APFloat(APFloat::IEEEquad(),
318 "-0x0.fffffffffffffffffffffffffffep-16382");
319 EXPECT_EQ(test.next(false), APFloat::opOK);
320 EXPECT_TRUE(test.isDenormal());
321 EXPECT_TRUE(test.isNegative());
322 EXPECT_TRUE(test.bitwiseIsEqual(expected));
323
324 // nextDown(+Largest Denormal) -> +Largest Denormal - inc.
325 test = APFloat(APFloat::IEEEquad(), "0x0.ffffffffffffffffffffffffffffp-16382");
326 expected = APFloat(APFloat::IEEEquad(),
327 "0x0.fffffffffffffffffffffffffffep-16382");
328 EXPECT_EQ(test.next(true), APFloat::opOK);
329 EXPECT_TRUE(test.isDenormal());
330 EXPECT_TRUE(!test.isNegative());
331 EXPECT_TRUE(test.bitwiseIsEqual(expected));
332
333 // nextUp(+Smallest Normal) -> +Smallest Normal + inc.
334 test = APFloat(APFloat::IEEEquad(), "0x1.0000000000000000000000000000p-16382");
335 expected = APFloat(APFloat::IEEEquad(),
336 "0x1.0000000000000000000000000001p-16382");
337 EXPECT_EQ(test.next(false), APFloat::opOK);
338 EXPECT_TRUE(!test.isDenormal());
339 EXPECT_TRUE(!test.isNegative());
340 EXPECT_TRUE(test.bitwiseIsEqual(expected));
341
342 // nextDown(-Smallest Normal) -> -Smallest Normal - inc.
343 test = APFloat(APFloat::IEEEquad(), "-0x1.0000000000000000000000000000p-16382");
344 expected = APFloat(APFloat::IEEEquad(),
345 "-0x1.0000000000000000000000000001p-16382");
346 EXPECT_EQ(test.next(true), APFloat::opOK);
347 EXPECT_TRUE(!test.isDenormal());
348 EXPECT_TRUE(test.isNegative());
349 EXPECT_TRUE(test.bitwiseIsEqual(expected));
350
351 // 2d. Test values which cause our exponent to go to min exponent. This
352 // is to ensure that guards in the code to check for min exponent
353 // trigger properly.
354 // * nextUp(-0x1p-16381) -> -0x1.ffffffffffffffffffffffffffffp-16382
355 // * nextDown(-0x1.ffffffffffffffffffffffffffffp-16382) ->
356 // -0x1p-16381
357 // * nextUp(0x1.ffffffffffffffffffffffffffffp-16382) -> 0x1p-16382
358 // * nextDown(0x1p-16382) -> 0x1.ffffffffffffffffffffffffffffp-16382
359
360 // nextUp(-0x1p-16381) -> -0x1.ffffffffffffffffffffffffffffp-16382
361 test = APFloat(APFloat::IEEEquad(), "-0x1p-16381");
362 expected = APFloat(APFloat::IEEEquad(),
363 "-0x1.ffffffffffffffffffffffffffffp-16382");
364 EXPECT_EQ(test.next(false), APFloat::opOK);
365 EXPECT_TRUE(test.bitwiseIsEqual(expected));
366
367 // nextDown(-0x1.ffffffffffffffffffffffffffffp-16382) ->
368 // -0x1p-16381
369 test = APFloat(APFloat::IEEEquad(), "-0x1.ffffffffffffffffffffffffffffp-16382");
370 expected = APFloat(APFloat::IEEEquad(), "-0x1p-16381");
371 EXPECT_EQ(test.next(true), APFloat::opOK);
372 EXPECT_TRUE(test.bitwiseIsEqual(expected));
373
374 // nextUp(0x1.ffffffffffffffffffffffffffffp-16382) -> 0x1p-16381
375 test = APFloat(APFloat::IEEEquad(), "0x1.ffffffffffffffffffffffffffffp-16382");
376 expected = APFloat(APFloat::IEEEquad(), "0x1p-16381");
377 EXPECT_EQ(test.next(false), APFloat::opOK);
378 EXPECT_TRUE(test.bitwiseIsEqual(expected));
379
380 // nextDown(0x1p-16381) -> 0x1.ffffffffffffffffffffffffffffp-16382
381 test = APFloat(APFloat::IEEEquad(), "0x1p-16381");
382 expected = APFloat(APFloat::IEEEquad(),
383 "0x1.ffffffffffffffffffffffffffffp-16382");
384 EXPECT_EQ(test.next(true), APFloat::opOK);
385 EXPECT_TRUE(test.bitwiseIsEqual(expected));
386
387 // 3. Now we test both denormal/normal computation which will not cause us
388 // to go across binade boundaries. Specifically we test:
389 // * nextUp(+Denormal) -> +Denormal.
390 // * nextDown(+Denormal) -> +Denormal.
391 // * nextUp(-Denormal) -> -Denormal.
392 // * nextDown(-Denormal) -> -Denormal.
393 // * nextUp(+Normal) -> +Normal.
394 // * nextDown(+Normal) -> +Normal.
395 // * nextUp(-Normal) -> -Normal.
396 // * nextDown(-Normal) -> -Normal.
397
398 // nextUp(+Denormal) -> +Denormal.
399 test = APFloat(APFloat::IEEEquad(),
400 "0x0.ffffffffffffffffffffffff000cp-16382");
401 expected = APFloat(APFloat::IEEEquad(),
402 "0x0.ffffffffffffffffffffffff000dp-16382");
403 EXPECT_EQ(test.next(false), APFloat::opOK);
404 EXPECT_TRUE(test.isDenormal());
405 EXPECT_TRUE(!test.isNegative());
406 EXPECT_TRUE(test.bitwiseIsEqual(expected));
407
408 // nextDown(+Denormal) -> +Denormal.
409 test = APFloat(APFloat::IEEEquad(),
410 "0x0.ffffffffffffffffffffffff000cp-16382");
411 expected = APFloat(APFloat::IEEEquad(),
412 "0x0.ffffffffffffffffffffffff000bp-16382");
413 EXPECT_EQ(test.next(true), APFloat::opOK);
414 EXPECT_TRUE(test.isDenormal());
415 EXPECT_TRUE(!test.isNegative());
416 EXPECT_TRUE(test.bitwiseIsEqual(expected));
417
418 // nextUp(-Denormal) -> -Denormal.
419 test = APFloat(APFloat::IEEEquad(),
420 "-0x0.ffffffffffffffffffffffff000cp-16382");
421 expected = APFloat(APFloat::IEEEquad(),
422 "-0x0.ffffffffffffffffffffffff000bp-16382");
423 EXPECT_EQ(test.next(false), APFloat::opOK);
424 EXPECT_TRUE(test.isDenormal());
425 EXPECT_TRUE(test.isNegative());
426 EXPECT_TRUE(test.bitwiseIsEqual(expected));
427
428 // nextDown(-Denormal) -> -Denormal
429 test = APFloat(APFloat::IEEEquad(),
430 "-0x0.ffffffffffffffffffffffff000cp-16382");
431 expected = APFloat(APFloat::IEEEquad(),
432 "-0x0.ffffffffffffffffffffffff000dp-16382");
433 EXPECT_EQ(test.next(true), APFloat::opOK);
434 EXPECT_TRUE(test.isDenormal());
435 EXPECT_TRUE(test.isNegative());
436 EXPECT_TRUE(test.bitwiseIsEqual(expected));
437
438 // nextUp(+Normal) -> +Normal.
439 test = APFloat(APFloat::IEEEquad(),
440 "0x1.ffffffffffffffffffffffff000cp-16000");
441 expected = APFloat(APFloat::IEEEquad(),
442 "0x1.ffffffffffffffffffffffff000dp-16000");
443 EXPECT_EQ(test.next(false), APFloat::opOK);
444 EXPECT_TRUE(!test.isDenormal());
445 EXPECT_TRUE(!test.isNegative());
446 EXPECT_TRUE(test.bitwiseIsEqual(expected));
447
448 // nextDown(+Normal) -> +Normal.
449 test = APFloat(APFloat::IEEEquad(),
450 "0x1.ffffffffffffffffffffffff000cp-16000");
451 expected = APFloat(APFloat::IEEEquad(),
452 "0x1.ffffffffffffffffffffffff000bp-16000");
453 EXPECT_EQ(test.next(true), APFloat::opOK);
454 EXPECT_TRUE(!test.isDenormal());
455 EXPECT_TRUE(!test.isNegative());
456 EXPECT_TRUE(test.bitwiseIsEqual(expected));
457
458 // nextUp(-Normal) -> -Normal.
459 test = APFloat(APFloat::IEEEquad(),
460 "-0x1.ffffffffffffffffffffffff000cp-16000");
461 expected = APFloat(APFloat::IEEEquad(),
462 "-0x1.ffffffffffffffffffffffff000bp-16000");
463 EXPECT_EQ(test.next(false), APFloat::opOK);
464 EXPECT_TRUE(!test.isDenormal());
465 EXPECT_TRUE(test.isNegative());
466 EXPECT_TRUE(test.bitwiseIsEqual(expected));
467
468 // nextDown(-Normal) -> -Normal.
469 test = APFloat(APFloat::IEEEquad(),
470 "-0x1.ffffffffffffffffffffffff000cp-16000");
471 expected = APFloat(APFloat::IEEEquad(),
472 "-0x1.ffffffffffffffffffffffff000dp-16000");
473 EXPECT_EQ(test.next(true), APFloat::opOK);
474 EXPECT_TRUE(!test.isDenormal());
475 EXPECT_TRUE(test.isNegative());
476 EXPECT_TRUE(test.bitwiseIsEqual(expected));
477 }
478
479 TEST(APFloatTest, FMA) {
480 APFloat::roundingMode rdmd = APFloat::rmNearestTiesToEven;
481
482 {
483 APFloat f1(14.5f);
484 APFloat f2(-14.5f);
485 APFloat f3(225.0f);
486 f1.fusedMultiplyAdd(f2, f3, APFloat::rmNearestTiesToEven);
487 EXPECT_EQ(14.75f, f1.convertToFloat());
488 }
489
490 {
491 APFloat Val2(2.0f);
492 APFloat f1((float)1.17549435e-38F);
493 APFloat f2((float)1.17549435e-38F);
494 f1.divide(Val2, rdmd);
495 f2.divide(Val2, rdmd);
496 APFloat f3(12.0f);
497 f1.fusedMultiplyAdd(f2, f3, APFloat::rmNearestTiesToEven);
498 EXPECT_EQ(12.0f, f1.convertToFloat());
499 }
500
501 // Test for correct zero sign when answer is exactly zero.
502 // fma(1.0, -1.0, 1.0) -> +ve 0.
503 {
504 APFloat f1(1.0);
505 APFloat f2(-1.0);
506 APFloat f3(1.0);
507 f1.fusedMultiplyAdd(f2, f3, APFloat::rmNearestTiesToEven);
508 EXPECT_TRUE(!f1.isNegative() && f1.isZero());
509 }
510
511 // Test for correct zero sign when answer is exactly zero and rounding towards
512 // negative.
513 // fma(1.0, -1.0, 1.0) -> +ve 0.
514 {
515 APFloat f1(1.0);
516 APFloat f2(-1.0);
517 APFloat f3(1.0);
518 f1.fusedMultiplyAdd(f2, f3, APFloat::rmTowardNegative);
519 EXPECT_TRUE(f1.isNegative() && f1.isZero());
520 }
521
522 // Test for correct (in this case -ve) sign when adding like signed zeros.
523 // Test fma(0.0, -0.0, -0.0) -> -ve 0.
524 {
525 APFloat f1(0.0);
526 APFloat f2(-0.0);
527 APFloat f3(-0.0);
528 f1.fusedMultiplyAdd(f2, f3, APFloat::rmNearestTiesToEven);
529 EXPECT_TRUE(f1.isNegative() && f1.isZero());
530 }
531
532 // Test -ve sign preservation when small negative results underflow.
533 {
534 APFloat f1(APFloat::IEEEdouble(), "-0x1p-1074");
535 APFloat f2(APFloat::IEEEdouble(), "+0x1p-1074");
536 APFloat f3(0.0);
537 f1.fusedMultiplyAdd(f2, f3, APFloat::rmNearestTiesToEven);
538 EXPECT_TRUE(f1.isNegative() && f1.isZero());
539 }
540
541 // Test x87 extended precision case from http://llvm.org/PR20728.
542 {
543 APFloat M1(APFloat::x87DoubleExtended(), 1);
544 APFloat M2(APFloat::x87DoubleExtended(), 1);
545 APFloat A(APFloat::x87DoubleExtended(), 3);
546
547 bool losesInfo = false;
548 M1.fusedMultiplyAdd(M1, A, APFloat::rmNearestTiesToEven);
549 M1.convert(APFloat::IEEEsingle(), APFloat::rmNearestTiesToEven, &losesInfo);
550 EXPECT_FALSE(losesInfo);
551 EXPECT_EQ(4.0f, M1.convertToFloat());
552 }
553
554 // Regression test that failed an assertion.
555 {
556 APFloat f1(-8.85242279E-41f);
557 APFloat f2(2.0f);
558 APFloat f3(8.85242279E-41f);
559 f1.fusedMultiplyAdd(f2, f3, APFloat::rmNearestTiesToEven);
560 EXPECT_EQ(-8.85242279E-41f, f1.convertToFloat());
561 }
562
563 // Test using only a single instance of APFloat.
564 {
565 APFloat F(1.5);
566
567 F.fusedMultiplyAdd(F, F, APFloat::rmNearestTiesToEven);
568 EXPECT_EQ(3.75, F.convertToDouble());
569 }
570 }
571
572 TEST(APFloatTest, MinNum) {
573 APFloat f1(1.0);
574 APFloat f2(2.0);
575 APFloat nan = APFloat::getNaN(APFloat::IEEEdouble());
576
577 EXPECT_EQ(1.0, minnum(f1, f2).convertToDouble());
578 EXPECT_EQ(1.0, minnum(f2, f1).convertToDouble());
579 EXPECT_EQ(1.0, minnum(f1, nan).convertToDouble());
580 EXPECT_EQ(1.0, minnum(nan, f1).convertToDouble());
581
582 APFloat zp(0.0);
583 APFloat zn(-0.0);
584 EXPECT_EQ(-0.0, minnum(zp, zn).convertToDouble());
585 EXPECT_EQ(-0.0, minnum(zn, zp).convertToDouble());
586 }
587
588 TEST(APFloatTest, MaxNum) {
589 APFloat f1(1.0);
590 APFloat f2(2.0);
591 APFloat nan = APFloat::getNaN(APFloat::IEEEdouble());
592
593 EXPECT_EQ(2.0, maxnum(f1, f2).convertToDouble());
594 EXPECT_EQ(2.0, maxnum(f2, f1).convertToDouble());
595 EXPECT_EQ(1.0, maxnum(f1, nan).convertToDouble());
596 EXPECT_EQ(1.0, maxnum(nan, f1).convertToDouble());
597
598 APFloat zp(0.0);
599 APFloat zn(-0.0);
600 EXPECT_EQ(0.0, maxnum(zp, zn).convertToDouble());
601 EXPECT_EQ(0.0, maxnum(zn, zp).convertToDouble());
602 }
603
604 TEST(APFloatTest, Minimum) {
605 APFloat f1(1.0);
606 APFloat f2(2.0);
607 APFloat zp(0.0);
608 APFloat zn(-0.0);
609 APFloat nan = APFloat::getNaN(APFloat::IEEEdouble());
610
611 EXPECT_EQ(1.0, minimum(f1, f2).convertToDouble());
612 EXPECT_EQ(1.0, minimum(f2, f1).convertToDouble());
613 EXPECT_EQ(-0.0, minimum(zp, zn).convertToDouble());
614 EXPECT_EQ(-0.0, minimum(zn, zp).convertToDouble());
615 EXPECT_TRUE(std::isnan(minimum(f1, nan).convertToDouble()));
616 EXPECT_TRUE(std::isnan(minimum(nan, f1).convertToDouble()));
617 }
618
619 TEST(APFloatTest, Maximum) {
620 APFloat f1(1.0);
621 APFloat f2(2.0);
622 APFloat zp(0.0);
623 APFloat zn(-0.0);
624 APFloat nan = APFloat::getNaN(APFloat::IEEEdouble());
625
626 EXPECT_EQ(2.0, maximum(f1, f2).convertToDouble());
627 EXPECT_EQ(2.0, maximum(f2, f1).convertToDouble());
628 EXPECT_EQ(0.0, maximum(zp, zn).convertToDouble());
629 EXPECT_EQ(0.0, maximum(zn, zp).convertToDouble());
630 EXPECT_TRUE(std::isnan(maximum(f1, nan).convertToDouble()));
631 EXPECT_TRUE(std::isnan(maximum(nan, f1).convertToDouble()));
632 }
633
634 TEST(APFloatTest, MinimumNumber) {
635 APFloat f1(1.0);
636 APFloat f2(2.0);
637 APFloat zp(0.0);
638 APFloat zn(-0.0);
639 APInt intPayload_89ab(64, 0x89ab);
640 APInt intPayload_cdef(64, 0xcdef);
641 APFloat nan_0123[2] = {APFloat::getNaN(APFloat::IEEEdouble(), false, 0x0123),
642 APFloat::getNaN(APFloat::IEEEdouble(), false, 0x0123)};
643 APFloat mnan_4567[2] = {APFloat::getNaN(APFloat::IEEEdouble(), true, 0x4567),
644 APFloat::getNaN(APFloat::IEEEdouble(), true, 0x4567)};
645 APFloat nan_89ab[2] = {
646 APFloat::getSNaN(APFloat::IEEEdouble(), false, &intPayload_89ab),
647 APFloat::getNaN(APFloat::IEEEdouble(), false, 0x89ab)};
648 APFloat mnan_cdef[2] = {
649 APFloat::getSNaN(APFloat::IEEEdouble(), true, &intPayload_cdef),
650 APFloat::getNaN(APFloat::IEEEdouble(), true, 0xcdef)};
651
652 EXPECT_TRUE(f1.bitwiseIsEqual(minimumnum(f1, f2)));
653 EXPECT_TRUE(f1.bitwiseIsEqual(minimumnum(f2, f1)));
654 EXPECT_TRUE(zn.bitwiseIsEqual(minimumnum(zp, zn)));
655 EXPECT_TRUE(zn.bitwiseIsEqual(minimumnum(zn, zp)));
656
657 EXPECT_TRUE(minimumnum(zn, zp).isNegative());
658 EXPECT_TRUE(minimumnum(zp, zn).isNegative());
659 EXPECT_TRUE(minimumnum(zn, zn).isNegative());
660 EXPECT_FALSE(minimumnum(zp, zp).isNegative());
661
662 for (APFloat n : {nan_0123[0], mnan_4567[0], nan_89ab[0], mnan_cdef[0]})
663 for (APFloat f : {f1, f2, zn, zp}) {
664 APFloat res = minimumnum(f, n);
665 EXPECT_FALSE(res.isNaN());
666 EXPECT_TRUE(res.bitwiseIsEqual(f));
667 res = minimumnum(n, f);
668 EXPECT_FALSE(res.isNaN());
669 EXPECT_TRUE(res.bitwiseIsEqual(f));
670 }
671
672 // When NaN vs NaN, we should keep payload/sign of either one.
673 for (auto n1 : {nan_0123, mnan_4567, nan_89ab, mnan_cdef})
674 for (auto n2 : {nan_0123, mnan_4567, nan_89ab, mnan_cdef}) {
675 APFloat res = minimumnum(n1[0], n2[0]);
676 EXPECT_TRUE(res.bitwiseIsEqual(n1[1]) || res.bitwiseIsEqual(n2[1]));
677 EXPECT_FALSE(res.isSignaling());
678 }
679 }
680
681 TEST(APFloatTest, MaximumNumber) {
682 APFloat f1(1.0);
683 APFloat f2(2.0);
684 APFloat zp(0.0);
685 APFloat zn(-0.0);
686 APInt intPayload_89ab(64, 0x89ab);
687 APInt intPayload_cdef(64, 0xcdef);
688 APFloat nan_0123[2] = {APFloat::getNaN(APFloat::IEEEdouble(), false, 0x0123),
689 APFloat::getNaN(APFloat::IEEEdouble(), false, 0x0123)};
690 APFloat mnan_4567[2] = {APFloat::getNaN(APFloat::IEEEdouble(), true, 0x4567),
691 APFloat::getNaN(APFloat::IEEEdouble(), true, 0x4567)};
692 APFloat nan_89ab[2] = {
693 APFloat::getSNaN(APFloat::IEEEdouble(), false, &intPayload_89ab),
694 APFloat::getNaN(APFloat::IEEEdouble(), false, 0x89ab)};
695 APFloat mnan_cdef[2] = {
696 APFloat::getSNaN(APFloat::IEEEdouble(), true, &intPayload_cdef),
697 APFloat::getNaN(APFloat::IEEEdouble(), true, 0xcdef)};
698
699 EXPECT_TRUE(f2.bitwiseIsEqual(maximumnum(f1, f2)));
700 EXPECT_TRUE(f2.bitwiseIsEqual(maximumnum(f2, f1)));
701 EXPECT_TRUE(zp.bitwiseIsEqual(maximumnum(zp, zn)));
702 EXPECT_TRUE(zp.bitwiseIsEqual(maximumnum(zn, zp)));
703
704 EXPECT_FALSE(maximumnum(zn, zp).isNegative());
705 EXPECT_FALSE(maximumnum(zp, zn).isNegative());
706 EXPECT_TRUE(maximumnum(zn, zn).isNegative());
707 EXPECT_FALSE(maximumnum(zp, zp).isNegative());
708
709 for (APFloat n : {nan_0123[0], mnan_4567[0], nan_89ab[0], mnan_cdef[0]})
710 for (APFloat f : {f1, f2, zn, zp}) {
711 APFloat res = maximumnum(f, n);
712 EXPECT_FALSE(res.isNaN());
713 EXPECT_TRUE(res.bitwiseIsEqual(f));
714 res = maximumnum(n, f);
715 EXPECT_FALSE(res.isNaN());
716 EXPECT_TRUE(res.bitwiseIsEqual(f));
717 }
718
719 // When NaN vs NaN, we should keep payload/sign of either one.
720 for (auto n1 : {nan_0123, mnan_4567, nan_89ab, mnan_cdef})
721 for (auto n2 : {nan_0123, mnan_4567, nan_89ab, mnan_cdef}) {
722 APFloat res = maximumnum(n1[0], n2[0]);
723 EXPECT_TRUE(res.bitwiseIsEqual(n1[1]) || res.bitwiseIsEqual(n2[1]));
724 EXPECT_FALSE(res.isSignaling());
725 }
726 }
727
728 TEST(APFloatTest, Denormal) {
729 APFloat::roundingMode rdmd = APFloat::rmNearestTiesToEven;
730
731 // Test single precision
732 {
733 const char *MinNormalStr = "1.17549435082228750797e-38";
734 EXPECT_FALSE(APFloat(APFloat::IEEEsingle(), MinNormalStr).isDenormal());
735 EXPECT_FALSE(APFloat(APFloat::IEEEsingle(), 0).isDenormal());
736
737 APFloat Val2(APFloat::IEEEsingle(), 2);
738 APFloat T(APFloat::IEEEsingle(), MinNormalStr);
739 T.divide(Val2, rdmd);
740 EXPECT_TRUE(T.isDenormal());
741 EXPECT_EQ(fcPosSubnormal, T.classify());
742
743
744 const char *NegMinNormalStr = "-1.17549435082228750797e-38";
745 EXPECT_FALSE(APFloat(APFloat::IEEEsingle(), NegMinNormalStr).isDenormal());
746 APFloat NegT(APFloat::IEEEsingle(), NegMinNormalStr);
747 NegT.divide(Val2, rdmd);
748 EXPECT_TRUE(NegT.isDenormal());
749 EXPECT_EQ(fcNegSubnormal, NegT.classify());
750 }
751
752 // Test double precision
753 {
754 const char *MinNormalStr = "2.22507385850720138309e-308";
755 EXPECT_FALSE(APFloat(APFloat::IEEEdouble(), MinNormalStr).isDenormal());
756 EXPECT_FALSE(APFloat(APFloat::IEEEdouble(), 0).isDenormal());
757
758 APFloat Val2(APFloat::IEEEdouble(), 2);
759 APFloat T(APFloat::IEEEdouble(), MinNormalStr);
760 T.divide(Val2, rdmd);
761 EXPECT_TRUE(T.isDenormal());
762 EXPECT_EQ(fcPosSubnormal, T.classify());
763 }
764
765 // Test Intel double-ext
766 {
767 const char *MinNormalStr = "3.36210314311209350626e-4932";
768 EXPECT_FALSE(APFloat(APFloat::x87DoubleExtended(), MinNormalStr).isDenormal());
769 EXPECT_FALSE(APFloat(APFloat::x87DoubleExtended(), 0).isDenormal());
770
771 APFloat Val2(APFloat::x87DoubleExtended(), 2);
772 APFloat T(APFloat::x87DoubleExtended(), MinNormalStr);
773 T.divide(Val2, rdmd);
774 EXPECT_TRUE(T.isDenormal());
775 EXPECT_EQ(fcPosSubnormal, T.classify());
776 }
777
778 // Test quadruple precision
779 {
780 const char *MinNormalStr = "3.36210314311209350626267781732175260e-4932";
781 EXPECT_FALSE(APFloat(APFloat::IEEEquad(), MinNormalStr).isDenormal());
782 EXPECT_FALSE(APFloat(APFloat::IEEEquad(), 0).isDenormal());
783
784 APFloat Val2(APFloat::IEEEquad(), 2);
785 APFloat T(APFloat::IEEEquad(), MinNormalStr);
786 T.divide(Val2, rdmd);
787 EXPECT_TRUE(T.isDenormal());
788 EXPECT_EQ(fcPosSubnormal, T.classify());
789 }
790
791 // Test TF32
792 {
793 const char *MinNormalStr = "1.17549435082228750797e-38";
794 EXPECT_FALSE(APFloat(APFloat::FloatTF32(), MinNormalStr).isDenormal());
795 EXPECT_FALSE(APFloat(APFloat::FloatTF32(), 0).isDenormal());
796
797 APFloat Val2(APFloat::FloatTF32(), 2);
798 APFloat T(APFloat::FloatTF32(), MinNormalStr);
799 T.divide(Val2, rdmd);
800 EXPECT_TRUE(T.isDenormal());
801 EXPECT_EQ(fcPosSubnormal, T.classify());
802
803 const char *NegMinNormalStr = "-1.17549435082228750797e-38";
804 EXPECT_FALSE(APFloat(APFloat::FloatTF32(), NegMinNormalStr).isDenormal());
805 APFloat NegT(APFloat::FloatTF32(), NegMinNormalStr);
806 NegT.divide(Val2, rdmd);
807 EXPECT_TRUE(NegT.isDenormal());
808 EXPECT_EQ(fcNegSubnormal, NegT.classify());
809 }
810 }
811
812 TEST(APFloatTest, IsSmallestNormalized) {
813 for (unsigned I = 0; I != APFloat::S_MaxSemantics + 1; ++I) {
814 const fltSemantics &Semantics =
815 APFloat::EnumToSemantics(static_cast<APFloat::Semantics>(I));
816
817 EXPECT_FALSE(APFloat::getZero(Semantics, false).isSmallestNormalized());
818 EXPECT_FALSE(APFloat::getZero(Semantics, true).isSmallestNormalized());
819
820 if (APFloat::hasNanOrInf(Semantics)) {
821 EXPECT_FALSE(APFloat::getInf(Semantics, false).isSmallestNormalized());
822 EXPECT_FALSE(APFloat::getInf(Semantics, true).isSmallestNormalized());
823
824 EXPECT_FALSE(APFloat::getQNaN(Semantics).isSmallestNormalized());
825 EXPECT_FALSE(APFloat::getSNaN(Semantics).isSmallestNormalized());
826 }
827
828 EXPECT_FALSE(APFloat::getLargest(Semantics).isSmallestNormalized());
829 EXPECT_FALSE(APFloat::getLargest(Semantics, true).isSmallestNormalized());
830
831 EXPECT_FALSE(APFloat::getSmallest(Semantics).isSmallestNormalized());
832 EXPECT_FALSE(APFloat::getSmallest(Semantics, true).isSmallestNormalized());
833
834 EXPECT_FALSE(APFloat::getAllOnesValue(Semantics).isSmallestNormalized());
835
836 APFloat PosSmallestNormalized =
837 APFloat::getSmallestNormalized(Semantics, false);
838 APFloat NegSmallestNormalized =
839 APFloat::getSmallestNormalized(Semantics, true);
840 EXPECT_TRUE(PosSmallestNormalized.isSmallestNormalized());
841 EXPECT_TRUE(NegSmallestNormalized.isSmallestNormalized());
842 EXPECT_EQ(fcPosNormal, PosSmallestNormalized.classify());
843 EXPECT_EQ(fcNegNormal, NegSmallestNormalized.classify());
844
845 for (APFloat *Val : {&PosSmallestNormalized, &NegSmallestNormalized}) {
846 bool OldSign = Val->isNegative();
847
848 // Step down, make sure it's still not smallest normalized.
849 EXPECT_EQ(APFloat::opOK, Val->next(false));
850 EXPECT_EQ(OldSign, Val->isNegative());
851 EXPECT_FALSE(Val->isSmallestNormalized());
852 EXPECT_EQ(OldSign, Val->isNegative());
853
854 // Step back up should restore it to being smallest normalized.
855 EXPECT_EQ(APFloat::opOK, Val->next(true));
856 EXPECT_TRUE(Val->isSmallestNormalized());
857 EXPECT_EQ(OldSign, Val->isNegative());
858
859 // Step beyond should no longer smallest normalized.
860 EXPECT_EQ(APFloat::opOK, Val->next(true));
861 EXPECT_FALSE(Val->isSmallestNormalized());
862 EXPECT_EQ(OldSign, Val->isNegative());
863 }
864 }
865 }
866
867 TEST(APFloatTest, Zero) {
868 EXPECT_EQ(0.0f, APFloat(0.0f).convertToFloat());
869 EXPECT_EQ(-0.0f, APFloat(-0.0f).convertToFloat());
870 EXPECT_TRUE(APFloat(-0.0f).isNegative());
871
872 EXPECT_EQ(0.0, APFloat(0.0).convertToDouble());
873 EXPECT_EQ(-0.0, APFloat(-0.0).convertToDouble());
874 EXPECT_TRUE(APFloat(-0.0).isNegative());
875
876 EXPECT_EQ(fcPosZero, APFloat(0.0).classify());
877 EXPECT_EQ(fcNegZero, APFloat(-0.0).classify());
878 }
879
880 TEST(APFloatTest, DecimalStringsWithoutNullTerminators) {
881 // Make sure that we can parse strings without null terminators.
882 // rdar://14323230.
883 EXPECT_EQ(convertToDoubleFromString(StringRef("0.00", 3)), 0.0);
884 EXPECT_EQ(convertToDoubleFromString(StringRef("0.01", 3)), 0.0);
885 EXPECT_EQ(convertToDoubleFromString(StringRef("0.09", 3)), 0.0);
886 EXPECT_EQ(convertToDoubleFromString(StringRef("0.095", 4)), 0.09);
887 EXPECT_EQ(convertToDoubleFromString(StringRef("0.00e+3", 7)), 0.00);
888 EXPECT_EQ(convertToDoubleFromString(StringRef("0e+3", 4)), 0.00);
889 }
890
891 TEST(APFloatTest, fromZeroDecimalString) {
892 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0").convertToDouble());
893 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0").convertToDouble());
894 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0").convertToDouble());
895
896 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0.").convertToDouble());
897 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0.").convertToDouble());
898 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0.").convertToDouble());
899
900 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), ".0").convertToDouble());
901 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+.0").convertToDouble());
902 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-.0").convertToDouble());
903
904 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0.0").convertToDouble());
905 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0.0").convertToDouble());
906 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0.0").convertToDouble());
907
908 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "00000.").convertToDouble());
909 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+00000.").convertToDouble());
910 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-00000.").convertToDouble());
911
912 EXPECT_EQ(0.0, APFloat(APFloat::IEEEdouble(), ".00000").convertToDouble());
913 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+.00000").convertToDouble());
914 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-.00000").convertToDouble());
915
916 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0000.00000").convertToDouble());
917 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0000.00000").convertToDouble());
918 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0000.00000").convertToDouble());
919 }
920
921 TEST(APFloatTest, fromZeroDecimalSingleExponentString) {
922 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0e1").convertToDouble());
923 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0e1").convertToDouble());
924 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0e1").convertToDouble());
925
926 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0e+1").convertToDouble());
927 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0e+1").convertToDouble());
928 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0e+1").convertToDouble());
929
930 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0e-1").convertToDouble());
931 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0e-1").convertToDouble());
932 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0e-1").convertToDouble());
933
934
935 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0.e1").convertToDouble());
936 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0.e1").convertToDouble());
937 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0.e1").convertToDouble());
938
939 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0.e+1").convertToDouble());
940 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0.e+1").convertToDouble());
941 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0.e+1").convertToDouble());
942
943 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0.e-1").convertToDouble());
944 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0.e-1").convertToDouble());
945 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0.e-1").convertToDouble());
946
947 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), ".0e1").convertToDouble());
948 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+.0e1").convertToDouble());
949 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-.0e1").convertToDouble());
950
951 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), ".0e+1").convertToDouble());
952 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+.0e+1").convertToDouble());
953 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-.0e+1").convertToDouble());
954
955 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), ".0e-1").convertToDouble());
956 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+.0e-1").convertToDouble());
957 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-.0e-1").convertToDouble());
958
959
960 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0.0e1").convertToDouble());
961 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0.0e1").convertToDouble());
962 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0.0e1").convertToDouble());
963
964 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0.0e+1").convertToDouble());
965 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0.0e+1").convertToDouble());
966 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0.0e+1").convertToDouble());
967
968 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0.0e-1").convertToDouble());
969 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0.0e-1").convertToDouble());
970 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0.0e-1").convertToDouble());
971
972
973 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "000.0000e1").convertToDouble());
974 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+000.0000e+1").convertToDouble());
975 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-000.0000e+1").convertToDouble());
976 }
977
978 TEST(APFloatTest, fromZeroDecimalLargeExponentString) {
979 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0e1234").convertToDouble());
980 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0e1234").convertToDouble());
981 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0e1234").convertToDouble());
982
983 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0e+1234").convertToDouble());
984 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0e+1234").convertToDouble());
985 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0e+1234").convertToDouble());
986
987 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0e-1234").convertToDouble());
988 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0e-1234").convertToDouble());
989 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0e-1234").convertToDouble());
990
991 EXPECT_EQ(0.0, APFloat(APFloat::IEEEdouble(), "000.0000e1234").convertToDouble());
992 EXPECT_EQ(0.0, APFloat(APFloat::IEEEdouble(), "000.0000e-1234").convertToDouble());
993
994 EXPECT_EQ(0.0, APFloat(APFloat::IEEEdouble(), StringRef("0e1234" "\0" "2", 6)).convertToDouble());
995 }
996
997 TEST(APFloatTest, fromZeroHexadecimalString) {
998 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x0p1").convertToDouble());
999 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0x0p1").convertToDouble());
1000 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0x0p1").convertToDouble());
1001
1002 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x0p+1").convertToDouble());
1003 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0x0p+1").convertToDouble());
1004 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0x0p+1").convertToDouble());
1005
1006 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x0p-1").convertToDouble());
1007 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0x0p-1").convertToDouble());
1008 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0x0p-1").convertToDouble());
1009
1010
1011 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x0.p1").convertToDouble());
1012 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0x0.p1").convertToDouble());
1013 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0x0.p1").convertToDouble());
1014
1015 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x0.p+1").convertToDouble());
1016 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0x0.p+1").convertToDouble());
1017 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0x0.p+1").convertToDouble());
1018
1019 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x0.p-1").convertToDouble());
1020 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0x0.p-1").convertToDouble());
1021 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0x0.p-1").convertToDouble());
1022
1023
1024 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x.0p1").convertToDouble());
1025 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0x.0p1").convertToDouble());
1026 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0x.0p1").convertToDouble());
1027
1028 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x.0p+1").convertToDouble());
1029 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0x.0p+1").convertToDouble());
1030 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0x.0p+1").convertToDouble());
1031
1032 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x.0p-1").convertToDouble());
1033 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0x.0p-1").convertToDouble());
1034 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0x.0p-1").convertToDouble());
1035
1036
1037 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x0.0p1").convertToDouble());
1038 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0x0.0p1").convertToDouble());
1039 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0x0.0p1").convertToDouble());
1040
1041 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x0.0p+1").convertToDouble());
1042 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0x0.0p+1").convertToDouble());
1043 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0x0.0p+1").convertToDouble());
1044
1045 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x0.0p-1").convertToDouble());
1046 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0x0.0p-1").convertToDouble());
1047 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0x0.0p-1").convertToDouble());
1048
1049
1050 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x00000.p1").convertToDouble());
1051 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x0000.00000p1").convertToDouble());
1052 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x.00000p1").convertToDouble());
1053 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x0.p1").convertToDouble());
1054 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x0p1234").convertToDouble());
1055 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0x0p1234").convertToDouble());
1056 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x00000.p1234").convertToDouble());
1057 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x0000.00000p1234").convertToDouble());
1058 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x.00000p1234").convertToDouble());
1059 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x0.p1234").convertToDouble());
1060 }
1061
1062 TEST(APFloatTest, fromDecimalString) {
1063 EXPECT_EQ(1.0, APFloat(APFloat::IEEEdouble(), "1").convertToDouble());
1064 EXPECT_EQ(2.0, APFloat(APFloat::IEEEdouble(), "2.").convertToDouble());
1065 EXPECT_EQ(0.5, APFloat(APFloat::IEEEdouble(), ".5").convertToDouble());
1066 EXPECT_EQ(1.0, APFloat(APFloat::IEEEdouble(), "1.0").convertToDouble());
1067 EXPECT_EQ(-2.0, APFloat(APFloat::IEEEdouble(), "-2").convertToDouble());
1068 EXPECT_EQ(-4.0, APFloat(APFloat::IEEEdouble(), "-4.").convertToDouble());
1069 EXPECT_EQ(-0.5, APFloat(APFloat::IEEEdouble(), "-.5").convertToDouble());
1070 EXPECT_EQ(-1.5, APFloat(APFloat::IEEEdouble(), "-1.5").convertToDouble());
1071 EXPECT_EQ(1.25e12, APFloat(APFloat::IEEEdouble(), "1.25e12").convertToDouble());
1072 EXPECT_EQ(1.25e+12, APFloat(APFloat::IEEEdouble(), "1.25e+12").convertToDouble());
1073 EXPECT_EQ(1.25e-12, APFloat(APFloat::IEEEdouble(), "1.25e-12").convertToDouble());
1074 EXPECT_EQ(1024.0, APFloat(APFloat::IEEEdouble(), "1024.").convertToDouble());
1075 EXPECT_EQ(1024.05, APFloat(APFloat::IEEEdouble(), "1024.05000").convertToDouble());
1076 EXPECT_EQ(0.05, APFloat(APFloat::IEEEdouble(), ".05000").convertToDouble());
1077 EXPECT_EQ(2.0, APFloat(APFloat::IEEEdouble(), "2.").convertToDouble());
1078 EXPECT_EQ(2.0e2, APFloat(APFloat::IEEEdouble(), "2.e2").convertToDouble());
1079 EXPECT_EQ(2.0e+2, APFloat(APFloat::IEEEdouble(), "2.e+2").convertToDouble());
1080 EXPECT_EQ(2.0e-2, APFloat(APFloat::IEEEdouble(), "2.e-2").convertToDouble());
1081 EXPECT_EQ(2.05e2, APFloat(APFloat::IEEEdouble(), "002.05000e2").convertToDouble());
1082 EXPECT_EQ(2.05e+2, APFloat(APFloat::IEEEdouble(), "002.05000e+2").convertToDouble());
1083 EXPECT_EQ(2.05e-2, APFloat(APFloat::IEEEdouble(), "002.05000e-2").convertToDouble());
1084 EXPECT_EQ(2.05e12, APFloat(APFloat::IEEEdouble(), "002.05000e12").convertToDouble());
1085 EXPECT_EQ(2.05e+12, APFloat(APFloat::IEEEdouble(), "002.05000e+12").convertToDouble());
1086 EXPECT_EQ(2.05e-12, APFloat(APFloat::IEEEdouble(), "002.05000e-12").convertToDouble());
1087
1088 EXPECT_EQ(1.0, APFloat(APFloat::IEEEdouble(), "1e").convertToDouble());
1089 EXPECT_EQ(1.0, APFloat(APFloat::IEEEdouble(), "+1e").convertToDouble());
1090 EXPECT_EQ(-1.0, APFloat(APFloat::IEEEdouble(), "-1e").convertToDouble());
1091
1092 EXPECT_EQ(1.0, APFloat(APFloat::IEEEdouble(), "1.e").convertToDouble());
1093 EXPECT_EQ(1.0, APFloat(APFloat::IEEEdouble(), "+1.e").convertToDouble());
1094 EXPECT_EQ(-1.0, APFloat(APFloat::IEEEdouble(), "-1.e").convertToDouble());
1095
1096 EXPECT_EQ(0.1, APFloat(APFloat::IEEEdouble(), ".1e").convertToDouble());
1097 EXPECT_EQ(0.1, APFloat(APFloat::IEEEdouble(), "+.1e").convertToDouble());
1098 EXPECT_EQ(-0.1, APFloat(APFloat::IEEEdouble(), "-.1e").convertToDouble());
1099
1100 EXPECT_EQ(1.1, APFloat(APFloat::IEEEdouble(), "1.1e").convertToDouble());
1101 EXPECT_EQ(1.1, APFloat(APFloat::IEEEdouble(), "+1.1e").convertToDouble());
1102 EXPECT_EQ(-1.1, APFloat(APFloat::IEEEdouble(), "-1.1e").convertToDouble());
1103
1104 EXPECT_EQ(1.0, APFloat(APFloat::IEEEdouble(), "1e+").convertToDouble());
1105 EXPECT_EQ(1.0, APFloat(APFloat::IEEEdouble(), "1e-").convertToDouble());
1106
1107 EXPECT_EQ(0.1, APFloat(APFloat::IEEEdouble(), ".1e").convertToDouble());
1108 EXPECT_EQ(0.1, APFloat(APFloat::IEEEdouble(), ".1e+").convertToDouble());
1109 EXPECT_EQ(0.1, APFloat(APFloat::IEEEdouble(), ".1e-").convertToDouble());
1110
1111 EXPECT_EQ(1.0, APFloat(APFloat::IEEEdouble(), "1.0e").convertToDouble());
1112 EXPECT_EQ(1.0, APFloat(APFloat::IEEEdouble(), "1.0e+").convertToDouble());
1113 EXPECT_EQ(1.0, APFloat(APFloat::IEEEdouble(), "1.0e-").convertToDouble());
1114
1115 // These are "carefully selected" to overflow the fast log-base
1116 // calculations in APFloat.cpp
1117 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "99e99999").isInfinity());
1118 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "-99e99999").isInfinity());
1119 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "1e-99999").isPosZero());
1120 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "-1e-99999").isNegZero());
1121
1122 EXPECT_EQ(2.71828, convertToDoubleFromString("2.71828"));
1123 }
1124
1125 TEST(APFloatTest, fromStringSpecials) {
1126 const fltSemantics &Sem = APFloat::IEEEdouble();
1127 const unsigned Precision = 53;
1128 const unsigned PayloadBits = Precision - 2;
1129 uint64_t PayloadMask = (uint64_t(1) << PayloadBits) - uint64_t(1);
1130
1131 uint64_t NaNPayloads[] = {
1132 0,
1133 1,
1134 123,
1135 0xDEADBEEF,
1136 uint64_t(-2),
1137 uint64_t(1) << PayloadBits, // overflow bit
1138 uint64_t(1) << (PayloadBits - 1), // signaling bit
1139 uint64_t(1) << (PayloadBits - 2) // highest possible bit
1140 };
1141
1142 // Convert payload integer to decimal string representation.
1143 std::string NaNPayloadDecStrings[std::size(NaNPayloads)];
1144 for (size_t I = 0; I < std::size(NaNPayloads); ++I)
1145 NaNPayloadDecStrings[I] = utostr(NaNPayloads[I]);
1146
1147 // Convert payload integer to hexadecimal string representation.
1148 std::string NaNPayloadHexStrings[std::size(NaNPayloads)];
1149 for (size_t I = 0; I < std::size(NaNPayloads); ++I)
1150 NaNPayloadHexStrings[I] = "0x" + utohexstr(NaNPayloads[I]);
1151
1152 // Fix payloads to expected result.
1153 for (uint64_t &Payload : NaNPayloads)
1154 Payload &= PayloadMask;
1155
1156 // Signaling NaN must have a non-zero payload. In case a zero payload is
1157 // requested, a default arbitrary payload is set instead. Save this payload
1158 // for testing.
1159 const uint64_t SNaNDefaultPayload =
1160 APFloat::getSNaN(Sem).bitcastToAPInt().getZExtValue() & PayloadMask;
1161
1162 // Negative sign prefix (or none - for positive).
1163 const char Signs[] = {0, '-'};
1164
1165 // "Signaling" prefix (or none - for "Quiet").
1166 const char NaNTypes[] = {0, 's', 'S'};
1167
1168 const StringRef NaNStrings[] = {"nan", "NaN"};
1169 for (StringRef NaNStr : NaNStrings)
1170 for (char TypeChar : NaNTypes) {
1171 bool Signaling = (TypeChar == 's' || TypeChar == 'S');
1172
1173 for (size_t J = 0; J < std::size(NaNPayloads); ++J) {
1174 uint64_t Payload = (Signaling && !NaNPayloads[J]) ? SNaNDefaultPayload
1175 : NaNPayloads[J];
1176 std::string &PayloadDec = NaNPayloadDecStrings[J];
1177 std::string &PayloadHex = NaNPayloadHexStrings[J];
1178
1179 for (char SignChar : Signs) {
1180 bool Negative = (SignChar == '-');
1181
1182 std::string TestStrings[5];
1183 size_t NumTestStrings = 0;
1184
1185 std::string Prefix;
1186 if (SignChar)
1187 Prefix += SignChar;
1188 if (TypeChar)
1189 Prefix += TypeChar;
1190 Prefix += NaNStr;
1191
1192 // Test without any paylod.
1193 if (!Payload)
1194 TestStrings[NumTestStrings++] = Prefix;
1195
1196 // Test with the payload as a suffix.
1197 TestStrings[NumTestStrings++] = Prefix + PayloadDec;
1198 TestStrings[NumTestStrings++] = Prefix + PayloadHex;
1199
1200 // Test with the payload inside parentheses.
1201 TestStrings[NumTestStrings++] = Prefix + '(' + PayloadDec + ')';
1202 TestStrings[NumTestStrings++] = Prefix + '(' + PayloadHex + ')';
1203
1204 for (size_t K = 0; K < NumTestStrings; ++K) {
1205 StringRef TestStr = TestStrings[K];
1206
1207 APFloat F(Sem);
1208 bool HasError = !F.convertFromString(
1209 TestStr, llvm::APFloat::rmNearestTiesToEven);
1210 EXPECT_FALSE(HasError);
1211 EXPECT_TRUE(F.isNaN());
1212 EXPECT_EQ(Signaling, F.isSignaling());
1213 EXPECT_EQ(Negative, F.isNegative());
1214 uint64_t PayloadResult =
1215 F.bitcastToAPInt().getZExtValue() & PayloadMask;
1216 EXPECT_EQ(Payload, PayloadResult);
1217 }
1218 }
1219 }
1220 }
1221
1222 const StringRef InfStrings[] = {"inf", "INFINITY", "+Inf",
1223 "-inf", "-INFINITY", "-Inf"};
1224 for (StringRef InfStr : InfStrings) {
1225 bool Negative = InfStr.front() == '-';
1226
1227 APFloat F(Sem);
1228 bool HasError =
1229 !F.convertFromString(InfStr, llvm::APFloat::rmNearestTiesToEven);
1230 EXPECT_FALSE(HasError);
1231 EXPECT_TRUE(F.isInfinity());
1232 EXPECT_EQ(Negative, F.isNegative());
1233 uint64_t PayloadResult = F.bitcastToAPInt().getZExtValue() & PayloadMask;
1234 EXPECT_EQ(UINT64_C(0), PayloadResult);
1235 }
1236 }
1237
1238 TEST(APFloatTest, fromToStringSpecials) {
1239 auto expects = [] (const char *first, const char *second) {
1240 std::string roundtrip = convertToString(convertToDoubleFromString(second), 0, 3);
1241 EXPECT_STREQ(first, roundtrip.c_str());
1242 };
1243 expects("+Inf", "+Inf");
1244 expects("+Inf", "INFINITY");
1245 expects("+Inf", "inf");
1246 expects("-Inf", "-Inf");
1247 expects("-Inf", "-INFINITY");
1248 expects("-Inf", "-inf");
1249 expects("NaN", "NaN");
1250 expects("NaN", "nan");
1251 expects("NaN", "-NaN");
1252 expects("NaN", "-nan");
1253 }
1254
1255 TEST(APFloatTest, fromHexadecimalString) {
1256 EXPECT_EQ( 1.0, APFloat(APFloat::IEEEdouble(), "0x1p0").convertToDouble());
1257 EXPECT_EQ(+1.0, APFloat(APFloat::IEEEdouble(), "+0x1p0").convertToDouble());
1258 EXPECT_EQ(-1.0, APFloat(APFloat::IEEEdouble(), "-0x1p0").convertToDouble());
1259
1260 EXPECT_EQ( 1.0, APFloat(APFloat::IEEEdouble(), "0x1p+0").convertToDouble());
1261 EXPECT_EQ(+1.0, APFloat(APFloat::IEEEdouble(), "+0x1p+0").convertToDouble());
1262 EXPECT_EQ(-1.0, APFloat(APFloat::IEEEdouble(), "-0x1p+0").convertToDouble());
1263
1264 EXPECT_EQ( 1.0, APFloat(APFloat::IEEEdouble(), "0x1p-0").convertToDouble());
1265 EXPECT_EQ(+1.0, APFloat(APFloat::IEEEdouble(), "+0x1p-0").convertToDouble());
1266 EXPECT_EQ(-1.0, APFloat(APFloat::IEEEdouble(), "-0x1p-0").convertToDouble());
1267
1268
1269 EXPECT_EQ( 2.0, APFloat(APFloat::IEEEdouble(), "0x1p1").convertToDouble());
1270 EXPECT_EQ(+2.0, APFloat(APFloat::IEEEdouble(), "+0x1p1").convertToDouble());
1271 EXPECT_EQ(-2.0, APFloat(APFloat::IEEEdouble(), "-0x1p1").convertToDouble());
1272
1273 EXPECT_EQ( 2.0, APFloat(APFloat::IEEEdouble(), "0x1p+1").convertToDouble());
1274 EXPECT_EQ(+2.0, APFloat(APFloat::IEEEdouble(), "+0x1p+1").convertToDouble());
1275 EXPECT_EQ(-2.0, APFloat(APFloat::IEEEdouble(), "-0x1p+1").convertToDouble());
1276
1277 EXPECT_EQ( 0.5, APFloat(APFloat::IEEEdouble(), "0x1p-1").convertToDouble());
1278 EXPECT_EQ(+0.5, APFloat(APFloat::IEEEdouble(), "+0x1p-1").convertToDouble());
1279 EXPECT_EQ(-0.5, APFloat(APFloat::IEEEdouble(), "-0x1p-1").convertToDouble());
1280
1281
1282 EXPECT_EQ( 3.0, APFloat(APFloat::IEEEdouble(), "0x1.8p1").convertToDouble());
1283 EXPECT_EQ(+3.0, APFloat(APFloat::IEEEdouble(), "+0x1.8p1").convertToDouble());
1284 EXPECT_EQ(-3.0, APFloat(APFloat::IEEEdouble(), "-0x1.8p1").convertToDouble());
1285
1286 EXPECT_EQ( 3.0, APFloat(APFloat::IEEEdouble(), "0x1.8p+1").convertToDouble());
1287 EXPECT_EQ(+3.0, APFloat(APFloat::IEEEdouble(), "+0x1.8p+1").convertToDouble());
1288 EXPECT_EQ(-3.0, APFloat(APFloat::IEEEdouble(), "-0x1.8p+1").convertToDouble());
1289
1290 EXPECT_EQ( 0.75, APFloat(APFloat::IEEEdouble(), "0x1.8p-1").convertToDouble());
1291 EXPECT_EQ(+0.75, APFloat(APFloat::IEEEdouble(), "+0x1.8p-1").convertToDouble());
1292 EXPECT_EQ(-0.75, APFloat(APFloat::IEEEdouble(), "-0x1.8p-1").convertToDouble());
1293
1294
1295 EXPECT_EQ( 8192.0, APFloat(APFloat::IEEEdouble(), "0x1000.000p1").convertToDouble());
1296 EXPECT_EQ(+8192.0, APFloat(APFloat::IEEEdouble(), "+0x1000.000p1").convertToDouble());
1297 EXPECT_EQ(-8192.0, APFloat(APFloat::IEEEdouble(), "-0x1000.000p1").convertToDouble());
1298
1299 EXPECT_EQ( 8192.0, APFloat(APFloat::IEEEdouble(), "0x1000.000p+1").convertToDouble());
1300 EXPECT_EQ(+8192.0, APFloat(APFloat::IEEEdouble(), "+0x1000.000p+1").convertToDouble());
1301 EXPECT_EQ(-8192.0, APFloat(APFloat::IEEEdouble(), "-0x1000.000p+1").convertToDouble());
1302
1303 EXPECT_EQ( 2048.0, APFloat(APFloat::IEEEdouble(), "0x1000.000p-1").convertToDouble());
1304 EXPECT_EQ(+2048.0, APFloat(APFloat::IEEEdouble(), "+0x1000.000p-1").convertToDouble());
1305 EXPECT_EQ(-2048.0, APFloat(APFloat::IEEEdouble(), "-0x1000.000p-1").convertToDouble());
1306
1307
1308 EXPECT_EQ( 8192.0, APFloat(APFloat::IEEEdouble(), "0x1000p1").convertToDouble());
1309 EXPECT_EQ(+8192.0, APFloat(APFloat::IEEEdouble(), "+0x1000p1").convertToDouble());
1310 EXPECT_EQ(-8192.0, APFloat(APFloat::IEEEdouble(), "-0x1000p1").convertToDouble());
1311
1312 EXPECT_EQ( 8192.0, APFloat(APFloat::IEEEdouble(), "0x1000p+1").convertToDouble());
1313 EXPECT_EQ(+8192.0, APFloat(APFloat::IEEEdouble(), "+0x1000p+1").convertToDouble());
1314 EXPECT_EQ(-8192.0, APFloat(APFloat::IEEEdouble(), "-0x1000p+1").convertToDouble());
1315
1316 EXPECT_EQ( 2048.0, APFloat(APFloat::IEEEdouble(), "0x1000p-1").convertToDouble());
1317 EXPECT_EQ(+2048.0, APFloat(APFloat::IEEEdouble(), "+0x1000p-1").convertToDouble());
1318 EXPECT_EQ(-2048.0, APFloat(APFloat::IEEEdouble(), "-0x1000p-1").convertToDouble());
1319
1320
1321 EXPECT_EQ( 16384.0, APFloat(APFloat::IEEEdouble(), "0x10p10").convertToDouble());
1322 EXPECT_EQ(+16384.0, APFloat(APFloat::IEEEdouble(), "+0x10p10").convertToDouble());
1323 EXPECT_EQ(-16384.0, APFloat(APFloat::IEEEdouble(), "-0x10p10").convertToDouble());
1324
1325 EXPECT_EQ( 16384.0, APFloat(APFloat::IEEEdouble(), "0x10p+10").convertToDouble());
1326 EXPECT_EQ(+16384.0, APFloat(APFloat::IEEEdouble(), "+0x10p+10").convertToDouble());
1327 EXPECT_EQ(-16384.0, APFloat(APFloat::IEEEdouble(), "-0x10p+10").convertToDouble());
1328
1329 EXPECT_EQ( 0.015625, APFloat(APFloat::IEEEdouble(), "0x10p-10").convertToDouble());
1330 EXPECT_EQ(+0.015625, APFloat(APFloat::IEEEdouble(), "+0x10p-10").convertToDouble());
1331 EXPECT_EQ(-0.015625, APFloat(APFloat::IEEEdouble(), "-0x10p-10").convertToDouble());
1332
1333 EXPECT_EQ(1.0625, APFloat(APFloat::IEEEdouble(), "0x1.1p0").convertToDouble());
1334 EXPECT_EQ(1.0, APFloat(APFloat::IEEEdouble(), "0x1p0").convertToDouble());
1335
1336 EXPECT_EQ(convertToDoubleFromString("0x1p-150"),
1337 convertToDoubleFromString("+0x800000000000000001.p-221"));
1338 EXPECT_EQ(2251799813685248.5,
1339 convertToDoubleFromString("0x80000000000004000000.010p-28"));
1340 }
1341
1342 TEST(APFloatTest, toString) {
1343 ASSERT_EQ("10", convertToString(10.0, 6, 3));
1344 ASSERT_EQ("1.0E+1", convertToString(10.0, 6, 0));
1345 ASSERT_EQ("10100", convertToString(1.01E+4, 5, 2));
1346 ASSERT_EQ("1.01E+4", convertToString(1.01E+4, 4, 2));
1347 ASSERT_EQ("1.01E+4", convertToString(1.01E+4, 5, 1));
1348 ASSERT_EQ("0.0101", convertToString(1.01E-2, 5, 2));
1349 ASSERT_EQ("0.0101", convertToString(1.01E-2, 4, 2));
1350 ASSERT_EQ("1.01E-2", convertToString(1.01E-2, 5, 1));
1351 ASSERT_EQ("0.78539816339744828", convertToString(0.78539816339744830961, 0, 3));
1352 ASSERT_EQ("4.9406564584124654E-324", convertToString(4.9406564584124654e-324, 0, 3));
1353 ASSERT_EQ("873.18340000000001", convertToString(873.1834, 0, 1));
1354 ASSERT_EQ("8.7318340000000001E+2", convertToString(873.1834, 0, 0));
1355 ASSERT_EQ("1.7976931348623157E+308", convertToString(1.7976931348623157E+308, 0, 0));
1356 ASSERT_EQ("10", convertToString(10.0, 6, 3, false));
1357 ASSERT_EQ("1.000000e+01", convertToString(10.0, 6, 0, false));
1358 ASSERT_EQ("10100", convertToString(1.01E+4, 5, 2, false));
1359 ASSERT_EQ("1.0100e+04", convertToString(1.01E+4, 4, 2, false));
1360 ASSERT_EQ("1.01000e+04", convertToString(1.01E+4, 5, 1, false));
1361 ASSERT_EQ("0.0101", convertToString(1.01E-2, 5, 2, false));
1362 ASSERT_EQ("0.0101", convertToString(1.01E-2, 4, 2, false));
1363 ASSERT_EQ("1.01000e-02", convertToString(1.01E-2, 5, 1, false));
1364 ASSERT_EQ("0.78539816339744828",
1365 convertToString(0.78539816339744830961, 0, 3, false));
1366 ASSERT_EQ("4.94065645841246540e-324",
1367 convertToString(4.9406564584124654e-324, 0, 3, false));
1368 ASSERT_EQ("873.18340000000001", convertToString(873.1834, 0, 1, false));
1369 ASSERT_EQ("8.73183400000000010e+02", convertToString(873.1834, 0, 0, false));
1370 ASSERT_EQ("1.79769313486231570e+308",
1371 convertToString(1.7976931348623157E+308, 0, 0, false));
1372
1373 {
1374 SmallString<64> Str;
1375 APFloat UnnormalZero(APFloat::x87DoubleExtended(), APInt(80, {0, 1}));
1376 UnnormalZero.toString(Str);
1377 ASSERT_EQ("NaN", Str);
1378 }
1379 }
1380
1381 TEST(APFloatTest, toInteger) {
1382 bool isExact = false;
1383 APSInt result(5, /*isUnsigned=*/true);
1384
1385 EXPECT_EQ(APFloat::opOK,
1386 APFloat(APFloat::IEEEdouble(), "10")
1387 .convertToInteger(result, APFloat::rmTowardZero, &isExact));
1388 EXPECT_TRUE(isExact);
1389 EXPECT_EQ(APSInt(APInt(5, 10), true), result);
1390
1391 EXPECT_EQ(APFloat::opInvalidOp,
1392 APFloat(APFloat::IEEEdouble(), "-10")
1393 .convertToInteger(result, APFloat::rmTowardZero, &isExact));
1394 EXPECT_FALSE(isExact);
1395 EXPECT_EQ(APSInt::getMinValue(5, true), result);
1396
1397 EXPECT_EQ(APFloat::opInvalidOp,
1398 APFloat(APFloat::IEEEdouble(), "32")
1399 .convertToInteger(result, APFloat::rmTowardZero, &isExact));
1400 EXPECT_FALSE(isExact);
1401 EXPECT_EQ(APSInt::getMaxValue(5, true), result);
1402
1403 EXPECT_EQ(APFloat::opInexact,
1404 APFloat(APFloat::IEEEdouble(), "7.9")
1405 .convertToInteger(result, APFloat::rmTowardZero, &isExact));
1406 EXPECT_FALSE(isExact);
1407 EXPECT_EQ(APSInt(APInt(5, 7), true), result);
1408
1409 result.setIsUnsigned(false);
1410 EXPECT_EQ(APFloat::opOK,
1411 APFloat(APFloat::IEEEdouble(), "-10")
1412 .convertToInteger(result, APFloat::rmTowardZero, &isExact));
1413 EXPECT_TRUE(isExact);
1414 EXPECT_EQ(APSInt(APInt(5, -10, true), false), result);
1415
1416 EXPECT_EQ(APFloat::opInvalidOp,
1417 APFloat(APFloat::IEEEdouble(), "-17")
1418 .convertToInteger(result, APFloat::rmTowardZero, &isExact));
1419 EXPECT_FALSE(isExact);
1420 EXPECT_EQ(APSInt::getMinValue(5, false), result);
1421
1422 EXPECT_EQ(APFloat::opInvalidOp,
1423 APFloat(APFloat::IEEEdouble(), "16")
1424 .convertToInteger(result, APFloat::rmTowardZero, &isExact));
1425 EXPECT_FALSE(isExact);
1426 EXPECT_EQ(APSInt::getMaxValue(5, false), result);
1427 }
1428
1429 static APInt nanbitsFromAPInt(const fltSemantics &Sem, bool SNaN, bool Negative,
1430 uint64_t payload) {
1431 APInt appayload(64, payload);
1432 if (SNaN)
1433 return APFloat::getSNaN(Sem, Negative, &appayload).bitcastToAPInt();
1434 else
1435 return APFloat::getQNaN(Sem, Negative, &appayload).bitcastToAPInt();
1436 }
1437
1438 TEST(APFloatTest, makeNaN) {
1439 const struct {
1440 uint64_t expected;
1441 const fltSemantics &semantics;
1442 bool SNaN;
1443 bool Negative;
1444 uint64_t payload;
1445 } tests[] = {
1446 // clang-format off
1447 /* expected semantics SNaN Neg payload */
1448 { 0x7fc00000ULL, APFloat::IEEEsingle(), false, false, 0x00000000ULL },
1449 { 0xffc00000ULL, APFloat::IEEEsingle(), false, true, 0x00000000ULL },
1450 { 0x7fc0ae72ULL, APFloat::IEEEsingle(), false, false, 0x0000ae72ULL },
1451 { 0x7fffae72ULL, APFloat::IEEEsingle(), false, false, 0xffffae72ULL },
1452 { 0x7fdaae72ULL, APFloat::IEEEsingle(), false, false, 0x00daae72ULL },
1453 { 0x7fa00000ULL, APFloat::IEEEsingle(), true, false, 0x00000000ULL },
1454 { 0xffa00000ULL, APFloat::IEEEsingle(), true, true, 0x00000000ULL },
1455 { 0x7f80ae72ULL, APFloat::IEEEsingle(), true, false, 0x0000ae72ULL },
1456 { 0x7fbfae72ULL, APFloat::IEEEsingle(), true, false, 0xffffae72ULL },
1457 { 0x7f9aae72ULL, APFloat::IEEEsingle(), true, false, 0x001aae72ULL },
1458 { 0x7ff8000000000000ULL, APFloat::IEEEdouble(), false, false, 0x0000000000000000ULL },
1459 { 0xfff8000000000000ULL, APFloat::IEEEdouble(), false, true, 0x0000000000000000ULL },
1460 { 0x7ff800000000ae72ULL, APFloat::IEEEdouble(), false, false, 0x000000000000ae72ULL },
1461 { 0x7fffffffffffae72ULL, APFloat::IEEEdouble(), false, false, 0xffffffffffffae72ULL },
1462 { 0x7ffdaaaaaaaaae72ULL, APFloat::IEEEdouble(), false, false, 0x000daaaaaaaaae72ULL },
1463 { 0x7ff4000000000000ULL, APFloat::IEEEdouble(), true, false, 0x0000000000000000ULL },
1464 { 0xfff4000000000000ULL, APFloat::IEEEdouble(), true, true, 0x0000000000000000ULL },
1465 { 0x7ff000000000ae72ULL, APFloat::IEEEdouble(), true, false, 0x000000000000ae72ULL },
1466 { 0x7ff7ffffffffae72ULL, APFloat::IEEEdouble(), true, false, 0xffffffffffffae72ULL },
1467 { 0x7ff1aaaaaaaaae72ULL, APFloat::IEEEdouble(), true, false, 0x0001aaaaaaaaae72ULL },
1468 { 0x80ULL, APFloat::Float8E5M2FNUZ(), false, false, 0xaaULL },
1469 { 0x80ULL, APFloat::Float8E5M2FNUZ(), false, true, 0xaaULL },
1470 { 0x80ULL, APFloat::Float8E5M2FNUZ(), true, false, 0xaaULL },
1471 { 0x80ULL, APFloat::Float8E5M2FNUZ(), true, true, 0xaaULL },
1472 { 0x80ULL, APFloat::Float8E4M3FNUZ(), false, false, 0xaaULL },
1473 { 0x80ULL, APFloat::Float8E4M3FNUZ(), false, true, 0xaaULL },
1474 { 0x80ULL, APFloat::Float8E4M3FNUZ(), true, false, 0xaaULL },
1475 { 0x80ULL, APFloat::Float8E4M3FNUZ(), true, true, 0xaaULL },
1476 { 0x80ULL, APFloat::Float8E4M3B11FNUZ(), false, false, 0xaaULL },
1477 { 0x80ULL, APFloat::Float8E4M3B11FNUZ(), false, true, 0xaaULL },
1478 { 0x80ULL, APFloat::Float8E4M3B11FNUZ(), true, false, 0xaaULL },
1479 { 0x80ULL, APFloat::Float8E4M3B11FNUZ(), true, true, 0xaaULL },
1480 { 0x3fe00ULL, APFloat::FloatTF32(), false, false, 0x00000000ULL },
1481 { 0x7fe00ULL, APFloat::FloatTF32(), false, true, 0x00000000ULL },
1482 { 0x3feaaULL, APFloat::FloatTF32(), false, false, 0xaaULL },
1483 { 0x3ffaaULL, APFloat::FloatTF32(), false, false, 0xdaaULL },
1484 { 0x3ffaaULL, APFloat::FloatTF32(), false, false, 0xfdaaULL },
1485 { 0x3fd00ULL, APFloat::FloatTF32(), true, false, 0x00000000ULL },
1486 { 0x7fd00ULL, APFloat::FloatTF32(), true, true, 0x00000000ULL },
1487 { 0x3fcaaULL, APFloat::FloatTF32(), true, false, 0xaaULL },
1488 { 0x3fdaaULL, APFloat::FloatTF32(), true, false, 0xfaaULL },
1489 { 0x3fdaaULL, APFloat::FloatTF32(), true, false, 0x1aaULL },
1490 // clang-format on
1491 };
1492
1493 for (const auto &t : tests) {
1494 ASSERT_EQ(t.expected, nanbitsFromAPInt(t.semantics, t.SNaN, t.Negative, t.payload));
1495 }
1496 }
1497
1498 #ifdef GTEST_HAS_DEATH_TEST
1499 #ifndef NDEBUG
1500 TEST(APFloatTest, SemanticsDeath) {
1501 EXPECT_DEATH(APFloat(APFloat::IEEEquad(), 0).convertToDouble(),
1502 "Float semantics is not representable by IEEEdouble");
1503 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), 0).convertToFloat(),
1504 "Float semantics is not representable by IEEEsingle");
1505 }
1506 #endif
1507 #endif
1508
1509 TEST(APFloatTest, StringDecimalError) {
1510 EXPECT_EQ("Invalid string length", convertToErrorFromString(""));
1511 EXPECT_EQ("String has no digits", convertToErrorFromString("+"));
1512 EXPECT_EQ("String has no digits", convertToErrorFromString("-"));
1513
1514 EXPECT_EQ("Invalid character in significand", convertToErrorFromString(StringRef("\0", 1)));
1515 EXPECT_EQ("Invalid character in significand", convertToErrorFromString(StringRef("1\0", 2)));
1516 EXPECT_EQ("Invalid character in significand", convertToErrorFromString(StringRef("1" "\0" "2", 3)));
1517 EXPECT_EQ("Invalid character in significand", convertToErrorFromString(StringRef("1" "\0" "2e1", 5)));
1518 EXPECT_EQ("Invalid character in exponent", convertToErrorFromString(StringRef("1e\0", 3)));
1519 EXPECT_EQ("Invalid character in exponent", convertToErrorFromString(StringRef("1e1\0", 4)));
1520 EXPECT_EQ("Invalid character in exponent", convertToErrorFromString(StringRef("1e1" "\0" "2", 5)));
1521
1522 EXPECT_EQ("Invalid character in significand", convertToErrorFromString("1.0f"));
1523
1524 EXPECT_EQ("String contains multiple dots", convertToErrorFromString(".."));
1525 EXPECT_EQ("String contains multiple dots", convertToErrorFromString("..0"));
1526 EXPECT_EQ("String contains multiple dots", convertToErrorFromString("1.0.0"));
1527 }
1528
1529 TEST(APFloatTest, StringDecimalSignificandError) {
1530 EXPECT_EQ("Significand has no digits", convertToErrorFromString( "."));
1531 EXPECT_EQ("Significand has no digits", convertToErrorFromString("+."));
1532 EXPECT_EQ("Significand has no digits", convertToErrorFromString("-."));
1533
1534
1535 EXPECT_EQ("Significand has no digits", convertToErrorFromString( "e"));
1536 EXPECT_EQ("Significand has no digits", convertToErrorFromString("+e"));
1537 EXPECT_EQ("Significand has no digits", convertToErrorFromString("-e"));
1538
1539 EXPECT_EQ("Significand has no digits", convertToErrorFromString( "e1"));
1540 EXPECT_EQ("Significand has no digits", convertToErrorFromString("+e1"));
1541 EXPECT_EQ("Significand has no digits", convertToErrorFromString("-e1"));
1542
1543 EXPECT_EQ("Significand has no digits", convertToErrorFromString( ".e1"));
1544 EXPECT_EQ("Significand has no digits", convertToErrorFromString("+.e1"));
1545 EXPECT_EQ("Significand has no digits", convertToErrorFromString("-.e1"));
1546
1547
1548 EXPECT_EQ("Significand has no digits", convertToErrorFromString( ".e"));
1549 EXPECT_EQ("Significand has no digits", convertToErrorFromString("+.e"));
1550 EXPECT_EQ("Significand has no digits", convertToErrorFromString("-.e"));
1551 }
1552
1553 TEST(APFloatTest, StringHexadecimalError) {
1554 EXPECT_EQ("Invalid string", convertToErrorFromString( "0x"));
1555 EXPECT_EQ("Invalid string", convertToErrorFromString("+0x"));
1556 EXPECT_EQ("Invalid string", convertToErrorFromString("-0x"));
1557
1558 EXPECT_EQ("Hex strings require an exponent", convertToErrorFromString( "0x0"));
1559 EXPECT_EQ("Hex strings require an exponent", convertToErrorFromString("+0x0"));
1560 EXPECT_EQ("Hex strings require an exponent", convertToErrorFromString("-0x0"));
1561
1562 EXPECT_EQ("Hex strings require an exponent", convertToErrorFromString( "0x0."));
1563 EXPECT_EQ("Hex strings require an exponent", convertToErrorFromString("+0x0."));
1564 EXPECT_EQ("Hex strings require an exponent", convertToErrorFromString("-0x0."));
1565
1566 EXPECT_EQ("Hex strings require an exponent", convertToErrorFromString( "0x.0"));
1567 EXPECT_EQ("Hex strings require an exponent", convertToErrorFromString("+0x.0"));
1568 EXPECT_EQ("Hex strings require an exponent", convertToErrorFromString("-0x.0"));
1569
1570 EXPECT_EQ("Hex strings require an exponent", convertToErrorFromString( "0x0.0"));
1571 EXPECT_EQ("Hex strings require an exponent", convertToErrorFromString("+0x0.0"));
1572 EXPECT_EQ("Hex strings require an exponent", convertToErrorFromString("-0x0.0"));
1573
1574 EXPECT_EQ("Invalid character in significand", convertToErrorFromString(StringRef("0x\0", 3)));
1575 EXPECT_EQ("Invalid character in significand", convertToErrorFromString(StringRef("0x1\0", 4)));
1576 EXPECT_EQ("Invalid character in significand", convertToErrorFromString(StringRef("0x1" "\0" "2", 5)));
1577 EXPECT_EQ("Invalid character in significand", convertToErrorFromString(StringRef("0x1" "\0" "2p1", 7)));
1578 EXPECT_EQ("Invalid character in exponent", convertToErrorFromString(StringRef("0x1p\0", 5)));
1579 EXPECT_EQ("Invalid character in exponent", convertToErrorFromString(StringRef("0x1p1\0", 6)));
1580 EXPECT_EQ("Invalid character in exponent", convertToErrorFromString(StringRef("0x1p1" "\0" "2", 7)));
1581
1582 EXPECT_EQ("Invalid character in exponent", convertToErrorFromString("0x1p0f"));
1583
1584 EXPECT_EQ("String contains multiple dots", convertToErrorFromString("0x..p1"));
1585 EXPECT_EQ("String contains multiple dots", convertToErrorFromString("0x..0p1"));
1586 EXPECT_EQ("String contains multiple dots", convertToErrorFromString("0x1.0.0p1"));
1587 }
1588
1589 TEST(APFloatTest, StringHexadecimalSignificandError) {
1590 EXPECT_EQ("Significand has no digits", convertToErrorFromString( "0x."));
1591 EXPECT_EQ("Significand has no digits", convertToErrorFromString("+0x."));
1592 EXPECT_EQ("Significand has no digits", convertToErrorFromString("-0x."));
1593
1594 EXPECT_EQ("Significand has no digits", convertToErrorFromString( "0xp"));
1595 EXPECT_EQ("Significand has no digits", convertToErrorFromString("+0xp"));
1596 EXPECT_EQ("Significand has no digits", convertToErrorFromString("-0xp"));
1597
1598 EXPECT_EQ("Significand has no digits", convertToErrorFromString( "0xp+"));
1599 EXPECT_EQ("Significand has no digits", convertToErrorFromString("+0xp+"));
1600 EXPECT_EQ("Significand has no digits", convertToErrorFromString("-0xp+"));
1601
1602 EXPECT_EQ("Significand has no digits", convertToErrorFromString( "0xp-"));
1603 EXPECT_EQ("Significand has no digits", convertToErrorFromString("+0xp-"));
1604 EXPECT_EQ("Significand has no digits", convertToErrorFromString("-0xp-"));
1605
1606
1607 EXPECT_EQ("Significand has no digits", convertToErrorFromString( "0x.p"));
1608 EXPECT_EQ("Significand has no digits", convertToErrorFromString("+0x.p"));
1609 EXPECT_EQ("Significand has no digits", convertToErrorFromString("-0x.p"));
1610
1611 EXPECT_EQ("Significand has no digits", convertToErrorFromString( "0x.p+"));
1612 EXPECT_EQ("Significand has no digits", convertToErrorFromString("+0x.p+"));
1613 EXPECT_EQ("Significand has no digits", convertToErrorFromString("-0x.p+"));
1614
1615 EXPECT_EQ("Significand has no digits", convertToErrorFromString( "0x.p-"));
1616 EXPECT_EQ("Significand has no digits", convertToErrorFromString("+0x.p-"));
1617 EXPECT_EQ("Significand has no digits", convertToErrorFromString("-0x.p-"));
1618 }
1619
1620 TEST(APFloatTest, StringHexadecimalExponentError) {
1621 EXPECT_EQ("Exponent has no digits", convertToErrorFromString( "0x1p"));
1622 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("+0x1p"));
1623 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("-0x1p"));
1624
1625 EXPECT_EQ("Exponent has no digits", convertToErrorFromString( "0x1p+"));
1626 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("+0x1p+"));
1627 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("-0x1p+"));
1628
1629 EXPECT_EQ("Exponent has no digits", convertToErrorFromString( "0x1p-"));
1630 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("+0x1p-"));
1631 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("-0x1p-"));
1632
1633
1634 EXPECT_EQ("Exponent has no digits", convertToErrorFromString( "0x1.p"));
1635 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("+0x1.p"));
1636 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("-0x1.p"));
1637
1638 EXPECT_EQ("Exponent has no digits", convertToErrorFromString( "0x1.p+"));
1639 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("+0x1.p+"));
1640 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("-0x1.p+"));
1641
1642 EXPECT_EQ("Exponent has no digits", convertToErrorFromString( "0x1.p-"));
1643 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("+0x1.p-"));
1644 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("-0x1.p-"));
1645
1646
1647 EXPECT_EQ("Exponent has no digits", convertToErrorFromString( "0x.1p"));
1648 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("+0x.1p"));
1649 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("-0x.1p"));
1650
1651 EXPECT_EQ("Exponent has no digits", convertToErrorFromString( "0x.1p+"));
1652 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("+0x.1p+"));
1653 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("-0x.1p+"));
1654
1655 EXPECT_EQ("Exponent has no digits", convertToErrorFromString( "0x.1p-"));
1656 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("+0x.1p-"));
1657 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("-0x.1p-"));
1658
1659
1660 EXPECT_EQ("Exponent has no digits", convertToErrorFromString( "0x1.1p"));
1661 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("+0x1.1p"));
1662 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("-0x1.1p"));
1663
1664 EXPECT_EQ("Exponent has no digits", convertToErrorFromString( "0x1.1p+"));
1665 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("+0x1.1p+"));
1666 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("-0x1.1p+"));
1667
1668 EXPECT_EQ("Exponent has no digits", convertToErrorFromString( "0x1.1p-"));
1669 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("+0x1.1p-"));
1670 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("-0x1.1p-"));
1671 }
1672
1673 TEST(APFloatTest, exactInverse) {
1674 APFloat inv(0.0f);
1675
1676 // Trivial operation.
1677 EXPECT_TRUE(APFloat(2.0).getExactInverse(&inv));
1678 EXPECT_TRUE(inv.bitwiseIsEqual(APFloat(0.5)));
1679 EXPECT_TRUE(APFloat(2.0f).getExactInverse(&inv));
1680 EXPECT_TRUE(inv.bitwiseIsEqual(APFloat(0.5f)));
1681 EXPECT_TRUE(APFloat(APFloat::IEEEquad(), "2.0").getExactInverse(&inv));
1682 EXPECT_TRUE(inv.bitwiseIsEqual(APFloat(APFloat::IEEEquad(), "0.5")));
1683 EXPECT_TRUE(APFloat(APFloat::PPCDoubleDouble(), "2.0").getExactInverse(&inv));
1684 EXPECT_TRUE(inv.bitwiseIsEqual(APFloat(APFloat::PPCDoubleDouble(), "0.5")));
1685 EXPECT_TRUE(APFloat(APFloat::x87DoubleExtended(), "2.0").getExactInverse(&inv));
1686 EXPECT_TRUE(inv.bitwiseIsEqual(APFloat(APFloat::x87DoubleExtended(), "0.5")));
1687
1688 // FLT_MIN
1689 EXPECT_TRUE(APFloat(1.17549435e-38f).getExactInverse(&inv));
1690 EXPECT_TRUE(inv.bitwiseIsEqual(APFloat(8.5070592e+37f)));
1691
1692 // Large float, inverse is a denormal.
1693 EXPECT_FALSE(APFloat(1.7014118e38f).getExactInverse(nullptr));
1694 // Zero
1695 EXPECT_FALSE(APFloat(0.0).getExactInverse(nullptr));
1696 // Denormalized float
1697 EXPECT_FALSE(APFloat(1.40129846e-45f).getExactInverse(nullptr));
1698 }
1699
1700 TEST(APFloatTest, roundToIntegral) {
1701 APFloat T(-0.5), S(3.14), R(APFloat::getLargest(APFloat::IEEEdouble())), P(0.0);
1702
1703 P = T;
1704 P.roundToIntegral(APFloat::rmTowardZero);
1705 EXPECT_EQ(-0.0, P.convertToDouble());
1706 P = T;
1707 P.roundToIntegral(APFloat::rmTowardNegative);
1708 EXPECT_EQ(-1.0, P.convertToDouble());
1709 P = T;
1710 P.roundToIntegral(APFloat::rmTowardPositive);
1711 EXPECT_EQ(-0.0, P.convertToDouble());
1712 P = T;
1713 P.roundToIntegral(APFloat::rmNearestTiesToEven);
1714 EXPECT_EQ(-0.0, P.convertToDouble());
1715
1716 P = S;
1717 P.roundToIntegral(APFloat::rmTowardZero);
1718 EXPECT_EQ(3.0, P.convertToDouble());
1719 P = S;
1720 P.roundToIntegral(APFloat::rmTowardNegative);
1721 EXPECT_EQ(3.0, P.convertToDouble());
1722 P = S;
1723 P.roundToIntegral(APFloat::rmTowardPositive);
1724 EXPECT_EQ(4.0, P.convertToDouble());
1725 P = S;
1726 P.roundToIntegral(APFloat::rmNearestTiesToEven);
1727 EXPECT_EQ(3.0, P.convertToDouble());
1728
1729 P = R;
1730 P.roundToIntegral(APFloat::rmTowardZero);
1731 EXPECT_EQ(R.convertToDouble(), P.convertToDouble());
1732 P = R;
1733 P.roundToIntegral(APFloat::rmTowardNegative);
1734 EXPECT_EQ(R.convertToDouble(), P.convertToDouble());
1735 P = R;
1736 P.roundToIntegral(APFloat::rmTowardPositive);
1737 EXPECT_EQ(R.convertToDouble(), P.convertToDouble());
1738 P = R;
1739 P.roundToIntegral(APFloat::rmNearestTiesToEven);
1740 EXPECT_EQ(R.convertToDouble(), P.convertToDouble());
1741
1742 P = APFloat::getZero(APFloat::IEEEdouble());
1743 P.roundToIntegral(APFloat::rmTowardZero);
1744 EXPECT_EQ(0.0, P.convertToDouble());
1745 P = APFloat::getZero(APFloat::IEEEdouble(), true);
1746 P.roundToIntegral(APFloat::rmTowardZero);
1747 EXPECT_EQ(-0.0, P.convertToDouble());
1748 P = APFloat::getNaN(APFloat::IEEEdouble());
1749 P.roundToIntegral(APFloat::rmTowardZero);
1750 EXPECT_TRUE(std::isnan(P.convertToDouble()));
1751 P = APFloat::getInf(APFloat::IEEEdouble());
1752 P.roundToIntegral(APFloat::rmTowardZero);
1753 EXPECT_TRUE(std::isinf(P.convertToDouble()) && P.convertToDouble() > 0.0);
1754 P = APFloat::getInf(APFloat::IEEEdouble(), true);
1755 P.roundToIntegral(APFloat::rmTowardZero);
1756 EXPECT_TRUE(std::isinf(P.convertToDouble()) && P.convertToDouble() < 0.0);
1757
1758 APFloat::opStatus St;
1759
1760 P = APFloat::getNaN(APFloat::IEEEdouble());
1761 St = P.roundToIntegral(APFloat::rmTowardZero);
1762 EXPECT_TRUE(P.isNaN());
1763 EXPECT_FALSE(P.isNegative());
1764 EXPECT_EQ(APFloat::opOK, St);
1765
1766 P = APFloat::getNaN(APFloat::IEEEdouble(), true);
1767 St = P.roundToIntegral(APFloat::rmTowardZero);
1768 EXPECT_TRUE(P.isNaN());
1769 EXPECT_TRUE(P.isNegative());
1770 EXPECT_EQ(APFloat::opOK, St);
1771
1772 P = APFloat::getSNaN(APFloat::IEEEdouble());
1773 St = P.roundToIntegral(APFloat::rmTowardZero);
1774 EXPECT_TRUE(P.isNaN());
1775 EXPECT_FALSE(P.isSignaling());
1776 EXPECT_FALSE(P.isNegative());
1777 EXPECT_EQ(APFloat::opInvalidOp, St);
1778
1779 P = APFloat::getSNaN(APFloat::IEEEdouble(), true);
1780 St = P.roundToIntegral(APFloat::rmTowardZero);
1781 EXPECT_TRUE(P.isNaN());
1782 EXPECT_FALSE(P.isSignaling());
1783 EXPECT_TRUE(P.isNegative());
1784 EXPECT_EQ(APFloat::opInvalidOp, St);
1785
1786 P = APFloat::getInf(APFloat::IEEEdouble());
1787 St = P.roundToIntegral(APFloat::rmTowardZero);
1788 EXPECT_TRUE(P.isInfinity());
1789 EXPECT_FALSE(P.isNegative());
1790 EXPECT_EQ(APFloat::opOK, St);
1791
1792 P = APFloat::getInf(APFloat::IEEEdouble(), true);
1793 St = P.roundToIntegral(APFloat::rmTowardZero);
1794 EXPECT_TRUE(P.isInfinity());
1795 EXPECT_TRUE(P.isNegative());
1796 EXPECT_EQ(APFloat::opOK, St);
1797
1798 P = APFloat::getZero(APFloat::IEEEdouble(), false);
1799 St = P.roundToIntegral(APFloat::rmTowardZero);
1800 EXPECT_TRUE(P.isZero());
1801 EXPECT_FALSE(P.isNegative());
1802 EXPECT_EQ(APFloat::opOK, St);
1803
1804 P = APFloat::getZero(APFloat::IEEEdouble(), false);
1805 St = P.roundToIntegral(APFloat::rmTowardNegative);
1806 EXPECT_TRUE(P.isZero());
1807 EXPECT_FALSE(P.isNegative());
1808 EXPECT_EQ(APFloat::opOK, St);
1809
1810 P = APFloat::getZero(APFloat::IEEEdouble(), true);
1811 St = P.roundToIntegral(APFloat::rmTowardZero);
1812 EXPECT_TRUE(P.isZero());
1813 EXPECT_TRUE(P.isNegative());
1814 EXPECT_EQ(APFloat::opOK, St);
1815
1816 P = APFloat::getZero(APFloat::IEEEdouble(), true);
1817 St = P.roundToIntegral(APFloat::rmTowardNegative);
1818 EXPECT_TRUE(P.isZero());
1819 EXPECT_TRUE(P.isNegative());
1820 EXPECT_EQ(APFloat::opOK, St);
1821
1822 P = APFloat(1E-100);
1823 St = P.roundToIntegral(APFloat::rmTowardNegative);
1824 EXPECT_TRUE(P.isZero());
1825 EXPECT_FALSE(P.isNegative());
1826 EXPECT_EQ(APFloat::opInexact, St);
1827
1828 P = APFloat(1E-100);
1829 St = P.roundToIntegral(APFloat::rmTowardPositive);
1830 EXPECT_EQ(1.0, P.convertToDouble());
1831 EXPECT_FALSE(P.isNegative());
1832 EXPECT_EQ(APFloat::opInexact, St);
1833
1834 P = APFloat(-1E-100);
1835 St = P.roundToIntegral(APFloat::rmTowardNegative);
1836 EXPECT_TRUE(P.isNegative());
1837 EXPECT_EQ(-1.0, P.convertToDouble());
1838 EXPECT_EQ(APFloat::opInexact, St);
1839
1840 P = APFloat(-1E-100);
1841 St = P.roundToIntegral(APFloat::rmTowardPositive);
1842 EXPECT_TRUE(P.isZero());
1843 EXPECT_TRUE(P.isNegative());
1844 EXPECT_EQ(APFloat::opInexact, St);
1845
1846 P = APFloat(10.0);
1847 St = P.roundToIntegral(APFloat::rmTowardZero);
1848 EXPECT_EQ(10.0, P.convertToDouble());
1849 EXPECT_EQ(APFloat::opOK, St);
1850
1851 P = APFloat(10.5);
1852 St = P.roundToIntegral(APFloat::rmTowardZero);
1853 EXPECT_EQ(10.0, P.convertToDouble());
1854 EXPECT_EQ(APFloat::opInexact, St);
1855
1856 P = APFloat(10.5);
1857 St = P.roundToIntegral(APFloat::rmTowardPositive);
1858 EXPECT_EQ(11.0, P.convertToDouble());
1859 EXPECT_EQ(APFloat::opInexact, St);
1860
1861 P = APFloat(10.5);
1862 St = P.roundToIntegral(APFloat::rmTowardNegative);
1863 EXPECT_EQ(10.0, P.convertToDouble());
1864 EXPECT_EQ(APFloat::opInexact, St);
1865
1866 P = APFloat(10.5);
1867 St = P.roundToIntegral(APFloat::rmNearestTiesToAway);
1868 EXPECT_EQ(11.0, P.convertToDouble());
1869 EXPECT_EQ(APFloat::opInexact, St);
1870
1871 P = APFloat(10.5);
1872 St = P.roundToIntegral(APFloat::rmNearestTiesToEven);
1873 EXPECT_EQ(10.0, P.convertToDouble());
1874 EXPECT_EQ(APFloat::opInexact, St);
1875 }
1876
1877 TEST(APFloatTest, isInteger) {
1878 APFloat T(-0.0);
1879 EXPECT_TRUE(T.isInteger());
1880 T = APFloat(3.14159);
1881 EXPECT_FALSE(T.isInteger());
1882 T = APFloat::getNaN(APFloat::IEEEdouble());
1883 EXPECT_FALSE(T.isInteger());
1884 T = APFloat::getInf(APFloat::IEEEdouble());
1885 EXPECT_FALSE(T.isInteger());
1886 T = APFloat::getInf(APFloat::IEEEdouble(), true);
1887 EXPECT_FALSE(T.isInteger());
1888 T = APFloat::getLargest(APFloat::IEEEdouble());
1889 EXPECT_TRUE(T.isInteger());
1890 }
1891
1892 TEST(DoubleAPFloatTest, isInteger) {
1893 APFloat F1(-0.0);
1894 APFloat F2(-0.0);
1895 llvm::detail::DoubleAPFloat T(APFloat::PPCDoubleDouble(), std::move(F1),
1896 std::move(F2));
1897 EXPECT_TRUE(T.isInteger());
1898 APFloat F3(3.14159);
1899 APFloat F4(-0.0);
1900 llvm::detail::DoubleAPFloat T2(APFloat::PPCDoubleDouble(), std::move(F3),
1901 std::move(F4));
1902 EXPECT_FALSE(T2.isInteger());
1903 APFloat F5(-0.0);
1904 APFloat F6(3.14159);
1905 llvm::detail::DoubleAPFloat T3(APFloat::PPCDoubleDouble(), std::move(F5),
1906 std::move(F6));
1907 EXPECT_FALSE(T3.isInteger());
1908 }
1909
1910 TEST(APFloatTest, getLargest) {
1911 EXPECT_EQ(3.402823466e+38f, APFloat::getLargest(APFloat::IEEEsingle()).convertToFloat());
1912 EXPECT_EQ(1.7976931348623158e+308, APFloat::getLargest(APFloat::IEEEdouble()).convertToDouble());
1913 EXPECT_EQ(448, APFloat::getLargest(APFloat::Float8E4M3FN()).convertToDouble());
1914 EXPECT_EQ(240,
1915 APFloat::getLargest(APFloat::Float8E4M3FNUZ()).convertToDouble());
1916 EXPECT_EQ(57344,
1917 APFloat::getLargest(APFloat::Float8E5M2FNUZ()).convertToDouble());
1918 EXPECT_EQ(
1919 30, APFloat::getLargest(APFloat::Float8E4M3B11FNUZ()).convertToDouble());
1920 EXPECT_EQ(3.40116213421e+38f,
1921 APFloat::getLargest(APFloat::FloatTF32()).convertToFloat());
1922 EXPECT_EQ(28, APFloat::getLargest(APFloat::Float6E3M2FN()).convertToDouble());
1923 EXPECT_EQ(7.5,
1924 APFloat::getLargest(APFloat::Float6E2M3FN()).convertToDouble());
1925 EXPECT_EQ(6, APFloat::getLargest(APFloat::Float4E2M1FN()).convertToDouble());
1926 }
1927
1928 TEST(APFloatTest, getSmallest) {
1929 APFloat test = APFloat::getSmallest(APFloat::IEEEsingle(), false);
1930 APFloat expected = APFloat(APFloat::IEEEsingle(), "0x0.000002p-126");
1931 EXPECT_FALSE(test.isNegative());
1932 EXPECT_TRUE(test.isFiniteNonZero());
1933 EXPECT_TRUE(test.isDenormal());
1934 EXPECT_TRUE(test.bitwiseIsEqual(expected));
1935
1936 test = APFloat::getSmallest(APFloat::IEEEsingle(), true);
1937 expected = APFloat(APFloat::IEEEsingle(), "-0x0.000002p-126");
1938 EXPECT_TRUE(test.isNegative());
1939 EXPECT_TRUE(test.isFiniteNonZero());
1940 EXPECT_TRUE(test.isDenormal());
1941 EXPECT_TRUE(test.bitwiseIsEqual(expected));
1942
1943 test = APFloat::getSmallest(APFloat::IEEEquad(), false);
1944 expected = APFloat(APFloat::IEEEquad(), "0x0.0000000000000000000000000001p-16382");
1945 EXPECT_FALSE(test.isNegative());
1946 EXPECT_TRUE(test.isFiniteNonZero());
1947 EXPECT_TRUE(test.isDenormal());
1948 EXPECT_TRUE(test.bitwiseIsEqual(expected));
1949
1950 test = APFloat::getSmallest(APFloat::IEEEquad(), true);
1951 expected = APFloat(APFloat::IEEEquad(), "-0x0.0000000000000000000000000001p-16382");
1952 EXPECT_TRUE(test.isNegative());
1953 EXPECT_TRUE(test.isFiniteNonZero());
1954 EXPECT_TRUE(test.isDenormal());
1955 EXPECT_TRUE(test.bitwiseIsEqual(expected));
1956
1957 test = APFloat::getSmallest(APFloat::Float8E5M2FNUZ(), false);
1958 expected = APFloat(APFloat::Float8E5M2FNUZ(), "0x0.4p-15");
1959 EXPECT_FALSE(test.isNegative());
1960 EXPECT_TRUE(test.isFiniteNonZero());
1961 EXPECT_TRUE(test.isDenormal());
1962 EXPECT_TRUE(test.bitwiseIsEqual(expected));
1963
1964 test = APFloat::getSmallest(APFloat::Float8E4M3FNUZ(), false);
1965 expected = APFloat(APFloat::Float8E4M3FNUZ(), "0x0.2p-7");
1966 EXPECT_FALSE(test.isNegative());
1967 EXPECT_TRUE(test.isFiniteNonZero());
1968 EXPECT_TRUE(test.isDenormal());
1969 EXPECT_TRUE(test.bitwiseIsEqual(expected));
1970
1971 test = APFloat::getSmallest(APFloat::Float8E4M3B11FNUZ(), false);
1972 expected = APFloat(APFloat::Float8E4M3B11FNUZ(), "0x0.2p-10");
1973 EXPECT_FALSE(test.isNegative());
1974 EXPECT_TRUE(test.isFiniteNonZero());
1975 EXPECT_TRUE(test.isDenormal());
1976 EXPECT_TRUE(test.bitwiseIsEqual(expected));
1977
1978 test = APFloat::getSmallest(APFloat::FloatTF32(), true);
1979 expected = APFloat(APFloat::FloatTF32(), "-0x0.004p-126");
1980 EXPECT_TRUE(test.isNegative());
1981 EXPECT_TRUE(test.isFiniteNonZero());
1982 EXPECT_TRUE(test.isDenormal());
1983 EXPECT_TRUE(test.bitwiseIsEqual(expected));
1984
1985 test = APFloat::getSmallest(APFloat::Float6E3M2FN(), false);
1986 expected = APFloat(APFloat::Float6E3M2FN(), "0x0.1p0");
1987 EXPECT_FALSE(test.isNegative());
1988 EXPECT_TRUE(test.isFiniteNonZero());
1989 EXPECT_TRUE(test.isDenormal());
1990 EXPECT_TRUE(test.bitwiseIsEqual(expected));
1991
1992 test = APFloat::getSmallest(APFloat::Float6E2M3FN(), false);
1993 expected = APFloat(APFloat::Float6E2M3FN(), "0x0.2p0");
1994 EXPECT_FALSE(test.isNegative());
1995 EXPECT_TRUE(test.isFiniteNonZero());
1996 EXPECT_TRUE(test.isDenormal());
1997 EXPECT_TRUE(test.bitwiseIsEqual(expected));
1998
1999 test = APFloat::getSmallest(APFloat::Float4E2M1FN(), false);
2000 expected = APFloat(APFloat::Float4E2M1FN(), "0x0.8p0");
2001 EXPECT_FALSE(test.isNegative());
2002 EXPECT_TRUE(test.isFiniteNonZero());
2003 EXPECT_TRUE(test.isDenormal());
2004 EXPECT_TRUE(test.bitwiseIsEqual(expected));
2005 }
2006
2007 TEST(APFloatTest, getSmallestNormalized) {
2008 APFloat test = APFloat::getSmallestNormalized(APFloat::IEEEsingle(), false);
2009 APFloat expected = APFloat(APFloat::IEEEsingle(), "0x1p-126");
2010 EXPECT_FALSE(test.isNegative());
2011 EXPECT_TRUE(test.isFiniteNonZero());
2012 EXPECT_FALSE(test.isDenormal());
2013 EXPECT_TRUE(test.bitwiseIsEqual(expected));
2014 EXPECT_TRUE(test.isSmallestNormalized());
2015
2016 test = APFloat::getSmallestNormalized(APFloat::IEEEsingle(), true);
2017 expected = APFloat(APFloat::IEEEsingle(), "-0x1p-126");
2018 EXPECT_TRUE(test.isNegative());
2019 EXPECT_TRUE(test.isFiniteNonZero());
2020 EXPECT_FALSE(test.isDenormal());
2021 EXPECT_TRUE(test.bitwiseIsEqual(expected));
2022 EXPECT_TRUE(test.isSmallestNormalized());
2023
2024 test = APFloat::getSmallestNormalized(APFloat::IEEEdouble(), false);
2025 expected = APFloat(APFloat::IEEEdouble(), "0x1p-1022");
2026 EXPECT_FALSE(test.isNegative());
2027 EXPECT_TRUE(test.isFiniteNonZero());
2028 EXPECT_FALSE(test.isDenormal());
2029 EXPECT_TRUE(test.bitwiseIsEqual(expected));
2030 EXPECT_TRUE(test.isSmallestNormalized());
2031
2032 test = APFloat::getSmallestNormalized(APFloat::IEEEdouble(), true);
2033 expected = APFloat(APFloat::IEEEdouble(), "-0x1p-1022");
2034 EXPECT_TRUE(test.isNegative());
2035 EXPECT_TRUE(test.isFiniteNonZero());
2036 EXPECT_FALSE(test.isDenormal());
2037 EXPECT_TRUE(test.bitwiseIsEqual(expected));
2038 EXPECT_TRUE(test.isSmallestNormalized());
2039
2040 test = APFloat::getSmallestNormalized(APFloat::IEEEquad(), false);
2041 expected = APFloat(APFloat::IEEEquad(), "0x1p-16382");
2042 EXPECT_FALSE(test.isNegative());
2043 EXPECT_TRUE(test.isFiniteNonZero());
2044 EXPECT_FALSE(test.isDenormal());
2045 EXPECT_TRUE(test.bitwiseIsEqual(expected));
2046 EXPECT_TRUE(test.isSmallestNormalized());
2047
2048 test = APFloat::getSmallestNormalized(APFloat::IEEEquad(), true);
2049 expected = APFloat(APFloat::IEEEquad(), "-0x1p-16382");
2050 EXPECT_TRUE(test.isNegative());
2051 EXPECT_TRUE(test.isFiniteNonZero());
2052 EXPECT_FALSE(test.isDenormal());
2053 EXPECT_TRUE(test.bitwiseIsEqual(expected));
2054 EXPECT_TRUE(test.isSmallestNormalized());
2055
2056 test = APFloat::getSmallestNormalized(APFloat::Float8E5M2FNUZ(), false);
2057 expected = APFloat(APFloat::Float8E5M2FNUZ(), "0x1.0p-15");
2058 EXPECT_FALSE(test.isNegative());
2059 EXPECT_TRUE(test.isFiniteNonZero());
2060 EXPECT_FALSE(test.isDenormal());
2061 EXPECT_TRUE(test.bitwiseIsEqual(expected));
2062 EXPECT_TRUE(test.isSmallestNormalized());
2063
2064 test = APFloat::getSmallestNormalized(APFloat::Float8E4M3FNUZ(), false);
2065 expected = APFloat(APFloat::Float8E4M3FNUZ(), "0x1.0p-7");
2066 EXPECT_FALSE(test.isNegative());
2067 EXPECT_TRUE(test.isFiniteNonZero());
2068 EXPECT_FALSE(test.isDenormal());
2069 EXPECT_TRUE(test.bitwiseIsEqual(expected));
2070 EXPECT_TRUE(test.isSmallestNormalized());
2071
2072 test = APFloat::getSmallestNormalized(APFloat::Float8E4M3B11FNUZ(), false);
2073 expected = APFloat(APFloat::Float8E4M3B11FNUZ(), "0x1.0p-10");
2074 EXPECT_FALSE(test.isNegative());
2075 EXPECT_TRUE(test.isFiniteNonZero());
2076 EXPECT_FALSE(test.isDenormal());
2077 EXPECT_TRUE(test.bitwiseIsEqual(expected));
2078 EXPECT_TRUE(test.isSmallestNormalized());
2079
2080 test = APFloat::getSmallestNormalized(APFloat::FloatTF32(), false);
2081 expected = APFloat(APFloat::FloatTF32(), "0x1p-126");
2082 EXPECT_FALSE(test.isNegative());
2083 EXPECT_TRUE(test.isFiniteNonZero());
2084 EXPECT_FALSE(test.isDenormal());
2085 EXPECT_TRUE(test.bitwiseIsEqual(expected));
2086 EXPECT_TRUE(test.isSmallestNormalized());
2087 test = APFloat::getSmallestNormalized(APFloat::Float6E3M2FN(), false);
2088 expected = APFloat(APFloat::Float6E3M2FN(), "0x1p-2");
2089
2090 test = APFloat::getSmallestNormalized(APFloat::Float4E2M1FN(), false);
2091 expected = APFloat(APFloat::Float4E2M1FN(), "0x1p0");
2092 EXPECT_FALSE(test.isNegative());
2093 EXPECT_TRUE(test.isFiniteNonZero());
2094 EXPECT_FALSE(test.isDenormal());
2095 EXPECT_TRUE(test.bitwiseIsEqual(expected));
2096 EXPECT_TRUE(test.isSmallestNormalized());
2097 EXPECT_FALSE(test.isNegative());
2098 EXPECT_TRUE(test.isFiniteNonZero());
2099 EXPECT_FALSE(test.isDenormal());
2100 EXPECT_TRUE(test.bitwiseIsEqual(expected));
2101 EXPECT_TRUE(test.isSmallestNormalized());
2102
2103 test = APFloat::getSmallestNormalized(APFloat::Float6E2M3FN(), false);
2104 expected = APFloat(APFloat::Float6E2M3FN(), "0x1p0");
2105 EXPECT_FALSE(test.isNegative());
2106 EXPECT_TRUE(test.isFiniteNonZero());
2107 EXPECT_FALSE(test.isDenormal());
2108 EXPECT_TRUE(test.bitwiseIsEqual(expected));
2109 EXPECT_TRUE(test.isSmallestNormalized());
2110 }
2111
2112 TEST(APFloatTest, getZero) {
2113 struct {
2114 const fltSemantics *semantics;
2115 const bool sign;
2116 const bool signedZero;
2117 const unsigned long long bitPattern[2];
2118 const unsigned bitPatternLength;
2119 } const GetZeroTest[] = {
2120 {&APFloat::IEEEhalf(), false, true, {0, 0}, 1},
2121 {&APFloat::IEEEhalf(), true, true, {0x8000ULL, 0}, 1},
2122 {&APFloat::IEEEsingle(), false, true, {0, 0}, 1},
2123 {&APFloat::IEEEsingle(), true, true, {0x80000000ULL, 0}, 1},
2124 {&APFloat::IEEEdouble(), false, true, {0, 0}, 1},
2125 {&APFloat::IEEEdouble(), true, true, {0x8000000000000000ULL, 0}, 1},
2126 {&APFloat::IEEEquad(), false, true, {0, 0}, 2},
2127 {&APFloat::IEEEquad(), true, true, {0, 0x8000000000000000ULL}, 2},
2128 {&APFloat::PPCDoubleDouble(), false, true, {0, 0}, 2},
2129 {&APFloat::PPCDoubleDouble(), true, true, {0x8000000000000000ULL, 0}, 2},
2130 {&APFloat::x87DoubleExtended(), false, true, {0, 0}, 2},
2131 {&APFloat::x87DoubleExtended(), true, true, {0, 0x8000ULL}, 2},
2132 {&APFloat::Float8E5M2(), false, true, {0, 0}, 1},
2133 {&APFloat::Float8E5M2(), true, true, {0x80ULL, 0}, 1},
2134 {&APFloat::Float8E5M2FNUZ(), false, false, {0, 0}, 1},
2135 {&APFloat::Float8E5M2FNUZ(), true, false, {0, 0}, 1},
2136 {&APFloat::Float8E4M3(), false, true, {0, 0}, 1},
2137 {&APFloat::Float8E4M3(), true, true, {0x80ULL, 0}, 1},
2138 {&APFloat::Float8E4M3FN(), false, true, {0, 0}, 1},
2139 {&APFloat::Float8E4M3FN(), true, true, {0x80ULL, 0}, 1},
2140 {&APFloat::Float8E4M3FNUZ(), false, false, {0, 0}, 1},
2141 {&APFloat::Float8E4M3FNUZ(), true, false, {0, 0}, 1},
2142 {&APFloat::Float8E4M3B11FNUZ(), false, false, {0, 0}, 1},
2143 {&APFloat::Float8E4M3B11FNUZ(), true, false, {0, 0}, 1},
2144 {&APFloat::FloatTF32(), false, true, {0, 0}, 1},
2145 {&APFloat::FloatTF32(), true, true, {0x40000ULL, 0}, 1},
2146 {&APFloat::Float6E3M2FN(), false, true, {0, 0}, 1},
2147 {&APFloat::Float6E3M2FN(), true, true, {0x20ULL, 0}, 1},
2148 {&APFloat::Float6E2M3FN(), false, true, {0, 0}, 1},
2149 {&APFloat::Float6E2M3FN(), true, true, {0x20ULL, 0}, 1},
2150 {&APFloat::Float4E2M1FN(), false, true, {0, 0}, 1},
2151 {&APFloat::Float4E2M1FN(), true, true, {0x8ULL, 0}, 1}};
2152 const unsigned NumGetZeroTests = std::size(GetZeroTest);
2153 for (unsigned i = 0; i < NumGetZeroTests; ++i) {
2154 APFloat test = APFloat::getZero(*GetZeroTest[i].semantics,
2155 GetZeroTest[i].sign);
2156 const char *pattern = GetZeroTest[i].sign? "-0x0p+0" : "0x0p+0";
2157 APFloat expected = APFloat(*GetZeroTest[i].semantics,
2158 pattern);
2159 EXPECT_TRUE(test.isZero());
2160 if (GetZeroTest[i].signedZero)
2161 EXPECT_TRUE(GetZeroTest[i].sign ? test.isNegative() : !test.isNegative());
2162 else
2163 EXPECT_TRUE(!test.isNegative());
2164 EXPECT_TRUE(test.bitwiseIsEqual(expected));
2165 for (unsigned j = 0, je = GetZeroTest[i].bitPatternLength; j < je; ++j) {
2166 EXPECT_EQ(GetZeroTest[i].bitPattern[j],
2167 test.bitcastToAPInt().getRawData()[j]);
2168 }
2169 }
2170 }
2171
2172 TEST(APFloatTest, copySign) {
2173 EXPECT_TRUE(APFloat(-42.0).bitwiseIsEqual(
2174 APFloat::copySign(APFloat(42.0), APFloat(-1.0))));
2175 EXPECT_TRUE(APFloat(42.0).bitwiseIsEqual(
2176 APFloat::copySign(APFloat(-42.0), APFloat(1.0))));
2177 EXPECT_TRUE(APFloat(-42.0).bitwiseIsEqual(
2178 APFloat::copySign(APFloat(-42.0), APFloat(-1.0))));
2179 EXPECT_TRUE(APFloat(42.0).bitwiseIsEqual(
2180 APFloat::copySign(APFloat(42.0), APFloat(1.0))));
2181 // For floating-point formats with unsigned 0, copySign() to a zero is a noop
2182 for (APFloat::Semantics S :
2183 {APFloat::S_Float8E4M3FNUZ, APFloat::S_Float8E4M3B11FNUZ}) {
2184 const llvm::fltSemantics &Sem = APFloat::EnumToSemantics(S);
2185 EXPECT_TRUE(APFloat::getZero(Sem).bitwiseIsEqual(
2186 APFloat::copySign(APFloat::getZero(Sem), APFloat(-1.0))));
2187 EXPECT_TRUE(APFloat::getNaN(Sem, true).bitwiseIsEqual(
2188 APFloat::copySign(APFloat::getNaN(Sem, true), APFloat(1.0))));
2189 }
2190 }
2191
2192 TEST(APFloatTest, convert) {
2193 bool losesInfo;
2194 APFloat test(APFloat::IEEEdouble(), "1.0");
2195 test.convert(APFloat::IEEEsingle(), APFloat::rmNearestTiesToEven, &losesInfo);
2196 EXPECT_EQ(1.0f, test.convertToFloat());
2197 EXPECT_FALSE(losesInfo);
2198
2199 test = APFloat(APFloat::x87DoubleExtended(), "0x1p-53");
2200 test.add(APFloat(APFloat::x87DoubleExtended(), "1.0"), APFloat::rmNearestTiesToEven);
2201 test.convert(APFloat::IEEEdouble(), APFloat::rmNearestTiesToEven, &losesInfo);
2202 EXPECT_EQ(1.0, test.convertToDouble());
2203 EXPECT_TRUE(losesInfo);
2204
2205 test = APFloat(APFloat::IEEEquad(), "0x1p-53");
2206 test.add(APFloat(APFloat::IEEEquad(), "1.0"), APFloat::rmNearestTiesToEven);
2207 test.convert(APFloat::IEEEdouble(), APFloat::rmNearestTiesToEven, &losesInfo);
2208 EXPECT_EQ(1.0, test.convertToDouble());
2209 EXPECT_TRUE(losesInfo);
2210
2211 test = APFloat(APFloat::x87DoubleExtended(), "0xf.fffffffp+28");
2212 test.convert(APFloat::IEEEdouble(), APFloat::rmNearestTiesToEven, &losesInfo);
2213 EXPECT_EQ(4294967295.0, test.convertToDouble());
2214 EXPECT_FALSE(losesInfo);
2215
2216 test = APFloat::getSNaN(APFloat::IEEEsingle());
2217 APFloat::opStatus status = test.convert(APFloat::x87DoubleExtended(), APFloat::rmNearestTiesToEven, &losesInfo);
2218 // Conversion quiets the SNAN, so now 2 bits of the 64-bit significand should be set.
2219 APInt topTwoBits(64, 0x6000000000000000);
2220 EXPECT_TRUE(test.bitwiseIsEqual(APFloat::getQNaN(APFloat::x87DoubleExtended(), false, &topTwoBits)));
2221 EXPECT_FALSE(losesInfo);
2222 EXPECT_EQ(status, APFloat::opInvalidOp);
2223
2224 test = APFloat::getQNaN(APFloat::IEEEsingle());
2225 APFloat X87QNaN = APFloat::getQNaN(APFloat::x87DoubleExtended());
2226 test.convert(APFloat::x87DoubleExtended(), APFloat::rmNearestTiesToEven,
2227 &losesInfo);
2228 EXPECT_TRUE(test.bitwiseIsEqual(X87QNaN));
2229 EXPECT_FALSE(losesInfo);
2230
2231 test = APFloat::getSNaN(APFloat::x87DoubleExtended());
2232 test.convert(APFloat::x87DoubleExtended(), APFloat::rmNearestTiesToEven,
2233 &losesInfo);
2234 APFloat X87SNaN = APFloat::getSNaN(APFloat::x87DoubleExtended());
2235 EXPECT_TRUE(test.bitwiseIsEqual(X87SNaN));
2236 EXPECT_FALSE(losesInfo);
2237
2238 test = APFloat::getQNaN(APFloat::x87DoubleExtended());
2239 test.convert(APFloat::x87DoubleExtended(), APFloat::rmNearestTiesToEven,
2240 &losesInfo);
2241 EXPECT_TRUE(test.bitwiseIsEqual(X87QNaN));
2242 EXPECT_FALSE(losesInfo);
2243
2244 // The payload is lost in truncation, but we retain NaN by setting the quiet bit.
2245 APInt payload(52, 1);
2246 test = APFloat::getSNaN(APFloat::IEEEdouble(), false, &payload);
2247 status = test.convert(APFloat::IEEEsingle(), APFloat::rmNearestTiesToEven, &losesInfo);
2248 EXPECT_EQ(0x7fc00000, test.bitcastToAPInt());
2249 EXPECT_TRUE(losesInfo);
2250 EXPECT_EQ(status, APFloat::opInvalidOp);
2251
2252 // The payload is lost in truncation. QNaN remains QNaN.
2253 test = APFloat::getQNaN(APFloat::IEEEdouble(), false, &payload);
2254 status = test.convert(APFloat::IEEEsingle(), APFloat::rmNearestTiesToEven, &losesInfo);
2255 EXPECT_EQ(0x7fc00000, test.bitcastToAPInt());
2256 EXPECT_TRUE(losesInfo);
2257 EXPECT_EQ(status, APFloat::opOK);
2258
2259 // Test that subnormals are handled correctly in double to float conversion
2260 test = APFloat(APFloat::IEEEdouble(), "0x0.0000010000000p-1022");
2261 test.convert(APFloat::IEEEsingle(), APFloat::rmNearestTiesToEven, &losesInfo);
2262 EXPECT_EQ(0.0f, test.convertToFloat());
2263 EXPECT_TRUE(losesInfo);
2264
2265 test = APFloat(APFloat::IEEEdouble(), "0x0.0000010000001p-1022");
2266 test.convert(APFloat::IEEEsingle(), APFloat::rmNearestTiesToEven, &losesInfo);
2267 EXPECT_EQ(0.0f, test.convertToFloat());
2268 EXPECT_TRUE(losesInfo);
2269
2270 test = APFloat(APFloat::IEEEdouble(), "-0x0.0000010000001p-1022");
2271 test.convert(APFloat::IEEEsingle(), APFloat::rmNearestTiesToEven, &losesInfo);
2272 EXPECT_EQ(0.0f, test.convertToFloat());
2273 EXPECT_TRUE(losesInfo);
2274
2275 test = APFloat(APFloat::IEEEdouble(), "0x0.0000020000000p-1022");
2276 test.convert(APFloat::IEEEsingle(), APFloat::rmNearestTiesToEven, &losesInfo);
2277 EXPECT_EQ(0.0f, test.convertToFloat());
2278 EXPECT_TRUE(losesInfo);
2279
2280 test = APFloat(APFloat::IEEEdouble(), "0x0.0000020000001p-1022");
2281 test.convert(APFloat::IEEEsingle(), APFloat::rmNearestTiesToEven, &losesInfo);
2282 EXPECT_EQ(0.0f, test.convertToFloat());
2283 EXPECT_TRUE(losesInfo);
2284
2285 // Test subnormal conversion to bfloat
2286 test = APFloat(APFloat::IEEEsingle(), "0x0.01p-126");
2287 test.convert(APFloat::BFloat(), APFloat::rmNearestTiesToEven, &losesInfo);
2288 EXPECT_EQ(0.0f, test.convertToFloat());
2289 EXPECT_TRUE(losesInfo);
2290
2291 test = APFloat(APFloat::IEEEsingle(), "0x0.02p-126");
2292 test.convert(APFloat::BFloat(), APFloat::rmNearestTiesToEven, &losesInfo);
2293 EXPECT_EQ(0x01, test.bitcastToAPInt());
2294 EXPECT_FALSE(losesInfo);
2295
2296 test = APFloat(APFloat::IEEEsingle(), "0x0.01p-126");
2297 test.convert(APFloat::BFloat(), APFloat::rmNearestTiesToAway, &losesInfo);
2298 EXPECT_EQ(0x01, test.bitcastToAPInt());
2299 EXPECT_TRUE(losesInfo);
2300 }
2301
2302 TEST(APFloatTest, Float8UZConvert) {
2303 bool losesInfo = false;
2304 std::pair<APFloat, APFloat::opStatus> toNaNTests[] = {
2305 {APFloat::getQNaN(APFloat::IEEEsingle(), false), APFloat::opOK},
2306 {APFloat::getQNaN(APFloat::IEEEsingle(), true), APFloat::opOK},
2307 {APFloat::getSNaN(APFloat::IEEEsingle(), false), APFloat::opInvalidOp},
2308 {APFloat::getSNaN(APFloat::IEEEsingle(), true), APFloat::opInvalidOp},
2309 {APFloat::getInf(APFloat::IEEEsingle(), false), APFloat::opInexact},
2310 {APFloat::getInf(APFloat::IEEEsingle(), true), APFloat::opInexact}};
2311 for (APFloat::Semantics S :
2312 {APFloat::S_Float8E5M2FNUZ, APFloat::S_Float8E4M3FNUZ,
2313 APFloat::S_Float8E4M3B11FNUZ}) {
2314 const llvm::fltSemantics &Sem = APFloat::EnumToSemantics(S);
2315 SCOPED_TRACE("Semantics = " + std::to_string(S));
2316 for (auto [toTest, expectedRes] : toNaNTests) {
2317 llvm::SmallString<16> value;
2318 toTest.toString(value);
2319 SCOPED_TRACE("toTest = " + value);
2320 losesInfo = false;
2321 APFloat test = toTest;
2322 EXPECT_EQ(test.convert(Sem, APFloat::rmNearestTiesToAway, &losesInfo),
2323 expectedRes);
2324 EXPECT_TRUE(test.isNaN());
2325 EXPECT_TRUE(test.isNegative());
2326 EXPECT_FALSE(test.isSignaling());
2327 EXPECT_FALSE(test.isInfinity());
2328 EXPECT_EQ(0x80, test.bitcastToAPInt());
2329 EXPECT_TRUE(losesInfo);
2330 }
2331
2332 // Negative zero conversions are information losing.
2333 losesInfo = false;
2334 APFloat test = APFloat::getZero(APFloat::IEEEsingle(), true);
2335 EXPECT_EQ(test.convert(Sem, APFloat::rmNearestTiesToAway, &losesInfo),
2336 APFloat::opInexact);
2337 EXPECT_TRUE(test.isZero());
2338 EXPECT_FALSE(test.isNegative());
2339 EXPECT_TRUE(losesInfo);
2340 EXPECT_EQ(0x0, test.bitcastToAPInt());
2341
2342 losesInfo = true;
2343 test = APFloat::getZero(APFloat::IEEEsingle(), false);
2344 EXPECT_EQ(test.convert(Sem, APFloat::rmNearestTiesToAway, &losesInfo),
2345 APFloat::opOK);
2346 EXPECT_TRUE(test.isZero());
2347 EXPECT_FALSE(test.isNegative());
2348 EXPECT_FALSE(losesInfo);
2349 EXPECT_EQ(0x0, test.bitcastToAPInt());
2350
2351 // Except in casts between ourselves.
2352 losesInfo = true;
2353 test = APFloat::getZero(Sem);
2354 EXPECT_EQ(test.convert(Sem, APFloat::rmNearestTiesToAway, &losesInfo),
2355 APFloat::opOK);
2356 EXPECT_FALSE(losesInfo);
2357 EXPECT_EQ(0x0, test.bitcastToAPInt());
2358 }
2359 }
2360
2361 TEST(APFloatTest, PPCDoubleDouble) {
2362 APFloat test(APFloat::PPCDoubleDouble(), "1.0");
2363 EXPECT_EQ(0x3ff0000000000000ull, test.bitcastToAPInt().getRawData()[0]);
2364 EXPECT_EQ(0x0000000000000000ull, test.bitcastToAPInt().getRawData()[1]);
2365
2366 // LDBL_MAX
2367 test = APFloat(APFloat::PPCDoubleDouble(), "1.79769313486231580793728971405301e+308");
2368 EXPECT_EQ(0x7fefffffffffffffull, test.bitcastToAPInt().getRawData()[0]);
2369 EXPECT_EQ(0x7c8ffffffffffffeull, test.bitcastToAPInt().getRawData()[1]);
2370
2371 // LDBL_MIN
2372 test = APFloat(APFloat::PPCDoubleDouble(), "2.00416836000897277799610805135016e-292");
2373 EXPECT_EQ(0x0360000000000000ull, test.bitcastToAPInt().getRawData()[0]);
2374 EXPECT_EQ(0x0000000000000000ull, test.bitcastToAPInt().getRawData()[1]);
2375
2376 // PR30869
2377 {
2378 auto Result = APFloat(APFloat::PPCDoubleDouble(), "1.0") +
2379 APFloat(APFloat::PPCDoubleDouble(), "1.0");
2380 EXPECT_EQ(&APFloat::PPCDoubleDouble(), &Result.getSemantics());
2381
2382 Result = APFloat(APFloat::PPCDoubleDouble(), "1.0") -
2383 APFloat(APFloat::PPCDoubleDouble(), "1.0");
2384 EXPECT_EQ(&APFloat::PPCDoubleDouble(), &Result.getSemantics());
2385
2386 Result = APFloat(APFloat::PPCDoubleDouble(), "1.0") *
2387 APFloat(APFloat::PPCDoubleDouble(), "1.0");
2388 EXPECT_EQ(&APFloat::PPCDoubleDouble(), &Result.getSemantics());
2389
2390 Result = APFloat(APFloat::PPCDoubleDouble(), "1.0") /
2391 APFloat(APFloat::PPCDoubleDouble(), "1.0");
2392 EXPECT_EQ(&APFloat::PPCDoubleDouble(), &Result.getSemantics());
2393
2394 int Exp;
2395 Result = frexp(APFloat(APFloat::PPCDoubleDouble(), "1.0"), Exp,
2396 APFloat::rmNearestTiesToEven);
2397 EXPECT_EQ(&APFloat::PPCDoubleDouble(), &Result.getSemantics());
2398
2399 Result = scalbn(APFloat(APFloat::PPCDoubleDouble(), "1.0"), 1,
2400 APFloat::rmNearestTiesToEven);
2401 EXPECT_EQ(&APFloat::PPCDoubleDouble(), &Result.getSemantics());
2402 }
2403 }
2404
2405 TEST(APFloatTest, isNegative) {
2406 APFloat t(APFloat::IEEEsingle(), "0x1p+0");
2407 EXPECT_FALSE(t.isNegative());
2408 t = APFloat(APFloat::IEEEsingle(), "-0x1p+0");
2409 EXPECT_TRUE(t.isNegative());
2410
2411 EXPECT_FALSE(APFloat::getInf(APFloat::IEEEsingle(), false).isNegative());
2412 EXPECT_TRUE(APFloat::getInf(APFloat::IEEEsingle(), true).isNegative());
2413
2414 EXPECT_FALSE(APFloat::getZero(APFloat::IEEEsingle(), false).isNegative());
2415 EXPECT_TRUE(APFloat::getZero(APFloat::IEEEsingle(), true).isNegative());
2416
2417 EXPECT_FALSE(APFloat::getNaN(APFloat::IEEEsingle(), false).isNegative());
2418 EXPECT_TRUE(APFloat::getNaN(APFloat::IEEEsingle(), true).isNegative());
2419
2420 EXPECT_FALSE(APFloat::getSNaN(APFloat::IEEEsingle(), false).isNegative());
2421 EXPECT_TRUE(APFloat::getSNaN(APFloat::IEEEsingle(), true).isNegative());
2422 }
2423
2424 TEST(APFloatTest, isNormal) {
2425 APFloat t(APFloat::IEEEsingle(), "0x1p+0");
2426 EXPECT_TRUE(t.isNormal());
2427
2428 EXPECT_FALSE(APFloat::getInf(APFloat::IEEEsingle(), false).isNormal());
2429 EXPECT_FALSE(APFloat::getZero(APFloat::IEEEsingle(), false).isNormal());
2430 EXPECT_FALSE(APFloat::getNaN(APFloat::IEEEsingle(), false).isNormal());
2431 EXPECT_FALSE(APFloat::getSNaN(APFloat::IEEEsingle(), false).isNormal());
2432 EXPECT_FALSE(APFloat(APFloat::IEEEsingle(), "0x1p-149").isNormal());
2433 }
2434
2435 TEST(APFloatTest, isFinite) {
2436 APFloat t(APFloat::IEEEsingle(), "0x1p+0");
2437 EXPECT_TRUE(t.isFinite());
2438 EXPECT_FALSE(APFloat::getInf(APFloat::IEEEsingle(), false).isFinite());
2439 EXPECT_TRUE(APFloat::getZero(APFloat::IEEEsingle(), false).isFinite());
2440 EXPECT_FALSE(APFloat::getNaN(APFloat::IEEEsingle(), false).isFinite());
2441 EXPECT_FALSE(APFloat::getSNaN(APFloat::IEEEsingle(), false).isFinite());
2442 EXPECT_TRUE(APFloat(APFloat::IEEEsingle(), "0x1p-149").isFinite());
2443 }
2444
2445 TEST(APFloatTest, isInfinity) {
2446 APFloat t(APFloat::IEEEsingle(), "0x1p+0");
2447 EXPECT_FALSE(t.isInfinity());
2448
2449 APFloat PosInf = APFloat::getInf(APFloat::IEEEsingle(), false);
2450 APFloat NegInf = APFloat::getInf(APFloat::IEEEsingle(), true);
2451
2452 EXPECT_TRUE(PosInf.isInfinity());
2453 EXPECT_TRUE(PosInf.isPosInfinity());
2454 EXPECT_FALSE(PosInf.isNegInfinity());
2455 EXPECT_EQ(fcPosInf, PosInf.classify());
2456
2457 EXPECT_TRUE(NegInf.isInfinity());
2458 EXPECT_FALSE(NegInf.isPosInfinity());
2459 EXPECT_TRUE(NegInf.isNegInfinity());
2460 EXPECT_EQ(fcNegInf, NegInf.classify());
2461
2462 EXPECT_FALSE(APFloat::getZero(APFloat::IEEEsingle(), false).isInfinity());
2463 EXPECT_FALSE(APFloat::getNaN(APFloat::IEEEsingle(), false).isInfinity());
2464 EXPECT_FALSE(APFloat::getSNaN(APFloat::IEEEsingle(), false).isInfinity());
2465 EXPECT_FALSE(APFloat(APFloat::IEEEsingle(), "0x1p-149").isInfinity());
2466 }
2467
2468 TEST(APFloatTest, isNaN) {
2469 APFloat t(APFloat::IEEEsingle(), "0x1p+0");
2470 EXPECT_FALSE(t.isNaN());
2471 EXPECT_FALSE(APFloat::getInf(APFloat::IEEEsingle(), false).isNaN());
2472 EXPECT_FALSE(APFloat::getZero(APFloat::IEEEsingle(), false).isNaN());
2473 EXPECT_TRUE(APFloat::getNaN(APFloat::IEEEsingle(), false).isNaN());
2474 EXPECT_TRUE(APFloat::getSNaN(APFloat::IEEEsingle(), false).isNaN());
2475 EXPECT_FALSE(APFloat(APFloat::IEEEsingle(), "0x1p-149").isNaN());
2476 }
2477
2478 TEST(APFloatTest, isFiniteNonZero) {
2479 // Test positive/negative normal value.
2480 EXPECT_TRUE(APFloat(APFloat::IEEEsingle(), "0x1p+0").isFiniteNonZero());
2481 EXPECT_TRUE(APFloat(APFloat::IEEEsingle(), "-0x1p+0").isFiniteNonZero());
2482
2483 // Test positive/negative denormal value.
2484 EXPECT_TRUE(APFloat(APFloat::IEEEsingle(), "0x1p-149").isFiniteNonZero());
2485 EXPECT_TRUE(APFloat(APFloat::IEEEsingle(), "-0x1p-149").isFiniteNonZero());
2486
2487 // Test +/- Infinity.
2488 EXPECT_FALSE(APFloat::getInf(APFloat::IEEEsingle(), false).isFiniteNonZero());
2489 EXPECT_FALSE(APFloat::getInf(APFloat::IEEEsingle(), true).isFiniteNonZero());
2490
2491 // Test +/- Zero.
2492 EXPECT_FALSE(APFloat::getZero(APFloat::IEEEsingle(), false).isFiniteNonZero());
2493 EXPECT_FALSE(APFloat::getZero(APFloat::IEEEsingle(), true).isFiniteNonZero());
2494
2495 // Test +/- qNaN. +/- dont mean anything with qNaN but paranoia can't hurt in
2496 // this instance.
2497 EXPECT_FALSE(APFloat::getNaN(APFloat::IEEEsingle(), false).isFiniteNonZero());
2498 EXPECT_FALSE(APFloat::getNaN(APFloat::IEEEsingle(), true).isFiniteNonZero());
2499
2500 // Test +/- sNaN. +/- dont mean anything with sNaN but paranoia can't hurt in
2501 // this instance.
2502 EXPECT_FALSE(APFloat::getSNaN(APFloat::IEEEsingle(), false).isFiniteNonZero());
2503 EXPECT_FALSE(APFloat::getSNaN(APFloat::IEEEsingle(), true).isFiniteNonZero());
2504 }
2505
2506 TEST(APFloatTest, add) {
2507 // Test Special Cases against each other and normal values.
2508
2509 APFloat PInf = APFloat::getInf(APFloat::IEEEsingle(), false);
2510 APFloat MInf = APFloat::getInf(APFloat::IEEEsingle(), true);
2511 APFloat PZero = APFloat::getZero(APFloat::IEEEsingle(), false);
2512 APFloat MZero = APFloat::getZero(APFloat::IEEEsingle(), true);
2513 APFloat QNaN = APFloat::getNaN(APFloat::IEEEsingle(), false);
2514 APFloat SNaN = APFloat(APFloat::IEEEsingle(), "snan123");
2515 APFloat PNormalValue = APFloat(APFloat::IEEEsingle(), "0x1p+0");
2516 APFloat MNormalValue = APFloat(APFloat::IEEEsingle(), "-0x1p+0");
2517 APFloat PLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), false);
2518 APFloat MLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), true);
2519 APFloat PSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), false);
2520 APFloat MSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), true);
2521 APFloat PSmallestNormalized =
2522 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), false);
2523 APFloat MSmallestNormalized =
2524 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), true);
2525
2526 const int OverflowStatus = APFloat::opOverflow | APFloat::opInexact;
2527
2528 struct {
2529 APFloat x;
2530 APFloat y;
2531 const char *result;
2532 int status;
2533 int category;
2534 } SpecialCaseTests[] = {
2535 { PInf, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2536 { PInf, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2537 { PInf, PZero, "inf", APFloat::opOK, APFloat::fcInfinity },
2538 { PInf, MZero, "inf", APFloat::opOK, APFloat::fcInfinity },
2539 { PInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2540 { PInf, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2541 { PInf, PNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2542 { PInf, MNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2543 { PInf, PLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2544 { PInf, MLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2545 { PInf, PSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2546 { PInf, MSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2547 { PInf, PSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity },
2548 { PInf, MSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity },
2549 { MInf, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2550 { MInf, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2551 { MInf, PZero, "-inf", APFloat::opOK, APFloat::fcInfinity },
2552 { MInf, MZero, "-inf", APFloat::opOK, APFloat::fcInfinity },
2553 { MInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2554 { MInf, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2555 { MInf, PNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2556 { MInf, MNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2557 { MInf, PLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2558 { MInf, MLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2559 { MInf, PSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2560 { MInf, MSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2561 { MInf, PSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity },
2562 { MInf, MSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity },
2563 { PZero, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2564 { PZero, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2565 { PZero, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2566 { PZero, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2567 { PZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2568 { PZero, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2569 { PZero, PNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2570 { PZero, MNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2571 { PZero, PLargestValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2572 { PZero, MLargestValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2573 { PZero, PSmallestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2574 { PZero, MSmallestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2575 { PZero, PSmallestNormalized, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2576 { PZero, MSmallestNormalized, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2577 { MZero, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2578 { MZero, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2579 { MZero, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2580 { MZero, MZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2581 { MZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2582 { MZero, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2583 { MZero, PNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2584 { MZero, MNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2585 { MZero, PLargestValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2586 { MZero, MLargestValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2587 { MZero, PSmallestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2588 { MZero, MSmallestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2589 { MZero, PSmallestNormalized, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2590 { MZero, MSmallestNormalized, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2591 { QNaN, PInf, "nan", APFloat::opOK, APFloat::fcNaN },
2592 { QNaN, MInf, "nan", APFloat::opOK, APFloat::fcNaN },
2593 { QNaN, PZero, "nan", APFloat::opOK, APFloat::fcNaN },
2594 { QNaN, MZero, "nan", APFloat::opOK, APFloat::fcNaN },
2595 { QNaN, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2596 { QNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2597 { QNaN, PNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
2598 { QNaN, MNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
2599 { QNaN, PLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2600 { QNaN, MLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2601 { QNaN, PSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2602 { QNaN, MSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2603 { QNaN, PSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
2604 { QNaN, MSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
2605 { SNaN, PInf, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2606 { SNaN, MInf, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2607 { SNaN, PZero, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2608 { SNaN, MZero, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2609 { SNaN, QNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2610 { SNaN, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2611 { SNaN, PNormalValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2612 { SNaN, MNormalValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2613 { SNaN, PLargestValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2614 { SNaN, MLargestValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2615 { SNaN, PSmallestValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2616 { SNaN, MSmallestValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2617 { SNaN, PSmallestNormalized, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2618 { SNaN, MSmallestNormalized, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2619 { PNormalValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2620 { PNormalValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2621 { PNormalValue, PZero, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2622 { PNormalValue, MZero, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2623 { PNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2624 { PNormalValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2625 { PNormalValue, PNormalValue, "0x1p+1", APFloat::opOK, APFloat::fcNormal },
2626 { PNormalValue, MNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2627 { PNormalValue, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2628 { PNormalValue, MLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2629 { PNormalValue, PSmallestValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2630 { PNormalValue, MSmallestValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2631 { PNormalValue, PSmallestNormalized, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2632 { PNormalValue, MSmallestNormalized, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2633 { MNormalValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2634 { MNormalValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2635 { MNormalValue, PZero, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2636 { MNormalValue, MZero, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2637 { MNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2638 { MNormalValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2639 { MNormalValue, PNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2640 { MNormalValue, MNormalValue, "-0x1p+1", APFloat::opOK, APFloat::fcNormal },
2641 { MNormalValue, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2642 { MNormalValue, MLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2643 { MNormalValue, PSmallestValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2644 { MNormalValue, MSmallestValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2645 { MNormalValue, PSmallestNormalized, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2646 { MNormalValue, MSmallestNormalized, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2647 { PLargestValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2648 { PLargestValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2649 { PLargestValue, PZero, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2650 { PLargestValue, MZero, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2651 { PLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2652 { PLargestValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2653 { PLargestValue, PNormalValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2654 { PLargestValue, MNormalValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2655 { PLargestValue, PLargestValue, "inf", OverflowStatus, APFloat::fcInfinity },
2656 { PLargestValue, MLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2657 { PLargestValue, PSmallestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2658 { PLargestValue, MSmallestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2659 { PLargestValue, PSmallestNormalized, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2660 { PLargestValue, MSmallestNormalized, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2661 { MLargestValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2662 { MLargestValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2663 { MLargestValue, PZero, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2664 { MLargestValue, MZero, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2665 { MLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2666 { MLargestValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2667 { MLargestValue, PNormalValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2668 { MLargestValue, MNormalValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2669 { MLargestValue, PLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2670 { MLargestValue, MLargestValue, "-inf", OverflowStatus, APFloat::fcInfinity },
2671 { MLargestValue, PSmallestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2672 { MLargestValue, MSmallestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2673 { MLargestValue, PSmallestNormalized, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2674 { MLargestValue, MSmallestNormalized, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2675 { PSmallestValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2676 { PSmallestValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2677 { PSmallestValue, PZero, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2678 { PSmallestValue, MZero, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2679 { PSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2680 { PSmallestValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2681 { PSmallestValue, PNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2682 { PSmallestValue, MNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2683 { PSmallestValue, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2684 { PSmallestValue, MLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2685 { PSmallestValue, PSmallestValue, "0x1p-148", APFloat::opOK, APFloat::fcNormal },
2686 { PSmallestValue, MSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2687 { PSmallestValue, PSmallestNormalized, "0x1.000002p-126", APFloat::opOK, APFloat::fcNormal },
2688 { PSmallestValue, MSmallestNormalized, "-0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal },
2689 { MSmallestValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2690 { MSmallestValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2691 { MSmallestValue, PZero, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2692 { MSmallestValue, MZero, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2693 { MSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2694 { MSmallestValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2695 { MSmallestValue, PNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2696 { MSmallestValue, MNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2697 { MSmallestValue, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2698 { MSmallestValue, MLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2699 { MSmallestValue, PSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2700 { MSmallestValue, MSmallestValue, "-0x1p-148", APFloat::opOK, APFloat::fcNormal },
2701 { MSmallestValue, PSmallestNormalized, "0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal },
2702 { MSmallestValue, MSmallestNormalized, "-0x1.000002p-126", APFloat::opOK, APFloat::fcNormal },
2703 { PSmallestNormalized, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2704 { PSmallestNormalized, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2705 { PSmallestNormalized, PZero, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2706 { PSmallestNormalized, MZero, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2707 { PSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2708 { PSmallestNormalized, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2709 { PSmallestNormalized, PNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2710 { PSmallestNormalized, MNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2711 { PSmallestNormalized, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2712 { PSmallestNormalized, MLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2713 { PSmallestNormalized, PSmallestValue, "0x1.000002p-126", APFloat::opOK, APFloat::fcNormal },
2714 { PSmallestNormalized, MSmallestValue, "0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal },
2715 { PSmallestNormalized, PSmallestNormalized, "0x1p-125", APFloat::opOK, APFloat::fcNormal },
2716 { PSmallestNormalized, MSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2717 { MSmallestNormalized, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2718 { MSmallestNormalized, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2719 { MSmallestNormalized, PZero, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2720 { MSmallestNormalized, MZero, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2721 { MSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2722 { MSmallestNormalized, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2723 { MSmallestNormalized, PNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2724 { MSmallestNormalized, MNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2725 { MSmallestNormalized, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2726 { MSmallestNormalized, MLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2727 { MSmallestNormalized, PSmallestValue, "-0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal },
2728 { MSmallestNormalized, MSmallestValue, "-0x1.000002p-126", APFloat::opOK, APFloat::fcNormal },
2729 { MSmallestNormalized, PSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2730 { MSmallestNormalized, MSmallestNormalized, "-0x1p-125", APFloat::opOK, APFloat::fcNormal }
2731 };
2732
2733 for (size_t i = 0; i < std::size(SpecialCaseTests); ++i) {
2734 APFloat x(SpecialCaseTests[i].x);
2735 APFloat y(SpecialCaseTests[i].y);
2736 APFloat::opStatus status = x.add(y, APFloat::rmNearestTiesToEven);
2737
2738 APFloat result(APFloat::IEEEsingle(), SpecialCaseTests[i].result);
2739
2740 EXPECT_TRUE(result.bitwiseIsEqual(x));
2741 EXPECT_EQ(SpecialCaseTests[i].status, (int)status);
2742 EXPECT_EQ(SpecialCaseTests[i].category, (int)x.getCategory());
2743 }
2744 }
2745
2746 TEST(APFloatTest, subtract) {
2747 // Test Special Cases against each other and normal values.
2748
2749 APFloat PInf = APFloat::getInf(APFloat::IEEEsingle(), false);
2750 APFloat MInf = APFloat::getInf(APFloat::IEEEsingle(), true);
2751 APFloat PZero = APFloat::getZero(APFloat::IEEEsingle(), false);
2752 APFloat MZero = APFloat::getZero(APFloat::IEEEsingle(), true);
2753 APFloat QNaN = APFloat::getNaN(APFloat::IEEEsingle(), false);
2754 APFloat SNaN = APFloat(APFloat::IEEEsingle(), "snan123");
2755 APFloat PNormalValue = APFloat(APFloat::IEEEsingle(), "0x1p+0");
2756 APFloat MNormalValue = APFloat(APFloat::IEEEsingle(), "-0x1p+0");
2757 APFloat PLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), false);
2758 APFloat MLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), true);
2759 APFloat PSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), false);
2760 APFloat MSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), true);
2761 APFloat PSmallestNormalized =
2762 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), false);
2763 APFloat MSmallestNormalized =
2764 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), true);
2765
2766 const int OverflowStatus = APFloat::opOverflow | APFloat::opInexact;
2767
2768 struct {
2769 APFloat x;
2770 APFloat y;
2771 const char *result;
2772 int status;
2773 int category;
2774 } SpecialCaseTests[] = {
2775 { PInf, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2776 { PInf, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2777 { PInf, PZero, "inf", APFloat::opOK, APFloat::fcInfinity },
2778 { PInf, MZero, "inf", APFloat::opOK, APFloat::fcInfinity },
2779 { PInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2780 { PInf, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2781 { PInf, PNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2782 { PInf, MNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2783 { PInf, PLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2784 { PInf, MLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2785 { PInf, PSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2786 { PInf, MSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2787 { PInf, PSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity },
2788 { PInf, MSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity },
2789 { MInf, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2790 { MInf, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2791 { MInf, PZero, "-inf", APFloat::opOK, APFloat::fcInfinity },
2792 { MInf, MZero, "-inf", APFloat::opOK, APFloat::fcInfinity },
2793 { MInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2794 { MInf, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2795 { MInf, PNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2796 { MInf, MNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2797 { MInf, PLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2798 { MInf, MLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2799 { MInf, PSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2800 { MInf, MSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2801 { MInf, PSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity },
2802 { MInf, MSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity },
2803 { PZero, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2804 { PZero, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2805 { PZero, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2806 { PZero, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2807 { PZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2808 { PZero, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2809 { PZero, PNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2810 { PZero, MNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2811 { PZero, PLargestValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2812 { PZero, MLargestValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2813 { PZero, PSmallestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2814 { PZero, MSmallestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2815 { PZero, PSmallestNormalized, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2816 { PZero, MSmallestNormalized, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2817 { MZero, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2818 { MZero, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2819 { MZero, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2820 { MZero, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2821 { MZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2822 { MZero, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2823 { MZero, PNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2824 { MZero, MNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2825 { MZero, PLargestValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2826 { MZero, MLargestValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2827 { MZero, PSmallestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2828 { MZero, MSmallestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2829 { MZero, PSmallestNormalized, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2830 { MZero, MSmallestNormalized, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2831 { QNaN, PInf, "nan", APFloat::opOK, APFloat::fcNaN },
2832 { QNaN, MInf, "nan", APFloat::opOK, APFloat::fcNaN },
2833 { QNaN, PZero, "nan", APFloat::opOK, APFloat::fcNaN },
2834 { QNaN, MZero, "nan", APFloat::opOK, APFloat::fcNaN },
2835 { QNaN, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2836 { QNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2837 { QNaN, PNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
2838 { QNaN, MNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
2839 { QNaN, PLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2840 { QNaN, MLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2841 { QNaN, PSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2842 { QNaN, MSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2843 { QNaN, PSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
2844 { QNaN, MSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
2845 { SNaN, PInf, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2846 { SNaN, MInf, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2847 { SNaN, PZero, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2848 { SNaN, MZero, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2849 { SNaN, QNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2850 { SNaN, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2851 { SNaN, PNormalValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2852 { SNaN, MNormalValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2853 { SNaN, PLargestValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2854 { SNaN, MLargestValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2855 { SNaN, PSmallestValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2856 { SNaN, MSmallestValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2857 { SNaN, PSmallestNormalized, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2858 { SNaN, MSmallestNormalized, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2859 { PNormalValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2860 { PNormalValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2861 { PNormalValue, PZero, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2862 { PNormalValue, MZero, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2863 { PNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2864 { PNormalValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2865 { PNormalValue, PNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2866 { PNormalValue, MNormalValue, "0x1p+1", APFloat::opOK, APFloat::fcNormal },
2867 { PNormalValue, PLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2868 { PNormalValue, MLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2869 { PNormalValue, PSmallestValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2870 { PNormalValue, MSmallestValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2871 { PNormalValue, PSmallestNormalized, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2872 { PNormalValue, MSmallestNormalized, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2873 { MNormalValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2874 { MNormalValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2875 { MNormalValue, PZero, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2876 { MNormalValue, MZero, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2877 { MNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2878 { MNormalValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2879 { MNormalValue, PNormalValue, "-0x1p+1", APFloat::opOK, APFloat::fcNormal },
2880 { MNormalValue, MNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2881 { MNormalValue, PLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2882 { MNormalValue, MLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2883 { MNormalValue, PSmallestValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2884 { MNormalValue, MSmallestValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2885 { MNormalValue, PSmallestNormalized, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2886 { MNormalValue, MSmallestNormalized, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2887 { PLargestValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2888 { PLargestValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2889 { PLargestValue, PZero, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2890 { PLargestValue, MZero, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2891 { PLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2892 { PLargestValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2893 { PLargestValue, PNormalValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2894 { PLargestValue, MNormalValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2895 { PLargestValue, PLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2896 { PLargestValue, MLargestValue, "inf", OverflowStatus, APFloat::fcInfinity },
2897 { PLargestValue, PSmallestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2898 { PLargestValue, MSmallestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2899 { PLargestValue, PSmallestNormalized, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2900 { PLargestValue, MSmallestNormalized, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2901 { MLargestValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2902 { MLargestValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2903 { MLargestValue, PZero, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2904 { MLargestValue, MZero, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2905 { MLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2906 { MLargestValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2907 { MLargestValue, PNormalValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2908 { MLargestValue, MNormalValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2909 { MLargestValue, PLargestValue, "-inf", OverflowStatus, APFloat::fcInfinity },
2910 { MLargestValue, MLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2911 { MLargestValue, PSmallestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2912 { MLargestValue, MSmallestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2913 { MLargestValue, PSmallestNormalized, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2914 { MLargestValue, MSmallestNormalized, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2915 { PSmallestValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2916 { PSmallestValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2917 { PSmallestValue, PZero, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2918 { PSmallestValue, MZero, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2919 { PSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2920 { PSmallestValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2921 { PSmallestValue, PNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2922 { PSmallestValue, MNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2923 { PSmallestValue, PLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2924 { PSmallestValue, MLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2925 { PSmallestValue, PSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2926 { PSmallestValue, MSmallestValue, "0x1p-148", APFloat::opOK, APFloat::fcNormal },
2927 { PSmallestValue, PSmallestNormalized, "-0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal },
2928 { PSmallestValue, MSmallestNormalized, "0x1.000002p-126", APFloat::opOK, APFloat::fcNormal },
2929 { MSmallestValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2930 { MSmallestValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2931 { MSmallestValue, PZero, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2932 { MSmallestValue, MZero, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2933 { MSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2934 { MSmallestValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2935 { MSmallestValue, PNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2936 { MSmallestValue, MNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2937 { MSmallestValue, PLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2938 { MSmallestValue, MLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2939 { MSmallestValue, PSmallestValue, "-0x1p-148", APFloat::opOK, APFloat::fcNormal },
2940 { MSmallestValue, MSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2941 { MSmallestValue, PSmallestNormalized, "-0x1.000002p-126", APFloat::opOK, APFloat::fcNormal },
2942 { MSmallestValue, MSmallestNormalized, "0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal },
2943 { PSmallestNormalized, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2944 { PSmallestNormalized, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2945 { PSmallestNormalized, PZero, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2946 { PSmallestNormalized, MZero, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2947 { PSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2948 { PSmallestNormalized, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2949 { PSmallestNormalized, PNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2950 { PSmallestNormalized, MNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2951 { PSmallestNormalized, PLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2952 { PSmallestNormalized, MLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2953 { PSmallestNormalized, PSmallestValue, "0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal },
2954 { PSmallestNormalized, MSmallestValue, "0x1.000002p-126", APFloat::opOK, APFloat::fcNormal },
2955 { PSmallestNormalized, PSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2956 { PSmallestNormalized, MSmallestNormalized, "0x1p-125", APFloat::opOK, APFloat::fcNormal },
2957 { MSmallestNormalized, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2958 { MSmallestNormalized, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2959 { MSmallestNormalized, PZero, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2960 { MSmallestNormalized, MZero, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2961 { MSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2962 { MSmallestNormalized, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2963 { MSmallestNormalized, PNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2964 { MSmallestNormalized, MNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2965 { MSmallestNormalized, PLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2966 { MSmallestNormalized, MLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2967 { MSmallestNormalized, PSmallestValue, "-0x1.000002p-126", APFloat::opOK, APFloat::fcNormal },
2968 { MSmallestNormalized, MSmallestValue, "-0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal },
2969 { MSmallestNormalized, PSmallestNormalized, "-0x1p-125", APFloat::opOK, APFloat::fcNormal },
2970 { MSmallestNormalized, MSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero }
2971 };
2972
2973 for (size_t i = 0; i < std::size(SpecialCaseTests); ++i) {
2974 APFloat x(SpecialCaseTests[i].x);
2975 APFloat y(SpecialCaseTests[i].y);
2976 APFloat::opStatus status = x.subtract(y, APFloat::rmNearestTiesToEven);
2977
2978 APFloat result(APFloat::IEEEsingle(), SpecialCaseTests[i].result);
2979
2980 EXPECT_TRUE(result.bitwiseIsEqual(x));
2981 EXPECT_EQ(SpecialCaseTests[i].status, (int)status);
2982 EXPECT_EQ(SpecialCaseTests[i].category, (int)x.getCategory());
2983 }
2984 }
2985
2986 TEST(APFloatTest, multiply) {
2987 // Test Special Cases against each other and normal values.
2988
2989 APFloat PInf = APFloat::getInf(APFloat::IEEEsingle(), false);
2990 APFloat MInf = APFloat::getInf(APFloat::IEEEsingle(), true);
2991 APFloat PZero = APFloat::getZero(APFloat::IEEEsingle(), false);
2992 APFloat MZero = APFloat::getZero(APFloat::IEEEsingle(), true);
2993 APFloat QNaN = APFloat::getNaN(APFloat::IEEEsingle(), false);
2994 APFloat SNaN = APFloat(APFloat::IEEEsingle(), "snan123");
2995 APFloat PNormalValue = APFloat(APFloat::IEEEsingle(), "0x1p+0");
2996 APFloat MNormalValue = APFloat(APFloat::IEEEsingle(), "-0x1p+0");
2997 APFloat PLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), false);
2998 APFloat MLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), true);
2999 APFloat PSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), false);
3000 APFloat MSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), true);
3001 APFloat PSmallestNormalized =
3002 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), false);
3003 APFloat MSmallestNormalized =
3004 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), true);
3005
3006 APFloat MaxQuad(APFloat::IEEEquad(),
3007 "0x1.ffffffffffffffffffffffffffffp+16383");
3008 APFloat MinQuad(APFloat::IEEEquad(),
3009 "0x0.0000000000000000000000000001p-16382");
3010 APFloat NMinQuad(APFloat::IEEEquad(),
3011 "-0x0.0000000000000000000000000001p-16382");
3012
3013 const int OverflowStatus = APFloat::opOverflow | APFloat::opInexact;
3014 const int UnderflowStatus = APFloat::opUnderflow | APFloat::opInexact;
3015
3016 struct {
3017 APFloat x;
3018 APFloat y;
3019 const char *result;
3020 int status;
3021 int category;
3022 APFloat::roundingMode roundingMode = APFloat::rmNearestTiesToEven;
3023 } SpecialCaseTests[] = {
3024 { PInf, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
3025 { PInf, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
3026 { PInf, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
3027 { PInf, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
3028 { PInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
3029 { PInf, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3030 { PInf, PNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
3031 { PInf, MNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
3032 { PInf, PLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
3033 { PInf, MLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
3034 { PInf, PSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
3035 { PInf, MSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
3036 { PInf, PSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity },
3037 { PInf, MSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity },
3038 { MInf, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
3039 { MInf, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
3040 { MInf, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
3041 { MInf, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
3042 { MInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
3043 { MInf, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3044 { MInf, PNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
3045 { MInf, MNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
3046 { MInf, PLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
3047 { MInf, MLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
3048 { MInf, PSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
3049 { MInf, MSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
3050 { MInf, PSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity },
3051 { MInf, MSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity },
3052 { PZero, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
3053 { PZero, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
3054 { PZero, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3055 { PZero, MZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3056 { PZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
3057 { PZero, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3058 { PZero, PNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3059 { PZero, MNormalValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3060 { PZero, PLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3061 { PZero, MLargestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3062 { PZero, PSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3063 { PZero, MSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3064 { PZero, PSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3065 { PZero, MSmallestNormalized, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3066 { MZero, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
3067 { MZero, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
3068 { MZero, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3069 { MZero, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3070 { MZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
3071 { MZero, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3072 { MZero, PNormalValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3073 { MZero, MNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3074 { MZero, PLargestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3075 { MZero, MLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3076 { MZero, PSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3077 { MZero, MSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3078 { MZero, PSmallestNormalized, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3079 { MZero, MSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3080 { QNaN, PInf, "nan", APFloat::opOK, APFloat::fcNaN },
3081 { QNaN, MInf, "nan", APFloat::opOK, APFloat::fcNaN },
3082 { QNaN, PZero, "nan", APFloat::opOK, APFloat::fcNaN },
3083 { QNaN, MZero, "nan", APFloat::opOK, APFloat::fcNaN },
3084 { QNaN, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
3085 { QNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
3086 { QNaN, PNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
3087 { QNaN, MNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
3088 { QNaN, PLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
3089 { QNaN, MLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
3090 { QNaN, PSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
3091 { QNaN, MSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
3092 { QNaN, PSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
3093 { QNaN, MSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
3094 { SNaN, PInf, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3095 { SNaN, MInf, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3096 { SNaN, PZero, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3097 { SNaN, MZero, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3098 { SNaN, QNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3099 { SNaN, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3100 { SNaN, PNormalValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3101 { SNaN, MNormalValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3102 { SNaN, PLargestValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3103 { SNaN, MLargestValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3104 { SNaN, PSmallestValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3105 { SNaN, MSmallestValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3106 { SNaN, PSmallestNormalized, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3107 { SNaN, MSmallestNormalized, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3108 { PNormalValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
3109 { PNormalValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
3110 { PNormalValue, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3111 { PNormalValue, MZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3112 { PNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
3113 { PNormalValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3114 { PNormalValue, PNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
3115 { PNormalValue, MNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
3116 { PNormalValue, PLargestValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
3117 { PNormalValue, MLargestValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
3118 { PNormalValue, PSmallestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
3119 { PNormalValue, MSmallestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
3120 { PNormalValue, PSmallestNormalized, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
3121 { PNormalValue, MSmallestNormalized, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
3122 { MNormalValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
3123 { MNormalValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
3124 { MNormalValue, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3125 { MNormalValue, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3126 { MNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
3127 { MNormalValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3128 { MNormalValue, PNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
3129 { MNormalValue, MNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
3130 { MNormalValue, PLargestValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
3131 { MNormalValue, MLargestValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
3132 { MNormalValue, PSmallestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
3133 { MNormalValue, MSmallestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
3134 { MNormalValue, PSmallestNormalized, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
3135 { MNormalValue, MSmallestNormalized, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
3136 { PLargestValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
3137 { PLargestValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
3138 { PLargestValue, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3139 { PLargestValue, MZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3140 { PLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
3141 { PLargestValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3142 { PLargestValue, PNormalValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
3143 { PLargestValue, MNormalValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
3144 { PLargestValue, PLargestValue, "inf", OverflowStatus, APFloat::fcInfinity },
3145 { PLargestValue, MLargestValue, "-inf", OverflowStatus, APFloat::fcInfinity },
3146 { PLargestValue, PSmallestValue, "0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal },
3147 { PLargestValue, MSmallestValue, "-0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal },
3148 { PLargestValue, PSmallestNormalized, "0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal },
3149 { PLargestValue, MSmallestNormalized, "-0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal },
3150 { MLargestValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
3151 { MLargestValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
3152 { MLargestValue, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3153 { MLargestValue, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3154 { MLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
3155 { MLargestValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3156 { MLargestValue, PNormalValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
3157 { MLargestValue, MNormalValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
3158 { MLargestValue, PLargestValue, "-inf", OverflowStatus, APFloat::fcInfinity },
3159 { MLargestValue, MLargestValue, "inf", OverflowStatus, APFloat::fcInfinity },
3160 { MLargestValue, PSmallestValue, "-0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal },
3161 { MLargestValue, MSmallestValue, "0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal },
3162 { MLargestValue, PSmallestNormalized, "-0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal },
3163 { MLargestValue, MSmallestNormalized, "0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal },
3164 { PSmallestValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
3165 { PSmallestValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
3166 { PSmallestValue, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3167 { PSmallestValue, MZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3168 { PSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
3169 { PSmallestValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3170 { PSmallestValue, PNormalValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
3171 { PSmallestValue, MNormalValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
3172 { PSmallestValue, PLargestValue, "0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal },
3173 { PSmallestValue, MLargestValue, "-0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal },
3174 { PSmallestValue, PSmallestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero },
3175 { PSmallestValue, MSmallestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
3176 { PSmallestValue, PSmallestNormalized, "0x0p+0", UnderflowStatus, APFloat::fcZero },
3177 { PSmallestValue, MSmallestNormalized, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
3178 { MSmallestValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
3179 { MSmallestValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
3180 { MSmallestValue, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3181 { MSmallestValue, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3182 { MSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
3183 { MSmallestValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3184 { MSmallestValue, PNormalValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
3185 { MSmallestValue, MNormalValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
3186 { MSmallestValue, PLargestValue, "-0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal },
3187 { MSmallestValue, MLargestValue, "0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal },
3188 { MSmallestValue, PSmallestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
3189 { MSmallestValue, MSmallestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero },
3190 { MSmallestValue, PSmallestNormalized, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
3191 { MSmallestValue, MSmallestNormalized, "0x0p+0", UnderflowStatus, APFloat::fcZero },
3192 { PSmallestNormalized, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
3193 { PSmallestNormalized, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
3194 { PSmallestNormalized, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3195 { PSmallestNormalized, MZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3196 { PSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
3197 { PSmallestNormalized, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3198 { PSmallestNormalized, PNormalValue, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
3199 { PSmallestNormalized, MNormalValue, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
3200 { PSmallestNormalized, PLargestValue, "0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal },
3201 { PSmallestNormalized, MLargestValue, "-0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal },
3202 { PSmallestNormalized, PSmallestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero },
3203 { PSmallestNormalized, MSmallestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
3204 { PSmallestNormalized, PSmallestNormalized, "0x0p+0", UnderflowStatus, APFloat::fcZero },
3205 { PSmallestNormalized, MSmallestNormalized, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
3206 { MSmallestNormalized, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
3207 { MSmallestNormalized, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
3208 { MSmallestNormalized, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3209 { MSmallestNormalized, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3210 { MSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
3211 { MSmallestNormalized, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3212 { MSmallestNormalized, PNormalValue, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
3213 { MSmallestNormalized, MNormalValue, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
3214 { MSmallestNormalized, PLargestValue, "-0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal },
3215 { MSmallestNormalized, MLargestValue, "0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal },
3216 { MSmallestNormalized, PSmallestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
3217 { MSmallestNormalized, MSmallestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero },
3218 { MSmallestNormalized, PSmallestNormalized, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
3219 { MSmallestNormalized, MSmallestNormalized, "0x0p+0", UnderflowStatus, APFloat::fcZero },
3220
3221 {MaxQuad, MinQuad, "0x1.ffffffffffffffffffffffffffffp-111", APFloat::opOK,
3222 APFloat::fcNormal, APFloat::rmNearestTiesToEven},
3223 {MaxQuad, MinQuad, "0x1.ffffffffffffffffffffffffffffp-111", APFloat::opOK,
3224 APFloat::fcNormal, APFloat::rmTowardPositive},
3225 {MaxQuad, MinQuad, "0x1.ffffffffffffffffffffffffffffp-111", APFloat::opOK,
3226 APFloat::fcNormal, APFloat::rmTowardNegative},
3227 {MaxQuad, MinQuad, "0x1.ffffffffffffffffffffffffffffp-111", APFloat::opOK,
3228 APFloat::fcNormal, APFloat::rmTowardZero},
3229 {MaxQuad, MinQuad, "0x1.ffffffffffffffffffffffffffffp-111", APFloat::opOK,
3230 APFloat::fcNormal, APFloat::rmNearestTiesToAway},
3231
3232 {MaxQuad, NMinQuad, "-0x1.ffffffffffffffffffffffffffffp-111", APFloat::opOK,
3233 APFloat::fcNormal, APFloat::rmNearestTiesToEven},
3234 {MaxQuad, NMinQuad, "-0x1.ffffffffffffffffffffffffffffp-111", APFloat::opOK,
3235 APFloat::fcNormal, APFloat::rmTowardPositive},
3236 {MaxQuad, NMinQuad, "-0x1.ffffffffffffffffffffffffffffp-111", APFloat::opOK,
3237 APFloat::fcNormal, APFloat::rmTowardNegative},
3238 {MaxQuad, NMinQuad, "-0x1.ffffffffffffffffffffffffffffp-111", APFloat::opOK,
3239 APFloat::fcNormal, APFloat::rmTowardZero},
3240 {MaxQuad, NMinQuad, "-0x1.ffffffffffffffffffffffffffffp-111", APFloat::opOK,
3241 APFloat::fcNormal, APFloat::rmNearestTiesToAway},
3242
3243 {MaxQuad, MaxQuad, "inf", OverflowStatus, APFloat::fcInfinity,
3244 APFloat::rmNearestTiesToEven},
3245 {MaxQuad, MaxQuad, "inf", OverflowStatus, APFloat::fcInfinity,
3246 APFloat::rmTowardPositive},
3247 {MaxQuad, MaxQuad, "0x1.ffffffffffffffffffffffffffffp+16383",
3248 APFloat::opInexact, APFloat::fcNormal, APFloat::rmTowardNegative},
3249 {MaxQuad, MaxQuad, "0x1.ffffffffffffffffffffffffffffp+16383",
3250 APFloat::opInexact, APFloat::fcNormal, APFloat::rmTowardZero},
3251 {MaxQuad, MaxQuad, "inf", OverflowStatus, APFloat::fcInfinity,
3252 APFloat::rmNearestTiesToAway},
3253
3254 {MinQuad, MinQuad, "0", UnderflowStatus, APFloat::fcZero,
3255 APFloat::rmNearestTiesToEven},
3256 {MinQuad, MinQuad, "0x0.0000000000000000000000000001p-16382",
3257 UnderflowStatus, APFloat::fcNormal, APFloat::rmTowardPositive},
3258 {MinQuad, MinQuad, "0", UnderflowStatus, APFloat::fcZero,
3259 APFloat::rmTowardNegative},
3260 {MinQuad, MinQuad, "0", UnderflowStatus, APFloat::fcZero,
3261 APFloat::rmTowardZero},
3262 {MinQuad, MinQuad, "0", UnderflowStatus, APFloat::fcZero,
3263 APFloat::rmNearestTiesToAway},
3264
3265 {MinQuad, NMinQuad, "-0", UnderflowStatus, APFloat::fcZero,
3266 APFloat::rmNearestTiesToEven},
3267 {MinQuad, NMinQuad, "-0", UnderflowStatus, APFloat::fcZero,
3268 APFloat::rmTowardPositive},
3269 {MinQuad, NMinQuad, "-0x0.0000000000000000000000000001p-16382",
3270 UnderflowStatus, APFloat::fcNormal, APFloat::rmTowardNegative},
3271 {MinQuad, NMinQuad, "-0", UnderflowStatus, APFloat::fcZero,
3272 APFloat::rmTowardZero},
3273 {MinQuad, NMinQuad, "-0", UnderflowStatus, APFloat::fcZero,
3274 APFloat::rmNearestTiesToAway},
3275 };
3276
3277 for (size_t i = 0; i < std::size(SpecialCaseTests); ++i) {
3278 APFloat x(SpecialCaseTests[i].x);
3279 APFloat y(SpecialCaseTests[i].y);
3280 APFloat::opStatus status = x.multiply(y, SpecialCaseTests[i].roundingMode);
3281
3282 APFloat result(x.getSemantics(), SpecialCaseTests[i].result);
3283
3284 EXPECT_TRUE(result.bitwiseIsEqual(x));
3285 EXPECT_EQ(SpecialCaseTests[i].status, (int)status);
3286 EXPECT_EQ(SpecialCaseTests[i].category, (int)x.getCategory());
3287 }
3288 }
3289
3290 TEST(APFloatTest, divide) {
3291 // Test Special Cases against each other and normal values.
3292
3293 APFloat PInf = APFloat::getInf(APFloat::IEEEsingle(), false);
3294 APFloat MInf = APFloat::getInf(APFloat::IEEEsingle(), true);
3295 APFloat PZero = APFloat::getZero(APFloat::IEEEsingle(), false);
3296 APFloat MZero = APFloat::getZero(APFloat::IEEEsingle(), true);
3297 APFloat QNaN = APFloat::getNaN(APFloat::IEEEsingle(), false);
3298 APFloat SNaN = APFloat(APFloat::IEEEsingle(), "snan123");
3299 APFloat PNormalValue = APFloat(APFloat::IEEEsingle(), "0x1p+0");
3300 APFloat MNormalValue = APFloat(APFloat::IEEEsingle(), "-0x1p+0");
3301 APFloat PLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), false);
3302 APFloat MLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), true);
3303 APFloat PSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), false);
3304 APFloat MSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), true);
3305 APFloat PSmallestNormalized =
3306 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), false);
3307 APFloat MSmallestNormalized =
3308 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), true);
3309
3310 APFloat MaxQuad(APFloat::IEEEquad(),
3311 "0x1.ffffffffffffffffffffffffffffp+16383");
3312 APFloat MinQuad(APFloat::IEEEquad(),
3313 "0x0.0000000000000000000000000001p-16382");
3314 APFloat NMinQuad(APFloat::IEEEquad(),
3315 "-0x0.0000000000000000000000000001p-16382");
3316
3317 const int OverflowStatus = APFloat::opOverflow | APFloat::opInexact;
3318 const int UnderflowStatus = APFloat::opUnderflow | APFloat::opInexact;
3319
3320 struct {
3321 APFloat x;
3322 APFloat y;
3323 const char *result;
3324 int status;
3325 int category;
3326 APFloat::roundingMode roundingMode = APFloat::rmNearestTiesToEven;
3327 } SpecialCaseTests[] = {
3328 { PInf, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
3329 { PInf, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
3330 { PInf, PZero, "inf", APFloat::opOK, APFloat::fcInfinity },
3331 { PInf, MZero, "-inf", APFloat::opOK, APFloat::fcInfinity },
3332 { PInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
3333 { PInf, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3334 { PInf, PNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
3335 { PInf, MNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
3336 { PInf, PLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
3337 { PInf, MLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
3338 { PInf, PSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
3339 { PInf, MSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
3340 { PInf, PSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity },
3341 { PInf, MSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity },
3342 { MInf, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
3343 { MInf, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
3344 { MInf, PZero, "-inf", APFloat::opOK, APFloat::fcInfinity },
3345 { MInf, MZero, "inf", APFloat::opOK, APFloat::fcInfinity },
3346 { MInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
3347 { MInf, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3348 { MInf, PNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
3349 { MInf, MNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
3350 { MInf, PLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
3351 { MInf, MLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
3352 { MInf, PSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
3353 { MInf, MSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
3354 { MInf, PSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity },
3355 { MInf, MSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity },
3356 { PZero, PInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3357 { PZero, MInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3358 { PZero, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
3359 { PZero, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
3360 { PZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
3361 { PZero, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3362 { PZero, PNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3363 { PZero, MNormalValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3364 { PZero, PLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3365 { PZero, MLargestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3366 { PZero, PSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3367 { PZero, MSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3368 { PZero, PSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3369 { PZero, MSmallestNormalized, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3370 { MZero, PInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3371 { MZero, MInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3372 { MZero, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
3373 { MZero, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
3374 { MZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
3375 { MZero, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3376 { MZero, PNormalValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3377 { MZero, MNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3378 { MZero, PLargestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3379 { MZero, MLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3380 { MZero, PSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3381 { MZero, MSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3382 { MZero, PSmallestNormalized, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3383 { MZero, MSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3384 { QNaN, PInf, "nan", APFloat::opOK, APFloat::fcNaN },
3385 { QNaN, MInf, "nan", APFloat::opOK, APFloat::fcNaN },
3386 { QNaN, PZero, "nan", APFloat::opOK, APFloat::fcNaN },
3387 { QNaN, MZero, "nan", APFloat::opOK, APFloat::fcNaN },
3388 { QNaN, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
3389 { QNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
3390 { QNaN, PNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
3391 { QNaN, MNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
3392 { QNaN, PLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
3393 { QNaN, MLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
3394 { QNaN, PSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
3395 { QNaN, MSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
3396 { QNaN, PSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
3397 { QNaN, MSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
3398 { SNaN, PInf, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3399 { SNaN, MInf, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3400 { SNaN, PZero, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3401 { SNaN, MZero, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3402 { SNaN, QNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3403 { SNaN, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3404 { SNaN, PNormalValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3405 { SNaN, MNormalValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3406 { SNaN, PLargestValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3407 { SNaN, MLargestValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3408 { SNaN, PSmallestValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3409 { SNaN, MSmallestValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3410 { SNaN, PSmallestNormalized, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3411 { SNaN, MSmallestNormalized, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3412 { PNormalValue, PInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3413 { PNormalValue, MInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3414 { PNormalValue, PZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
3415 { PNormalValue, MZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
3416 { PNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
3417 { PNormalValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3418 { PNormalValue, PNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
3419 { PNormalValue, MNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
3420 { PNormalValue, PLargestValue, "0x1p-128", UnderflowStatus, APFloat::fcNormal },
3421 { PNormalValue, MLargestValue, "-0x1p-128", UnderflowStatus, APFloat::fcNormal },
3422 { PNormalValue, PSmallestValue, "inf", OverflowStatus, APFloat::fcInfinity },
3423 { PNormalValue, MSmallestValue, "-inf", OverflowStatus, APFloat::fcInfinity },
3424 { PNormalValue, PSmallestNormalized, "0x1p+126", APFloat::opOK, APFloat::fcNormal },
3425 { PNormalValue, MSmallestNormalized, "-0x1p+126", APFloat::opOK, APFloat::fcNormal },
3426 { MNormalValue, PInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3427 { MNormalValue, MInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3428 { MNormalValue, PZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
3429 { MNormalValue, MZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
3430 { MNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
3431 { MNormalValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3432 { MNormalValue, PNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
3433 { MNormalValue, MNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
3434 { MNormalValue, PLargestValue, "-0x1p-128", UnderflowStatus, APFloat::fcNormal },
3435 { MNormalValue, MLargestValue, "0x1p-128", UnderflowStatus, APFloat::fcNormal },
3436 { MNormalValue, PSmallestValue, "-inf", OverflowStatus, APFloat::fcInfinity },
3437 { MNormalValue, MSmallestValue, "inf", OverflowStatus, APFloat::fcInfinity },
3438 { MNormalValue, PSmallestNormalized, "-0x1p+126", APFloat::opOK, APFloat::fcNormal },
3439 { MNormalValue, MSmallestNormalized, "0x1p+126", APFloat::opOK, APFloat::fcNormal },
3440 { PLargestValue, PInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3441 { PLargestValue, MInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3442 { PLargestValue, PZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
3443 { PLargestValue, MZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
3444 { PLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
3445 { PLargestValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3446 { PLargestValue, PNormalValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
3447 { PLargestValue, MNormalValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
3448 { PLargestValue, PLargestValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
3449 { PLargestValue, MLargestValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
3450 { PLargestValue, PSmallestValue, "inf", OverflowStatus, APFloat::fcInfinity },
3451 { PLargestValue, MSmallestValue, "-inf", OverflowStatus, APFloat::fcInfinity },
3452 { PLargestValue, PSmallestNormalized, "inf", OverflowStatus, APFloat::fcInfinity },
3453 { PLargestValue, MSmallestNormalized, "-inf", OverflowStatus, APFloat::fcInfinity },
3454 { MLargestValue, PInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3455 { MLargestValue, MInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3456 { MLargestValue, PZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
3457 { MLargestValue, MZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
3458 { MLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
3459 { MLargestValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3460 { MLargestValue, PNormalValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
3461 { MLargestValue, MNormalValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
3462 { MLargestValue, PLargestValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
3463 { MLargestValue, MLargestValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
3464 { MLargestValue, PSmallestValue, "-inf", OverflowStatus, APFloat::fcInfinity },
3465 { MLargestValue, MSmallestValue, "inf", OverflowStatus, APFloat::fcInfinity },
3466 { MLargestValue, PSmallestNormalized, "-inf", OverflowStatus, APFloat::fcInfinity },
3467 { MLargestValue, MSmallestNormalized, "inf", OverflowStatus, APFloat::fcInfinity },
3468 { PSmallestValue, PInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3469 { PSmallestValue, MInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3470 { PSmallestValue, PZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
3471 { PSmallestValue, MZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
3472 { PSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
3473 { PSmallestValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3474 { PSmallestValue, PNormalValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
3475 { PSmallestValue, MNormalValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
3476 { PSmallestValue, PLargestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero },
3477 { PSmallestValue, MLargestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
3478 { PSmallestValue, PSmallestValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
3479 { PSmallestValue, MSmallestValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
3480 { PSmallestValue, PSmallestNormalized, "0x1p-23", APFloat::opOK, APFloat::fcNormal },
3481 { PSmallestValue, MSmallestNormalized, "-0x1p-23", APFloat::opOK, APFloat::fcNormal },
3482 { MSmallestValue, PInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3483 { MSmallestValue, MInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3484 { MSmallestValue, PZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
3485 { MSmallestValue, MZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
3486 { MSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
3487 { MSmallestValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3488 { MSmallestValue, PNormalValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
3489 { MSmallestValue, MNormalValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
3490 { MSmallestValue, PLargestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
3491 { MSmallestValue, MLargestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero },
3492 { MSmallestValue, PSmallestValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
3493 { MSmallestValue, MSmallestValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
3494 { MSmallestValue, PSmallestNormalized, "-0x1p-23", APFloat::opOK, APFloat::fcNormal },
3495 { MSmallestValue, MSmallestNormalized, "0x1p-23", APFloat::opOK, APFloat::fcNormal },
3496 { PSmallestNormalized, PInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3497 { PSmallestNormalized, MInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3498 { PSmallestNormalized, PZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
3499 { PSmallestNormalized, MZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
3500 { PSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
3501 { PSmallestNormalized, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3502 { PSmallestNormalized, PNormalValue, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
3503 { PSmallestNormalized, MNormalValue, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
3504 { PSmallestNormalized, PLargestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero },
3505 { PSmallestNormalized, MLargestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
3506 { PSmallestNormalized, PSmallestValue, "0x1p+23", APFloat::opOK, APFloat::fcNormal },
3507 { PSmallestNormalized, MSmallestValue, "-0x1p+23", APFloat::opOK, APFloat::fcNormal },
3508 { PSmallestNormalized, PSmallestNormalized, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
3509 { PSmallestNormalized, MSmallestNormalized, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
3510 { MSmallestNormalized, PInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3511 { MSmallestNormalized, MInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3512 { MSmallestNormalized, PZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
3513 { MSmallestNormalized, MZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
3514 { MSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
3515 { MSmallestNormalized, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3516 { MSmallestNormalized, PNormalValue, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
3517 { MSmallestNormalized, MNormalValue, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
3518 { MSmallestNormalized, PLargestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
3519 { MSmallestNormalized, MLargestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero },
3520 { MSmallestNormalized, PSmallestValue, "-0x1p+23", APFloat::opOK, APFloat::fcNormal },
3521 { MSmallestNormalized, MSmallestValue, "0x1p+23", APFloat::opOK, APFloat::fcNormal },
3522 { MSmallestNormalized, PSmallestNormalized, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
3523 { MSmallestNormalized, MSmallestNormalized, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
3524
3525 {MaxQuad, NMinQuad, "-inf", OverflowStatus, APFloat::fcInfinity,
3526 APFloat::rmNearestTiesToEven},
3527 {MaxQuad, NMinQuad, "-0x1.ffffffffffffffffffffffffffffp+16383",
3528 APFloat::opInexact, APFloat::fcNormal, APFloat::rmTowardPositive},
3529 {MaxQuad, NMinQuad, "-inf", OverflowStatus, APFloat::fcInfinity,
3530 APFloat::rmTowardNegative},
3531 {MaxQuad, NMinQuad, "-0x1.ffffffffffffffffffffffffffffp+16383",
3532 APFloat::opInexact, APFloat::fcNormal, APFloat::rmTowardZero},
3533 {MaxQuad, NMinQuad, "-inf", OverflowStatus, APFloat::fcInfinity,
3534 APFloat::rmNearestTiesToAway},
3535
3536 {MinQuad, MaxQuad, "0", UnderflowStatus, APFloat::fcZero,
3537 APFloat::rmNearestTiesToEven},
3538 {MinQuad, MaxQuad, "0x0.0000000000000000000000000001p-16382",
3539 UnderflowStatus, APFloat::fcNormal, APFloat::rmTowardPositive},
3540 {MinQuad, MaxQuad, "0", UnderflowStatus, APFloat::fcZero,
3541 APFloat::rmTowardNegative},
3542 {MinQuad, MaxQuad, "0", UnderflowStatus, APFloat::fcZero,
3543 APFloat::rmTowardZero},
3544 {MinQuad, MaxQuad, "0", UnderflowStatus, APFloat::fcZero,
3545 APFloat::rmNearestTiesToAway},
3546
3547 {NMinQuad, MaxQuad, "-0", UnderflowStatus, APFloat::fcZero,
3548 APFloat::rmNearestTiesToEven},
3549 {NMinQuad, MaxQuad, "-0", UnderflowStatus, APFloat::fcZero,
3550 APFloat::rmTowardPositive},
3551 {NMinQuad, MaxQuad, "-0x0.0000000000000000000000000001p-16382",
3552 UnderflowStatus, APFloat::fcNormal, APFloat::rmTowardNegative},
3553 {NMinQuad, MaxQuad, "-0", UnderflowStatus, APFloat::fcZero,
3554 APFloat::rmTowardZero},
3555 {NMinQuad, MaxQuad, "-0", UnderflowStatus, APFloat::fcZero,
3556 APFloat::rmNearestTiesToAway},
3557 };
3558
3559 for (size_t i = 0; i < std::size(SpecialCaseTests); ++i) {
3560 APFloat x(SpecialCaseTests[i].x);
3561 APFloat y(SpecialCaseTests[i].y);
3562 APFloat::opStatus status = x.divide(y, SpecialCaseTests[i].roundingMode);
3563
3564 APFloat result(x.getSemantics(), SpecialCaseTests[i].result);
3565
3566 EXPECT_TRUE(result.bitwiseIsEqual(x));
3567 EXPECT_EQ(SpecialCaseTests[i].status, (int)status);
3568 EXPECT_EQ(SpecialCaseTests[i].category, (int)x.getCategory());
3569 }
3570 }
3571
3572 TEST(APFloatTest, operatorOverloads) {
3573 // This is mostly testing that these operator overloads compile.
3574 APFloat One = APFloat(APFloat::IEEEsingle(), "0x1p+0");
3575 APFloat Two = APFloat(APFloat::IEEEsingle(), "0x2p+0");
3576 EXPECT_TRUE(Two.bitwiseIsEqual(One + One));
3577 EXPECT_TRUE(One.bitwiseIsEqual(Two - One));
3578 EXPECT_TRUE(Two.bitwiseIsEqual(One * Two));
3579 EXPECT_TRUE(One.bitwiseIsEqual(Two / Two));
3580 }
3581
3582 TEST(APFloatTest, Comparisons) {
3583 enum {MNan, MInf, MBig, MOne, MZer, PZer, POne, PBig, PInf, PNan, NumVals};
3584 APFloat Vals[NumVals] = {
3585 APFloat::getNaN(APFloat::IEEEsingle(), true),
3586 APFloat::getInf(APFloat::IEEEsingle(), true),
3587 APFloat::getLargest(APFloat::IEEEsingle(), true),
3588 APFloat(APFloat::IEEEsingle(), "-0x1p+0"),
3589 APFloat::getZero(APFloat::IEEEsingle(), true),
3590 APFloat::getZero(APFloat::IEEEsingle(), false),
3591 APFloat(APFloat::IEEEsingle(), "0x1p+0"),
3592 APFloat::getLargest(APFloat::IEEEsingle(), false),
3593 APFloat::getInf(APFloat::IEEEsingle(), false),
3594 APFloat::getNaN(APFloat::IEEEsingle(), false),
3595 };
3596 using Relation = void (*)(const APFloat &, const APFloat &);
3597 Relation LT = [](const APFloat &LHS, const APFloat &RHS) {
3598 EXPECT_FALSE(LHS == RHS);
3599 EXPECT_TRUE(LHS != RHS);
3600 EXPECT_TRUE(LHS < RHS);
3601 EXPECT_FALSE(LHS > RHS);
3602 EXPECT_TRUE(LHS <= RHS);
3603 EXPECT_FALSE(LHS >= RHS);
3604 };
3605 Relation EQ = [](const APFloat &LHS, const APFloat &RHS) {
3606 EXPECT_TRUE(LHS == RHS);
3607 EXPECT_FALSE(LHS != RHS);
3608 EXPECT_FALSE(LHS < RHS);
3609 EXPECT_FALSE(LHS > RHS);
3610 EXPECT_TRUE(LHS <= RHS);
3611 EXPECT_TRUE(LHS >= RHS);
3612 };
3613 Relation GT = [](const APFloat &LHS, const APFloat &RHS) {
3614 EXPECT_FALSE(LHS == RHS);
3615 EXPECT_TRUE(LHS != RHS);
3616 EXPECT_FALSE(LHS < RHS);
3617 EXPECT_TRUE(LHS > RHS);
3618 EXPECT_FALSE(LHS <= RHS);
3619 EXPECT_TRUE(LHS >= RHS);
3620 };
3621 Relation UN = [](const APFloat &LHS, const APFloat &RHS) {
3622 EXPECT_FALSE(LHS == RHS);
3623 EXPECT_TRUE(LHS != RHS);
3624 EXPECT_FALSE(LHS < RHS);
3625 EXPECT_FALSE(LHS > RHS);
3626 EXPECT_FALSE(LHS <= RHS);
3627 EXPECT_FALSE(LHS >= RHS);
3628 };
3629 Relation Relations[NumVals][NumVals] = {
3630 // -N -I -B -1 -0 +0 +1 +B +I +N
3631 /* MNan */ {UN, UN, UN, UN, UN, UN, UN, UN, UN, UN},
3632 /* MInf */ {UN, EQ, LT, LT, LT, LT, LT, LT, LT, UN},
3633 /* MBig */ {UN, GT, EQ, LT, LT, LT, LT, LT, LT, UN},
3634 /* MOne */ {UN, GT, GT, EQ, LT, LT, LT, LT, LT, UN},
3635 /* MZer */ {UN, GT, GT, GT, EQ, EQ, LT, LT, LT, UN},
3636 /* PZer */ {UN, GT, GT, GT, EQ, EQ, LT, LT, LT, UN},
3637 /* POne */ {UN, GT, GT, GT, GT, GT, EQ, LT, LT, UN},
3638 /* PBig */ {UN, GT, GT, GT, GT, GT, GT, EQ, LT, UN},
3639 /* PInf */ {UN, GT, GT, GT, GT, GT, GT, GT, EQ, UN},
3640 /* PNan */ {UN, UN, UN, UN, UN, UN, UN, UN, UN, UN},
3641 };
3642 for (unsigned I = 0; I < NumVals; ++I)
3643 for (unsigned J = 0; J < NumVals; ++J)
3644 Relations[I][J](Vals[I], Vals[J]);
3645 }
3646
3647 TEST(APFloatTest, abs) {
3648 APFloat PInf = APFloat::getInf(APFloat::IEEEsingle(), false);
3649 APFloat MInf = APFloat::getInf(APFloat::IEEEsingle(), true);
3650 APFloat PZero = APFloat::getZero(APFloat::IEEEsingle(), false);
3651 APFloat MZero = APFloat::getZero(APFloat::IEEEsingle(), true);
3652 APFloat PQNaN = APFloat::getNaN(APFloat::IEEEsingle(), false);
3653 APFloat MQNaN = APFloat::getNaN(APFloat::IEEEsingle(), true);
3654 APFloat PSNaN = APFloat::getSNaN(APFloat::IEEEsingle(), false);
3655 APFloat MSNaN = APFloat::getSNaN(APFloat::IEEEsingle(), true);
3656 APFloat PNormalValue = APFloat(APFloat::IEEEsingle(), "0x1p+0");
3657 APFloat MNormalValue = APFloat(APFloat::IEEEsingle(), "-0x1p+0");
3658 APFloat PLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), false);
3659 APFloat MLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), true);
3660 APFloat PSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), false);
3661 APFloat MSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), true);
3662 APFloat PSmallestNormalized =
3663 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), false);
3664 APFloat MSmallestNormalized =
3665 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), true);
3666
3667 EXPECT_TRUE(PInf.bitwiseIsEqual(abs(PInf)));
3668 EXPECT_TRUE(PInf.bitwiseIsEqual(abs(MInf)));
3669 EXPECT_TRUE(PZero.bitwiseIsEqual(abs(PZero)));
3670 EXPECT_TRUE(PZero.bitwiseIsEqual(abs(MZero)));
3671 EXPECT_TRUE(PQNaN.bitwiseIsEqual(abs(PQNaN)));
3672 EXPECT_TRUE(PQNaN.bitwiseIsEqual(abs(MQNaN)));
3673 EXPECT_TRUE(PSNaN.bitwiseIsEqual(abs(PSNaN)));
3674 EXPECT_TRUE(PSNaN.bitwiseIsEqual(abs(MSNaN)));
3675 EXPECT_TRUE(PNormalValue.bitwiseIsEqual(abs(PNormalValue)));
3676 EXPECT_TRUE(PNormalValue.bitwiseIsEqual(abs(MNormalValue)));
3677 EXPECT_TRUE(PLargestValue.bitwiseIsEqual(abs(PLargestValue)));
3678 EXPECT_TRUE(PLargestValue.bitwiseIsEqual(abs(MLargestValue)));
3679 EXPECT_TRUE(PSmallestValue.bitwiseIsEqual(abs(PSmallestValue)));
3680 EXPECT_TRUE(PSmallestValue.bitwiseIsEqual(abs(MSmallestValue)));
3681 EXPECT_TRUE(PSmallestNormalized.bitwiseIsEqual(abs(PSmallestNormalized)));
3682 EXPECT_TRUE(PSmallestNormalized.bitwiseIsEqual(abs(MSmallestNormalized)));
3683 }
3684
3685 TEST(APFloatTest, neg) {
3686 APFloat One = APFloat(APFloat::IEEEsingle(), "1.0");
3687 APFloat NegOne = APFloat(APFloat::IEEEsingle(), "-1.0");
3688 APFloat Zero = APFloat::getZero(APFloat::IEEEsingle(), false);
3689 APFloat NegZero = APFloat::getZero(APFloat::IEEEsingle(), true);
3690 APFloat Inf = APFloat::getInf(APFloat::IEEEsingle(), false);
3691 APFloat NegInf = APFloat::getInf(APFloat::IEEEsingle(), true);
3692 APFloat QNaN = APFloat::getNaN(APFloat::IEEEsingle(), false);
3693 APFloat NegQNaN = APFloat::getNaN(APFloat::IEEEsingle(), true);
3694
3695 EXPECT_TRUE(NegOne.bitwiseIsEqual(neg(One)));
3696 EXPECT_TRUE(One.bitwiseIsEqual(neg(NegOne)));
3697 EXPECT_TRUE(NegZero.bitwiseIsEqual(neg(Zero)));
3698 EXPECT_TRUE(Zero.bitwiseIsEqual(neg(NegZero)));
3699 EXPECT_TRUE(NegInf.bitwiseIsEqual(neg(Inf)));
3700 EXPECT_TRUE(Inf.bitwiseIsEqual(neg(NegInf)));
3701 EXPECT_TRUE(NegInf.bitwiseIsEqual(neg(Inf)));
3702 EXPECT_TRUE(Inf.bitwiseIsEqual(neg(NegInf)));
3703 EXPECT_TRUE(NegQNaN.bitwiseIsEqual(neg(QNaN)));
3704 EXPECT_TRUE(QNaN.bitwiseIsEqual(neg(NegQNaN)));
3705
3706 EXPECT_TRUE(NegOne.bitwiseIsEqual(-One));
3707 EXPECT_TRUE(One.bitwiseIsEqual(-NegOne));
3708 EXPECT_TRUE(NegZero.bitwiseIsEqual(-Zero));
3709 EXPECT_TRUE(Zero.bitwiseIsEqual(-NegZero));
3710 EXPECT_TRUE(NegInf.bitwiseIsEqual(-Inf));
3711 EXPECT_TRUE(Inf.bitwiseIsEqual(-NegInf));
3712 EXPECT_TRUE(NegInf.bitwiseIsEqual(-Inf));
3713 EXPECT_TRUE(Inf.bitwiseIsEqual(-NegInf));
3714 EXPECT_TRUE(NegQNaN.bitwiseIsEqual(-QNaN));
3715 EXPECT_TRUE(QNaN.bitwiseIsEqual(-NegQNaN));
3716 }
3717
3718 TEST(APFloatTest, ilogb) {
3719 EXPECT_EQ(-1074, ilogb(APFloat::getSmallest(APFloat::IEEEdouble(), false)));
3720 EXPECT_EQ(-1074, ilogb(APFloat::getSmallest(APFloat::IEEEdouble(), true)));
3721 EXPECT_EQ(-1023, ilogb(APFloat(APFloat::IEEEdouble(), "0x1.ffffffffffffep-1024")));
3722 EXPECT_EQ(-1023, ilogb(APFloat(APFloat::IEEEdouble(), "0x1.ffffffffffffep-1023")));
3723 EXPECT_EQ(-1023, ilogb(APFloat(APFloat::IEEEdouble(), "-0x1.ffffffffffffep-1023")));
3724 EXPECT_EQ(-51, ilogb(APFloat(APFloat::IEEEdouble(), "0x1p-51")));
3725 EXPECT_EQ(-1023, ilogb(APFloat(APFloat::IEEEdouble(), "0x1.c60f120d9f87cp-1023")));
3726 EXPECT_EQ(-2, ilogb(APFloat(APFloat::IEEEdouble(), "0x0.ffffp-1")));
3727 EXPECT_EQ(-1023, ilogb(APFloat(APFloat::IEEEdouble(), "0x1.fffep-1023")));
3728 EXPECT_EQ(1023, ilogb(APFloat::getLargest(APFloat::IEEEdouble(), false)));
3729 EXPECT_EQ(1023, ilogb(APFloat::getLargest(APFloat::IEEEdouble(), true)));
3730
3731
3732 EXPECT_EQ(0, ilogb(APFloat(APFloat::IEEEsingle(), "0x1p+0")));
3733 EXPECT_EQ(0, ilogb(APFloat(APFloat::IEEEsingle(), "-0x1p+0")));
3734 EXPECT_EQ(42, ilogb(APFloat(APFloat::IEEEsingle(), "0x1p+42")));
3735 EXPECT_EQ(-42, ilogb(APFloat(APFloat::IEEEsingle(), "0x1p-42")));
3736
3737 EXPECT_EQ(APFloat::IEK_Inf,
3738 ilogb(APFloat::getInf(APFloat::IEEEsingle(), false)));
3739 EXPECT_EQ(APFloat::IEK_Inf,
3740 ilogb(APFloat::getInf(APFloat::IEEEsingle(), true)));
3741 EXPECT_EQ(APFloat::IEK_Zero,
3742 ilogb(APFloat::getZero(APFloat::IEEEsingle(), false)));
3743 EXPECT_EQ(APFloat::IEK_Zero,
3744 ilogb(APFloat::getZero(APFloat::IEEEsingle(), true)));
3745 EXPECT_EQ(APFloat::IEK_NaN,
3746 ilogb(APFloat::getNaN(APFloat::IEEEsingle(), false)));
3747 EXPECT_EQ(APFloat::IEK_NaN,
3748 ilogb(APFloat::getSNaN(APFloat::IEEEsingle(), false)));
3749
3750 EXPECT_EQ(127, ilogb(APFloat::getLargest(APFloat::IEEEsingle(), false)));
3751 EXPECT_EQ(127, ilogb(APFloat::getLargest(APFloat::IEEEsingle(), true)));
3752
3753 EXPECT_EQ(-149, ilogb(APFloat::getSmallest(APFloat::IEEEsingle(), false)));
3754 EXPECT_EQ(-149, ilogb(APFloat::getSmallest(APFloat::IEEEsingle(), true)));
3755 EXPECT_EQ(-126,
3756 ilogb(APFloat::getSmallestNormalized(APFloat::IEEEsingle(), false)));
3757 EXPECT_EQ(-126,
3758 ilogb(APFloat::getSmallestNormalized(APFloat::IEEEsingle(), true)));
3759 }
3760
3761 TEST(APFloatTest, scalbn) {
3762
3763 const APFloat::roundingMode RM = APFloat::rmNearestTiesToEven;
3764 EXPECT_TRUE(
3765 APFloat(APFloat::IEEEsingle(), "0x1p+0")
3766 .bitwiseIsEqual(scalbn(APFloat(APFloat::IEEEsingle(), "0x1p+0"), 0, RM)));
3767 EXPECT_TRUE(
3768 APFloat(APFloat::IEEEsingle(), "0x1p+42")
3769 .bitwiseIsEqual(scalbn(APFloat(APFloat::IEEEsingle(), "0x1p+0"), 42, RM)));
3770 EXPECT_TRUE(
3771 APFloat(APFloat::IEEEsingle(), "0x1p-42")
3772 .bitwiseIsEqual(scalbn(APFloat(APFloat::IEEEsingle(), "0x1p+0"), -42, RM)));
3773
3774 APFloat PInf = APFloat::getInf(APFloat::IEEEsingle(), false);
3775 APFloat MInf = APFloat::getInf(APFloat::IEEEsingle(), true);
3776 APFloat PZero = APFloat::getZero(APFloat::IEEEsingle(), false);
3777 APFloat MZero = APFloat::getZero(APFloat::IEEEsingle(), true);
3778 APFloat QPNaN = APFloat::getNaN(APFloat::IEEEsingle(), false);
3779 APFloat QMNaN = APFloat::getNaN(APFloat::IEEEsingle(), true);
3780 APFloat SNaN = APFloat::getSNaN(APFloat::IEEEsingle(), false);
3781
3782 EXPECT_TRUE(PInf.bitwiseIsEqual(scalbn(PInf, 0, RM)));
3783 EXPECT_TRUE(MInf.bitwiseIsEqual(scalbn(MInf, 0, RM)));
3784 EXPECT_TRUE(PZero.bitwiseIsEqual(scalbn(PZero, 0, RM)));
3785 EXPECT_TRUE(MZero.bitwiseIsEqual(scalbn(MZero, 0, RM)));
3786 EXPECT_TRUE(QPNaN.bitwiseIsEqual(scalbn(QPNaN, 0, RM)));
3787 EXPECT_TRUE(QMNaN.bitwiseIsEqual(scalbn(QMNaN, 0, RM)));
3788 EXPECT_FALSE(scalbn(SNaN, 0, RM).isSignaling());
3789
3790 APFloat ScalbnSNaN = scalbn(SNaN, 1, RM);
3791 EXPECT_TRUE(ScalbnSNaN.isNaN() && !ScalbnSNaN.isSignaling());
3792
3793 // Make sure highest bit of payload is preserved.
3794 const APInt Payload(64, (UINT64_C(1) << 50) |
3795 (UINT64_C(1) << 49) |
3796 (UINT64_C(1234) << 32) |
3797 1);
3798
3799 APFloat SNaNWithPayload = APFloat::getSNaN(APFloat::IEEEdouble(), false,
3800 &Payload);
3801 APFloat QuietPayload = scalbn(SNaNWithPayload, 1, RM);
3802 EXPECT_TRUE(QuietPayload.isNaN() && !QuietPayload.isSignaling());
3803 EXPECT_EQ(Payload, QuietPayload.bitcastToAPInt().getLoBits(51));
3804
3805 EXPECT_TRUE(PInf.bitwiseIsEqual(
3806 scalbn(APFloat(APFloat::IEEEsingle(), "0x1p+0"), 128, RM)));
3807 EXPECT_TRUE(MInf.bitwiseIsEqual(
3808 scalbn(APFloat(APFloat::IEEEsingle(), "-0x1p+0"), 128, RM)));
3809 EXPECT_TRUE(PInf.bitwiseIsEqual(
3810 scalbn(APFloat(APFloat::IEEEsingle(), "0x1p+127"), 1, RM)));
3811 EXPECT_TRUE(PZero.bitwiseIsEqual(
3812 scalbn(APFloat(APFloat::IEEEsingle(), "0x1p-127"), -127, RM)));
3813 EXPECT_TRUE(MZero.bitwiseIsEqual(
3814 scalbn(APFloat(APFloat::IEEEsingle(), "-0x1p-127"), -127, RM)));
3815 EXPECT_TRUE(APFloat(APFloat::IEEEsingle(), "-0x1p-149").bitwiseIsEqual(
3816 scalbn(APFloat(APFloat::IEEEsingle(), "-0x1p-127"), -22, RM)));
3817 EXPECT_TRUE(PZero.bitwiseIsEqual(
3818 scalbn(APFloat(APFloat::IEEEsingle(), "0x1p-126"), -24, RM)));
3819
3820
3821 APFloat SmallestF64 = APFloat::getSmallest(APFloat::IEEEdouble(), false);
3822 APFloat NegSmallestF64 = APFloat::getSmallest(APFloat::IEEEdouble(), true);
3823
3824 APFloat LargestF64 = APFloat::getLargest(APFloat::IEEEdouble(), false);
3825 APFloat NegLargestF64 = APFloat::getLargest(APFloat::IEEEdouble(), true);
3826
3827 APFloat SmallestNormalizedF64
3828 = APFloat::getSmallestNormalized(APFloat::IEEEdouble(), false);
3829 APFloat NegSmallestNormalizedF64
3830 = APFloat::getSmallestNormalized(APFloat::IEEEdouble(), true);
3831
3832 APFloat LargestDenormalF64(APFloat::IEEEdouble(), "0x1.ffffffffffffep-1023");
3833 APFloat NegLargestDenormalF64(APFloat::IEEEdouble(), "-0x1.ffffffffffffep-1023");
3834
3835
3836 EXPECT_TRUE(SmallestF64.bitwiseIsEqual(
3837 scalbn(APFloat(APFloat::IEEEdouble(), "0x1p-1074"), 0, RM)));
3838 EXPECT_TRUE(NegSmallestF64.bitwiseIsEqual(
3839 scalbn(APFloat(APFloat::IEEEdouble(), "-0x1p-1074"), 0, RM)));
3840
3841 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1p+1023")
3842 .bitwiseIsEqual(scalbn(SmallestF64, 2097, RM)));
3843
3844 EXPECT_TRUE(scalbn(SmallestF64, -2097, RM).isPosZero());
3845 EXPECT_TRUE(scalbn(SmallestF64, -2098, RM).isPosZero());
3846 EXPECT_TRUE(scalbn(SmallestF64, -2099, RM).isPosZero());
3847 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1p+1022")
3848 .bitwiseIsEqual(scalbn(SmallestF64, 2096, RM)));
3849 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1p+1023")
3850 .bitwiseIsEqual(scalbn(SmallestF64, 2097, RM)));
3851 EXPECT_TRUE(scalbn(SmallestF64, 2098, RM).isInfinity());
3852 EXPECT_TRUE(scalbn(SmallestF64, 2099, RM).isInfinity());
3853
3854 // Test for integer overflows when adding to exponent.
3855 EXPECT_TRUE(scalbn(SmallestF64, -INT_MAX, RM).isPosZero());
3856 EXPECT_TRUE(scalbn(LargestF64, INT_MAX, RM).isInfinity());
3857
3858 EXPECT_TRUE(LargestDenormalF64
3859 .bitwiseIsEqual(scalbn(LargestDenormalF64, 0, RM)));
3860 EXPECT_TRUE(NegLargestDenormalF64
3861 .bitwiseIsEqual(scalbn(NegLargestDenormalF64, 0, RM)));
3862
3863 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.ffffffffffffep-1022")
3864 .bitwiseIsEqual(scalbn(LargestDenormalF64, 1, RM)));
3865 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "-0x1.ffffffffffffep-1021")
3866 .bitwiseIsEqual(scalbn(NegLargestDenormalF64, 2, RM)));
3867
3868 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.ffffffffffffep+1")
3869 .bitwiseIsEqual(scalbn(LargestDenormalF64, 1024, RM)));
3870 EXPECT_TRUE(scalbn(LargestDenormalF64, -1023, RM).isPosZero());
3871 EXPECT_TRUE(scalbn(LargestDenormalF64, -1024, RM).isPosZero());
3872 EXPECT_TRUE(scalbn(LargestDenormalF64, -2048, RM).isPosZero());
3873 EXPECT_TRUE(scalbn(LargestDenormalF64, 2047, RM).isInfinity());
3874 EXPECT_TRUE(scalbn(LargestDenormalF64, 2098, RM).isInfinity());
3875 EXPECT_TRUE(scalbn(LargestDenormalF64, 2099, RM).isInfinity());
3876
3877 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.ffffffffffffep-2")
3878 .bitwiseIsEqual(scalbn(LargestDenormalF64, 1021, RM)));
3879 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.ffffffffffffep-1")
3880 .bitwiseIsEqual(scalbn(LargestDenormalF64, 1022, RM)));
3881 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.ffffffffffffep+0")
3882 .bitwiseIsEqual(scalbn(LargestDenormalF64, 1023, RM)));
3883 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.ffffffffffffep+1023")
3884 .bitwiseIsEqual(scalbn(LargestDenormalF64, 2046, RM)));
3885 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1p+974")
3886 .bitwiseIsEqual(scalbn(SmallestF64, 2048, RM)));
3887
3888 APFloat RandomDenormalF64(APFloat::IEEEdouble(), "0x1.c60f120d9f87cp+51");
3889 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.c60f120d9f87cp-972")
3890 .bitwiseIsEqual(scalbn(RandomDenormalF64, -1023, RM)));
3891 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.c60f120d9f87cp-1")
3892 .bitwiseIsEqual(scalbn(RandomDenormalF64, -52, RM)));
3893 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.c60f120d9f87cp-2")
3894 .bitwiseIsEqual(scalbn(RandomDenormalF64, -53, RM)));
3895 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.c60f120d9f87cp+0")
3896 .bitwiseIsEqual(scalbn(RandomDenormalF64, -51, RM)));
3897
3898 EXPECT_TRUE(scalbn(RandomDenormalF64, -2097, RM).isPosZero());
3899 EXPECT_TRUE(scalbn(RandomDenormalF64, -2090, RM).isPosZero());
3900
3901
3902 EXPECT_TRUE(
3903 APFloat(APFloat::IEEEdouble(), "-0x1p-1073")
3904 .bitwiseIsEqual(scalbn(NegLargestF64, -2097, RM)));
3905
3906 EXPECT_TRUE(
3907 APFloat(APFloat::IEEEdouble(), "-0x1p-1024")
3908 .bitwiseIsEqual(scalbn(NegLargestF64, -2048, RM)));
3909
3910 EXPECT_TRUE(
3911 APFloat(APFloat::IEEEdouble(), "0x1p-1073")
3912 .bitwiseIsEqual(scalbn(LargestF64, -2097, RM)));
3913
3914 EXPECT_TRUE(
3915 APFloat(APFloat::IEEEdouble(), "0x1p-1074")
3916 .bitwiseIsEqual(scalbn(LargestF64, -2098, RM)));
3917 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "-0x1p-1074")
3918 .bitwiseIsEqual(scalbn(NegLargestF64, -2098, RM)));
3919 EXPECT_TRUE(scalbn(NegLargestF64, -2099, RM).isNegZero());
3920 EXPECT_TRUE(scalbn(LargestF64, 1, RM).isInfinity());
3921
3922
3923 EXPECT_TRUE(
3924 APFloat(APFloat::IEEEdouble(), "0x1p+0")
3925 .bitwiseIsEqual(scalbn(APFloat(APFloat::IEEEdouble(), "0x1p+52"), -52, RM)));
3926
3927 EXPECT_TRUE(
3928 APFloat(APFloat::IEEEdouble(), "0x1p-103")
3929 .bitwiseIsEqual(scalbn(APFloat(APFloat::IEEEdouble(), "0x1p-51"), -52, RM)));
3930 }
3931
3932 TEST(APFloatTest, frexp) {
3933 const APFloat::roundingMode RM = APFloat::rmNearestTiesToEven;
3934
3935 APFloat PZero = APFloat::getZero(APFloat::IEEEdouble(), false);
3936 APFloat MZero = APFloat::getZero(APFloat::IEEEdouble(), true);
3937 APFloat One(1.0);
3938 APFloat MOne(-1.0);
3939 APFloat Two(2.0);
3940 APFloat MTwo(-2.0);
3941
3942 APFloat LargestDenormal(APFloat::IEEEdouble(), "0x1.ffffffffffffep-1023");
3943 APFloat NegLargestDenormal(APFloat::IEEEdouble(), "-0x1.ffffffffffffep-1023");
3944
3945 APFloat Smallest = APFloat::getSmallest(APFloat::IEEEdouble(), false);
3946 APFloat NegSmallest = APFloat::getSmallest(APFloat::IEEEdouble(), true);
3947
3948 APFloat Largest = APFloat::getLargest(APFloat::IEEEdouble(), false);
3949 APFloat NegLargest = APFloat::getLargest(APFloat::IEEEdouble(), true);
3950
3951 APFloat PInf = APFloat::getInf(APFloat::IEEEdouble(), false);
3952 APFloat MInf = APFloat::getInf(APFloat::IEEEdouble(), true);
3953
3954 APFloat QPNaN = APFloat::getNaN(APFloat::IEEEdouble(), false);
3955 APFloat QMNaN = APFloat::getNaN(APFloat::IEEEdouble(), true);
3956 APFloat SNaN = APFloat::getSNaN(APFloat::IEEEdouble(), false);
3957
3958 // Make sure highest bit of payload is preserved.
3959 const APInt Payload(64, (UINT64_C(1) << 50) |
3960 (UINT64_C(1) << 49) |
3961 (UINT64_C(1234) << 32) |
3962 1);
3963
3964 APFloat SNaNWithPayload = APFloat::getSNaN(APFloat::IEEEdouble(), false,
3965 &Payload);
3966
3967 APFloat SmallestNormalized
3968 = APFloat::getSmallestNormalized(APFloat::IEEEdouble(), false);
3969 APFloat NegSmallestNormalized
3970 = APFloat::getSmallestNormalized(APFloat::IEEEdouble(), true);
3971
3972 int Exp;
3973 APFloat Frac(APFloat::IEEEdouble());
3974
3975
3976 Frac = frexp(PZero, Exp, RM);
3977 EXPECT_EQ(0, Exp);
3978 EXPECT_TRUE(Frac.isPosZero());
3979
3980 Frac = frexp(MZero, Exp, RM);
3981 EXPECT_EQ(0, Exp);
3982 EXPECT_TRUE(Frac.isNegZero());
3983
3984
3985 Frac = frexp(One, Exp, RM);
3986 EXPECT_EQ(1, Exp);
3987 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1p-1").bitwiseIsEqual(Frac));
3988
3989 Frac = frexp(MOne, Exp, RM);
3990 EXPECT_EQ(1, Exp);
3991 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "-0x1p-1").bitwiseIsEqual(Frac));
3992
3993 Frac = frexp(LargestDenormal, Exp, RM);
3994 EXPECT_EQ(-1022, Exp);
3995 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.ffffffffffffep-1").bitwiseIsEqual(Frac));
3996
3997 Frac = frexp(NegLargestDenormal, Exp, RM);
3998 EXPECT_EQ(-1022, Exp);
3999 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "-0x1.ffffffffffffep-1").bitwiseIsEqual(Frac));
4000
4001
4002 Frac = frexp(Smallest, Exp, RM);
4003 EXPECT_EQ(-1073, Exp);
4004 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1p-1").bitwiseIsEqual(Frac));
4005
4006 Frac = frexp(NegSmallest, Exp, RM);
4007 EXPECT_EQ(-1073, Exp);
4008 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "-0x1p-1").bitwiseIsEqual(Frac));
4009
4010
4011 Frac = frexp(Largest, Exp, RM);
4012 EXPECT_EQ(1024, Exp);
4013 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.fffffffffffffp-1").bitwiseIsEqual(Frac));
4014
4015 Frac = frexp(NegLargest, Exp, RM);
4016 EXPECT_EQ(1024, Exp);
4017 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "-0x1.fffffffffffffp-1").bitwiseIsEqual(Frac));
4018
4019
4020 Frac = frexp(PInf, Exp, RM);
4021 EXPECT_EQ(INT_MAX, Exp);
4022 EXPECT_TRUE(Frac.isInfinity() && !Frac.isNegative());
4023
4024 Frac = frexp(MInf, Exp, RM);
4025 EXPECT_EQ(INT_MAX, Exp);
4026 EXPECT_TRUE(Frac.isInfinity() && Frac.isNegative());
4027
4028 Frac = frexp(QPNaN, Exp, RM);
4029 EXPECT_EQ(INT_MIN, Exp);
4030 EXPECT_TRUE(Frac.isNaN());
4031
4032 Frac = frexp(QMNaN, Exp, RM);
4033 EXPECT_EQ(INT_MIN, Exp);
4034 EXPECT_TRUE(Frac.isNaN());
4035
4036 Frac = frexp(SNaN, Exp, RM);
4037 EXPECT_EQ(INT_MIN, Exp);
4038 EXPECT_TRUE(Frac.isNaN() && !Frac.isSignaling());
4039
4040 Frac = frexp(SNaNWithPayload, Exp, RM);
4041 EXPECT_EQ(INT_MIN, Exp);
4042 EXPECT_TRUE(Frac.isNaN() && !Frac.isSignaling());
4043 EXPECT_EQ(Payload, Frac.bitcastToAPInt().getLoBits(51));
4044
4045 Frac = frexp(APFloat(APFloat::IEEEdouble(), "0x0.ffffp-1"), Exp, RM);
4046 EXPECT_EQ(-1, Exp);
4047 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.fffep-1").bitwiseIsEqual(Frac));
4048
4049 Frac = frexp(APFloat(APFloat::IEEEdouble(), "0x1p-51"), Exp, RM);
4050 EXPECT_EQ(-50, Exp);
4051 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1p-1").bitwiseIsEqual(Frac));
4052
4053 Frac = frexp(APFloat(APFloat::IEEEdouble(), "0x1.c60f120d9f87cp+51"), Exp, RM);
4054 EXPECT_EQ(52, Exp);
4055 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.c60f120d9f87cp-1").bitwiseIsEqual(Frac));
4056 }
4057
4058 TEST(APFloatTest, mod) {
4059 {
4060 APFloat f1(APFloat::IEEEdouble(), "1.5");
4061 APFloat f2(APFloat::IEEEdouble(), "1.0");
4062 APFloat expected(APFloat::IEEEdouble(), "0.5");
4063 EXPECT_EQ(f1.mod(f2), APFloat::opOK);
4064 EXPECT_TRUE(f1.bitwiseIsEqual(expected));
4065 }
4066 {
4067 APFloat f1(APFloat::IEEEdouble(), "0.5");
4068 APFloat f2(APFloat::IEEEdouble(), "1.0");
4069 APFloat expected(APFloat::IEEEdouble(), "0.5");
4070 EXPECT_EQ(f1.mod(f2), APFloat::opOK);
4071 EXPECT_TRUE(f1.bitwiseIsEqual(expected));
4072 }
4073 {
4074 APFloat f1(APFloat::IEEEdouble(), "0x1.3333333333333p-2"); // 0.3
4075 APFloat f2(APFloat::IEEEdouble(), "0x1.47ae147ae147bp-7"); // 0.01
4076 APFloat expected(APFloat::IEEEdouble(),
4077 "0x1.47ae147ae1471p-7"); // 0.009999999999999983
4078 EXPECT_EQ(f1.mod(f2), APFloat::opOK);
4079 EXPECT_TRUE(f1.bitwiseIsEqual(expected));
4080 }
4081 {
4082 APFloat f1(APFloat::IEEEdouble(), "0x1p64"); // 1.8446744073709552e19
4083 APFloat f2(APFloat::IEEEdouble(), "1.5");
4084 APFloat expected(APFloat::IEEEdouble(), "1.0");
4085 EXPECT_EQ(f1.mod(f2), APFloat::opOK);
4086 EXPECT_TRUE(f1.bitwiseIsEqual(expected));
4087 }
4088 {
4089 APFloat f1(APFloat::IEEEdouble(), "0x1p1000");
4090 APFloat f2(APFloat::IEEEdouble(), "0x1p-1000");
4091 APFloat expected(APFloat::IEEEdouble(), "0.0");
4092 EXPECT_EQ(f1.mod(f2), APFloat::opOK);
4093 EXPECT_TRUE(f1.bitwiseIsEqual(expected));
4094 }
4095 {
4096 APFloat f1(APFloat::IEEEdouble(), "0.0");
4097 APFloat f2(APFloat::IEEEdouble(), "1.0");
4098 APFloat expected(APFloat::IEEEdouble(), "0.0");
4099 EXPECT_EQ(f1.mod(f2), APFloat::opOK);
4100 EXPECT_TRUE(f1.bitwiseIsEqual(expected));
4101 }
4102 {
4103 APFloat f1(APFloat::IEEEdouble(), "1.0");
4104 APFloat f2(APFloat::IEEEdouble(), "0.0");
4105 EXPECT_EQ(f1.mod(f2), APFloat::opInvalidOp);
4106 EXPECT_TRUE(f1.isNaN());
4107 }
4108 {
4109 APFloat f1(APFloat::IEEEdouble(), "0.0");
4110 APFloat f2(APFloat::IEEEdouble(), "0.0");
4111 EXPECT_EQ(f1.mod(f2), APFloat::opInvalidOp);
4112 EXPECT_TRUE(f1.isNaN());
4113 }
4114 {
4115 APFloat f1 = APFloat::getInf(APFloat::IEEEdouble(), false);
4116 APFloat f2(APFloat::IEEEdouble(), "1.0");
4117 EXPECT_EQ(f1.mod(f2), APFloat::opInvalidOp);
4118 EXPECT_TRUE(f1.isNaN());
4119 }
4120 {
4121 APFloat f1(APFloat::IEEEdouble(), "-4.0");
4122 APFloat f2(APFloat::IEEEdouble(), "-2.0");
4123 APFloat expected(APFloat::IEEEdouble(), "-0.0");
4124 EXPECT_EQ(f1.mod(f2), APFloat::opOK);
4125 EXPECT_TRUE(f1.bitwiseIsEqual(expected));
4126 }
4127 {
4128 APFloat f1(APFloat::IEEEdouble(), "-4.0");
4129 APFloat f2(APFloat::IEEEdouble(), "2.0");
4130 APFloat expected(APFloat::IEEEdouble(), "-0.0");
4131 EXPECT_EQ(f1.mod(f2), APFloat::opOK);
4132 EXPECT_TRUE(f1.bitwiseIsEqual(expected));
4133 }
4134 {
4135 // Test E4M3FN mod where the LHS exponent is maxExponent (8) and the RHS is
4136 // the max value whose exponent is minExponent (-6). This requires special
4137 // logic in the mod implementation to prevent overflow to NaN.
4138 APFloat f1(APFloat::Float8E4M3FN(), "0x1p8"); // 256
4139 APFloat f2(APFloat::Float8E4M3FN(), "0x1.ep-6"); // 0.029296875
4140 APFloat expected(APFloat::Float8E4M3FN(), "0x1p-8"); // 0.00390625
4141 EXPECT_EQ(f1.mod(f2), APFloat::opOK);
4142 EXPECT_TRUE(f1.bitwiseIsEqual(expected));
4143 }
4144 }
4145
4146 TEST(APFloatTest, remainder) {
4147 // Test Special Cases against each other and normal values.
4148
4149 APFloat PInf = APFloat::getInf(APFloat::IEEEsingle(), false);
4150 APFloat MInf = APFloat::getInf(APFloat::IEEEsingle(), true);
4151 APFloat PZero = APFloat::getZero(APFloat::IEEEsingle(), false);
4152 APFloat MZero = APFloat::getZero(APFloat::IEEEsingle(), true);
4153 APFloat QNaN = APFloat::getNaN(APFloat::IEEEsingle(), false);
4154 APFloat SNaN = APFloat(APFloat::IEEEsingle(), "snan123");
4155 APFloat PNormalValue = APFloat(APFloat::IEEEsingle(), "0x1p+0");
4156 APFloat MNormalValue = APFloat(APFloat::IEEEsingle(), "-0x1p+0");
4157 APFloat PLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), false);
4158 APFloat MLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), true);
4159 APFloat PSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), false);
4160 APFloat MSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), true);
4161 APFloat PSmallestNormalized =
4162 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), false);
4163 APFloat MSmallestNormalized =
4164 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), true);
4165
4166 APFloat PVal1(APFloat::IEEEsingle(), "0x1.fffffep+126");
4167 APFloat MVal1(APFloat::IEEEsingle(), "-0x1.fffffep+126");
4168 APFloat PVal2(APFloat::IEEEsingle(), "0x1.fffffep-126");
4169 APFloat MVal2(APFloat::IEEEsingle(), "-0x1.fffffep-126");
4170 APFloat PVal3(APFloat::IEEEsingle(), "0x1p-125");
4171 APFloat MVal3(APFloat::IEEEsingle(), "-0x1p-125");
4172 APFloat PVal4(APFloat::IEEEsingle(), "0x1p+127");
4173 APFloat MVal4(APFloat::IEEEsingle(), "-0x1p+127");
4174 APFloat PVal5(APFloat::IEEEsingle(), "1.5");
4175 APFloat MVal5(APFloat::IEEEsingle(), "-1.5");
4176 APFloat PVal6(APFloat::IEEEsingle(), "1");
4177 APFloat MVal6(APFloat::IEEEsingle(), "-1");
4178
4179 struct {
4180 APFloat x;
4181 APFloat y;
4182 const char *result;
4183 int status;
4184 int category;
4185 } SpecialCaseTests[] = {
4186 { PInf, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
4187 { PInf, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
4188 { PInf, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
4189 { PInf, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
4190 { PInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
4191 { PInf, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
4192 { PInf, PNormalValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
4193 { PInf, MNormalValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
4194 { PInf, PLargestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
4195 { PInf, MLargestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
4196 { PInf, PSmallestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
4197 { PInf, MSmallestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
4198 { PInf, PSmallestNormalized, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
4199 { PInf, MSmallestNormalized, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
4200 { MInf, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
4201 { MInf, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
4202 { MInf, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
4203 { MInf, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
4204 { MInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
4205 { MInf, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
4206 { MInf, PNormalValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
4207 { MInf, MNormalValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
4208 { MInf, PLargestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
4209 { MInf, MLargestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
4210 { MInf, PSmallestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
4211 { MInf, MSmallestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
4212 { MInf, PSmallestNormalized, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
4213 { MInf, MSmallestNormalized, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
4214 { PZero, PInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
4215 { PZero, MInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
4216 { PZero, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
4217 { PZero, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
4218 { PZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
4219 { PZero, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
4220 { PZero, PNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
4221 { PZero, MNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
4222 { PZero, PLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
4223 { PZero, MLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
4224 { PZero, PSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
4225 { PZero, MSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
4226 { PZero, PSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
4227 { PZero, MSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
4228 { MZero, PInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
4229 { MZero, MInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
4230 { MZero, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
4231 { MZero, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
4232 { MZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
4233 { MZero, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
4234 { MZero, PNormalValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
4235 { MZero, MNormalValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
4236 { MZero, PLargestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
4237 { MZero, MLargestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
4238 { MZero, PSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
4239 { MZero, MSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
4240 { MZero, PSmallestNormalized, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
4241 { MZero, MSmallestNormalized, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
4242 { QNaN, PInf, "nan", APFloat::opOK, APFloat::fcNaN },
4243 { QNaN, MInf, "nan", APFloat::opOK, APFloat::fcNaN },
4244 { QNaN, PZero, "nan", APFloat::opOK, APFloat::fcNaN },
4245 { QNaN, MZero, "nan", APFloat::opOK, APFloat::fcNaN },
4246 { QNaN, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
4247 { QNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
4248 { QNaN, PNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
4249 { QNaN, MNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
4250 { QNaN, PLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
4251 { QNaN, MLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
4252 { QNaN, PSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
4253 { QNaN, MSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
4254 { QNaN, PSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
4255 { QNaN, MSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
4256 { SNaN, PInf, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
4257 { SNaN, MInf, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
4258 { SNaN, PZero, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
4259 { SNaN, MZero, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
4260 { SNaN, QNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
4261 { SNaN, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
4262 { SNaN, PNormalValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
4263 { SNaN, MNormalValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
4264 { SNaN, PLargestValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
4265 { SNaN, MLargestValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
4266 { SNaN, PSmallestValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
4267 { SNaN, MSmallestValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
4268 { SNaN, PSmallestNormalized, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
4269 { SNaN, MSmallestNormalized, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
4270 { PNormalValue, PInf, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
4271 { PNormalValue, MInf, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
4272 { PNormalValue, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
4273 { PNormalValue, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
4274 { PNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
4275 { PNormalValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
4276 { PNormalValue, PNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
4277 { PNormalValue, MNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
4278 { PNormalValue, PLargestValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
4279 { PNormalValue, MLargestValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
4280 { PNormalValue, PSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
4281 { PNormalValue, MSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
4282 { PNormalValue, PSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
4283 { PNormalValue, MSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
4284 { MNormalValue, PInf, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
4285 { MNormalValue, MInf, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
4286 { MNormalValue, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
4287 { MNormalValue, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
4288 { MNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
4289 { MNormalValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
4290 { MNormalValue, PNormalValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
4291 { MNormalValue, MNormalValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
4292 { MNormalValue, PLargestValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
4293 { MNormalValue, MLargestValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
4294 { MNormalValue, PSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
4295 { MNormalValue, MSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
4296 { MNormalValue, PSmallestNormalized, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
4297 { MNormalValue, MSmallestNormalized, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
4298 { PLargestValue, PInf, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
4299 { PLargestValue, MInf, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
4300 { PLargestValue, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
4301 { PLargestValue, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
4302 { PLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
4303 { PLargestValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
4304 { PLargestValue, PNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
4305 { PLargestValue, MNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
4306 { PLargestValue, PLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
4307 { PLargestValue, MLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
4308 { PLargestValue, PSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
4309 { PLargestValue, MSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
4310 { PLargestValue, PSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
4311 { PLargestValue, MSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
4312 { MLargestValue, PInf, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
4313 { MLargestValue, MInf, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
4314 { MLargestValue, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
4315 { MLargestValue, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
4316 { MLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
4317 { MLargestValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
4318 { MLargestValue, PNormalValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
4319 { MLargestValue, MNormalValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
4320 { MLargestValue, PLargestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
4321 { MLargestValue, MLargestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
4322 { MLargestValue, PSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
4323 { MLargestValue, MSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
4324 { MLargestValue, PSmallestNormalized, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
4325 { MLargestValue, MSmallestNormalized, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
4326 { PSmallestValue, PInf, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
4327 { PSmallestValue, MInf, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
4328 { PSmallestValue, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
4329 { PSmallestValue, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
4330 { PSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
4331 { PSmallestValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
4332 { PSmallestValue, PNormalValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
4333 { PSmallestValue, MNormalValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
4334 { PSmallestValue, PLargestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
4335 { PSmallestValue, MLargestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
4336 { PSmallestValue, PSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
4337 { PSmallestValue, MSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
4338 { PSmallestValue, PSmallestNormalized, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
4339 { PSmallestValue, MSmallestNormalized, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
4340 { MSmallestValue, PInf, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
4341 { MSmallestValue, MInf, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
4342 { MSmallestValue, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
4343 { MSmallestValue, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
4344 { MSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
4345 { MSmallestValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
4346 { MSmallestValue, PNormalValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
4347 { MSmallestValue, MNormalValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
4348 { MSmallestValue, PLargestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
4349 { MSmallestValue, MLargestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
4350 { MSmallestValue, PSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
4351 { MSmallestValue, MSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
4352 { MSmallestValue, PSmallestNormalized, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
4353 { MSmallestValue, MSmallestNormalized, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
4354 { PSmallestNormalized, PInf, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
4355 { PSmallestNormalized, MInf, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
4356 { PSmallestNormalized, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
4357 { PSmallestNormalized, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
4358 { PSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
4359 { PSmallestNormalized, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
4360 { PSmallestNormalized, PNormalValue, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
4361 { PSmallestNormalized, MNormalValue, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
4362 { PSmallestNormalized, PLargestValue, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
4363 { PSmallestNormalized, MLargestValue, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
4364 { PSmallestNormalized, PSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
4365 { PSmallestNormalized, MSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
4366 { PSmallestNormalized, PSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
4367 { PSmallestNormalized, MSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
4368 { MSmallestNormalized, PInf, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
4369 { MSmallestNormalized, MInf, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
4370 { MSmallestNormalized, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
4371 { MSmallestNormalized, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
4372 { MSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
4373 { MSmallestNormalized, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
4374 { MSmallestNormalized, PNormalValue, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
4375 { MSmallestNormalized, MNormalValue, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
4376 { MSmallestNormalized, PLargestValue, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
4377 { MSmallestNormalized, MLargestValue, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
4378 { MSmallestNormalized, PSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
4379 { MSmallestNormalized, MSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
4380 { MSmallestNormalized, PSmallestNormalized, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
4381 { MSmallestNormalized, MSmallestNormalized, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
4382
4383 { PVal1, PVal1, "0x0p+0", APFloat::opOK, APFloat::fcZero },
4384 { PVal1, MVal1, "0x0p+0", APFloat::opOK, APFloat::fcZero },
4385 { PVal1, PVal2, "0x0p+0", APFloat::opOK, APFloat::fcZero },
4386 { PVal1, MVal2, "0x0p+0", APFloat::opOK, APFloat::fcZero },
4387 { PVal1, PVal3, "0x0p+0", APFloat::opOK, APFloat::fcZero },
4388 { PVal1, MVal3, "0x0p+0", APFloat::opOK, APFloat::fcZero },
4389 { PVal1, PVal4, "-0x1p+103", APFloat::opOK, APFloat::fcNormal },
4390 { PVal1, MVal4, "-0x1p+103", APFloat::opOK, APFloat::fcNormal },
4391 { PVal1, PVal5, "0x0p+0", APFloat::opOK, APFloat::fcZero },
4392 { PVal1, MVal5, "0x0p+0", APFloat::opOK, APFloat::fcZero },
4393 { PVal1, PVal6, "0x0p+0", APFloat::opOK, APFloat::fcZero },
4394 { PVal1, MVal6, "0x0p+0", APFloat::opOK, APFloat::fcZero },
4395 { MVal1, PVal1, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
4396 { MVal1, MVal1, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
4397 { MVal1, PVal2, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
4398 { MVal1, MVal2, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
4399 { MVal1, PVal3, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
4400 { MVal1, MVal3, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
4401 { MVal1, PVal4, "0x1p+103", APFloat::opOK, APFloat::fcNormal },
4402 { MVal1, MVal4, "0x1p+103", APFloat::opOK, APFloat::fcNormal },
4403 { MVal1, PVal5, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
4404 { MVal1, MVal5, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
4405 { MVal1, PVal6, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
4406 { MVal1, MVal6, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
4407 { PVal2, PVal1, "0x1.fffffep-126", APFloat::opOK, APFloat::fcNormal },
4408 { PVal2, MVal1, "0x1.fffffep-126", APFloat::opOK, APFloat::fcNormal },
4409 { PVal2, PVal2, "0x0p+0", APFloat::opOK, APFloat::fcZero },
4410 { PVal2, MVal2, "0x0p+0", APFloat::opOK, APFloat::fcZero },
4411 { PVal2, PVal3, "-0x0.000002p-126", APFloat::opOK, APFloat::fcNormal },
4412 { PVal2, MVal3, "-0x0.000002p-126", APFloat::opOK, APFloat::fcNormal },
4413 { PVal2, PVal4, "0x1.fffffep-126", APFloat::opOK, APFloat::fcNormal },
4414 { PVal2, MVal4, "0x1.fffffep-126", APFloat::opOK, APFloat::fcNormal },
4415 { PVal2, PVal5, "0x1.fffffep-126", APFloat::opOK, APFloat::fcNormal },
4416 { PVal2, MVal5, "0x1.fffffep-126", APFloat::opOK, APFloat::fcNormal },
4417 { PVal2, PVal6, "0x1.fffffep-126", APFloat::opOK, APFloat::fcNormal },
4418 { PVal2, MVal6, "0x1.fffffep-126", APFloat::opOK, APFloat::fcNormal },
4419 { MVal2, PVal1, "-0x1.fffffep-126", APFloat::opOK, APFloat::fcNormal },
4420 { MVal2, MVal1, "-0x1.fffffep-126", APFloat::opOK, APFloat::fcNormal },
4421 { MVal2, PVal2, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
4422 { MVal2, MVal2, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
4423 { MVal2, PVal3, "0x0.000002p-126", APFloat::opOK, APFloat::fcNormal },
4424 { MVal2, MVal3, "0x0.000002p-126", APFloat::opOK, APFloat::fcNormal },
4425 { MVal2, PVal4, "-0x1.fffffep-126", APFloat::opOK, APFloat::fcNormal },
4426 { MVal2, MVal4, "-0x1.fffffep-126", APFloat::opOK, APFloat::fcNormal },
4427 { MVal2, PVal5, "-0x1.fffffep-126", APFloat::opOK, APFloat::fcNormal },
4428 { MVal2, MVal5, "-0x1.fffffep-126", APFloat::opOK, APFloat::fcNormal },
4429 { MVal2, PVal6, "-0x1.fffffep-126", APFloat::opOK, APFloat::fcNormal },
4430 { MVal2, MVal6, "-0x1.fffffep-126", APFloat::opOK, APFloat::fcNormal },
4431 { PVal3, PVal1, "0x1p-125", APFloat::opOK, APFloat::fcNormal },
4432 { PVal3, MVal1, "0x1p-125", APFloat::opOK, APFloat::fcNormal },
4433 { PVal3, PVal2, "0x0.000002p-126", APFloat::opOK, APFloat::fcNormal },
4434 { PVal3, MVal2, "0x0.000002p-126", APFloat::opOK, APFloat::fcNormal },
4435 { PVal3, PVal3, "0x0p+0", APFloat::opOK, APFloat::fcZero },
4436 { PVal3, MVal3, "0x0p+0", APFloat::opOK, APFloat::fcZero },
4437 { PVal3, PVal4, "0x1p-125", APFloat::opOK, APFloat::fcNormal },
4438 { PVal3, MVal4, "0x1p-125", APFloat::opOK, APFloat::fcNormal },
4439 { PVal3, PVal5, "0x1p-125", APFloat::opOK, APFloat::fcNormal },
4440 { PVal3, MVal5, "0x1p-125", APFloat::opOK, APFloat::fcNormal },
4441 { PVal3, PVal6, "0x1p-125", APFloat::opOK, APFloat::fcNormal },
4442 { PVal3, MVal6, "0x1p-125", APFloat::opOK, APFloat::fcNormal },
4443 { MVal3, PVal1, "-0x1p-125", APFloat::opOK, APFloat::fcNormal },
4444 { MVal3, MVal1, "-0x1p-125", APFloat::opOK, APFloat::fcNormal },
4445 { MVal3, PVal2, "-0x0.000002p-126", APFloat::opOK, APFloat::fcNormal },
4446 { MVal3, MVal2, "-0x0.000002p-126", APFloat::opOK, APFloat::fcNormal },
4447 { MVal3, PVal3, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
4448 { MVal3, MVal3, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
4449 { MVal3, PVal4, "-0x1p-125", APFloat::opOK, APFloat::fcNormal },
4450 { MVal3, MVal4, "-0x1p-125", APFloat::opOK, APFloat::fcNormal },
4451 { MVal3, PVal5, "-0x1p-125", APFloat::opOK, APFloat::fcNormal },
4452 { MVal3, MVal5, "-0x1p-125", APFloat::opOK, APFloat::fcNormal },
4453 { MVal3, PVal6, "-0x1p-125", APFloat::opOK, APFloat::fcNormal },
4454 { MVal3, MVal6, "-0x1p-125", APFloat::opOK, APFloat::fcNormal },
4455 { PVal4, PVal1, "0x1p+103", APFloat::opOK, APFloat::fcNormal },
4456 { PVal4, MVal1, "0x1p+103", APFloat::opOK, APFloat::fcNormal },
4457 { PVal4, PVal2, "0x0.002p-126", APFloat::opOK, APFloat::fcNormal },
4458 { PVal4, MVal2, "0x0.002p-126", APFloat::opOK, APFloat::fcNormal },
4459 { PVal4, PVal3, "0x0p+0", APFloat::opOK, APFloat::fcZero },
4460 { PVal4, MVal3, "0x0p+0", APFloat::opOK, APFloat::fcZero },
4461 { PVal4, PVal4, "0x0p+0", APFloat::opOK, APFloat::fcZero },
4462 { PVal4, MVal4, "0x0p+0", APFloat::opOK, APFloat::fcZero },
4463 { PVal4, PVal5, "0.5", APFloat::opOK, APFloat::fcNormal },
4464 { PVal4, MVal5, "0.5", APFloat::opOK, APFloat::fcNormal },
4465 { PVal4, PVal6, "0x0p+0", APFloat::opOK, APFloat::fcZero },
4466 { PVal4, MVal6, "0x0p+0", APFloat::opOK, APFloat::fcZero },
4467 { MVal4, PVal1, "-0x1p+103", APFloat::opOK, APFloat::fcNormal },
4468 { MVal4, MVal1, "-0x1p+103", APFloat::opOK, APFloat::fcNormal },
4469 { MVal4, PVal2, "-0x0.002p-126", APFloat::opOK, APFloat::fcNormal },
4470 { MVal4, MVal2, "-0x0.002p-126", APFloat::opOK, APFloat::fcNormal },
4471 { MVal4, PVal3, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
4472 { MVal4, MVal3, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
4473 { MVal4, PVal4, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
4474 { MVal4, MVal4, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
4475 { MVal4, PVal5, "-0.5", APFloat::opOK, APFloat::fcNormal },
4476 { MVal4, MVal5, "-0.5", APFloat::opOK, APFloat::fcNormal },
4477 { MVal4, PVal6, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
4478 { MVal4, MVal6, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
4479 { PVal5, PVal1, "1.5", APFloat::opOK, APFloat::fcNormal },
4480 { PVal5, MVal1, "1.5", APFloat::opOK, APFloat::fcNormal },
4481 { PVal5, PVal2, "0x0.00006p-126", APFloat::opOK, APFloat::fcNormal },
4482 { PVal5, MVal2, "0x0.00006p-126", APFloat::opOK, APFloat::fcNormal },
4483 { PVal5, PVal3, "0x0p+0", APFloat::opOK, APFloat::fcZero },
4484 { PVal5, MVal3, "0x0p+0", APFloat::opOK, APFloat::fcZero },
4485 { PVal5, PVal4, "1.5", APFloat::opOK, APFloat::fcNormal },
4486 { PVal5, MVal4, "1.5", APFloat::opOK, APFloat::fcNormal },
4487 { PVal5, PVal5, "0x0p+0", APFloat::opOK, APFloat::fcZero },
4488 { PVal5, MVal5, "0x0p+0", APFloat::opOK, APFloat::fcZero },
4489 { PVal5, PVal6, "-0.5", APFloat::opOK, APFloat::fcNormal },
4490 { PVal5, MVal6, "-0.5", APFloat::opOK, APFloat::fcNormal },
4491 { MVal5, PVal1, "-1.5", APFloat::opOK, APFloat::fcNormal },
4492 { MVal5, MVal1, "-1.5", APFloat::opOK, APFloat::fcNormal },
4493 { MVal5, PVal2, "-0x0.00006p-126", APFloat::opOK, APFloat::fcNormal },
4494 { MVal5, MVal2, "-0x0.00006p-126", APFloat::opOK, APFloat::fcNormal },
4495 { MVal5, PVal3, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
4496 { MVal5, MVal3, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
4497 { MVal5, PVal4, "-1.5", APFloat::opOK, APFloat::fcNormal },
4498 { MVal5, MVal4, "-1.5", APFloat::opOK, APFloat::fcNormal },
4499 { MVal5, PVal5, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
4500 { MVal5, MVal5, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
4501 { MVal5, PVal6, "0.5", APFloat::opOK, APFloat::fcNormal },
4502 { MVal5, MVal6, "0.5", APFloat::opOK, APFloat::fcNormal },
4503 { PVal6, PVal1, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
4504 { PVal6, MVal1, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
4505 { PVal6, PVal2, "0x0.00004p-126", APFloat::opOK, APFloat::fcNormal },
4506 { PVal6, MVal2, "0x0.00004p-126", APFloat::opOK, APFloat::fcNormal },
4507 { PVal6, PVal3, "0x0p+0", APFloat::opOK, APFloat::fcZero },
4508 { PVal6, MVal3, "0x0p+0", APFloat::opOK, APFloat::fcZero },
4509 { PVal6, PVal4, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
4510 { PVal6, MVal4, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
4511 { PVal6, PVal5, "-0.5", APFloat::opOK, APFloat::fcNormal },
4512 { PVal6, MVal5, "-0.5", APFloat::opOK, APFloat::fcNormal },
4513 { PVal6, PVal6, "0x0p+0", APFloat::opOK, APFloat::fcZero },
4514 { PVal6, MVal6, "0x0p+0", APFloat::opOK, APFloat::fcZero },
4515 { MVal6, PVal1, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
4516 { MVal6, MVal1, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
4517 { MVal6, PVal2, "-0x0.00004p-126", APFloat::opOK, APFloat::fcNormal },
4518 { MVal6, MVal2, "-0x0.00004p-126", APFloat::opOK, APFloat::fcNormal },
4519 { MVal6, PVal3, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
4520 { MVal6, MVal3, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
4521 { MVal6, PVal4, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
4522 { MVal6, MVal4, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
4523 { MVal6, PVal5, "0.5", APFloat::opOK, APFloat::fcNormal },
4524 { MVal6, MVal5, "0.5", APFloat::opOK, APFloat::fcNormal },
4525 { MVal6, PVal6, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
4526 { MVal6, MVal6, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
4527 };
4528
4529 for (size_t i = 0; i < std::size(SpecialCaseTests); ++i) {
4530 APFloat x(SpecialCaseTests[i].x);
4531 APFloat y(SpecialCaseTests[i].y);
4532 APFloat::opStatus status = x.remainder(y);
4533
4534 APFloat result(x.getSemantics(), SpecialCaseTests[i].result);
4535
4536 EXPECT_TRUE(result.bitwiseIsEqual(x));
4537 EXPECT_EQ(SpecialCaseTests[i].status, (int)status);
4538 EXPECT_EQ(SpecialCaseTests[i].category, (int)x.getCategory());
4539 }
4540
4541 {
4542 APFloat f1(APFloat::IEEEdouble(), "0x1.3333333333333p-2"); // 0.3
4543 APFloat f2(APFloat::IEEEdouble(), "0x1.47ae147ae147bp-7"); // 0.01
4544 APFloat expected(APFloat::IEEEdouble(), "-0x1.4p-56");
4545 EXPECT_EQ(APFloat::opOK, f1.remainder(f2));
4546 EXPECT_TRUE(f1.bitwiseIsEqual(expected));
4547 }
4548 {
4549 APFloat f1(APFloat::IEEEdouble(), "0x1p64"); // 1.8446744073709552e19
4550 APFloat f2(APFloat::IEEEdouble(), "1.5");
4551 APFloat expected(APFloat::IEEEdouble(), "-0.5");
4552 EXPECT_EQ(APFloat::opOK, f1.remainder(f2));
4553 EXPECT_TRUE(f1.bitwiseIsEqual(expected));
4554 }
4555 {
4556 APFloat f1(APFloat::IEEEdouble(), "0x1p1000");
4557 APFloat f2(APFloat::IEEEdouble(), "0x1p-1000");
4558 APFloat expected(APFloat::IEEEdouble(), "0.0");
4559 EXPECT_EQ(APFloat::opOK, f1.remainder(f2));
4560 EXPECT_TRUE(f1.bitwiseIsEqual(expected));
4561 }
4562 {
4563 APFloat f1 = APFloat::getInf(APFloat::IEEEdouble(), false);
4564 APFloat f2(APFloat::IEEEdouble(), "1.0");
4565 EXPECT_EQ(f1.remainder(f2), APFloat::opInvalidOp);
4566 EXPECT_TRUE(f1.isNaN());
4567 }
4568 {
4569 APFloat f1(APFloat::IEEEdouble(), "-4.0");
4570 APFloat f2(APFloat::IEEEdouble(), "-2.0");
4571 APFloat expected(APFloat::IEEEdouble(), "-0.0");
4572 EXPECT_EQ(APFloat::opOK, f1.remainder(f2));
4573 EXPECT_TRUE(f1.bitwiseIsEqual(expected));
4574 }
4575 {
4576 APFloat f1(APFloat::IEEEdouble(), "-4.0");
4577 APFloat f2(APFloat::IEEEdouble(), "2.0");
4578 APFloat expected(APFloat::IEEEdouble(), "-0.0");
4579 EXPECT_EQ(APFloat::opOK, f1.remainder(f2));
4580 EXPECT_TRUE(f1.bitwiseIsEqual(expected));
4581 }
4582 }
4583
4584 TEST(APFloatTest, PPCDoubleDoubleAddSpecial) {
4585 using DataType = std::tuple<uint64_t, uint64_t, uint64_t, uint64_t,
4586 APFloat::fltCategory, APFloat::roundingMode>;
4587 DataType Data[] = {
4588 // (1 + 0) + (-1 + 0) = fcZero
4589 std::make_tuple(0x3ff0000000000000ull, 0, 0xbff0000000000000ull, 0,
4590 APFloat::fcZero, APFloat::rmNearestTiesToEven),
4591 // LDBL_MAX + (1.1 >> (1023 - 106) + 0)) = fcInfinity
4592 std::make_tuple(0x7fefffffffffffffull, 0x7c8ffffffffffffeull,
4593 0x7948000000000000ull, 0ull, APFloat::fcInfinity,
4594 APFloat::rmNearestTiesToEven),
4595 // TODO: change the 4th 0x75effffffffffffe to 0x75efffffffffffff when
4596 // semPPCDoubleDoubleLegacy is gone.
4597 // LDBL_MAX + (1.011111... >> (1023 - 106) + (1.1111111...0 >> (1023 -
4598 // 160))) = fcNormal
4599 std::make_tuple(0x7fefffffffffffffull, 0x7c8ffffffffffffeull,
4600 0x7947ffffffffffffull, 0x75effffffffffffeull,
4601 APFloat::fcNormal, APFloat::rmNearestTiesToEven),
4602 // LDBL_MAX + (1.1 >> (1023 - 106) + 0)) = fcInfinity
4603 std::make_tuple(0x7fefffffffffffffull, 0x7c8ffffffffffffeull,
4604 0x7fefffffffffffffull, 0x7c8ffffffffffffeull,
4605 APFloat::fcInfinity, APFloat::rmNearestTiesToEven),
4606 // NaN + (1 + 0) = fcNaN
4607 std::make_tuple(0x7ff8000000000000ull, 0, 0x3ff0000000000000ull, 0,
4608 APFloat::fcNaN, APFloat::rmNearestTiesToEven),
4609 };
4610
4611 for (auto Tp : Data) {
4612 uint64_t Op1[2], Op2[2];
4613 APFloat::fltCategory Expected;
4614 APFloat::roundingMode RM;
4615 std::tie(Op1[0], Op1[1], Op2[0], Op2[1], Expected, RM) = Tp;
4616
4617 {
4618 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
4619 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
4620 A1.add(A2, RM);
4621
4622 EXPECT_EQ(Expected, A1.getCategory())
4623 << formatv("({0:x} + {1:x}) + ({2:x} + {3:x})", Op1[0], Op1[1],
4624 Op2[0], Op2[1])
4625 .str();
4626 }
4627 {
4628 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
4629 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
4630 A2.add(A1, RM);
4631
4632 EXPECT_EQ(Expected, A2.getCategory())
4633 << formatv("({0:x} + {1:x}) + ({2:x} + {3:x})", Op2[0], Op2[1],
4634 Op1[0], Op1[1])
4635 .str();
4636 }
4637 }
4638 }
4639
4640 TEST(APFloatTest, PPCDoubleDoubleAdd) {
4641 using DataType = std::tuple<uint64_t, uint64_t, uint64_t, uint64_t, uint64_t,
4642 uint64_t, APFloat::roundingMode>;
4643 DataType Data[] = {
4644 // (1 + 0) + (1e-105 + 0) = (1 + 1e-105)
4645 std::make_tuple(0x3ff0000000000000ull, 0, 0x3960000000000000ull, 0,
4646 0x3ff0000000000000ull, 0x3960000000000000ull,
4647 APFloat::rmNearestTiesToEven),
4648 // (1 + 0) + (1e-106 + 0) = (1 + 1e-106)
4649 std::make_tuple(0x3ff0000000000000ull, 0, 0x3950000000000000ull, 0,
4650 0x3ff0000000000000ull, 0x3950000000000000ull,
4651 APFloat::rmNearestTiesToEven),
4652 // (1 + 1e-106) + (1e-106 + 0) = (1 + 1e-105)
4653 std::make_tuple(0x3ff0000000000000ull, 0x3950000000000000ull,
4654 0x3950000000000000ull, 0, 0x3ff0000000000000ull,
4655 0x3960000000000000ull, APFloat::rmNearestTiesToEven),
4656 // (1 + 0) + (epsilon + 0) = (1 + epsilon)
4657 std::make_tuple(0x3ff0000000000000ull, 0, 0x0000000000000001ull, 0,
4658 0x3ff0000000000000ull, 0x0000000000000001ull,
4659 APFloat::rmNearestTiesToEven),
4660 // TODO: change 0xf950000000000000 to 0xf940000000000000, when
4661 // semPPCDoubleDoubleLegacy is gone.
4662 // (DBL_MAX - 1 << (1023 - 105)) + (1 << (1023 - 53) + 0) = DBL_MAX +
4663 // 1.11111... << (1023 - 52)
4664 std::make_tuple(0x7fefffffffffffffull, 0xf950000000000000ull,
4665 0x7c90000000000000ull, 0, 0x7fefffffffffffffull,
4666 0x7c8ffffffffffffeull, APFloat::rmNearestTiesToEven),
4667 // TODO: change 0xf950000000000000 to 0xf940000000000000, when
4668 // semPPCDoubleDoubleLegacy is gone.
4669 // (1 << (1023 - 53) + 0) + (DBL_MAX - 1 << (1023 - 105)) = DBL_MAX +
4670 // 1.11111... << (1023 - 52)
4671 std::make_tuple(0x7c90000000000000ull, 0, 0x7fefffffffffffffull,
4672 0xf950000000000000ull, 0x7fefffffffffffffull,
4673 0x7c8ffffffffffffeull, APFloat::rmNearestTiesToEven),
4674 };
4675
4676 for (auto Tp : Data) {
4677 uint64_t Op1[2], Op2[2], Expected[2];
4678 APFloat::roundingMode RM;
4679 std::tie(Op1[0], Op1[1], Op2[0], Op2[1], Expected[0], Expected[1], RM) = Tp;
4680
4681 {
4682 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
4683 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
4684 A1.add(A2, RM);
4685
4686 EXPECT_EQ(Expected[0], A1.bitcastToAPInt().getRawData()[0])
4687 << formatv("({0:x} + {1:x}) + ({2:x} + {3:x})", Op1[0], Op1[1],
4688 Op2[0], Op2[1])
4689 .str();
4690 EXPECT_EQ(Expected[1], A1.bitcastToAPInt().getRawData()[1])
4691 << formatv("({0:x} + {1:x}) + ({2:x} + {3:x})", Op1[0], Op1[1],
4692 Op2[0], Op2[1])
4693 .str();
4694 }
4695 {
4696 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
4697 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
4698 A2.add(A1, RM);
4699
4700 EXPECT_EQ(Expected[0], A2.bitcastToAPInt().getRawData()[0])
4701 << formatv("({0:x} + {1:x}) + ({2:x} + {3:x})", Op2[0], Op2[1],
4702 Op1[0], Op1[1])
4703 .str();
4704 EXPECT_EQ(Expected[1], A2.bitcastToAPInt().getRawData()[1])
4705 << formatv("({0:x} + {1:x}) + ({2:x} + {3:x})", Op2[0], Op2[1],
4706 Op1[0], Op1[1])
4707 .str();
4708 }
4709 }
4710 }
4711
4712 TEST(APFloatTest, PPCDoubleDoubleSubtract) {
4713 using DataType = std::tuple<uint64_t, uint64_t, uint64_t, uint64_t, uint64_t,
4714 uint64_t, APFloat::roundingMode>;
4715 DataType Data[] = {
4716 // (1 + 0) - (-1e-105 + 0) = (1 + 1e-105)
4717 std::make_tuple(0x3ff0000000000000ull, 0, 0xb960000000000000ull, 0,
4718 0x3ff0000000000000ull, 0x3960000000000000ull,
4719 APFloat::rmNearestTiesToEven),
4720 // (1 + 0) - (-1e-106 + 0) = (1 + 1e-106)
4721 std::make_tuple(0x3ff0000000000000ull, 0, 0xb950000000000000ull, 0,
4722 0x3ff0000000000000ull, 0x3950000000000000ull,
4723 APFloat::rmNearestTiesToEven),
4724 };
4725
4726 for (auto Tp : Data) {
4727 uint64_t Op1[2], Op2[2], Expected[2];
4728 APFloat::roundingMode RM;
4729 std::tie(Op1[0], Op1[1], Op2[0], Op2[1], Expected[0], Expected[1], RM) = Tp;
4730
4731 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
4732 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
4733 A1.subtract(A2, RM);
4734
4735 EXPECT_EQ(Expected[0], A1.bitcastToAPInt().getRawData()[0])
4736 << formatv("({0:x} + {1:x}) - ({2:x} + {3:x})", Op1[0], Op1[1], Op2[0],
4737 Op2[1])
4738 .str();
4739 EXPECT_EQ(Expected[1], A1.bitcastToAPInt().getRawData()[1])
4740 << formatv("({0:x} + {1:x}) - ({2:x} + {3:x})", Op1[0], Op1[1], Op2[0],
4741 Op2[1])
4742 .str();
4743 }
4744 }
4745
4746 TEST(APFloatTest, PPCDoubleDoubleMultiplySpecial) {
4747 using DataType = std::tuple<uint64_t, uint64_t, uint64_t, uint64_t,
4748 APFloat::fltCategory, APFloat::roundingMode>;
4749 DataType Data[] = {
4750 // fcNaN * fcNaN = fcNaN
4751 std::make_tuple(0x7ff8000000000000ull, 0, 0x7ff8000000000000ull, 0,
4752 APFloat::fcNaN, APFloat::rmNearestTiesToEven),
4753 // fcNaN * fcZero = fcNaN
4754 std::make_tuple(0x7ff8000000000000ull, 0, 0, 0, APFloat::fcNaN,
4755 APFloat::rmNearestTiesToEven),
4756 // fcNaN * fcInfinity = fcNaN
4757 std::make_tuple(0x7ff8000000000000ull, 0, 0x7ff0000000000000ull, 0,
4758 APFloat::fcNaN, APFloat::rmNearestTiesToEven),
4759 // fcNaN * fcNormal = fcNaN
4760 std::make_tuple(0x7ff8000000000000ull, 0, 0x3ff0000000000000ull, 0,
4761 APFloat::fcNaN, APFloat::rmNearestTiesToEven),
4762 // fcInfinity * fcInfinity = fcInfinity
4763 std::make_tuple(0x7ff0000000000000ull, 0, 0x7ff0000000000000ull, 0,
4764 APFloat::fcInfinity, APFloat::rmNearestTiesToEven),
4765 // fcInfinity * fcZero = fcNaN
4766 std::make_tuple(0x7ff0000000000000ull, 0, 0, 0, APFloat::fcNaN,
4767 APFloat::rmNearestTiesToEven),
4768 // fcInfinity * fcNormal = fcInfinity
4769 std::make_tuple(0x7ff0000000000000ull, 0, 0x3ff0000000000000ull, 0,
4770 APFloat::fcInfinity, APFloat::rmNearestTiesToEven),
4771 // fcZero * fcZero = fcZero
4772 std::make_tuple(0, 0, 0, 0, APFloat::fcZero,
4773 APFloat::rmNearestTiesToEven),
4774 // fcZero * fcNormal = fcZero
4775 std::make_tuple(0, 0, 0x3ff0000000000000ull, 0, APFloat::fcZero,
4776 APFloat::rmNearestTiesToEven),
4777 };
4778
4779 for (auto Tp : Data) {
4780 uint64_t Op1[2], Op2[2];
4781 APFloat::fltCategory Expected;
4782 APFloat::roundingMode RM;
4783 std::tie(Op1[0], Op1[1], Op2[0], Op2[1], Expected, RM) = Tp;
4784
4785 {
4786 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
4787 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
4788 A1.multiply(A2, RM);
4789
4790 EXPECT_EQ(Expected, A1.getCategory())
4791 << formatv("({0:x} + {1:x}) * ({2:x} + {3:x})", Op1[0], Op1[1],
4792 Op2[0], Op2[1])
4793 .str();
4794 }
4795 {
4796 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
4797 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
4798 A2.multiply(A1, RM);
4799
4800 EXPECT_EQ(Expected, A2.getCategory())
4801 << formatv("({0:x} + {1:x}) * ({2:x} + {3:x})", Op2[0], Op2[1],
4802 Op1[0], Op1[1])
4803 .str();
4804 }
4805 }
4806 }
4807
4808 TEST(APFloatTest, PPCDoubleDoubleMultiply) {
4809 using DataType = std::tuple<uint64_t, uint64_t, uint64_t, uint64_t, uint64_t,
4810 uint64_t, APFloat::roundingMode>;
4811 DataType Data[] = {
4812 // 1/3 * 3 = 1.0
4813 std::make_tuple(0x3fd5555555555555ull, 0x3c75555555555556ull,
4814 0x4008000000000000ull, 0, 0x3ff0000000000000ull, 0,
4815 APFloat::rmNearestTiesToEven),
4816 // (1 + epsilon) * (1 + 0) = fcZero
4817 std::make_tuple(0x3ff0000000000000ull, 0x0000000000000001ull,
4818 0x3ff0000000000000ull, 0, 0x3ff0000000000000ull,
4819 0x0000000000000001ull, APFloat::rmNearestTiesToEven),
4820 // (1 + epsilon) * (1 + epsilon) = 1 + 2 * epsilon
4821 std::make_tuple(0x3ff0000000000000ull, 0x0000000000000001ull,
4822 0x3ff0000000000000ull, 0x0000000000000001ull,
4823 0x3ff0000000000000ull, 0x0000000000000002ull,
4824 APFloat::rmNearestTiesToEven),
4825 // -(1 + epsilon) * (1 + epsilon) = -1
4826 std::make_tuple(0xbff0000000000000ull, 0x0000000000000001ull,
4827 0x3ff0000000000000ull, 0x0000000000000001ull,
4828 0xbff0000000000000ull, 0, APFloat::rmNearestTiesToEven),
4829 // (0.5 + 0) * (1 + 2 * epsilon) = 0.5 + epsilon
4830 std::make_tuple(0x3fe0000000000000ull, 0, 0x3ff0000000000000ull,
4831 0x0000000000000002ull, 0x3fe0000000000000ull,
4832 0x0000000000000001ull, APFloat::rmNearestTiesToEven),
4833 // (0.5 + 0) * (1 + epsilon) = 0.5
4834 std::make_tuple(0x3fe0000000000000ull, 0, 0x3ff0000000000000ull,
4835 0x0000000000000001ull, 0x3fe0000000000000ull, 0,
4836 APFloat::rmNearestTiesToEven),
4837 // __LDBL_MAX__ * (1 + 1 << 106) = inf
4838 std::make_tuple(0x7fefffffffffffffull, 0x7c8ffffffffffffeull,
4839 0x3ff0000000000000ull, 0x3950000000000000ull,
4840 0x7ff0000000000000ull, 0, APFloat::rmNearestTiesToEven),
4841 // __LDBL_MAX__ * (1 + 1 << 107) > __LDBL_MAX__, but not inf, yes =_=|||
4842 std::make_tuple(0x7fefffffffffffffull, 0x7c8ffffffffffffeull,
4843 0x3ff0000000000000ull, 0x3940000000000000ull,
4844 0x7fefffffffffffffull, 0x7c8fffffffffffffull,
4845 APFloat::rmNearestTiesToEven),
4846 // __LDBL_MAX__ * (1 + 1 << 108) = __LDBL_MAX__
4847 std::make_tuple(0x7fefffffffffffffull, 0x7c8ffffffffffffeull,
4848 0x3ff0000000000000ull, 0x3930000000000000ull,
4849 0x7fefffffffffffffull, 0x7c8ffffffffffffeull,
4850 APFloat::rmNearestTiesToEven),
4851 };
4852
4853 for (auto Tp : Data) {
4854 uint64_t Op1[2], Op2[2], Expected[2];
4855 APFloat::roundingMode RM;
4856 std::tie(Op1[0], Op1[1], Op2[0], Op2[1], Expected[0], Expected[1], RM) = Tp;
4857
4858 {
4859 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
4860 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
4861 A1.multiply(A2, RM);
4862
4863 EXPECT_EQ(Expected[0], A1.bitcastToAPInt().getRawData()[0])
4864 << formatv("({0:x} + {1:x}) * ({2:x} + {3:x})", Op1[0], Op1[1],
4865 Op2[0], Op2[1])
4866 .str();
4867 EXPECT_EQ(Expected[1], A1.bitcastToAPInt().getRawData()[1])
4868 << formatv("({0:x} + {1:x}) * ({2:x} + {3:x})", Op1[0], Op1[1],
4869 Op2[0], Op2[1])
4870 .str();
4871 }
4872 {
4873 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
4874 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
4875 A2.multiply(A1, RM);
4876
4877 EXPECT_EQ(Expected[0], A2.bitcastToAPInt().getRawData()[0])
4878 << formatv("({0:x} + {1:x}) * ({2:x} + {3:x})", Op2[0], Op2[1],
4879 Op1[0], Op1[1])
4880 .str();
4881 EXPECT_EQ(Expected[1], A2.bitcastToAPInt().getRawData()[1])
4882 << formatv("({0:x} + {1:x}) * ({2:x} + {3:x})", Op2[0], Op2[1],
4883 Op1[0], Op1[1])
4884 .str();
4885 }
4886 }
4887 }
4888
4889 TEST(APFloatTest, PPCDoubleDoubleDivide) {
4890 using DataType = std::tuple<uint64_t, uint64_t, uint64_t, uint64_t, uint64_t,
4891 uint64_t, APFloat::roundingMode>;
4892 // TODO: Only a sanity check for now. Add more edge cases when the
4893 // double-double algorithm is implemented.
4894 DataType Data[] = {
4895 // 1 / 3 = 1/3
4896 std::make_tuple(0x3ff0000000000000ull, 0, 0x4008000000000000ull, 0,
4897 0x3fd5555555555555ull, 0x3c75555555555556ull,
4898 APFloat::rmNearestTiesToEven),
4899 };
4900
4901 for (auto Tp : Data) {
4902 uint64_t Op1[2], Op2[2], Expected[2];
4903 APFloat::roundingMode RM;
4904 std::tie(Op1[0], Op1[1], Op2[0], Op2[1], Expected[0], Expected[1], RM) = Tp;
4905
4906 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
4907 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
4908 A1.divide(A2, RM);
4909
4910 EXPECT_EQ(Expected[0], A1.bitcastToAPInt().getRawData()[0])
4911 << formatv("({0:x} + {1:x}) / ({2:x} + {3:x})", Op1[0], Op1[1], Op2[0],
4912 Op2[1])
4913 .str();
4914 EXPECT_EQ(Expected[1], A1.bitcastToAPInt().getRawData()[1])
4915 << formatv("({0:x} + {1:x}) / ({2:x} + {3:x})", Op1[0], Op1[1], Op2[0],
4916 Op2[1])
4917 .str();
4918 }
4919 }
4920
4921 TEST(APFloatTest, PPCDoubleDoubleRemainder) {
4922 using DataType =
4923 std::tuple<uint64_t, uint64_t, uint64_t, uint64_t, uint64_t, uint64_t>;
4924 DataType Data[] = {
4925 // remainder(3.0 + 3.0 << 53, 1.25 + 1.25 << 53) = (0.5 + 0.5 << 53)
4926 std::make_tuple(0x4008000000000000ull, 0x3cb8000000000000ull,
4927 0x3ff4000000000000ull, 0x3ca4000000000000ull,
4928 0x3fe0000000000000ull, 0x3c90000000000000ull),
4929 // remainder(3.0 + 3.0 << 53, 1.75 + 1.75 << 53) = (-0.5 - 0.5 << 53)
4930 std::make_tuple(0x4008000000000000ull, 0x3cb8000000000000ull,
4931 0x3ffc000000000000ull, 0x3cac000000000000ull,
4932 0xbfe0000000000000ull, 0xbc90000000000000ull),
4933 };
4934
4935 for (auto Tp : Data) {
4936 uint64_t Op1[2], Op2[2], Expected[2];
4937 std::tie(Op1[0], Op1[1], Op2[0], Op2[1], Expected[0], Expected[1]) = Tp;
4938
4939 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
4940 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
4941 A1.remainder(A2);
4942
4943 EXPECT_EQ(Expected[0], A1.bitcastToAPInt().getRawData()[0])
4944 << formatv("remainder({0:x} + {1:x}), ({2:x} + {3:x}))", Op1[0], Op1[1],
4945 Op2[0], Op2[1])
4946 .str();
4947 EXPECT_EQ(Expected[1], A1.bitcastToAPInt().getRawData()[1])
4948 << formatv("remainder(({0:x} + {1:x}), ({2:x} + {3:x}))", Op1[0],
4949 Op1[1], Op2[0], Op2[1])
4950 .str();
4951 }
4952 }
4953
4954 TEST(APFloatTest, PPCDoubleDoubleMod) {
4955 using DataType =
4956 std::tuple<uint64_t, uint64_t, uint64_t, uint64_t, uint64_t, uint64_t>;
4957 DataType Data[] = {
4958 // mod(3.0 + 3.0 << 53, 1.25 + 1.25 << 53) = (0.5 + 0.5 << 53)
4959 std::make_tuple(0x4008000000000000ull, 0x3cb8000000000000ull,
4960 0x3ff4000000000000ull, 0x3ca4000000000000ull,
4961 0x3fe0000000000000ull, 0x3c90000000000000ull),
4962 // mod(3.0 + 3.0 << 53, 1.75 + 1.75 << 53) = (1.25 + 1.25 << 53)
4963 // 0xbc98000000000000 doesn't seem right, but it's what we currently have.
4964 // TODO: investigate
4965 std::make_tuple(0x4008000000000000ull, 0x3cb8000000000000ull,
4966 0x3ffc000000000000ull, 0x3cac000000000000ull,
4967 0x3ff4000000000001ull, 0xbc98000000000000ull),
4968 };
4969
4970 for (auto Tp : Data) {
4971 uint64_t Op1[2], Op2[2], Expected[2];
4972 std::tie(Op1[0], Op1[1], Op2[0], Op2[1], Expected[0], Expected[1]) = Tp;
4973
4974 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
4975 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
4976 A1.mod(A2);
4977
4978 EXPECT_EQ(Expected[0], A1.bitcastToAPInt().getRawData()[0])
4979 << formatv("fmod(({0:x} + {1:x}), ({2:x} + {3:x}))", Op1[0], Op1[1],
4980 Op2[0], Op2[1])
4981 .str();
4982 EXPECT_EQ(Expected[1], A1.bitcastToAPInt().getRawData()[1])
4983 << formatv("fmod(({0:x} + {1:x}), ({2:x} + {3:x}))", Op1[0], Op1[1],
4984 Op2[0], Op2[1])
4985 .str();
4986 }
4987 }
4988
4989 TEST(APFloatTest, PPCDoubleDoubleFMA) {
4990 // Sanity check for now.
4991 APFloat A(APFloat::PPCDoubleDouble(), "2");
4992 A.fusedMultiplyAdd(APFloat(APFloat::PPCDoubleDouble(), "3"),
4993 APFloat(APFloat::PPCDoubleDouble(), "4"),
4994 APFloat::rmNearestTiesToEven);
4995 EXPECT_EQ(APFloat::cmpEqual,
4996 APFloat(APFloat::PPCDoubleDouble(), "10").compare(A));
4997 }
4998
4999 TEST(APFloatTest, PPCDoubleDoubleRoundToIntegral) {
5000 {
5001 APFloat A(APFloat::PPCDoubleDouble(), "1.5");
5002 A.roundToIntegral(APFloat::rmNearestTiesToEven);
5003 EXPECT_EQ(APFloat::cmpEqual,
5004 APFloat(APFloat::PPCDoubleDouble(), "2").compare(A));
5005 }
5006 {
5007 APFloat A(APFloat::PPCDoubleDouble(), "2.5");
5008 A.roundToIntegral(APFloat::rmNearestTiesToEven);
5009 EXPECT_EQ(APFloat::cmpEqual,
5010 APFloat(APFloat::PPCDoubleDouble(), "2").compare(A));
5011 }
5012 }
5013
5014 TEST(APFloatTest, PPCDoubleDoubleCompare) {
5015 using DataType =
5016 std::tuple<uint64_t, uint64_t, uint64_t, uint64_t, APFloat::cmpResult>;
5017
5018 DataType Data[] = {
5019 // (1 + 0) = (1 + 0)
5020 std::make_tuple(0x3ff0000000000000ull, 0, 0x3ff0000000000000ull, 0,
5021 APFloat::cmpEqual),
5022 // (1 + 0) < (1.00...1 + 0)
5023 std::make_tuple(0x3ff0000000000000ull, 0, 0x3ff0000000000001ull, 0,
5024 APFloat::cmpLessThan),
5025 // (1.00...1 + 0) > (1 + 0)
5026 std::make_tuple(0x3ff0000000000001ull, 0, 0x3ff0000000000000ull, 0,
5027 APFloat::cmpGreaterThan),
5028 // (1 + 0) < (1 + epsilon)
5029 std::make_tuple(0x3ff0000000000000ull, 0, 0x3ff0000000000001ull,
5030 0x0000000000000001ull, APFloat::cmpLessThan),
5031 // NaN != NaN
5032 std::make_tuple(0x7ff8000000000000ull, 0, 0x7ff8000000000000ull, 0,
5033 APFloat::cmpUnordered),
5034 // (1 + 0) != NaN
5035 std::make_tuple(0x3ff0000000000000ull, 0, 0x7ff8000000000000ull, 0,
5036 APFloat::cmpUnordered),
5037 // Inf = Inf
5038 std::make_tuple(0x7ff0000000000000ull, 0, 0x7ff0000000000000ull, 0,
5039 APFloat::cmpEqual),
5040 };
5041
5042 for (auto Tp : Data) {
5043 uint64_t Op1[2], Op2[2];
5044 APFloat::cmpResult Expected;
5045 std::tie(Op1[0], Op1[1], Op2[0], Op2[1], Expected) = Tp;
5046
5047 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
5048 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
5049 EXPECT_EQ(Expected, A1.compare(A2))
5050 << formatv("compare(({0:x} + {1:x}), ({2:x} + {3:x}))", Op1[0], Op1[1],
5051 Op2[0], Op2[1])
5052 .str();
5053 }
5054 }
5055
5056 TEST(APFloatTest, PPCDoubleDoubleBitwiseIsEqual) {
5057 using DataType = std::tuple<uint64_t, uint64_t, uint64_t, uint64_t, bool>;
5058
5059 DataType Data[] = {
5060 // (1 + 0) = (1 + 0)
5061 std::make_tuple(0x3ff0000000000000ull, 0, 0x3ff0000000000000ull, 0, true),
5062 // (1 + 0) != (1.00...1 + 0)
5063 std::make_tuple(0x3ff0000000000000ull, 0, 0x3ff0000000000001ull, 0,
5064 false),
5065 // NaN = NaN
5066 std::make_tuple(0x7ff8000000000000ull, 0, 0x7ff8000000000000ull, 0, true),
5067 // NaN != NaN with a different bit pattern
5068 std::make_tuple(0x7ff8000000000000ull, 0, 0x7ff8000000000000ull,
5069 0x3ff0000000000000ull, false),
5070 // Inf = Inf
5071 std::make_tuple(0x7ff0000000000000ull, 0, 0x7ff0000000000000ull, 0, true),
5072 };
5073
5074 for (auto Tp : Data) {
5075 uint64_t Op1[2], Op2[2];
5076 bool Expected;
5077 std::tie(Op1[0], Op1[1], Op2[0], Op2[1], Expected) = Tp;
5078
5079 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
5080 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
5081 EXPECT_EQ(Expected, A1.bitwiseIsEqual(A2))
5082 << formatv("({0:x} + {1:x}) = ({2:x} + {3:x})", Op1[0], Op1[1], Op2[0],
5083 Op2[1])
5084 .str();
5085 }
5086 }
5087
5088 TEST(APFloatTest, PPCDoubleDoubleHashValue) {
5089 uint64_t Data1[] = {0x3ff0000000000001ull, 0x0000000000000001ull};
5090 uint64_t Data2[] = {0x3ff0000000000001ull, 0};
5091 // The hash values are *hopefully* different.
5092 EXPECT_NE(
5093 hash_value(APFloat(APFloat::PPCDoubleDouble(), APInt(128, 2, Data1))),
5094 hash_value(APFloat(APFloat::PPCDoubleDouble(), APInt(128, 2, Data2))));
5095 }
5096
5097 TEST(APFloatTest, PPCDoubleDoubleChangeSign) {
5098 uint64_t Data[] = {
5099 0x400f000000000000ull, 0xbcb0000000000000ull,
5100 };
5101 APFloat Float(APFloat::PPCDoubleDouble(), APInt(128, 2, Data));
5102 {
5103 APFloat Actual =
5104 APFloat::copySign(Float, APFloat(APFloat::IEEEdouble(), "1"));
5105 EXPECT_EQ(0x400f000000000000ull, Actual.bitcastToAPInt().getRawData()[0]);
5106 EXPECT_EQ(0xbcb0000000000000ull, Actual.bitcastToAPInt().getRawData()[1]);
5107 }
5108 {
5109 APFloat Actual =
5110 APFloat::copySign(Float, APFloat(APFloat::IEEEdouble(), "-1"));
5111 EXPECT_EQ(0xc00f000000000000ull, Actual.bitcastToAPInt().getRawData()[0]);
5112 EXPECT_EQ(0x3cb0000000000000ull, Actual.bitcastToAPInt().getRawData()[1]);
5113 }
5114 }
5115
5116 TEST(APFloatTest, PPCDoubleDoubleFactories) {
5117 {
5118 uint64_t Data[] = {
5119 0, 0,
5120 };
5121 EXPECT_EQ(APInt(128, 2, Data),
5122 APFloat::getZero(APFloat::PPCDoubleDouble()).bitcastToAPInt());
5123 }
5124 {
5125 uint64_t Data[] = {
5126 0x7fefffffffffffffull, 0x7c8ffffffffffffeull,
5127 };
5128 EXPECT_EQ(APInt(128, 2, Data),
5129 APFloat::getLargest(APFloat::PPCDoubleDouble()).bitcastToAPInt());
5130 }
5131 {
5132 uint64_t Data[] = {
5133 0x0000000000000001ull, 0,
5134 };
5135 EXPECT_EQ(
5136 APInt(128, 2, Data),
5137 APFloat::getSmallest(APFloat::PPCDoubleDouble()).bitcastToAPInt());
5138 }
5139 {
5140 uint64_t Data[] = {0x0360000000000000ull, 0};
5141 EXPECT_EQ(APInt(128, 2, Data),
5142 APFloat::getSmallestNormalized(APFloat::PPCDoubleDouble())
5143 .bitcastToAPInt());
5144 }
5145 {
5146 uint64_t Data[] = {
5147 0x8000000000000000ull, 0x0000000000000000ull,
5148 };
5149 EXPECT_EQ(
5150 APInt(128, 2, Data),
5151 APFloat::getZero(APFloat::PPCDoubleDouble(), true).bitcastToAPInt());
5152 }
5153 {
5154 uint64_t Data[] = {
5155 0xffefffffffffffffull, 0xfc8ffffffffffffeull,
5156 };
5157 EXPECT_EQ(
5158 APInt(128, 2, Data),
5159 APFloat::getLargest(APFloat::PPCDoubleDouble(), true).bitcastToAPInt());
5160 }
5161 {
5162 uint64_t Data[] = {
5163 0x8000000000000001ull, 0x0000000000000000ull,
5164 };
5165 EXPECT_EQ(APInt(128, 2, Data),
5166 APFloat::getSmallest(APFloat::PPCDoubleDouble(), true)
5167 .bitcastToAPInt());
5168 }
5169 {
5170 uint64_t Data[] = {
5171 0x8360000000000000ull, 0x0000000000000000ull,
5172 };
5173 EXPECT_EQ(APInt(128, 2, Data),
5174 APFloat::getSmallestNormalized(APFloat::PPCDoubleDouble(), true)
5175 .bitcastToAPInt());
5176 }
5177 EXPECT_TRUE(APFloat::getSmallest(APFloat::PPCDoubleDouble()).isSmallest());
5178 EXPECT_TRUE(APFloat::getLargest(APFloat::PPCDoubleDouble()).isLargest());
5179 }
5180
5181 TEST(APFloatTest, PPCDoubleDoubleIsDenormal) {
5182 EXPECT_TRUE(APFloat::getSmallest(APFloat::PPCDoubleDouble()).isDenormal());
5183 EXPECT_FALSE(APFloat::getLargest(APFloat::PPCDoubleDouble()).isDenormal());
5184 EXPECT_FALSE(
5185 APFloat::getSmallestNormalized(APFloat::PPCDoubleDouble()).isDenormal());
5186 {
5187 // (4 + 3) is not normalized
5188 uint64_t Data[] = {
5189 0x4010000000000000ull, 0x4008000000000000ull,
5190 };
5191 EXPECT_TRUE(
5192 APFloat(APFloat::PPCDoubleDouble(), APInt(128, 2, Data)).isDenormal());
5193 }
5194 }
5195
5196 TEST(APFloatTest, PPCDoubleDoubleScalbn) {
5197 // 3.0 + 3.0 << 53
5198 uint64_t Input[] = {
5199 0x4008000000000000ull, 0x3cb8000000000000ull,
5200 };
5201 APFloat Result =
5202 scalbn(APFloat(APFloat::PPCDoubleDouble(), APInt(128, 2, Input)), 1,
5203 APFloat::rmNearestTiesToEven);
5204 // 6.0 + 6.0 << 53
5205 EXPECT_EQ(0x4018000000000000ull, Result.bitcastToAPInt().getRawData()[0]);
5206 EXPECT_EQ(0x3cc8000000000000ull, Result.bitcastToAPInt().getRawData()[1]);
5207 }
5208
5209 TEST(APFloatTest, PPCDoubleDoubleFrexp) {
5210 // 3.0 + 3.0 << 53
5211 uint64_t Input[] = {
5212 0x4008000000000000ull, 0x3cb8000000000000ull,
5213 };
5214 int Exp;
5215 // 0.75 + 0.75 << 53
5216 APFloat Result =
5217 frexp(APFloat(APFloat::PPCDoubleDouble(), APInt(128, 2, Input)), Exp,
5218 APFloat::rmNearestTiesToEven);
5219 EXPECT_EQ(2, Exp);
5220 EXPECT_EQ(0x3fe8000000000000ull, Result.bitcastToAPInt().getRawData()[0]);
5221 EXPECT_EQ(0x3c98000000000000ull, Result.bitcastToAPInt().getRawData()[1]);
5222 }
5223
5224 TEST(APFloatTest, x87Largest) {
5225 APFloat MaxX87Val = APFloat::getLargest(APFloat::x87DoubleExtended());
5226 EXPECT_TRUE(MaxX87Val.isLargest());
5227 }
5228
5229 TEST(APFloatTest, x87Next) {
5230 APFloat F(APFloat::x87DoubleExtended(), "-1.0");
5231 F.next(false);
5232 EXPECT_TRUE(ilogb(F) == -1);
5233 }
5234
5235 TEST(APFloatTest, Float8ExhaustivePair) {
5236 // Test each pair of 8-bit floats with non-standard semantics
5237 for (APFloat::Semantics Sem :
5238 {APFloat::S_Float8E4M3FN, APFloat::S_Float8E5M2FNUZ,
5239 APFloat::S_Float8E4M3FNUZ, APFloat::S_Float8E4M3B11FNUZ}) {
5240 const llvm::fltSemantics &S = APFloat::EnumToSemantics(Sem);
5241 for (int i = 0; i < 256; i++) {
5242 for (int j = 0; j < 256; j++) {
5243 SCOPED_TRACE("sem=" + std::to_string(Sem) + ",i=" + std::to_string(i) +
5244 ",j=" + std::to_string(j));
5245 APFloat x(S, APInt(8, i));
5246 APFloat y(S, APInt(8, j));
5247
5248 bool losesInfo;
5249 APFloat x16 = x;
5250 x16.convert(APFloat::IEEEhalf(), APFloat::rmNearestTiesToEven,
5251 &losesInfo);
5252 EXPECT_FALSE(losesInfo);
5253 APFloat y16 = y;
5254 y16.convert(APFloat::IEEEhalf(), APFloat::rmNearestTiesToEven,
5255 &losesInfo);
5256 EXPECT_FALSE(losesInfo);
5257
5258 // Add
5259 APFloat z = x;
5260 z.add(y, APFloat::rmNearestTiesToEven);
5261 APFloat z16 = x16;
5262 z16.add(y16, APFloat::rmNearestTiesToEven);
5263 z16.convert(S, APFloat::rmNearestTiesToEven, &losesInfo);
5264 EXPECT_TRUE(z.bitwiseIsEqual(z16))
5265 << "sem=" << Sem << ", i=" << i << ", j=" << j;
5266
5267 // Subtract
5268 z = x;
5269 z.subtract(y, APFloat::rmNearestTiesToEven);
5270 z16 = x16;
5271 z16.subtract(y16, APFloat::rmNearestTiesToEven);
5272 z16.convert(S, APFloat::rmNearestTiesToEven, &losesInfo);
5273 EXPECT_TRUE(z.bitwiseIsEqual(z16))
5274 << "sem=" << Sem << ", i=" << i << ", j=" << j;
5275
5276 // Multiply
5277 z = x;
5278 z.multiply(y, APFloat::rmNearestTiesToEven);
5279 z16 = x16;
5280 z16.multiply(y16, APFloat::rmNearestTiesToEven);
5281 z16.convert(S, APFloat::rmNearestTiesToEven, &losesInfo);
5282 EXPECT_TRUE(z.bitwiseIsEqual(z16))
5283 << "sem=" << Sem << ", i=" << i << ", j=" << j;
5284
5285 // Divide
5286 z = x;
5287 z.divide(y, APFloat::rmNearestTiesToEven);
5288 z16 = x16;
5289 z16.divide(y16, APFloat::rmNearestTiesToEven);
5290 z16.convert(S, APFloat::rmNearestTiesToEven, &losesInfo);
5291 EXPECT_TRUE(z.bitwiseIsEqual(z16))
5292 << "sem=" << Sem << ", i=" << i << ", j=" << j;
5293
5294 // Mod
5295 z = x;
5296 z.mod(y);
5297 z16 = x16;
5298 z16.mod(y16);
5299 z16.convert(S, APFloat::rmNearestTiesToEven, &losesInfo);
5300 EXPECT_TRUE(z.bitwiseIsEqual(z16))
5301 << "sem=" << Sem << ", i=" << i << ", j=" << j;
5302
5303 // Remainder
5304 z = x;
5305 z.remainder(y);
5306 z16 = x16;
5307 z16.remainder(y16);
5308 z16.convert(S, APFloat::rmNearestTiesToEven, &losesInfo);
5309 EXPECT_TRUE(z.bitwiseIsEqual(z16))
5310 << "sem=" << Sem << ", i=" << i << ", j=" << j;
5311 }
5312 }
5313 }
5314 }
5315
5316 TEST(APFloatTest, Float6ExhaustivePair) {
5317 // Test each pair of 6-bit floats with non-standard semantics
5318 for (APFloat::Semantics Sem :
5319 {APFloat::S_Float6E3M2FN, APFloat::S_Float6E2M3FN}) {
5320 const llvm::fltSemantics &S = APFloat::EnumToSemantics(Sem);
5321 for (int i = 1; i < 64; i++) {
5322 for (int j = 1; j < 64; j++) {
5323 SCOPED_TRACE("sem=" + std::to_string(Sem) + ",i=" + std::to_string(i) +
5324 ",j=" + std::to_string(j));
5325 APFloat x(S, APInt(6, i));
5326 APFloat y(S, APInt(6, j));
5327
5328 bool losesInfo;
5329 APFloat x16 = x;
5330 x16.convert(APFloat::IEEEhalf(), APFloat::rmNearestTiesToEven,
5331 &losesInfo);
5332 EXPECT_FALSE(losesInfo);
5333 APFloat y16 = y;
5334 y16.convert(APFloat::IEEEhalf(), APFloat::rmNearestTiesToEven,
5335 &losesInfo);
5336 EXPECT_FALSE(losesInfo);
5337
5338 // Add
5339 APFloat z = x;
5340 z.add(y, APFloat::rmNearestTiesToEven);
5341 APFloat z16 = x16;
5342 z16.add(y16, APFloat::rmNearestTiesToEven);
5343 z16.convert(S, APFloat::rmNearestTiesToEven, &losesInfo);
5344 EXPECT_TRUE(z.bitwiseIsEqual(z16))
5345 << "sem=" << Sem << ", i=" << i << ", j=" << j;
5346
5347 // Subtract
5348 z = x;
5349 z.subtract(y, APFloat::rmNearestTiesToEven);
5350 z16 = x16;
5351 z16.subtract(y16, APFloat::rmNearestTiesToEven);
5352 z16.convert(S, APFloat::rmNearestTiesToEven, &losesInfo);
5353 EXPECT_TRUE(z.bitwiseIsEqual(z16))
5354 << "sem=" << Sem << ", i=" << i << ", j=" << j;
5355
5356 // Multiply
5357 z = x;
5358 z.multiply(y, APFloat::rmNearestTiesToEven);
5359 z16 = x16;
5360 z16.multiply(y16, APFloat::rmNearestTiesToEven);
5361 z16.convert(S, APFloat::rmNearestTiesToEven, &losesInfo);
5362 EXPECT_TRUE(z.bitwiseIsEqual(z16))
5363 << "sem=" << Sem << ", i=" << i << ", j=" << j;
5364
5365 // Skip divide by 0
5366 if (j == 0 || j == 32)
5367 continue;
5368
5369 // Divide
5370 z = x;
5371 z.divide(y, APFloat::rmNearestTiesToEven);
5372 z16 = x16;
5373 z16.divide(y16, APFloat::rmNearestTiesToEven);
5374 z16.convert(S, APFloat::rmNearestTiesToEven, &losesInfo);
5375 EXPECT_TRUE(z.bitwiseIsEqual(z16))
5376 << "sem=" << Sem << ", i=" << i << ", j=" << j;
5377
5378 // Mod
5379 z = x;
5380 z.mod(y);
5381 z16 = x16;
5382 z16.mod(y16);
5383 z16.convert(S, APFloat::rmNearestTiesToEven, &losesInfo);
5384 EXPECT_TRUE(z.bitwiseIsEqual(z16))
5385 << "sem=" << Sem << ", i=" << i << ", j=" << j;
5386
5387 // Remainder
5388 z = x;
5389 z.remainder(y);
5390 z16 = x16;
5391 z16.remainder(y16);
5392 z16.convert(S, APFloat::rmNearestTiesToEven, &losesInfo);
5393 EXPECT_TRUE(z.bitwiseIsEqual(z16))
5394 << "sem=" << Sem << ", i=" << i << ", j=" << j;
5395 }
5396 }
5397 }
5398 }
5399
5400 TEST(APFloatTest, Float4ExhaustivePair) {
5401 // Test each pair of 4-bit floats with non-standard semantics
5402 for (APFloat::Semantics Sem : {APFloat::S_Float4E2M1FN}) {
5403 const llvm::fltSemantics &S = APFloat::EnumToSemantics(Sem);
5404 for (int i = 0; i < 16; i++) {
5405 for (int j = 0; j < 16; j++) {
5406 SCOPED_TRACE("sem=" + std::to_string(Sem) + ",i=" + std::to_string(i) +
5407 ",j=" + std::to_string(j));
5408 APFloat x(S, APInt(4, i));
5409 APFloat y(S, APInt(4, j));
5410
5411 bool losesInfo;
5412 APFloat x16 = x;
5413 x16.convert(APFloat::IEEEhalf(), APFloat::rmNearestTiesToEven,
5414 &losesInfo);
5415 EXPECT_FALSE(losesInfo);
5416 APFloat y16 = y;
5417 y16.convert(APFloat::IEEEhalf(), APFloat::rmNearestTiesToEven,
5418 &losesInfo);
5419 EXPECT_FALSE(losesInfo);
5420
5421 // Add
5422 APFloat z = x;
5423 z.add(y, APFloat::rmNearestTiesToEven);
5424 APFloat z16 = x16;
5425 z16.add(y16, APFloat::rmNearestTiesToEven);
5426 z16.convert(S, APFloat::rmNearestTiesToEven, &losesInfo);
5427 EXPECT_TRUE(z.bitwiseIsEqual(z16))
5428 << "sem=" << Sem << ", i=" << i << ", j=" << j;
5429
5430 // Subtract
5431 z = x;
5432 z.subtract(y, APFloat::rmNearestTiesToEven);
5433 z16 = x16;
5434 z16.subtract(y16, APFloat::rmNearestTiesToEven);
5435 z16.convert(S, APFloat::rmNearestTiesToEven, &losesInfo);
5436 EXPECT_TRUE(z.bitwiseIsEqual(z16))
5437 << "sem=" << Sem << ", i=" << i << ", j=" << j;
5438
5439 // Multiply
5440 z = x;
5441 z.multiply(y, APFloat::rmNearestTiesToEven);
5442 z16 = x16;
5443 z16.multiply(y16, APFloat::rmNearestTiesToEven);
5444 z16.convert(S, APFloat::rmNearestTiesToEven, &losesInfo);
5445 EXPECT_TRUE(z.bitwiseIsEqual(z16))
5446 << "sem=" << Sem << ", i=" << i << ", j=" << j;
5447
5448 // Skip divide by 0
5449 if (j == 0 || j == 8)
5450 continue;
5451
5452 // Divide
5453 z = x;
5454 z.divide(y, APFloat::rmNearestTiesToEven);
5455 z16 = x16;
5456 z16.divide(y16, APFloat::rmNearestTiesToEven);
5457 z16.convert(S, APFloat::rmNearestTiesToEven, &losesInfo);
5458 EXPECT_TRUE(z.bitwiseIsEqual(z16))
5459 << "sem=" << Sem << ", i=" << i << ", j=" << j;
5460
5461 // Mod
5462 z = x;
5463 z.mod(y);
5464 z16 = x16;
5465 z16.mod(y16);
5466 z16.convert(S, APFloat::rmNearestTiesToEven, &losesInfo);
5467 EXPECT_TRUE(z.bitwiseIsEqual(z16))
5468 << "sem=" << Sem << ", i=" << i << ", j=" << j;
5469
5470 // Remainder
5471 z = x;
5472 z.remainder(y);
5473 z16 = x16;
5474 z16.remainder(y16);
5475 z16.convert(S, APFloat::rmNearestTiesToEven, &losesInfo);
5476 EXPECT_TRUE(z.bitwiseIsEqual(z16))
5477 << "sem=" << Sem << ", i=" << i << ", j=" << j;
5478 }
5479 }
5480 }
5481 }
5482
5483 TEST(APFloatTest, ConvertE4M3FNToE5M2) {
5484 bool losesInfo;
5485 APFloat test(APFloat::Float8E4M3FN(), "1.0");
5486 APFloat::opStatus status = test.convert(
5487 APFloat::Float8E5M2(), APFloat::rmNearestTiesToEven, &losesInfo);
5488 EXPECT_EQ(1.0f, test.convertToFloat());
5489 EXPECT_FALSE(losesInfo);
5490 EXPECT_EQ(status, APFloat::opOK);
5491
5492 test = APFloat(APFloat::Float8E4M3FN(), "0.0");
5493 status = test.convert(APFloat::Float8E5M2(), APFloat::rmNearestTiesToEven,
5494 &losesInfo);
5495 EXPECT_EQ(0.0f, test.convertToFloat());
5496 EXPECT_FALSE(losesInfo);
5497 EXPECT_EQ(status, APFloat::opOK);
5498
5499 test = APFloat(APFloat::Float8E4M3FN(), "0x1.2p0"); // 1.125
5500 status = test.convert(APFloat::Float8E5M2(), APFloat::rmNearestTiesToEven,
5501 &losesInfo);
5502 EXPECT_EQ(0x1.0p0 /* 1.0 */, test.convertToFloat());
5503 EXPECT_TRUE(losesInfo);
5504 EXPECT_EQ(status, APFloat::opInexact);
5505
5506 test = APFloat(APFloat::Float8E4M3FN(), "0x1.6p0"); // 1.375
5507 status = test.convert(APFloat::Float8E5M2(), APFloat::rmNearestTiesToEven,
5508 &losesInfo);
5509 EXPECT_EQ(0x1.8p0 /* 1.5 */, test.convertToFloat());
5510 EXPECT_TRUE(losesInfo);
5511 EXPECT_EQ(status, APFloat::opInexact);
5512
5513 // Convert E4M3FN denormal to E5M2 normal. Should not be truncated, despite
5514 // the destination format having one fewer significand bit
5515 test = APFloat(APFloat::Float8E4M3FN(), "0x1.Cp-7");
5516 status = test.convert(APFloat::Float8E5M2(), APFloat::rmNearestTiesToEven,
5517 &losesInfo);
5518 EXPECT_EQ(0x1.Cp-7, test.convertToFloat());
5519 EXPECT_FALSE(losesInfo);
5520 EXPECT_EQ(status, APFloat::opOK);
5521
5522 // Test convert from NaN
5523 test = APFloat(APFloat::Float8E4M3FN(), "nan");
5524 status = test.convert(APFloat::Float8E5M2(), APFloat::rmNearestTiesToEven,
5525 &losesInfo);
5526 EXPECT_TRUE(std::isnan(test.convertToFloat()));
5527 EXPECT_FALSE(losesInfo);
5528 EXPECT_EQ(status, APFloat::opOK);
5529 }
5530
5531 TEST(APFloatTest, ConvertE5M2ToE4M3FN) {
5532 bool losesInfo;
5533 APFloat test(APFloat::Float8E5M2(), "1.0");
5534 APFloat::opStatus status = test.convert(
5535 APFloat::Float8E4M3FN(), APFloat::rmNearestTiesToEven, &losesInfo);
5536 EXPECT_EQ(1.0f, test.convertToFloat());
5537 EXPECT_FALSE(losesInfo);
5538 EXPECT_EQ(status, APFloat::opOK);
5539
5540 test = APFloat(APFloat::Float8E5M2(), "0.0");
5541 status = test.convert(APFloat::Float8E4M3FN(), APFloat::rmNearestTiesToEven,
5542 &losesInfo);
5543 EXPECT_EQ(0.0f, test.convertToFloat());
5544 EXPECT_FALSE(losesInfo);
5545 EXPECT_EQ(status, APFloat::opOK);
5546
5547 test = APFloat(APFloat::Float8E5M2(), "0x1.Cp8"); // 448
5548 status = test.convert(APFloat::Float8E4M3FN(), APFloat::rmNearestTiesToEven,
5549 &losesInfo);
5550 EXPECT_EQ(0x1.Cp8 /* 448 */, test.convertToFloat());
5551 EXPECT_FALSE(losesInfo);
5552 EXPECT_EQ(status, APFloat::opOK);
5553
5554 // Test overflow
5555 test = APFloat(APFloat::Float8E5M2(), "0x1.0p9"); // 512
5556 status = test.convert(APFloat::Float8E4M3FN(), APFloat::rmNearestTiesToEven,
5557 &losesInfo);
5558 EXPECT_TRUE(std::isnan(test.convertToFloat()));
5559 EXPECT_TRUE(losesInfo);
5560 EXPECT_EQ(status, APFloat::opOverflow | APFloat::opInexact);
5561
5562 // Test underflow
5563 test = APFloat(APFloat::Float8E5M2(), "0x1.0p-10");
5564 status = test.convert(APFloat::Float8E4M3FN(), APFloat::rmNearestTiesToEven,
5565 &losesInfo);
5566 EXPECT_EQ(0., test.convertToFloat());
5567 EXPECT_TRUE(losesInfo);
5568 EXPECT_EQ(status, APFloat::opUnderflow | APFloat::opInexact);
5569
5570 // Test rounding up to smallest denormal number
5571 test = APFloat(APFloat::Float8E5M2(), "0x1.8p-10");
5572 status = test.convert(APFloat::Float8E4M3FN(), APFloat::rmNearestTiesToEven,
5573 &losesInfo);
5574 EXPECT_EQ(0x1.0p-9, test.convertToFloat());
5575 EXPECT_TRUE(losesInfo);
5576 EXPECT_EQ(status, APFloat::opUnderflow | APFloat::opInexact);
5577
5578 // Testing inexact rounding to denormal number
5579 test = APFloat(APFloat::Float8E5M2(), "0x1.8p-9");
5580 status = test.convert(APFloat::Float8E4M3FN(), APFloat::rmNearestTiesToEven,
5581 &losesInfo);
5582 EXPECT_EQ(0x1.0p-8, test.convertToFloat());
5583 EXPECT_TRUE(losesInfo);
5584 EXPECT_EQ(status, APFloat::opUnderflow | APFloat::opInexact);
5585
5586 APFloat nan = APFloat(APFloat::Float8E4M3FN(), "nan");
5587
5588 // Testing convert from Inf
5589 test = APFloat(APFloat::Float8E5M2(), "inf");
5590 status = test.convert(APFloat::Float8E4M3FN(), APFloat::rmNearestTiesToEven,
5591 &losesInfo);
5592 EXPECT_TRUE(std::isnan(test.convertToFloat()));
5593 EXPECT_TRUE(losesInfo);
5594 EXPECT_EQ(status, APFloat::opInexact);
5595 EXPECT_TRUE(test.bitwiseIsEqual(nan));
5596
5597 // Testing convert from quiet NaN
5598 test = APFloat(APFloat::Float8E5M2(), "nan");
5599 status = test.convert(APFloat::Float8E4M3FN(), APFloat::rmNearestTiesToEven,
5600 &losesInfo);
5601 EXPECT_TRUE(std::isnan(test.convertToFloat()));
5602 EXPECT_TRUE(losesInfo);
5603 EXPECT_EQ(status, APFloat::opOK);
5604 EXPECT_TRUE(test.bitwiseIsEqual(nan));
5605
5606 // Testing convert from signaling NaN
5607 test = APFloat(APFloat::Float8E5M2(), "snan");
5608 status = test.convert(APFloat::Float8E4M3FN(), APFloat::rmNearestTiesToEven,
5609 &losesInfo);
5610 EXPECT_TRUE(std::isnan(test.convertToFloat()));
5611 EXPECT_TRUE(losesInfo);
5612 EXPECT_EQ(status, APFloat::opInvalidOp);
5613 EXPECT_TRUE(test.bitwiseIsEqual(nan));
5614 }
5615
5616 TEST(APFloatTest, Float8E4M3FNGetInf) {
5617 APFloat t = APFloat::getInf(APFloat::Float8E4M3FN());
5618 EXPECT_TRUE(t.isNaN());
5619 EXPECT_FALSE(t.isInfinity());
5620 }
5621
5622 TEST(APFloatTest, Float8E4M3FNFromString) {
5623 // Exactly representable
5624 EXPECT_EQ(448, APFloat(APFloat::Float8E4M3FN(), "448").convertToDouble());
5625 // Round down to maximum value
5626 EXPECT_EQ(448, APFloat(APFloat::Float8E4M3FN(), "464").convertToDouble());
5627 // Round up, causing overflow to NaN
5628 EXPECT_TRUE(APFloat(APFloat::Float8E4M3FN(), "465").isNaN());
5629 // Overflow without rounding
5630 EXPECT_TRUE(APFloat(APFloat::Float8E4M3FN(), "480").isNaN());
5631 // Inf converted to NaN
5632 EXPECT_TRUE(APFloat(APFloat::Float8E4M3FN(), "inf").isNaN());
5633 // NaN converted to NaN
5634 EXPECT_TRUE(APFloat(APFloat::Float8E4M3FN(), "nan").isNaN());
5635 }
5636
5637 TEST(APFloatTest, Float8E4M3FNAdd) {
5638 APFloat QNaN = APFloat::getNaN(APFloat::Float8E4M3FN(), false);
5639
5640 auto FromStr = [](StringRef S) {
5641 return APFloat(APFloat::Float8E4M3FN(), S);
5642 };
5643
5644 struct {
5645 APFloat x;
5646 APFloat y;
5647 const char *result;
5648 int status;
5649 int category;
5650 APFloat::roundingMode roundingMode = APFloat::rmNearestTiesToEven;
5651 } AdditionTests[] = {
5652 // Test addition operations involving NaN, overflow, and the max E4M3FN
5653 // value (448) because E4M3FN differs from IEEE-754 types in these regards
5654 {FromStr("448"), FromStr("16"), "448", APFloat::opInexact,
5655 APFloat::fcNormal},
5656 {FromStr("448"), FromStr("18"), "NaN",
5657 APFloat::opOverflow | APFloat::opInexact, APFloat::fcNaN},
5658 {FromStr("448"), FromStr("32"), "NaN",
5659 APFloat::opOverflow | APFloat::opInexact, APFloat::fcNaN},
5660 {FromStr("-448"), FromStr("-32"), "-NaN",
5661 APFloat::opOverflow | APFloat::opInexact, APFloat::fcNaN},
5662 {QNaN, FromStr("-448"), "NaN", APFloat::opOK, APFloat::fcNaN},
5663 {FromStr("448"), FromStr("-32"), "416", APFloat::opOK, APFloat::fcNormal},
5664 {FromStr("448"), FromStr("0"), "448", APFloat::opOK, APFloat::fcNormal},
5665 {FromStr("448"), FromStr("32"), "448", APFloat::opInexact,
5666 APFloat::fcNormal, APFloat::rmTowardZero},
5667 {FromStr("448"), FromStr("448"), "448", APFloat::opInexact,
5668 APFloat::fcNormal, APFloat::rmTowardZero},
5669 };
5670
5671 for (size_t i = 0; i < std::size(AdditionTests); ++i) {
5672 APFloat x(AdditionTests[i].x);
5673 APFloat y(AdditionTests[i].y);
5674 APFloat::opStatus status = x.add(y, AdditionTests[i].roundingMode);
5675
5676 APFloat result(APFloat::Float8E4M3FN(), AdditionTests[i].result);
5677
5678 EXPECT_TRUE(result.bitwiseIsEqual(x));
5679 EXPECT_EQ(AdditionTests[i].status, (int)status);
5680 EXPECT_EQ(AdditionTests[i].category, (int)x.getCategory());
5681 }
5682 }
5683
5684 TEST(APFloatTest, Float8E4M3FNDivideByZero) {
5685 APFloat x(APFloat::Float8E4M3FN(), "1");
5686 APFloat zero(APFloat::Float8E4M3FN(), "0");
5687 EXPECT_EQ(x.divide(zero, APFloat::rmNearestTiesToEven), APFloat::opDivByZero);
5688 EXPECT_TRUE(x.isNaN());
5689 }
5690
5691 TEST(APFloatTest, Float8E4M3FNNext) {
5692 APFloat test(APFloat::Float8E4M3FN(), APFloat::uninitialized);
5693 APFloat expected(APFloat::Float8E4M3FN(), APFloat::uninitialized);
5694
5695 // nextUp on positive numbers
5696 for (int i = 0; i < 127; i++) {
5697 test = APFloat(APFloat::Float8E4M3FN(), APInt(8, i));
5698 expected = APFloat(APFloat::Float8E4M3FN(), APInt(8, i + 1));
5699 EXPECT_EQ(test.next(false), APFloat::opOK);
5700 EXPECT_TRUE(test.bitwiseIsEqual(expected));
5701 }
5702
5703 // nextUp on negative zero
5704 test = APFloat::getZero(APFloat::Float8E4M3FN(), true);
5705 expected = APFloat::getSmallest(APFloat::Float8E4M3FN(), false);
5706 EXPECT_EQ(test.next(false), APFloat::opOK);
5707 EXPECT_TRUE(test.bitwiseIsEqual(expected));
5708
5709 // nextUp on negative nonzero numbers
5710 for (int i = 129; i < 255; i++) {
5711 test = APFloat(APFloat::Float8E4M3FN(), APInt(8, i));
5712 expected = APFloat(APFloat::Float8E4M3FN(), APInt(8, i - 1));
5713 EXPECT_EQ(test.next(false), APFloat::opOK);
5714 EXPECT_TRUE(test.bitwiseIsEqual(expected));
5715 }
5716
5717 // nextUp on NaN
5718 test = APFloat::getQNaN(APFloat::Float8E4M3FN(), false);
5719 expected = APFloat::getQNaN(APFloat::Float8E4M3FN(), false);
5720 EXPECT_EQ(test.next(false), APFloat::opOK);
5721 EXPECT_TRUE(test.bitwiseIsEqual(expected));
5722
5723 // nextDown on positive nonzero finite numbers
5724 for (int i = 1; i < 127; i++) {
5725 test = APFloat(APFloat::Float8E4M3FN(), APInt(8, i));
5726 expected = APFloat(APFloat::Float8E4M3FN(), APInt(8, i - 1));
5727 EXPECT_EQ(test.next(true), APFloat::opOK);
5728 EXPECT_TRUE(test.bitwiseIsEqual(expected));
5729 }
5730
5731 // nextDown on positive zero
5732 test = APFloat::getZero(APFloat::Float8E4M3FN(), true);
5733 expected = APFloat::getSmallest(APFloat::Float8E4M3FN(), true);
5734 EXPECT_EQ(test.next(true), APFloat::opOK);
5735 EXPECT_TRUE(test.bitwiseIsEqual(expected));
5736
5737 // nextDown on negative finite numbers
5738 for (int i = 128; i < 255; i++) {
5739 test = APFloat(APFloat::Float8E4M3FN(), APInt(8, i));
5740 expected = APFloat(APFloat::Float8E4M3FN(), APInt(8, i + 1));
5741 EXPECT_EQ(test.next(true), APFloat::opOK);
5742 EXPECT_TRUE(test.bitwiseIsEqual(expected));
5743 }
5744
5745 // nextDown on NaN
5746 test = APFloat::getQNaN(APFloat::Float8E4M3FN(), false);
5747 expected = APFloat::getQNaN(APFloat::Float8E4M3FN(), false);
5748 EXPECT_EQ(test.next(true), APFloat::opOK);
5749 EXPECT_TRUE(test.bitwiseIsEqual(expected));
5750 }
5751
5752 TEST(APFloatTest, Float8E4M3FNExhaustive) {
5753 // Test each of the 256 Float8E4M3FN values.
5754 for (int i = 0; i < 256; i++) {
5755 APFloat test(APFloat::Float8E4M3FN(), APInt(8, i));
5756 SCOPED_TRACE("i=" + std::to_string(i));
5757
5758 // isLargest
5759 if (i == 126 || i == 254) {
5760 EXPECT_TRUE(test.isLargest());
5761 EXPECT_EQ(abs(test).convertToDouble(), 448.);
5762 } else {
5763 EXPECT_FALSE(test.isLargest());
5764 }
5765
5766 // isSmallest
5767 if (i == 1 || i == 129) {
5768 EXPECT_TRUE(test.isSmallest());
5769 EXPECT_EQ(abs(test).convertToDouble(), 0x1p-9);
5770 } else {
5771 EXPECT_FALSE(test.isSmallest());
5772 }
5773
5774 // convert to BFloat
5775 APFloat test2 = test;
5776 bool losesInfo;
5777 APFloat::opStatus status = test2.convert(
5778 APFloat::BFloat(), APFloat::rmNearestTiesToEven, &losesInfo);
5779 EXPECT_EQ(status, APFloat::opOK);
5780 EXPECT_FALSE(losesInfo);
5781 if (i == 127 || i == 255)
5782 EXPECT_TRUE(test2.isNaN());
5783 else
5784 EXPECT_EQ(test.convertToFloat(), test2.convertToFloat());
5785
5786 // bitcastToAPInt
5787 EXPECT_EQ(i, test.bitcastToAPInt());
5788 }
5789 }
5790
5791 TEST(APFloatTest, Float8E5M2FNUZNext) {
5792 APFloat test(APFloat::Float8E5M2FNUZ(), APFloat::uninitialized);
5793 APFloat expected(APFloat::Float8E5M2FNUZ(), APFloat::uninitialized);
5794
5795 // 1. NextUp of largest bit pattern is nan
5796 test = APFloat::getLargest(APFloat::Float8E5M2FNUZ());
5797 expected = APFloat::getNaN(APFloat::Float8E5M2FNUZ());
5798 EXPECT_EQ(test.next(false), APFloat::opOK);
5799 EXPECT_FALSE(test.isInfinity());
5800 EXPECT_FALSE(test.isZero());
5801 EXPECT_TRUE(test.isNaN());
5802 EXPECT_TRUE(test.bitwiseIsEqual(expected));
5803
5804 // 2. NextUp of smallest negative denormal is +0
5805 test = APFloat::getSmallest(APFloat::Float8E5M2FNUZ(), true);
5806 expected = APFloat::getZero(APFloat::Float8E5M2FNUZ(), false);
5807 EXPECT_EQ(test.next(false), APFloat::opOK);
5808 EXPECT_FALSE(test.isNegZero());
5809 EXPECT_TRUE(test.isPosZero());
5810 EXPECT_TRUE(test.bitwiseIsEqual(expected));
5811
5812 // 3. nextDown of negative of largest value is NaN
5813 test = APFloat::getLargest(APFloat::Float8E5M2FNUZ(), true);
5814 expected = APFloat::getNaN(APFloat::Float8E5M2FNUZ());
5815 EXPECT_EQ(test.next(true), APFloat::opOK);
5816 EXPECT_FALSE(test.isInfinity());
5817 EXPECT_FALSE(test.isZero());
5818 EXPECT_TRUE(test.isNaN());
5819 EXPECT_TRUE(test.bitwiseIsEqual(expected));
5820
5821 // 4. nextDown of +0 is smallest negative denormal
5822 test = APFloat::getZero(APFloat::Float8E5M2FNUZ(), false);
5823 expected = APFloat::getSmallest(APFloat::Float8E5M2FNUZ(), true);
5824 EXPECT_EQ(test.next(true), APFloat::opOK);
5825 EXPECT_FALSE(test.isZero());
5826 EXPECT_TRUE(test.isDenormal());
5827 EXPECT_TRUE(test.bitwiseIsEqual(expected));
5828
5829 // 5. nextUp of NaN is NaN
5830 test = APFloat::getNaN(APFloat::Float8E5M2FNUZ(), false);
5831 expected = APFloat::getNaN(APFloat::Float8E5M2FNUZ(), true);
5832 EXPECT_EQ(test.next(false), APFloat::opOK);
5833 EXPECT_TRUE(test.isNaN());
5834
5835 // 6. nextDown of NaN is NaN
5836 test = APFloat::getNaN(APFloat::Float8E5M2FNUZ(), false);
5837 expected = APFloat::getNaN(APFloat::Float8E5M2FNUZ(), true);
5838 EXPECT_EQ(test.next(true), APFloat::opOK);
5839 EXPECT_TRUE(test.isNaN());
5840 }
5841
5842 TEST(APFloatTest, Float8E5M2FNUZChangeSign) {
5843 APFloat test = APFloat(APFloat::Float8E5M2FNUZ(), "1.0");
5844 APFloat expected = APFloat(APFloat::Float8E5M2FNUZ(), "-1.0");
5845 test.changeSign();
5846 EXPECT_TRUE(test.bitwiseIsEqual(expected));
5847
5848 test = APFloat::getZero(APFloat::Float8E5M2FNUZ());
5849 expected = test;
5850 test.changeSign();
5851 EXPECT_TRUE(test.bitwiseIsEqual(expected));
5852
5853 test = APFloat::getNaN(APFloat::Float8E5M2FNUZ());
5854 expected = test;
5855 test.changeSign();
5856 EXPECT_TRUE(test.bitwiseIsEqual(expected));
5857 }
5858
5859 TEST(APFloatTest, Float8E5M2FNUZFromString) {
5860 // Exactly representable
5861 EXPECT_EQ(57344,
5862 APFloat(APFloat::Float8E5M2FNUZ(), "57344").convertToDouble());
5863 // Round down to maximum value
5864 EXPECT_EQ(57344,
5865 APFloat(APFloat::Float8E5M2FNUZ(), "59392").convertToDouble());
5866 // Round up, causing overflow to NaN
5867 EXPECT_TRUE(APFloat(APFloat::Float8E5M2FNUZ(), "61440").isNaN());
5868 // Overflow without rounding
5869 EXPECT_TRUE(APFloat(APFloat::Float8E5M2FNUZ(), "131072").isNaN());
5870 // Inf converted to NaN
5871 EXPECT_TRUE(APFloat(APFloat::Float8E5M2FNUZ(), "inf").isNaN());
5872 // NaN converted to NaN
5873 EXPECT_TRUE(APFloat(APFloat::Float8E5M2FNUZ(), "nan").isNaN());
5874 // Negative zero converted to positive zero
5875 EXPECT_TRUE(APFloat(APFloat::Float8E5M2FNUZ(), "-0").isPosZero());
5876 }
5877
5878 TEST(APFloatTest, UnsignedZeroArithmeticSpecial) {
5879 // Float semantics with only unsigned zero (ex. Float8E4M3FNUZ) violate the
5880 // IEEE rules about signs in arithmetic operations when producing zeros,
5881 // because they only have one zero. Most of the rest of the complexities of
5882 // arithmetic on these values are covered by the other Float8 types' test
5883 // cases and so are not repeated here.
5884
5885 // The IEEE round towards negative rule doesn't apply
5886 for (APFloat::Semantics S :
5887 {APFloat::S_Float8E4M3FNUZ, APFloat::S_Float8E4M3B11FNUZ}) {
5888 const llvm::fltSemantics &Sem = APFloat::EnumToSemantics(S);
5889 APFloat test = APFloat::getSmallest(Sem);
5890 APFloat rhs = test;
5891 EXPECT_EQ(test.subtract(rhs, APFloat::rmTowardNegative), APFloat::opOK);
5892 EXPECT_TRUE(test.isZero());
5893 EXPECT_FALSE(test.isNegative());
5894
5895 // Multiplication of (small) * (-small) is +0
5896 test = APFloat::getSmallestNormalized(Sem);
5897 rhs = -test;
5898 EXPECT_EQ(test.multiply(rhs, APFloat::rmNearestTiesToAway),
5899 APFloat::opInexact | APFloat::opUnderflow);
5900 EXPECT_TRUE(test.isZero());
5901 EXPECT_FALSE(test.isNegative());
5902
5903 // Dividing the negatize float_min by anything gives +0
5904 test = APFloat::getSmallest(Sem, true);
5905 rhs = APFloat(Sem, "2.0");
5906 EXPECT_EQ(test.divide(rhs, APFloat::rmNearestTiesToEven),
5907 APFloat::opInexact | APFloat::opUnderflow);
5908 EXPECT_TRUE(test.isZero());
5909 EXPECT_FALSE(test.isNegative());
5910
5911 // Remainder can't copy sign because there's only one zero
5912 test = APFloat(Sem, "-4.0");
5913 rhs = APFloat(Sem, "2.0");
5914 EXPECT_EQ(test.remainder(rhs), APFloat::opOK);
5915 EXPECT_TRUE(test.isZero());
5916 EXPECT_FALSE(test.isNegative());
5917
5918 // And same for mod
5919 test = APFloat(Sem, "-4.0");
5920 rhs = APFloat(Sem, "2.0");
5921 EXPECT_EQ(test.mod(rhs), APFloat::opOK);
5922 EXPECT_TRUE(test.isZero());
5923 EXPECT_FALSE(test.isNegative());
5924
5925 // FMA correctly handles both the multiply and add parts of all this
5926 test = APFloat(Sem, "2.0");
5927 rhs = test;
5928 APFloat addend = APFloat(Sem, "-4.0");
5929 EXPECT_EQ(test.fusedMultiplyAdd(rhs, addend, APFloat::rmTowardNegative),
5930 APFloat::opOK);
5931 EXPECT_TRUE(test.isZero());
5932 EXPECT_FALSE(test.isNegative());
5933 }
5934 }
5935
5936 TEST(APFloatTest, Float8E5M2FNUZAdd) {
5937 APFloat QNaN = APFloat::getNaN(APFloat::Float8E5M2FNUZ(), false);
5938
5939 auto FromStr = [](StringRef S) {
5940 return APFloat(APFloat::Float8E5M2FNUZ(), S);
5941 };
5942
5943 struct {
5944 APFloat x;
5945 APFloat y;
5946 const char *result;
5947 int status;
5948 int category;
5949 APFloat::roundingMode roundingMode = APFloat::rmNearestTiesToEven;
5950 } AdditionTests[] = {
5951 // Test addition operations involving NaN, overflow, and the max E5M2FNUZ
5952 // value (57344) because E5M2FNUZ differs from IEEE-754 types in these
5953 // regards
5954 {FromStr("57344"), FromStr("2048"), "57344", APFloat::opInexact,
5955 APFloat::fcNormal},
5956 {FromStr("57344"), FromStr("4096"), "NaN",
5957 APFloat::opOverflow | APFloat::opInexact, APFloat::fcNaN},
5958 {FromStr("-57344"), FromStr("-4096"), "NaN",
5959 APFloat::opOverflow | APFloat::opInexact, APFloat::fcNaN},
5960 {QNaN, FromStr("-57344"), "NaN", APFloat::opOK, APFloat::fcNaN},
5961 {FromStr("57344"), FromStr("-8192"), "49152", APFloat::opOK,
5962 APFloat::fcNormal},
5963 {FromStr("57344"), FromStr("0"), "57344", APFloat::opOK,
5964 APFloat::fcNormal},
5965 {FromStr("57344"), FromStr("4096"), "57344", APFloat::opInexact,
5966 APFloat::fcNormal, APFloat::rmTowardZero},
5967 {FromStr("57344"), FromStr("57344"), "57344", APFloat::opInexact,
5968 APFloat::fcNormal, APFloat::rmTowardZero},
5969 };
5970
5971 for (size_t i = 0; i < std::size(AdditionTests); ++i) {
5972 APFloat x(AdditionTests[i].x);
5973 APFloat y(AdditionTests[i].y);
5974 APFloat::opStatus status = x.add(y, AdditionTests[i].roundingMode);
5975
5976 APFloat result(APFloat::Float8E5M2FNUZ(), AdditionTests[i].result);
5977
5978 EXPECT_TRUE(result.bitwiseIsEqual(x));
5979 EXPECT_EQ(AdditionTests[i].status, (int)status);
5980 EXPECT_EQ(AdditionTests[i].category, (int)x.getCategory());
5981 }
5982 }
5983
5984 TEST(APFloatTest, Float8E5M2FNUZDivideByZero) {
5985 APFloat x(APFloat::Float8E5M2FNUZ(), "1");
5986 APFloat zero(APFloat::Float8E5M2FNUZ(), "0");
5987 EXPECT_EQ(x.divide(zero, APFloat::rmNearestTiesToEven), APFloat::opDivByZero);
5988 EXPECT_TRUE(x.isNaN());
5989 }
5990
5991 TEST(APFloatTest, Float8UnsignedZeroExhaustive) {
5992 struct {
5993 const fltSemantics *semantics;
5994 const double largest;
5995 const double smallest;
5996 } const exhaustiveTests[] = {{&APFloat::Float8E5M2FNUZ(), 57344., 0x1.0p-17},
5997 {&APFloat::Float8E4M3FNUZ(), 240., 0x1.0p-10},
5998 {&APFloat::Float8E4M3B11FNUZ(), 30., 0x1.0p-13}};
5999 for (const auto &testInfo : exhaustiveTests) {
6000 const fltSemantics &sem = *testInfo.semantics;
6001 SCOPED_TRACE("Semantics=" + std::to_string(APFloat::SemanticsToEnum(sem)));
6002 // Test each of the 256 values.
6003 for (int i = 0; i < 256; i++) {
6004 SCOPED_TRACE("i=" + std::to_string(i));
6005 APFloat test(sem, APInt(8, i));
6006
6007 // isLargest
6008 if (i == 127 || i == 255) {
6009 EXPECT_TRUE(test.isLargest());
6010 EXPECT_EQ(abs(test).convertToDouble(), testInfo.largest);
6011 } else {
6012 EXPECT_FALSE(test.isLargest());
6013 }
6014
6015 // isSmallest
6016 if (i == 1 || i == 129) {
6017 EXPECT_TRUE(test.isSmallest());
6018 EXPECT_EQ(abs(test).convertToDouble(), testInfo.smallest);
6019 } else {
6020 EXPECT_FALSE(test.isSmallest());
6021 }
6022
6023 // convert to BFloat
6024 APFloat test2 = test;
6025 bool losesInfo;
6026 APFloat::opStatus status = test2.convert(
6027 APFloat::BFloat(), APFloat::rmNearestTiesToEven, &losesInfo);
6028 EXPECT_EQ(status, APFloat::opOK);
6029 EXPECT_FALSE(losesInfo);
6030 if (i == 128)
6031 EXPECT_TRUE(test2.isNaN());
6032 else
6033 EXPECT_EQ(test.convertToFloat(), test2.convertToFloat());
6034
6035 // bitcastToAPInt
6036 EXPECT_EQ(i, test.bitcastToAPInt());
6037 }
6038 }
6039 }
6040
6041 TEST(APFloatTest, Float8E4M3FNUZNext) {
6042 for (APFloat::Semantics S :
6043 {APFloat::S_Float8E4M3FNUZ, APFloat::S_Float8E4M3B11FNUZ}) {
6044 const llvm::fltSemantics &Sem = APFloat::EnumToSemantics(S);
6045 APFloat test(Sem, APFloat::uninitialized);
6046 APFloat expected(Sem, APFloat::uninitialized);
6047
6048 // 1. NextUp of largest bit pattern is nan
6049 test = APFloat::getLargest(Sem);
6050 expected = APFloat::getNaN(Sem);
6051 EXPECT_EQ(test.next(false), APFloat::opOK);
6052 EXPECT_FALSE(test.isInfinity());
6053 EXPECT_FALSE(test.isZero());
6054 EXPECT_TRUE(test.isNaN());
6055 EXPECT_TRUE(test.bitwiseIsEqual(expected));
6056
6057 // 2. NextUp of smallest negative denormal is +0
6058 test = APFloat::getSmallest(Sem, true);
6059 expected = APFloat::getZero(Sem, false);
6060 EXPECT_EQ(test.next(false), APFloat::opOK);
6061 EXPECT_FALSE(test.isNegZero());
6062 EXPECT_TRUE(test.isPosZero());
6063 EXPECT_TRUE(test.bitwiseIsEqual(expected));
6064
6065 // 3. nextDown of negative of largest value is NaN
6066 test = APFloat::getLargest(Sem, true);
6067 expected = APFloat::getNaN(Sem);
6068 EXPECT_EQ(test.next(true), APFloat::opOK);
6069 EXPECT_FALSE(test.isInfinity());
6070 EXPECT_FALSE(test.isZero());
6071 EXPECT_TRUE(test.isNaN());
6072 EXPECT_TRUE(test.bitwiseIsEqual(expected));
6073
6074 // 4. nextDown of +0 is smallest negative denormal
6075 test = APFloat::getZero(Sem, false);
6076 expected = APFloat::getSmallest(Sem, true);
6077 EXPECT_EQ(test.next(true), APFloat::opOK);
6078 EXPECT_FALSE(test.isZero());
6079 EXPECT_TRUE(test.isDenormal());
6080 EXPECT_TRUE(test.bitwiseIsEqual(expected));
6081
6082 // 5. nextUp of NaN is NaN
6083 test = APFloat::getNaN(Sem, false);
6084 expected = APFloat::getNaN(Sem, true);
6085 EXPECT_EQ(test.next(false), APFloat::opOK);
6086 EXPECT_TRUE(test.isNaN());
6087
6088 // 6. nextDown of NaN is NaN
6089 test = APFloat::getNaN(Sem, false);
6090 expected = APFloat::getNaN(Sem, true);
6091 EXPECT_EQ(test.next(true), APFloat::opOK);
6092 EXPECT_TRUE(test.isNaN());
6093 }
6094 }
6095
6096 TEST(APFloatTest, Float8E4M3FNUZChangeSign) {
6097 for (APFloat::Semantics S :
6098 {APFloat::S_Float8E4M3FNUZ, APFloat::S_Float8E4M3B11FNUZ}) {
6099 const llvm::fltSemantics &Sem = APFloat::EnumToSemantics(S);
6100 APFloat test = APFloat(Sem, "1.0");
6101 APFloat expected = APFloat(Sem, "-1.0");
6102 test.changeSign();
6103 EXPECT_TRUE(test.bitwiseIsEqual(expected));
6104
6105 test = APFloat::getZero(Sem);
6106 expected = test;
6107 test.changeSign();
6108 EXPECT_TRUE(test.bitwiseIsEqual(expected));
6109
6110 test = APFloat::getNaN(Sem);
6111 expected = test;
6112 test.changeSign();
6113 EXPECT_TRUE(test.bitwiseIsEqual(expected));
6114 }
6115 }
6116
6117 TEST(APFloatTest, Float8E4M3FNUZFromString) {
6118 // Exactly representable
6119 EXPECT_EQ(240, APFloat(APFloat::Float8E4M3FNUZ(), "240").convertToDouble());
6120 // Round down to maximum value
6121 EXPECT_EQ(240, APFloat(APFloat::Float8E4M3FNUZ(), "247").convertToDouble());
6122 // Round up, causing overflow to NaN
6123 EXPECT_TRUE(APFloat(APFloat::Float8E4M3FNUZ(), "248").isNaN());
6124 // Overflow without rounding
6125 EXPECT_TRUE(APFloat(APFloat::Float8E4M3FNUZ(), "480").isNaN());
6126 // Inf converted to NaN
6127 EXPECT_TRUE(APFloat(APFloat::Float8E4M3FNUZ(), "inf").isNaN());
6128 // NaN converted to NaN
6129 EXPECT_TRUE(APFloat(APFloat::Float8E4M3FNUZ(), "nan").isNaN());
6130 // Negative zero converted to positive zero
6131 EXPECT_TRUE(APFloat(APFloat::Float8E4M3FNUZ(), "-0").isPosZero());
6132 }
6133
6134 TEST(APFloatTest, Float8E4M3FNUZAdd) {
6135 APFloat QNaN = APFloat::getNaN(APFloat::Float8E4M3FNUZ(), false);
6136
6137 auto FromStr = [](StringRef S) {
6138 return APFloat(APFloat::Float8E4M3FNUZ(), S);
6139 };
6140
6141 struct {
6142 APFloat x;
6143 APFloat y;
6144 const char *result;
6145 int status;
6146 int category;
6147 APFloat::roundingMode roundingMode = APFloat::rmNearestTiesToEven;
6148 } AdditionTests[] = {
6149 // Test addition operations involving NaN, overflow, and the max E4M3FNUZ
6150 // value (240) because E4M3FNUZ differs from IEEE-754 types in these
6151 // regards
6152 {FromStr("240"), FromStr("4"), "240", APFloat::opInexact,
6153 APFloat::fcNormal},
6154 {FromStr("240"), FromStr("8"), "NaN",
6155 APFloat::opOverflow | APFloat::opInexact, APFloat::fcNaN},
6156 {FromStr("240"), FromStr("16"), "NaN",
6157 APFloat::opOverflow | APFloat::opInexact, APFloat::fcNaN},
6158 {FromStr("-240"), FromStr("-16"), "NaN",
6159 APFloat::opOverflow | APFloat::opInexact, APFloat::fcNaN},
6160 {QNaN, FromStr("-240"), "NaN", APFloat::opOK, APFloat::fcNaN},
6161 {FromStr("240"), FromStr("-16"), "224", APFloat::opOK, APFloat::fcNormal},
6162 {FromStr("240"), FromStr("0"), "240", APFloat::opOK, APFloat::fcNormal},
6163 {FromStr("240"), FromStr("32"), "240", APFloat::opInexact,
6164 APFloat::fcNormal, APFloat::rmTowardZero},
6165 {FromStr("240"), FromStr("240"), "240", APFloat::opInexact,
6166 APFloat::fcNormal, APFloat::rmTowardZero},
6167 };
6168
6169 for (size_t i = 0; i < std::size(AdditionTests); ++i) {
6170 APFloat x(AdditionTests[i].x);
6171 APFloat y(AdditionTests[i].y);
6172 APFloat::opStatus status = x.add(y, AdditionTests[i].roundingMode);
6173
6174 APFloat result(APFloat::Float8E4M3FNUZ(), AdditionTests[i].result);
6175
6176 EXPECT_TRUE(result.bitwiseIsEqual(x));
6177 EXPECT_EQ(AdditionTests[i].status, (int)status);
6178 EXPECT_EQ(AdditionTests[i].category, (int)x.getCategory());
6179 }
6180 }
6181
6182 TEST(APFloatTest, Float8E4M3FNUZDivideByZero) {
6183 APFloat x(APFloat::Float8E4M3FNUZ(), "1");
6184 APFloat zero(APFloat::Float8E4M3FNUZ(), "0");
6185 EXPECT_EQ(x.divide(zero, APFloat::rmNearestTiesToEven), APFloat::opDivByZero);
6186 EXPECT_TRUE(x.isNaN());
6187 }
6188
6189 TEST(APFloatTest, ConvertE5M2FNUZToE4M3FNUZ) {
6190 bool losesInfo;
6191 APFloat test(APFloat::Float8E5M2FNUZ(), "1.0");
6192 APFloat::opStatus status = test.convert(
6193 APFloat::Float8E4M3FNUZ(), APFloat::rmNearestTiesToEven, &losesInfo);
6194 EXPECT_EQ(1.0f, test.convertToFloat());
6195 EXPECT_FALSE(losesInfo);
6196 EXPECT_EQ(status, APFloat::opOK);
6197
6198 losesInfo = true;
6199 test = APFloat(APFloat::Float8E5M2FNUZ(), "0.0");
6200 status = test.convert(APFloat::Float8E4M3FNUZ(), APFloat::rmNearestTiesToEven,
6201 &losesInfo);
6202 EXPECT_EQ(0.0f, test.convertToFloat());
6203 EXPECT_FALSE(losesInfo);
6204 EXPECT_EQ(status, APFloat::opOK);
6205
6206 losesInfo = true;
6207 test = APFloat(APFloat::Float8E5M2FNUZ(), "0x1.Cp7"); // 224
6208 status = test.convert(APFloat::Float8E4M3FNUZ(), APFloat::rmNearestTiesToEven,
6209 &losesInfo);
6210 EXPECT_EQ(0x1.Cp7 /* 224 */, test.convertToFloat());
6211 EXPECT_FALSE(losesInfo);
6212 EXPECT_EQ(status, APFloat::opOK);
6213
6214 // Test overflow
6215 losesInfo = false;
6216 test = APFloat(APFloat::Float8E5M2FNUZ(), "0x1.0p8"); // 256
6217 status = test.convert(APFloat::Float8E4M3FNUZ(), APFloat::rmNearestTiesToEven,
6218 &losesInfo);
6219 EXPECT_TRUE(std::isnan(test.convertToFloat()));
6220 EXPECT_TRUE(losesInfo);
6221 EXPECT_EQ(status, APFloat::opOverflow | APFloat::opInexact);
6222
6223 // Test underflow
6224 test = APFloat(APFloat::Float8E5M2FNUZ(), "0x1.0p-11");
6225 status = test.convert(APFloat::Float8E4M3FNUZ(), APFloat::rmNearestTiesToEven,
6226 &losesInfo);
6227 EXPECT_EQ(0., test.convertToFloat());
6228 EXPECT_TRUE(losesInfo);
6229 EXPECT_EQ(status, APFloat::opUnderflow | APFloat::opInexact);
6230
6231 // Test rounding up to smallest denormal number
6232 losesInfo = false;
6233 test = APFloat(APFloat::Float8E5M2FNUZ(), "0x1.8p-11");
6234 status = test.convert(APFloat::Float8E4M3FNUZ(), APFloat::rmNearestTiesToEven,
6235 &losesInfo);
6236 EXPECT_EQ(0x1.0p-10, test.convertToFloat());
6237 EXPECT_TRUE(losesInfo);
6238 EXPECT_EQ(status, APFloat::opUnderflow | APFloat::opInexact);
6239
6240 // Testing inexact rounding to denormal number
6241 losesInfo = false;
6242 test = APFloat(APFloat::Float8E5M2FNUZ(), "0x1.8p-10");
6243 status = test.convert(APFloat::Float8E4M3FNUZ(), APFloat::rmNearestTiesToEven,
6244 &losesInfo);
6245 EXPECT_EQ(0x1.0p-9, test.convertToFloat());
6246 EXPECT_TRUE(losesInfo);
6247 EXPECT_EQ(status, APFloat::opUnderflow | APFloat::opInexact);
6248 }
6249
6250 TEST(APFloatTest, ConvertE4M3FNUZToE5M2FNUZ) {
6251 bool losesInfo;
6252 APFloat test(APFloat::Float8E4M3FNUZ(), "1.0");
6253 APFloat::opStatus status = test.convert(
6254 APFloat::Float8E5M2FNUZ(), APFloat::rmNearestTiesToEven, &losesInfo);
6255 EXPECT_EQ(1.0f, test.convertToFloat());
6256 EXPECT_FALSE(losesInfo);
6257 EXPECT_EQ(status, APFloat::opOK);
6258
6259 losesInfo = true;
6260 test = APFloat(APFloat::Float8E4M3FNUZ(), "0.0");
6261 status = test.convert(APFloat::Float8E5M2FNUZ(), APFloat::rmNearestTiesToEven,
6262 &losesInfo);
6263 EXPECT_EQ(0.0f, test.convertToFloat());
6264 EXPECT_FALSE(losesInfo);
6265 EXPECT_EQ(status, APFloat::opOK);
6266
6267 losesInfo = false;
6268 test = APFloat(APFloat::Float8E4M3FNUZ(), "0x1.2p0"); // 1.125
6269 status = test.convert(APFloat::Float8E5M2FNUZ(), APFloat::rmNearestTiesToEven,
6270 &losesInfo);
6271 EXPECT_EQ(0x1.0p0 /* 1.0 */, test.convertToFloat());
6272 EXPECT_TRUE(losesInfo);
6273 EXPECT_EQ(status, APFloat::opInexact);
6274
6275 losesInfo = false;
6276 test = APFloat(APFloat::Float8E4M3FNUZ(), "0x1.6p0"); // 1.375
6277 status = test.convert(APFloat::Float8E5M2FNUZ(), APFloat::rmNearestTiesToEven,
6278 &losesInfo);
6279 EXPECT_EQ(0x1.8p0 /* 1.5 */, test.convertToFloat());
6280 EXPECT_TRUE(losesInfo);
6281 EXPECT_EQ(status, APFloat::opInexact);
6282
6283 // Convert E4M3FNUZ denormal to E5M2 normal. Should not be truncated, despite
6284 // the destination format having one fewer significand bit
6285 losesInfo = true;
6286 test = APFloat(APFloat::Float8E4M3FNUZ(), "0x1.Cp-8");
6287 status = test.convert(APFloat::Float8E5M2FNUZ(), APFloat::rmNearestTiesToEven,
6288 &losesInfo);
6289 EXPECT_EQ(0x1.Cp-8, test.convertToFloat());
6290 EXPECT_FALSE(losesInfo);
6291 EXPECT_EQ(status, APFloat::opOK);
6292 }
6293
6294 TEST(APFloatTest, F8ToString) {
6295 for (APFloat::Semantics S :
6296 {APFloat::S_Float8E5M2, APFloat::S_Float8E4M3FN,
6297 APFloat::S_Float8E5M2FNUZ, APFloat::S_Float8E4M3FNUZ,
6298 APFloat::S_Float8E4M3B11FNUZ}) {
6299 SCOPED_TRACE("Semantics=" + std::to_string(S));
6300 for (int i = 0; i < 256; i++) {
6301 SCOPED_TRACE("i=" + std::to_string(i));
6302 APFloat test(APFloat::EnumToSemantics(S), APInt(8, i));
6303 llvm::SmallString<128> str;
6304 test.toString(str);
6305
6306 if (test.isNaN()) {
6307 EXPECT_EQ(str, "NaN");
6308 } else {
6309 APFloat test2(APFloat::EnumToSemantics(S), str);
6310 EXPECT_TRUE(test.bitwiseIsEqual(test2));
6311 }
6312 }
6313 }
6314 }
6315
6316 TEST(APFloatTest, BitsToF8ToBits) {
6317 for (APFloat::Semantics S :
6318 {APFloat::S_Float8E5M2, APFloat::S_Float8E4M3FN,
6319 APFloat::S_Float8E5M2FNUZ, APFloat::S_Float8E4M3FNUZ,
6320 APFloat::S_Float8E4M3B11FNUZ}) {
6321 SCOPED_TRACE("Semantics=" + std::to_string(S));
6322 for (int i = 0; i < 256; i++) {
6323 SCOPED_TRACE("i=" + std::to_string(i));
6324 APInt bits_in = APInt(8, i);
6325 APFloat test(APFloat::EnumToSemantics(S), bits_in);
6326 APInt bits_out = test.bitcastToAPInt();
6327 EXPECT_EQ(bits_in, bits_out);
6328 }
6329 }
6330 }
6331
6332 TEST(APFloatTest, F8ToBitsToF8) {
6333 for (APFloat::Semantics S :
6334 {APFloat::S_Float8E5M2, APFloat::S_Float8E4M3FN,
6335 APFloat::S_Float8E5M2FNUZ, APFloat::S_Float8E4M3FNUZ,
6336 APFloat::S_Float8E4M3B11FNUZ}) {
6337 SCOPED_TRACE("Semantics=" + std::to_string(S));
6338 auto &Sem = APFloat::EnumToSemantics(S);
6339 for (bool negative : {false, true}) {
6340 SCOPED_TRACE("negative=" + std::to_string(negative));
6341 APFloat test = APFloat::getZero(Sem, /*Negative=*/negative);
6342 for (int i = 0; i < 128; i++, test.next(/*nextDown=*/negative)) {
6343 SCOPED_TRACE("i=" + std::to_string(i));
6344 APInt bits = test.bitcastToAPInt();
6345 APFloat test2 = APFloat(Sem, bits);
6346 if (test.isNaN()) {
6347 EXPECT_TRUE(test2.isNaN());
6348 } else {
6349 EXPECT_TRUE(test.bitwiseIsEqual(test2));
6350 }
6351 }
6352 }
6353 }
6354 }
6355
6356 TEST(APFloatTest, IEEEdoubleToDouble) {
6357 APFloat DPosZero(0.0);
6358 APFloat DPosZeroToDouble(DPosZero.convertToDouble());
6359 EXPECT_TRUE(DPosZeroToDouble.isPosZero());
6360 APFloat DNegZero(-0.0);
6361 APFloat DNegZeroToDouble(DNegZero.convertToDouble());
6362 EXPECT_TRUE(DNegZeroToDouble.isNegZero());
6363
6364 APFloat DOne(1.0);
6365 EXPECT_EQ(1.0, DOne.convertToDouble());
6366 APFloat DPosLargest = APFloat::getLargest(APFloat::IEEEdouble(), false);
6367 EXPECT_EQ(std::numeric_limits<double>::max(), DPosLargest.convertToDouble());
6368 APFloat DNegLargest = APFloat::getLargest(APFloat::IEEEdouble(), true);
6369 EXPECT_EQ(-std::numeric_limits<double>::max(), DNegLargest.convertToDouble());
6370 APFloat DPosSmallest =
6371 APFloat::getSmallestNormalized(APFloat::IEEEdouble(), false);
6372 EXPECT_EQ(std::numeric_limits<double>::min(), DPosSmallest.convertToDouble());
6373 APFloat DNegSmallest =
6374 APFloat::getSmallestNormalized(APFloat::IEEEdouble(), true);
6375 EXPECT_EQ(-std::numeric_limits<double>::min(),
6376 DNegSmallest.convertToDouble());
6377
6378 APFloat DSmallestDenorm = APFloat::getSmallest(APFloat::IEEEdouble(), false);
6379 EXPECT_EQ(std::numeric_limits<double>::denorm_min(),
6380 DSmallestDenorm.convertToDouble());
6381 APFloat DLargestDenorm(APFloat::IEEEdouble(), "0x0.FFFFFFFFFFFFFp-1022");
6382 EXPECT_EQ(/*0x0.FFFFFFFFFFFFFp-1022*/ 2.225073858507201e-308,
6383 DLargestDenorm.convertToDouble());
6384
6385 APFloat DPosInf = APFloat::getInf(APFloat::IEEEdouble());
6386 EXPECT_EQ(std::numeric_limits<double>::infinity(), DPosInf.convertToDouble());
6387 APFloat DNegInf = APFloat::getInf(APFloat::IEEEdouble(), true);
6388 EXPECT_EQ(-std::numeric_limits<double>::infinity(),
6389 DNegInf.convertToDouble());
6390 APFloat DQNaN = APFloat::getQNaN(APFloat::IEEEdouble());
6391 EXPECT_TRUE(std::isnan(DQNaN.convertToDouble()));
6392 }
6393
6394 TEST(APFloatTest, IEEEsingleToDouble) {
6395 APFloat FPosZero(0.0F);
6396 APFloat FPosZeroToDouble(FPosZero.convertToDouble());
6397 EXPECT_TRUE(FPosZeroToDouble.isPosZero());
6398 APFloat FNegZero(-0.0F);
6399 APFloat FNegZeroToDouble(FNegZero.convertToDouble());
6400 EXPECT_TRUE(FNegZeroToDouble.isNegZero());
6401
6402 APFloat FOne(1.0F);
6403 EXPECT_EQ(1.0, FOne.convertToDouble());
6404 APFloat FPosLargest = APFloat::getLargest(APFloat::IEEEsingle(), false);
6405 EXPECT_EQ(std::numeric_limits<float>::max(), FPosLargest.convertToDouble());
6406 APFloat FNegLargest = APFloat::getLargest(APFloat::IEEEsingle(), true);
6407 EXPECT_EQ(-std::numeric_limits<float>::max(), FNegLargest.convertToDouble());
6408 APFloat FPosSmallest =
6409 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), false);
6410 EXPECT_EQ(std::numeric_limits<float>::min(), FPosSmallest.convertToDouble());
6411 APFloat FNegSmallest =
6412 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), true);
6413 EXPECT_EQ(-std::numeric_limits<float>::min(), FNegSmallest.convertToDouble());
6414
6415 APFloat FSmallestDenorm = APFloat::getSmallest(APFloat::IEEEsingle(), false);
6416 EXPECT_EQ(std::numeric_limits<float>::denorm_min(),
6417 FSmallestDenorm.convertToDouble());
6418 APFloat FLargestDenorm(APFloat::IEEEdouble(), "0x0.FFFFFEp-126");
6419 EXPECT_EQ(/*0x0.FFFFFEp-126*/ 1.1754942106924411e-38,
6420 FLargestDenorm.convertToDouble());
6421
6422 APFloat FPosInf = APFloat::getInf(APFloat::IEEEsingle());
6423 EXPECT_EQ(std::numeric_limits<double>::infinity(), FPosInf.convertToDouble());
6424 APFloat FNegInf = APFloat::getInf(APFloat::IEEEsingle(), true);
6425 EXPECT_EQ(-std::numeric_limits<double>::infinity(),
6426 FNegInf.convertToDouble());
6427 APFloat FQNaN = APFloat::getQNaN(APFloat::IEEEsingle());
6428 EXPECT_TRUE(std::isnan(FQNaN.convertToDouble()));
6429 }
6430
6431 TEST(APFloatTest, IEEEhalfToDouble) {
6432 APFloat HPosZero = APFloat::getZero(APFloat::IEEEhalf());
6433 APFloat HPosZeroToDouble(HPosZero.convertToDouble());
6434 EXPECT_TRUE(HPosZeroToDouble.isPosZero());
6435 APFloat HNegZero = APFloat::getZero(APFloat::IEEEhalf(), true);
6436 APFloat HNegZeroToDouble(HNegZero.convertToDouble());
6437 EXPECT_TRUE(HNegZeroToDouble.isNegZero());
6438
6439 APFloat HOne(APFloat::IEEEhalf(), "1.0");
6440 EXPECT_EQ(1.0, HOne.convertToDouble());
6441 APFloat HPosLargest = APFloat::getLargest(APFloat::IEEEhalf(), false);
6442 EXPECT_EQ(65504.0, HPosLargest.convertToDouble());
6443 APFloat HNegLargest = APFloat::getLargest(APFloat::IEEEhalf(), true);
6444 EXPECT_EQ(-65504.0, HNegLargest.convertToDouble());
6445 APFloat HPosSmallest =
6446 APFloat::getSmallestNormalized(APFloat::IEEEhalf(), false);
6447 EXPECT_EQ(/*0x1.p-14*/ 6.103515625e-05, HPosSmallest.convertToDouble());
6448 APFloat HNegSmallest =
6449 APFloat::getSmallestNormalized(APFloat::IEEEhalf(), true);
6450 EXPECT_EQ(/*-0x1.p-14*/ -6.103515625e-05, HNegSmallest.convertToDouble());
6451
6452 APFloat HSmallestDenorm = APFloat::getSmallest(APFloat::IEEEhalf(), false);
6453 EXPECT_EQ(/*0x1.p-24*/ 5.960464477539063e-08,
6454 HSmallestDenorm.convertToDouble());
6455 APFloat HLargestDenorm(APFloat::IEEEhalf(), "0x1.FFCp-14");
6456 EXPECT_EQ(/*0x1.FFCp-14*/ 0.00012201070785522461,
6457 HLargestDenorm.convertToDouble());
6458
6459 APFloat HPosInf = APFloat::getInf(APFloat::IEEEhalf());
6460 EXPECT_EQ(std::numeric_limits<double>::infinity(), HPosInf.convertToDouble());
6461 APFloat HNegInf = APFloat::getInf(APFloat::IEEEhalf(), true);
6462 EXPECT_EQ(-std::numeric_limits<double>::infinity(),
6463 HNegInf.convertToDouble());
6464 APFloat HQNaN = APFloat::getQNaN(APFloat::IEEEhalf());
6465 EXPECT_TRUE(std::isnan(HQNaN.convertToDouble()));
6466
6467 APFloat BPosZero = APFloat::getZero(APFloat::IEEEhalf());
6468 APFloat BPosZeroToDouble(BPosZero.convertToDouble());
6469 EXPECT_TRUE(BPosZeroToDouble.isPosZero());
6470 APFloat BNegZero = APFloat::getZero(APFloat::IEEEhalf(), true);
6471 APFloat BNegZeroToDouble(BNegZero.convertToDouble());
6472 EXPECT_TRUE(BNegZeroToDouble.isNegZero());
6473 }
6474
6475 TEST(APFloatTest, BFloatToDouble) {
6476 APFloat BOne(APFloat::BFloat(), "1.0");
6477 EXPECT_EQ(1.0, BOne.convertToDouble());
6478 APFloat BPosLargest = APFloat::getLargest(APFloat::BFloat(), false);
6479 EXPECT_EQ(/*0x1.FEp127*/ 3.3895313892515355e+38,
6480 BPosLargest.convertToDouble());
6481 APFloat BNegLargest = APFloat::getLargest(APFloat::BFloat(), true);
6482 EXPECT_EQ(/*-0x1.FEp127*/ -3.3895313892515355e+38,
6483 BNegLargest.convertToDouble());
6484 APFloat BPosSmallest =
6485 APFloat::getSmallestNormalized(APFloat::BFloat(), false);
6486 EXPECT_EQ(/*0x1.p-126*/ 1.1754943508222875e-38,
6487 BPosSmallest.convertToDouble());
6488 APFloat BNegSmallest =
6489 APFloat::getSmallestNormalized(APFloat::BFloat(), true);
6490 EXPECT_EQ(/*-0x1.p-126*/ -1.1754943508222875e-38,
6491 BNegSmallest.convertToDouble());
6492
6493 APFloat BSmallestDenorm = APFloat::getSmallest(APFloat::BFloat(), false);
6494 EXPECT_EQ(/*0x1.p-133*/ 9.183549615799121e-41,
6495 BSmallestDenorm.convertToDouble());
6496 APFloat BLargestDenorm(APFloat::BFloat(), "0x1.FCp-127");
6497 EXPECT_EQ(/*0x1.FCp-127*/ 1.1663108012064884e-38,
6498 BLargestDenorm.convertToDouble());
6499
6500 APFloat BPosInf = APFloat::getInf(APFloat::BFloat());
6501 EXPECT_EQ(std::numeric_limits<double>::infinity(), BPosInf.convertToDouble());
6502 APFloat BNegInf = APFloat::getInf(APFloat::BFloat(), true);
6503 EXPECT_EQ(-std::numeric_limits<double>::infinity(),
6504 BNegInf.convertToDouble());
6505 APFloat BQNaN = APFloat::getQNaN(APFloat::BFloat());
6506 EXPECT_TRUE(std::isnan(BQNaN.convertToDouble()));
6507 }
6508
6509 TEST(APFloatTest, Float8E5M2ToDouble) {
6510 APFloat One(APFloat::Float8E5M2(), "1.0");
6511 EXPECT_EQ(1.0, One.convertToDouble());
6512 APFloat Two(APFloat::Float8E5M2(), "2.0");
6513 EXPECT_EQ(2.0, Two.convertToDouble());
6514 APFloat PosLargest = APFloat::getLargest(APFloat::Float8E5M2(), false);
6515 EXPECT_EQ(5.734400e+04, PosLargest.convertToDouble());
6516 APFloat NegLargest = APFloat::getLargest(APFloat::Float8E5M2(), true);
6517 EXPECT_EQ(-5.734400e+04, NegLargest.convertToDouble());
6518 APFloat PosSmallest =
6519 APFloat::getSmallestNormalized(APFloat::Float8E5M2(), false);
6520 EXPECT_EQ(0x1.p-14, PosSmallest.convertToDouble());
6521 APFloat NegSmallest =
6522 APFloat::getSmallestNormalized(APFloat::Float8E5M2(), true);
6523 EXPECT_EQ(-0x1.p-14, NegSmallest.convertToDouble());
6524
6525 APFloat SmallestDenorm = APFloat::getSmallest(APFloat::Float8E5M2(), false);
6526 EXPECT_TRUE(SmallestDenorm.isDenormal());
6527 EXPECT_EQ(0x1p-16, SmallestDenorm.convertToDouble());
6528
6529 APFloat PosInf = APFloat::getInf(APFloat::Float8E5M2());
6530 EXPECT_EQ(std::numeric_limits<double>::infinity(), PosInf.convertToDouble());
6531 APFloat NegInf = APFloat::getInf(APFloat::Float8E5M2(), true);
6532 EXPECT_EQ(-std::numeric_limits<double>::infinity(), NegInf.convertToDouble());
6533 APFloat QNaN = APFloat::getQNaN(APFloat::Float8E5M2());
6534 EXPECT_TRUE(std::isnan(QNaN.convertToDouble()));
6535 }
6536
6537 TEST(APFloatTest, Float8E4M3ToDouble) {
6538 APFloat One(APFloat::Float8E4M3(), "1.0");
6539 EXPECT_EQ(1.0, One.convertToDouble());
6540 APFloat Two(APFloat::Float8E4M3(), "2.0");
6541 EXPECT_EQ(2.0, Two.convertToDouble());
6542 APFloat PosLargest = APFloat::getLargest(APFloat::Float8E4M3(), false);
6543 EXPECT_EQ(240.0F, PosLargest.convertToDouble());
6544 APFloat NegLargest = APFloat::getLargest(APFloat::Float8E4M3(), true);
6545 EXPECT_EQ(-240.0F, NegLargest.convertToDouble());
6546 APFloat PosSmallest =
6547 APFloat::getSmallestNormalized(APFloat::Float8E4M3(), false);
6548 EXPECT_EQ(0x1.p-6, PosSmallest.convertToDouble());
6549 APFloat NegSmallest =
6550 APFloat::getSmallestNormalized(APFloat::Float8E4M3(), true);
6551 EXPECT_EQ(-0x1.p-6, NegSmallest.convertToDouble());
6552
6553 APFloat SmallestDenorm = APFloat::getSmallest(APFloat::Float8E4M3(), false);
6554 EXPECT_TRUE(SmallestDenorm.isDenormal());
6555 EXPECT_EQ(0x1.p-9, SmallestDenorm.convertToDouble());
6556
6557 APFloat PosInf = APFloat::getInf(APFloat::Float8E4M3());
6558 EXPECT_EQ(std::numeric_limits<double>::infinity(), PosInf.convertToDouble());
6559 APFloat NegInf = APFloat::getInf(APFloat::Float8E4M3(), true);
6560 EXPECT_EQ(-std::numeric_limits<double>::infinity(), NegInf.convertToDouble());
6561 APFloat QNaN = APFloat::getQNaN(APFloat::Float8E4M3());
6562 EXPECT_TRUE(std::isnan(QNaN.convertToDouble()));
6563 }
6564
6565 TEST(APFloatTest, Float8E4M3FNToDouble) {
6566 APFloat One(APFloat::Float8E4M3FN(), "1.0");
6567 EXPECT_EQ(1.0, One.convertToDouble());
6568 APFloat Two(APFloat::Float8E4M3FN(), "2.0");
6569 EXPECT_EQ(2.0, Two.convertToDouble());
6570 APFloat PosLargest = APFloat::getLargest(APFloat::Float8E4M3FN(), false);
6571 EXPECT_EQ(448., PosLargest.convertToDouble());
6572 APFloat NegLargest = APFloat::getLargest(APFloat::Float8E4M3FN(), true);
6573 EXPECT_EQ(-448., NegLargest.convertToDouble());
6574 APFloat PosSmallest =
6575 APFloat::getSmallestNormalized(APFloat::Float8E4M3FN(), false);
6576 EXPECT_EQ(0x1.p-6, PosSmallest.convertToDouble());
6577 APFloat NegSmallest =
6578 APFloat::getSmallestNormalized(APFloat::Float8E4M3FN(), true);
6579 EXPECT_EQ(-0x1.p-6, NegSmallest.convertToDouble());
6580
6581 APFloat SmallestDenorm = APFloat::getSmallest(APFloat::Float8E4M3FN(), false);
6582 EXPECT_TRUE(SmallestDenorm.isDenormal());
6583 EXPECT_EQ(0x1p-9, SmallestDenorm.convertToDouble());
6584
6585 APFloat QNaN = APFloat::getQNaN(APFloat::Float8E4M3FN());
6586 EXPECT_TRUE(std::isnan(QNaN.convertToDouble()));
6587 }
6588
6589 TEST(APFloatTest, Float8E5M2FNUZToDouble) {
6590 APFloat One(APFloat::Float8E5M2FNUZ(), "1.0");
6591 EXPECT_EQ(1.0, One.convertToDouble());
6592 APFloat Two(APFloat::Float8E5M2FNUZ(), "2.0");
6593 EXPECT_EQ(2.0, Two.convertToDouble());
6594 APFloat PosLargest = APFloat::getLargest(APFloat::Float8E5M2FNUZ(), false);
6595 EXPECT_EQ(57344., PosLargest.convertToDouble());
6596 APFloat NegLargest = APFloat::getLargest(APFloat::Float8E5M2FNUZ(), true);
6597 EXPECT_EQ(-57344., NegLargest.convertToDouble());
6598 APFloat PosSmallest =
6599 APFloat::getSmallestNormalized(APFloat::Float8E5M2FNUZ(), false);
6600 EXPECT_EQ(0x1.p-15, PosSmallest.convertToDouble());
6601 APFloat NegSmallest =
6602 APFloat::getSmallestNormalized(APFloat::Float8E5M2FNUZ(), true);
6603 EXPECT_EQ(-0x1.p-15, NegSmallest.convertToDouble());
6604
6605 APFloat SmallestDenorm =
6606 APFloat::getSmallest(APFloat::Float8E5M2FNUZ(), false);
6607 EXPECT_TRUE(SmallestDenorm.isDenormal());
6608 EXPECT_EQ(0x1p-17, SmallestDenorm.convertToDouble());
6609
6610 APFloat QNaN = APFloat::getQNaN(APFloat::Float8E5M2FNUZ());
6611 EXPECT_TRUE(std::isnan(QNaN.convertToDouble()));
6612 }
6613
6614 TEST(APFloatTest, Float8E4M3FNUZToDouble) {
6615 APFloat One(APFloat::Float8E4M3FNUZ(), "1.0");
6616 EXPECT_EQ(1.0, One.convertToDouble());
6617 APFloat Two(APFloat::Float8E4M3FNUZ(), "2.0");
6618 EXPECT_EQ(2.0, Two.convertToDouble());
6619 APFloat PosLargest = APFloat::getLargest(APFloat::Float8E4M3FNUZ(), false);
6620 EXPECT_EQ(240., PosLargest.convertToDouble());
6621 APFloat NegLargest = APFloat::getLargest(APFloat::Float8E4M3FNUZ(), true);
6622 EXPECT_EQ(-240., NegLargest.convertToDouble());
6623 APFloat PosSmallest =
6624 APFloat::getSmallestNormalized(APFloat::Float8E4M3FNUZ(), false);
6625 EXPECT_EQ(0x1.p-7, PosSmallest.convertToDouble());
6626 APFloat NegSmallest =
6627 APFloat::getSmallestNormalized(APFloat::Float8E4M3FNUZ(), true);
6628 EXPECT_EQ(-0x1.p-7, NegSmallest.convertToDouble());
6629
6630 APFloat SmallestDenorm =
6631 APFloat::getSmallest(APFloat::Float8E4M3FNUZ(), false);
6632 EXPECT_TRUE(SmallestDenorm.isDenormal());
6633 EXPECT_EQ(0x1p-10, SmallestDenorm.convertToDouble());
6634
6635 APFloat QNaN = APFloat::getQNaN(APFloat::Float8E4M3FNUZ());
6636 EXPECT_TRUE(std::isnan(QNaN.convertToDouble()));
6637 }
6638
6639 TEST(APFloatTest, FloatTF32ToDouble) {
6640 APFloat One(APFloat::FloatTF32(), "1.0");
6641 EXPECT_EQ(1.0, One.convertToDouble());
6642 APFloat PosLargest = APFloat::getLargest(APFloat::FloatTF32(), false);
6643 EXPECT_EQ(3.401162134214653489792616e+38, PosLargest.convertToDouble());
6644 APFloat NegLargest = APFloat::getLargest(APFloat::FloatTF32(), true);
6645 EXPECT_EQ(-3.401162134214653489792616e+38, NegLargest.convertToDouble());
6646 APFloat PosSmallest =
6647 APFloat::getSmallestNormalized(APFloat::FloatTF32(), false);
6648 EXPECT_EQ(1.1754943508222875079687e-38, PosSmallest.convertToDouble());
6649 APFloat NegSmallest =
6650 APFloat::getSmallestNormalized(APFloat::FloatTF32(), true);
6651 EXPECT_EQ(-1.1754943508222875079687e-38, NegSmallest.convertToDouble());
6652
6653 APFloat SmallestDenorm = APFloat::getSmallest(APFloat::FloatTF32(), false);
6654 EXPECT_EQ(1.1479437019748901445007e-41, SmallestDenorm.convertToDouble());
6655 APFloat LargestDenorm(APFloat::FloatTF32(), "0x1.FF8p-127");
6656 EXPECT_EQ(/*0x1.FF8p-127*/ 1.1743464071203126178242e-38,
6657 LargestDenorm.convertToDouble());
6658
6659 APFloat PosInf = APFloat::getInf(APFloat::FloatTF32());
6660 EXPECT_EQ(std::numeric_limits<double>::infinity(), PosInf.convertToDouble());
6661 APFloat NegInf = APFloat::getInf(APFloat::FloatTF32(), true);
6662 EXPECT_EQ(-std::numeric_limits<double>::infinity(), NegInf.convertToDouble());
6663 APFloat QNaN = APFloat::getQNaN(APFloat::FloatTF32());
6664 EXPECT_TRUE(std::isnan(QNaN.convertToDouble()));
6665 }
6666
6667 TEST(APFloatTest, Float8E5M2FNUZToFloat) {
6668 APFloat PosZero = APFloat::getZero(APFloat::Float8E5M2FNUZ());
6669 APFloat PosZeroToFloat(PosZero.convertToFloat());
6670 EXPECT_TRUE(PosZeroToFloat.isPosZero());
6671 // Negative zero is not supported
6672 APFloat NegZero = APFloat::getZero(APFloat::Float8E5M2FNUZ(), true);
6673 APFloat NegZeroToFloat(NegZero.convertToFloat());
6674 EXPECT_TRUE(NegZeroToFloat.isPosZero());
6675 APFloat One(APFloat::Float8E5M2FNUZ(), "1.0");
6676 EXPECT_EQ(1.0F, One.convertToFloat());
6677 APFloat Two(APFloat::Float8E5M2FNUZ(), "2.0");
6678 EXPECT_EQ(2.0F, Two.convertToFloat());
6679 APFloat PosLargest = APFloat::getLargest(APFloat::Float8E5M2FNUZ(), false);
6680 EXPECT_EQ(57344.F, PosLargest.convertToFloat());
6681 APFloat NegLargest = APFloat::getLargest(APFloat::Float8E5M2FNUZ(), true);
6682 EXPECT_EQ(-57344.F, NegLargest.convertToFloat());
6683 APFloat PosSmallest =
6684 APFloat::getSmallestNormalized(APFloat::Float8E5M2FNUZ(), false);
6685 EXPECT_EQ(0x1.p-15F, PosSmallest.convertToFloat());
6686 APFloat NegSmallest =
6687 APFloat::getSmallestNormalized(APFloat::Float8E5M2FNUZ(), true);
6688 EXPECT_EQ(-0x1.p-15F, NegSmallest.convertToFloat());
6689
6690 APFloat SmallestDenorm =
6691 APFloat::getSmallest(APFloat::Float8E5M2FNUZ(), false);
6692 EXPECT_TRUE(SmallestDenorm.isDenormal());
6693 EXPECT_EQ(0x1p-17F, SmallestDenorm.convertToFloat());
6694
6695 APFloat QNaN = APFloat::getQNaN(APFloat::Float8E5M2FNUZ());
6696 EXPECT_TRUE(std::isnan(QNaN.convertToFloat()));
6697 }
6698
6699 TEST(APFloatTest, Float8E4M3FNUZToFloat) {
6700 APFloat PosZero = APFloat::getZero(APFloat::Float8E4M3FNUZ());
6701 APFloat PosZeroToFloat(PosZero.convertToFloat());
6702 EXPECT_TRUE(PosZeroToFloat.isPosZero());
6703 // Negative zero is not supported
6704 APFloat NegZero = APFloat::getZero(APFloat::Float8E4M3FNUZ(), true);
6705 APFloat NegZeroToFloat(NegZero.convertToFloat());
6706 EXPECT_TRUE(NegZeroToFloat.isPosZero());
6707 APFloat One(APFloat::Float8E4M3FNUZ(), "1.0");
6708 EXPECT_EQ(1.0F, One.convertToFloat());
6709 APFloat Two(APFloat::Float8E4M3FNUZ(), "2.0");
6710 EXPECT_EQ(2.0F, Two.convertToFloat());
6711 APFloat PosLargest = APFloat::getLargest(APFloat::Float8E4M3FNUZ(), false);
6712 EXPECT_EQ(240.F, PosLargest.convertToFloat());
6713 APFloat NegLargest = APFloat::getLargest(APFloat::Float8E4M3FNUZ(), true);
6714 EXPECT_EQ(-240.F, NegLargest.convertToFloat());
6715 APFloat PosSmallest =
6716 APFloat::getSmallestNormalized(APFloat::Float8E4M3FNUZ(), false);
6717 EXPECT_EQ(0x1.p-7F, PosSmallest.convertToFloat());
6718 APFloat NegSmallest =
6719 APFloat::getSmallestNormalized(APFloat::Float8E4M3FNUZ(), true);
6720 EXPECT_EQ(-0x1.p-7F, NegSmallest.convertToFloat());
6721
6722 APFloat SmallestDenorm =
6723 APFloat::getSmallest(APFloat::Float8E4M3FNUZ(), false);
6724 EXPECT_TRUE(SmallestDenorm.isDenormal());
6725 EXPECT_EQ(0x1p-10F, SmallestDenorm.convertToFloat());
6726
6727 APFloat QNaN = APFloat::getQNaN(APFloat::Float8E4M3FNUZ());
6728 EXPECT_TRUE(std::isnan(QNaN.convertToFloat()));
6729 }
6730
6731 TEST(APFloatTest, IEEEsingleToFloat) {
6732 APFloat FPosZero(0.0F);
6733 APFloat FPosZeroToFloat(FPosZero.convertToFloat());
6734 EXPECT_TRUE(FPosZeroToFloat.isPosZero());
6735 APFloat FNegZero(-0.0F);
6736 APFloat FNegZeroToFloat(FNegZero.convertToFloat());
6737 EXPECT_TRUE(FNegZeroToFloat.isNegZero());
6738
6739 APFloat FOne(1.0F);
6740 EXPECT_EQ(1.0F, FOne.convertToFloat());
6741 APFloat FPosLargest = APFloat::getLargest(APFloat::IEEEsingle(), false);
6742 EXPECT_EQ(std::numeric_limits<float>::max(), FPosLargest.convertToFloat());
6743 APFloat FNegLargest = APFloat::getLargest(APFloat::IEEEsingle(), true);
6744 EXPECT_EQ(-std::numeric_limits<float>::max(), FNegLargest.convertToFloat());
6745 APFloat FPosSmallest =
6746 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), false);
6747 EXPECT_EQ(std::numeric_limits<float>::min(), FPosSmallest.convertToFloat());
6748 APFloat FNegSmallest =
6749 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), true);
6750 EXPECT_EQ(-std::numeric_limits<float>::min(), FNegSmallest.convertToFloat());
6751
6752 APFloat FSmallestDenorm = APFloat::getSmallest(APFloat::IEEEsingle(), false);
6753 EXPECT_EQ(std::numeric_limits<float>::denorm_min(),
6754 FSmallestDenorm.convertToFloat());
6755 APFloat FLargestDenorm(APFloat::IEEEsingle(), "0x1.FFFFFEp-126");
6756 EXPECT_EQ(/*0x1.FFFFFEp-126*/ 2.3509885615147286e-38F,
6757 FLargestDenorm.convertToFloat());
6758
6759 APFloat FPosInf = APFloat::getInf(APFloat::IEEEsingle());
6760 EXPECT_EQ(std::numeric_limits<float>::infinity(), FPosInf.convertToFloat());
6761 APFloat FNegInf = APFloat::getInf(APFloat::IEEEsingle(), true);
6762 EXPECT_EQ(-std::numeric_limits<float>::infinity(), FNegInf.convertToFloat());
6763 APFloat FQNaN = APFloat::getQNaN(APFloat::IEEEsingle());
6764 EXPECT_TRUE(std::isnan(FQNaN.convertToFloat()));
6765 }
6766
6767 TEST(APFloatTest, IEEEhalfToFloat) {
6768 APFloat HPosZero = APFloat::getZero(APFloat::IEEEhalf());
6769 APFloat HPosZeroToFloat(HPosZero.convertToFloat());
6770 EXPECT_TRUE(HPosZeroToFloat.isPosZero());
6771 APFloat HNegZero = APFloat::getZero(APFloat::IEEEhalf(), true);
6772 APFloat HNegZeroToFloat(HNegZero.convertToFloat());
6773 EXPECT_TRUE(HNegZeroToFloat.isNegZero());
6774
6775 APFloat HOne(APFloat::IEEEhalf(), "1.0");
6776 EXPECT_EQ(1.0F, HOne.convertToFloat());
6777 APFloat HPosLargest = APFloat::getLargest(APFloat::IEEEhalf(), false);
6778 EXPECT_EQ(/*0x1.FFCp15*/ 65504.0F, HPosLargest.convertToFloat());
6779 APFloat HNegLargest = APFloat::getLargest(APFloat::IEEEhalf(), true);
6780 EXPECT_EQ(/*-0x1.FFCp15*/ -65504.0F, HNegLargest.convertToFloat());
6781 APFloat HPosSmallest =
6782 APFloat::getSmallestNormalized(APFloat::IEEEhalf(), false);
6783 EXPECT_EQ(/*0x1.p-14*/ 6.103515625e-05F, HPosSmallest.convertToFloat());
6784 APFloat HNegSmallest =
6785 APFloat::getSmallestNormalized(APFloat::IEEEhalf(), true);
6786 EXPECT_EQ(/*-0x1.p-14*/ -6.103515625e-05F, HNegSmallest.convertToFloat());
6787
6788 APFloat HSmallestDenorm = APFloat::getSmallest(APFloat::IEEEhalf(), false);
6789 EXPECT_EQ(/*0x1.p-24*/ 5.960464477539063e-08F,
6790 HSmallestDenorm.convertToFloat());
6791 APFloat HLargestDenorm(APFloat::IEEEhalf(), "0x1.FFCp-14");
6792 EXPECT_EQ(/*0x1.FFCp-14*/ 0.00012201070785522461F,
6793 HLargestDenorm.convertToFloat());
6794
6795 APFloat HPosInf = APFloat::getInf(APFloat::IEEEhalf());
6796 EXPECT_EQ(std::numeric_limits<float>::infinity(), HPosInf.convertToFloat());
6797 APFloat HNegInf = APFloat::getInf(APFloat::IEEEhalf(), true);
6798 EXPECT_EQ(-std::numeric_limits<float>::infinity(), HNegInf.convertToFloat());
6799 APFloat HQNaN = APFloat::getQNaN(APFloat::IEEEhalf());
6800 EXPECT_TRUE(std::isnan(HQNaN.convertToFloat()));
6801 }
6802
6803 TEST(APFloatTest, BFloatToFloat) {
6804 APFloat BPosZero = APFloat::getZero(APFloat::BFloat());
6805 APFloat BPosZeroToDouble(BPosZero.convertToFloat());
6806 EXPECT_TRUE(BPosZeroToDouble.isPosZero());
6807 APFloat BNegZero = APFloat::getZero(APFloat::BFloat(), true);
6808 APFloat BNegZeroToDouble(BNegZero.convertToFloat());
6809 EXPECT_TRUE(BNegZeroToDouble.isNegZero());
6810
6811 APFloat BOne(APFloat::BFloat(), "1.0");
6812 EXPECT_EQ(1.0F, BOne.convertToFloat());
6813 APFloat BPosLargest = APFloat::getLargest(APFloat::BFloat(), false);
6814 EXPECT_EQ(/*0x1.FEp127*/ 3.3895313892515355e+38F,
6815 BPosLargest.convertToFloat());
6816 APFloat BNegLargest = APFloat::getLargest(APFloat::BFloat(), true);
6817 EXPECT_EQ(/*-0x1.FEp127*/ -3.3895313892515355e+38F,
6818 BNegLargest.convertToFloat());
6819 APFloat BPosSmallest =
6820 APFloat::getSmallestNormalized(APFloat::BFloat(), false);
6821 EXPECT_EQ(/*0x1.p-126*/ 1.1754943508222875e-38F,
6822 BPosSmallest.convertToFloat());
6823 APFloat BNegSmallest =
6824 APFloat::getSmallestNormalized(APFloat::BFloat(), true);
6825 EXPECT_EQ(/*-0x1.p-126*/ -1.1754943508222875e-38F,
6826 BNegSmallest.convertToFloat());
6827
6828 APFloat BSmallestDenorm = APFloat::getSmallest(APFloat::BFloat(), false);
6829 EXPECT_EQ(/*0x1.p-133*/ 9.183549615799121e-41F,
6830 BSmallestDenorm.convertToFloat());
6831 APFloat BLargestDenorm(APFloat::BFloat(), "0x1.FCp-127");
6832 EXPECT_EQ(/*0x1.FCp-127*/ 1.1663108012064884e-38F,
6833 BLargestDenorm.convertToFloat());
6834
6835 APFloat BPosInf = APFloat::getInf(APFloat::BFloat());
6836 EXPECT_EQ(std::numeric_limits<float>::infinity(), BPosInf.convertToFloat());
6837 APFloat BNegInf = APFloat::getInf(APFloat::BFloat(), true);
6838 EXPECT_EQ(-std::numeric_limits<float>::infinity(), BNegInf.convertToFloat());
6839 APFloat BQNaN = APFloat::getQNaN(APFloat::BFloat());
6840 EXPECT_TRUE(std::isnan(BQNaN.convertToFloat()));
6841 }
6842
6843 TEST(APFloatTest, Float8E5M2ToFloat) {
6844 APFloat PosZero = APFloat::getZero(APFloat::Float8E5M2());
6845 APFloat PosZeroToFloat(PosZero.convertToFloat());
6846 EXPECT_TRUE(PosZeroToFloat.isPosZero());
6847 APFloat NegZero = APFloat::getZero(APFloat::Float8E5M2(), true);
6848 APFloat NegZeroToFloat(NegZero.convertToFloat());
6849 EXPECT_TRUE(NegZeroToFloat.isNegZero());
6850
6851 APFloat One(APFloat::Float8E5M2(), "1.0");
6852 EXPECT_EQ(1.0F, One.convertToFloat());
6853 APFloat Two(APFloat::Float8E5M2(), "2.0");
6854 EXPECT_EQ(2.0F, Two.convertToFloat());
6855
6856 APFloat PosLargest = APFloat::getLargest(APFloat::Float8E5M2(), false);
6857 EXPECT_EQ(5.734400e+04, PosLargest.convertToFloat());
6858 APFloat NegLargest = APFloat::getLargest(APFloat::Float8E5M2(), true);
6859 EXPECT_EQ(-5.734400e+04, NegLargest.convertToFloat());
6860 APFloat PosSmallest =
6861 APFloat::getSmallestNormalized(APFloat::Float8E5M2(), false);
6862 EXPECT_EQ(0x1.p-14, PosSmallest.convertToFloat());
6863 APFloat NegSmallest =
6864 APFloat::getSmallestNormalized(APFloat::Float8E5M2(), true);
6865 EXPECT_EQ(-0x1.p-14, NegSmallest.convertToFloat());
6866
6867 APFloat SmallestDenorm = APFloat::getSmallest(APFloat::Float8E5M2(), false);
6868 EXPECT_TRUE(SmallestDenorm.isDenormal());
6869 EXPECT_EQ(0x1.p-16, SmallestDenorm.convertToFloat());
6870
6871 APFloat PosInf = APFloat::getInf(APFloat::Float8E5M2());
6872 EXPECT_EQ(std::numeric_limits<float>::infinity(), PosInf.convertToFloat());
6873 APFloat NegInf = APFloat::getInf(APFloat::Float8E5M2(), true);
6874 EXPECT_EQ(-std::numeric_limits<float>::infinity(), NegInf.convertToFloat());
6875 APFloat QNaN = APFloat::getQNaN(APFloat::Float8E5M2());
6876 EXPECT_TRUE(std::isnan(QNaN.convertToFloat()));
6877 }
6878
6879 TEST(APFloatTest, Float8E4M3ToFloat) {
6880 APFloat PosZero = APFloat::getZero(APFloat::Float8E4M3());
6881 APFloat PosZeroToFloat(PosZero.convertToFloat());
6882 EXPECT_TRUE(PosZeroToFloat.isPosZero());
6883 APFloat NegZero = APFloat::getZero(APFloat::Float8E4M3(), true);
6884 APFloat NegZeroToFloat(NegZero.convertToFloat());
6885 EXPECT_TRUE(NegZeroToFloat.isNegZero());
6886
6887 APFloat One(APFloat::Float8E4M3(), "1.0");
6888 EXPECT_EQ(1.0F, One.convertToFloat());
6889 APFloat Two(APFloat::Float8E4M3(), "2.0");
6890 EXPECT_EQ(2.0F, Two.convertToFloat());
6891
6892 APFloat PosLargest = APFloat::getLargest(APFloat::Float8E4M3(), false);
6893 EXPECT_EQ(240.0F, PosLargest.convertToFloat());
6894 APFloat NegLargest = APFloat::getLargest(APFloat::Float8E4M3(), true);
6895 EXPECT_EQ(-240.0F, NegLargest.convertToFloat());
6896 APFloat PosSmallest =
6897 APFloat::getSmallestNormalized(APFloat::Float8E4M3(), false);
6898 EXPECT_EQ(0x1.p-6, PosSmallest.convertToFloat());
6899 APFloat NegSmallest =
6900 APFloat::getSmallestNormalized(APFloat::Float8E4M3(), true);
6901 EXPECT_EQ(-0x1.p-6, NegSmallest.convertToFloat());
6902
6903 APFloat SmallestDenorm = APFloat::getSmallest(APFloat::Float8E4M3(), false);
6904 EXPECT_TRUE(SmallestDenorm.isDenormal());
6905 EXPECT_EQ(0x1.p-9, SmallestDenorm.convertToFloat());
6906
6907 APFloat PosInf = APFloat::getInf(APFloat::Float8E4M3());
6908 EXPECT_EQ(std::numeric_limits<float>::infinity(), PosInf.convertToFloat());
6909 APFloat NegInf = APFloat::getInf(APFloat::Float8E4M3(), true);
6910 EXPECT_EQ(-std::numeric_limits<float>::infinity(), NegInf.convertToFloat());
6911 APFloat QNaN = APFloat::getQNaN(APFloat::Float8E4M3());
6912 EXPECT_TRUE(std::isnan(QNaN.convertToFloat()));
6913 }
6914
6915 TEST(APFloatTest, Float8E4M3FNToFloat) {
6916 APFloat PosZero = APFloat::getZero(APFloat::Float8E4M3FN());
6917 APFloat PosZeroToFloat(PosZero.convertToFloat());
6918 EXPECT_TRUE(PosZeroToFloat.isPosZero());
6919 APFloat NegZero = APFloat::getZero(APFloat::Float8E4M3FN(), true);
6920 APFloat NegZeroToFloat(NegZero.convertToFloat());
6921 EXPECT_TRUE(NegZeroToFloat.isNegZero());
6922
6923 APFloat One(APFloat::Float8E4M3FN(), "1.0");
6924 EXPECT_EQ(1.0F, One.convertToFloat());
6925 APFloat Two(APFloat::Float8E4M3FN(), "2.0");
6926 EXPECT_EQ(2.0F, Two.convertToFloat());
6927
6928 APFloat PosLargest = APFloat::getLargest(APFloat::Float8E4M3FN(), false);
6929 EXPECT_EQ(448., PosLargest.convertToFloat());
6930 APFloat NegLargest = APFloat::getLargest(APFloat::Float8E4M3FN(), true);
6931 EXPECT_EQ(-448, NegLargest.convertToFloat());
6932 APFloat PosSmallest =
6933 APFloat::getSmallestNormalized(APFloat::Float8E4M3FN(), false);
6934 EXPECT_EQ(0x1.p-6, PosSmallest.convertToFloat());
6935 APFloat NegSmallest =
6936 APFloat::getSmallestNormalized(APFloat::Float8E4M3FN(), true);
6937 EXPECT_EQ(-0x1.p-6, NegSmallest.convertToFloat());
6938
6939 APFloat SmallestDenorm = APFloat::getSmallest(APFloat::Float8E4M3FN(), false);
6940 EXPECT_TRUE(SmallestDenorm.isDenormal());
6941 EXPECT_EQ(0x1.p-9, SmallestDenorm.convertToFloat());
6942
6943 APFloat QNaN = APFloat::getQNaN(APFloat::Float8E4M3FN());
6944 EXPECT_TRUE(std::isnan(QNaN.convertToFloat()));
6945 }
6946
6947 TEST(APFloatTest, FloatTF32ToFloat) {
6948 APFloat PosZero = APFloat::getZero(APFloat::FloatTF32());
6949 APFloat PosZeroToFloat(PosZero.convertToFloat());
6950 EXPECT_TRUE(PosZeroToFloat.isPosZero());
6951 APFloat NegZero = APFloat::getZero(APFloat::FloatTF32(), true);
6952 APFloat NegZeroToFloat(NegZero.convertToFloat());
6953 EXPECT_TRUE(NegZeroToFloat.isNegZero());
6954
6955 APFloat One(APFloat::FloatTF32(), "1.0");
6956 EXPECT_EQ(1.0F, One.convertToFloat());
6957 APFloat Two(APFloat::FloatTF32(), "2.0");
6958 EXPECT_EQ(2.0F, Two.convertToFloat());
6959
6960 APFloat PosLargest = APFloat::getLargest(APFloat::FloatTF32(), false);
6961 EXPECT_EQ(3.40116213421e+38F, PosLargest.convertToFloat());
6962
6963 APFloat NegLargest = APFloat::getLargest(APFloat::FloatTF32(), true);
6964 EXPECT_EQ(-3.40116213421e+38F, NegLargest.convertToFloat());
6965
6966 APFloat PosSmallest =
6967 APFloat::getSmallestNormalized(APFloat::FloatTF32(), false);
6968 EXPECT_EQ(/*0x1.p-126*/ 1.1754943508222875e-38F,
6969 PosSmallest.convertToFloat());
6970 APFloat NegSmallest =
6971 APFloat::getSmallestNormalized(APFloat::FloatTF32(), true);
6972 EXPECT_EQ(/*-0x1.p-126*/ -1.1754943508222875e-38F,
6973 NegSmallest.convertToFloat());
6974
6975 APFloat SmallestDenorm = APFloat::getSmallest(APFloat::FloatTF32(), false);
6976 EXPECT_TRUE(SmallestDenorm.isDenormal());
6977 EXPECT_EQ(0x0.004p-126, SmallestDenorm.convertToFloat());
6978
6979 APFloat QNaN = APFloat::getQNaN(APFloat::FloatTF32());
6980 EXPECT_TRUE(std::isnan(QNaN.convertToFloat()));
6981 }
6982
6983 TEST(APFloatTest, getExactLog2) {
6984 for (unsigned I = 0; I != APFloat::S_MaxSemantics + 1; ++I) {
6985 auto SemEnum = static_cast<APFloat::Semantics>(I);
6986 const fltSemantics &Semantics = APFloat::EnumToSemantics(SemEnum);
6987
6988 APFloat One(Semantics, "1.0");
6989
6990 if (I == APFloat::S_PPCDoubleDouble) {
6991 // Not implemented
6992 EXPECT_EQ(INT_MIN, One.getExactLog2());
6993 EXPECT_EQ(INT_MIN, One.getExactLog2Abs());
6994 continue;
6995 }
6996
6997 int MinExp = APFloat::semanticsMinExponent(Semantics);
6998 int MaxExp = APFloat::semanticsMaxExponent(Semantics);
6999 int Precision = APFloat::semanticsPrecision(Semantics);
7000
7001 EXPECT_EQ(0, One.getExactLog2());
7002 EXPECT_EQ(INT_MIN, APFloat(Semantics, "3.0").getExactLog2());
7003 EXPECT_EQ(INT_MIN, APFloat(Semantics, "-3.0").getExactLog2());
7004 EXPECT_EQ(INT_MIN, APFloat(Semantics, "3.0").getExactLog2Abs());
7005 EXPECT_EQ(INT_MIN, APFloat(Semantics, "-3.0").getExactLog2Abs());
7006
7007 if (I == APFloat::S_Float6E2M3FN || I == APFloat::S_Float4E2M1FN) {
7008 EXPECT_EQ(2, APFloat(Semantics, "4.0").getExactLog2());
7009 EXPECT_EQ(INT_MIN, APFloat(Semantics, "-4.0").getExactLog2());
7010 EXPECT_EQ(2, APFloat(Semantics, "4.0").getExactLog2Abs());
7011 EXPECT_EQ(2, APFloat(Semantics, "-4.0").getExactLog2Abs());
7012 } else {
7013 EXPECT_EQ(3, APFloat(Semantics, "8.0").getExactLog2());
7014 EXPECT_EQ(INT_MIN, APFloat(Semantics, "-8.0").getExactLog2());
7015 EXPECT_EQ(-2, APFloat(Semantics, "0.25").getExactLog2());
7016 EXPECT_EQ(-2, APFloat(Semantics, "0.25").getExactLog2Abs());
7017 EXPECT_EQ(INT_MIN, APFloat(Semantics, "-0.25").getExactLog2());
7018 EXPECT_EQ(-2, APFloat(Semantics, "-0.25").getExactLog2Abs());
7019 EXPECT_EQ(3, APFloat(Semantics, "8.0").getExactLog2Abs());
7020 EXPECT_EQ(3, APFloat(Semantics, "-8.0").getExactLog2Abs());
7021 }
7022
7023 EXPECT_EQ(INT_MIN, APFloat::getZero(Semantics, false).getExactLog2());
7024 EXPECT_EQ(INT_MIN, APFloat::getZero(Semantics, true).getExactLog2());
7025 EXPECT_EQ(INT_MIN, APFloat::getZero(Semantics, false).getExactLog2Abs());
7026 EXPECT_EQ(INT_MIN, APFloat::getZero(Semantics, true).getExactLog2Abs());
7027
7028 if (APFloat::hasNanOrInf(Semantics)) {
7029 EXPECT_EQ(INT_MIN, APFloat::getInf(Semantics).getExactLog2());
7030 EXPECT_EQ(INT_MIN, APFloat::getInf(Semantics, true).getExactLog2());
7031 EXPECT_EQ(INT_MIN, APFloat::getNaN(Semantics, false).getExactLog2());
7032 EXPECT_EQ(INT_MIN, APFloat::getNaN(Semantics, true).getExactLog2());
7033
7034 EXPECT_EQ(INT_MIN, APFloat::getInf(Semantics).getExactLog2Abs());
7035 EXPECT_EQ(INT_MIN, APFloat::getInf(Semantics, true).getExactLog2Abs());
7036 EXPECT_EQ(INT_MIN, APFloat::getNaN(Semantics, false).getExactLog2Abs());
7037 EXPECT_EQ(INT_MIN, APFloat::getNaN(Semantics, true).getExactLog2Abs());
7038 }
7039
7040 EXPECT_EQ(INT_MIN,
7041 scalbn(One, MinExp - Precision - 1, APFloat::rmNearestTiesToEven)
7042 .getExactLog2());
7043 EXPECT_EQ(INT_MIN,
7044 scalbn(One, MinExp - Precision, APFloat::rmNearestTiesToEven)
7045 .getExactLog2());
7046
7047 EXPECT_EQ(
7048 INT_MIN,
7049 scalbn(One, MaxExp + 1, APFloat::rmNearestTiesToEven).getExactLog2());
7050
7051 for (int i = MinExp - Precision + 1; i <= MaxExp; ++i) {
7052 EXPECT_EQ(i, scalbn(One, i, APFloat::rmNearestTiesToEven).getExactLog2());
7053 }
7054 }
7055 }
7056
7057 TEST(APFloatTest, Float6E3M2FNFromString) {
7058 // Exactly representable
7059 EXPECT_EQ(28, APFloat(APFloat::Float6E3M2FN(), "28").convertToDouble());
7060 // Round down to maximum value
7061 EXPECT_EQ(28, APFloat(APFloat::Float6E3M2FN(), "32").convertToDouble());
7062
7063 #ifdef GTEST_HAS_DEATH_TEST
7064 #ifndef NDEBUG
7065 EXPECT_DEATH(APFloat(APFloat::Float6E3M2FN(), "inf"),
7066 "This floating point format does not support Inf");
7067 EXPECT_DEATH(APFloat(APFloat::Float6E3M2FN(), "nan"),
7068 "This floating point format does not support NaN");
7069 #endif
7070 #endif
7071
7072 EXPECT_TRUE(APFloat(APFloat::Float6E3M2FN(), "0").isPosZero());
7073 EXPECT_TRUE(APFloat(APFloat::Float6E3M2FN(), "-0").isNegZero());
7074 }
7075
7076 TEST(APFloatTest, Float6E2M3FNFromString) {
7077 // Exactly representable
7078 EXPECT_EQ(7.5, APFloat(APFloat::Float6E2M3FN(), "7.5").convertToDouble());
7079 // Round down to maximum value
7080 EXPECT_EQ(7.5, APFloat(APFloat::Float6E2M3FN(), "32").convertToDouble());
7081
7082 #ifdef GTEST_HAS_DEATH_TEST
7083 #ifndef NDEBUG
7084 EXPECT_DEATH(APFloat(APFloat::Float6E2M3FN(), "inf"),
7085 "This floating point format does not support Inf");
7086 EXPECT_DEATH(APFloat(APFloat::Float6E2M3FN(), "nan"),
7087 "This floating point format does not support NaN");
7088 #endif
7089 #endif
7090
7091 EXPECT_TRUE(APFloat(APFloat::Float6E2M3FN(), "0").isPosZero());
7092 EXPECT_TRUE(APFloat(APFloat::Float6E2M3FN(), "-0").isNegZero());
7093 }
7094
7095 TEST(APFloatTest, Float4E2M1FNFromString) {
7096 // Exactly representable
7097 EXPECT_EQ(6, APFloat(APFloat::Float4E2M1FN(), "6").convertToDouble());
7098 // Round down to maximum value
7099 EXPECT_EQ(6, APFloat(APFloat::Float4E2M1FN(), "32").convertToDouble());
7100
7101 #ifdef GTEST_HAS_DEATH_TEST
7102 #ifndef NDEBUG
7103 EXPECT_DEATH(APFloat(APFloat::Float4E2M1FN(), "inf"),
7104 "This floating point format does not support Inf");
7105 EXPECT_DEATH(APFloat(APFloat::Float4E2M1FN(), "nan"),
7106 "This floating point format does not support NaN");
7107 #endif
7108 #endif
7109
7110 EXPECT_TRUE(APFloat(APFloat::Float4E2M1FN(), "0").isPosZero());
7111 EXPECT_TRUE(APFloat(APFloat::Float4E2M1FN(), "-0").isNegZero());
7112 }
7113
7114 TEST(APFloatTest, ConvertE3M2FToE2M3F) {
7115 bool losesInfo;
7116 APFloat test(APFloat::Float6E3M2FN(), "1.0");
7117 APFloat::opStatus status = test.convert(
7118 APFloat::Float6E2M3FN(), APFloat::rmNearestTiesToEven, &losesInfo);
7119 EXPECT_EQ(1.0f, test.convertToFloat());
7120 EXPECT_FALSE(losesInfo);
7121 EXPECT_EQ(status, APFloat::opOK);
7122
7123 test = APFloat(APFloat::Float6E3M2FN(), "0.0");
7124 status = test.convert(APFloat::Float6E2M3FN(), APFloat::rmNearestTiesToEven,
7125 &losesInfo);
7126 EXPECT_EQ(0.0f, test.convertToFloat());
7127 EXPECT_FALSE(losesInfo);
7128 EXPECT_EQ(status, APFloat::opOK);
7129
7130 // Test overflow
7131 test = APFloat(APFloat::Float6E3M2FN(), "28");
7132 status = test.convert(APFloat::Float6E2M3FN(), APFloat::rmNearestTiesToEven,
7133 &losesInfo);
7134 EXPECT_EQ(7.5f, test.convertToFloat());
7135 EXPECT_TRUE(losesInfo);
7136 EXPECT_EQ(status, APFloat::opInexact);
7137
7138 // Test underflow
7139 test = APFloat(APFloat::Float6E3M2FN(), ".0625");
7140 status = test.convert(APFloat::Float6E2M3FN(), APFloat::rmNearestTiesToEven,
7141 &losesInfo);
7142 EXPECT_EQ(0., test.convertToFloat());
7143 EXPECT_TRUE(losesInfo);
7144 EXPECT_EQ(status, APFloat::opUnderflow | APFloat::opInexact);
7145
7146 // Testing inexact rounding to denormal number
7147 test = APFloat(APFloat::Float6E3M2FN(), "0.1875");
7148 status = test.convert(APFloat::Float6E2M3FN(), APFloat::rmNearestTiesToEven,
7149 &losesInfo);
7150 EXPECT_EQ(0.25, test.convertToFloat());
7151 EXPECT_TRUE(losesInfo);
7152 EXPECT_EQ(status, APFloat::opUnderflow | APFloat::opInexact);
7153 }
7154
7155 TEST(APFloatTest, ConvertE2M3FToE3M2F) {
7156 bool losesInfo;
7157 APFloat test(APFloat::Float6E2M3FN(), "1.0");
7158 APFloat::opStatus status = test.convert(
7159 APFloat::Float6E3M2FN(), APFloat::rmNearestTiesToEven, &losesInfo);
7160 EXPECT_EQ(1.0f, test.convertToFloat());
7161 EXPECT_FALSE(losesInfo);
7162 EXPECT_EQ(status, APFloat::opOK);
7163
7164 test = APFloat(APFloat::Float6E2M3FN(), "0.0");
7165 status = test.convert(APFloat::Float6E3M2FN(), APFloat::rmNearestTiesToEven,
7166 &losesInfo);
7167 EXPECT_EQ(0.0f, test.convertToFloat());
7168 EXPECT_FALSE(losesInfo);
7169 EXPECT_EQ(status, APFloat::opOK);
7170
7171 test = APFloat(APFloat::Float6E2M3FN(), ".125");
7172 status = test.convert(APFloat::Float6E3M2FN(), APFloat::rmNearestTiesToEven,
7173 &losesInfo);
7174 EXPECT_EQ(.125, test.convertToFloat());
7175 EXPECT_FALSE(losesInfo);
7176 EXPECT_EQ(status, APFloat::opOK);
7177
7178 // Test inexact rounding
7179 test = APFloat(APFloat::Float6E2M3FN(), "7.5");
7180 status = test.convert(APFloat::Float6E3M2FN(), APFloat::rmNearestTiesToEven,
7181 &losesInfo);
7182 EXPECT_EQ(8, test.convertToFloat());
7183 EXPECT_TRUE(losesInfo);
7184 EXPECT_EQ(status, APFloat::opInexact);
7185 }
7186
7187 TEST(APFloatTest, ConvertDoubleToE2M1F) {
7188 bool losesInfo;
7189 APFloat test(APFloat::IEEEdouble(), "1.0");
7190 APFloat::opStatus status = test.convert(
7191 APFloat::Float4E2M1FN(), APFloat::rmNearestTiesToEven, &losesInfo);
7192 EXPECT_EQ(1.0, test.convertToDouble());
7193 EXPECT_FALSE(losesInfo);
7194 EXPECT_EQ(status, APFloat::opOK);
7195
7196 test = APFloat(APFloat::IEEEdouble(), "0.0");
7197 status = test.convert(APFloat::Float4E2M1FN(), APFloat::rmNearestTiesToEven,
7198 &losesInfo);
7199 EXPECT_EQ(0.0f, test.convertToDouble());
7200 EXPECT_FALSE(losesInfo);
7201 EXPECT_EQ(status, APFloat::opOK);
7202
7203 // Test overflow
7204 test = APFloat(APFloat::IEEEdouble(), "8");
7205 status = test.convert(APFloat::Float4E2M1FN(), APFloat::rmNearestTiesToEven,
7206 &losesInfo);
7207 EXPECT_EQ(6, test.convertToDouble());
7208 EXPECT_TRUE(losesInfo);
7209 EXPECT_EQ(status, APFloat::opInexact);
7210
7211 // Test underflow
7212 test = APFloat(APFloat::IEEEdouble(), "0.25");
7213 status = test.convert(APFloat::Float4E2M1FN(), APFloat::rmNearestTiesToEven,
7214 &losesInfo);
7215 EXPECT_EQ(0., test.convertToDouble());
7216 EXPECT_TRUE(losesInfo);
7217 EXPECT_FALSE(test.isDenormal());
7218 EXPECT_EQ(status, APFloat::opUnderflow | APFloat::opInexact);
7219 }
7220
7221 TEST(APFloatTest, Float6E3M2FNNext) {
7222 APFloat test(APFloat::Float6E3M2FN(), APFloat::uninitialized);
7223 APFloat expected(APFloat::Float6E3M2FN(), APFloat::uninitialized);
7224
7225 // 1. NextUp of largest bit pattern is the same
7226 test = APFloat::getLargest(APFloat::Float6E3M2FN());
7227 expected = APFloat::getLargest(APFloat::Float6E3M2FN());
7228 EXPECT_EQ(test.next(false), APFloat::opOK);
7229 EXPECT_FALSE(test.isInfinity());
7230 EXPECT_FALSE(test.isZero());
7231 EXPECT_TRUE(test.bitwiseIsEqual(expected));
7232
7233 // 2. NextUp of smallest negative denormal is -0
7234 test = APFloat::getSmallest(APFloat::Float6E3M2FN(), true);
7235 expected = APFloat::getZero(APFloat::Float6E3M2FN(), true);
7236 EXPECT_EQ(test.next(false), APFloat::opOK);
7237 EXPECT_TRUE(test.isNegZero());
7238 EXPECT_FALSE(test.isPosZero());
7239 EXPECT_TRUE(test.bitwiseIsEqual(expected));
7240
7241 // 3. nextDown of negative of largest value is the same
7242 test = APFloat::getLargest(APFloat::Float6E3M2FN(), true);
7243 expected = test;
7244 EXPECT_EQ(test.next(true), APFloat::opOK);
7245 EXPECT_FALSE(test.isInfinity());
7246 EXPECT_FALSE(test.isZero());
7247 EXPECT_FALSE(test.isNaN());
7248 EXPECT_TRUE(test.bitwiseIsEqual(expected));
7249
7250 // 4. nextDown of +0 is smallest negative denormal
7251 test = APFloat::getZero(APFloat::Float6E3M2FN(), false);
7252 expected = APFloat::getSmallest(APFloat::Float6E3M2FN(), true);
7253 EXPECT_EQ(test.next(true), APFloat::opOK);
7254 EXPECT_FALSE(test.isZero());
7255 EXPECT_TRUE(test.isDenormal());
7256 EXPECT_TRUE(test.bitwiseIsEqual(expected));
7257 }
7258
7259 TEST(APFloatTest, Float6E2M3FNNext) {
7260 APFloat test(APFloat::Float6E2M3FN(), APFloat::uninitialized);
7261 APFloat expected(APFloat::Float6E2M3FN(), APFloat::uninitialized);
7262
7263 // 1. NextUp of largest bit pattern is the same
7264 test = APFloat::getLargest(APFloat::Float6E2M3FN());
7265 expected = APFloat::getLargest(APFloat::Float6E2M3FN());
7266 EXPECT_EQ(test.next(false), APFloat::opOK);
7267 EXPECT_FALSE(test.isInfinity());
7268 EXPECT_FALSE(test.isZero());
7269 EXPECT_TRUE(test.bitwiseIsEqual(expected));
7270
7271 // 2. NextUp of smallest negative denormal is -0
7272 test = APFloat::getSmallest(APFloat::Float6E2M3FN(), true);
7273 expected = APFloat::getZero(APFloat::Float6E2M3FN(), true);
7274 EXPECT_EQ(test.next(false), APFloat::opOK);
7275 EXPECT_TRUE(test.isNegZero());
7276 EXPECT_FALSE(test.isPosZero());
7277 EXPECT_TRUE(test.bitwiseIsEqual(expected));
7278
7279 // 3. nextDown of negative of largest value is the same
7280 test = APFloat::getLargest(APFloat::Float6E2M3FN(), true);
7281 expected = test;
7282 EXPECT_EQ(test.next(true), APFloat::opOK);
7283 EXPECT_FALSE(test.isInfinity());
7284 EXPECT_FALSE(test.isZero());
7285 EXPECT_FALSE(test.isNaN());
7286 EXPECT_TRUE(test.bitwiseIsEqual(expected));
7287
7288 // 4. nextDown of +0 is smallest negative denormal
7289 test = APFloat::getZero(APFloat::Float6E2M3FN(), false);
7290 expected = APFloat::getSmallest(APFloat::Float6E2M3FN(), true);
7291 EXPECT_EQ(test.next(true), APFloat::opOK);
7292 EXPECT_FALSE(test.isZero());
7293 EXPECT_TRUE(test.isDenormal());
7294 EXPECT_TRUE(test.bitwiseIsEqual(expected));
7295 }
7296
7297 TEST(APFloatTest, Float4E2M1FNNext) {
7298 APFloat test(APFloat::Float4E2M1FN(), APFloat::uninitialized);
7299 APFloat expected(APFloat::Float4E2M1FN(), APFloat::uninitialized);
7300
7301 // 1. NextUp of largest bit pattern is the same
7302 test = APFloat::getLargest(APFloat::Float4E2M1FN());
7303 expected = APFloat::getLargest(APFloat::Float4E2M1FN());
7304 EXPECT_EQ(test.next(false), APFloat::opOK);
7305 EXPECT_FALSE(test.isInfinity());
7306 EXPECT_FALSE(test.isZero());
7307 EXPECT_TRUE(test.bitwiseIsEqual(expected));
7308
7309 // 2. NextUp of smallest negative denormal is -0
7310 test = APFloat::getSmallest(APFloat::Float4E2M1FN(), true);
7311 expected = APFloat::getZero(APFloat::Float4E2M1FN(), true);
7312 EXPECT_EQ(test.next(false), APFloat::opOK);
7313 EXPECT_TRUE(test.isNegZero());
7314 EXPECT_FALSE(test.isPosZero());
7315 EXPECT_TRUE(test.bitwiseIsEqual(expected));
7316
7317 // 3. nextDown of negative of largest value is the same
7318 test = APFloat::getLargest(APFloat::Float4E2M1FN(), true);
7319 expected = test;
7320 EXPECT_EQ(test.next(true), APFloat::opOK);
7321 EXPECT_FALSE(test.isInfinity());
7322 EXPECT_FALSE(test.isZero());
7323 EXPECT_FALSE(test.isNaN());
7324 EXPECT_TRUE(test.bitwiseIsEqual(expected));
7325
7326 // 4. nextDown of +0 is smallest negative denormal
7327 test = APFloat::getZero(APFloat::Float4E2M1FN(), false);
7328 expected = APFloat::getSmallest(APFloat::Float4E2M1FN(), true);
7329 EXPECT_EQ(test.next(true), APFloat::opOK);
7330 EXPECT_FALSE(test.isZero());
7331 EXPECT_TRUE(test.isDenormal());
7332 EXPECT_TRUE(test.bitwiseIsEqual(expected));
7333 }
7334
7335 #ifdef GTEST_HAS_DEATH_TEST
7336 #ifndef NDEBUG
7337 TEST(APFloatTest, Float6E3M2FNGetInfNaN) {
7338 EXPECT_DEATH(APFloat::getInf(APFloat::Float6E3M2FN()),
7339 "This floating point format does not support Inf");
7340 EXPECT_DEATH(APFloat::getNaN(APFloat::Float6E3M2FN()),
7341 "This floating point format does not support NaN");
7342 }
7343
7344 TEST(APFloatTest, Float6E2M3FNGetInfNaN) {
7345 EXPECT_DEATH(APFloat::getInf(APFloat::Float6E2M3FN()),
7346 "This floating point format does not support Inf");
7347 EXPECT_DEATH(APFloat::getNaN(APFloat::Float6E2M3FN()),
7348 "This floating point format does not support NaN");
7349 }
7350
7351 TEST(APFloatTest, Float4E2M1FNGetInfNaN) {
7352 EXPECT_DEATH(APFloat::getInf(APFloat::Float4E2M1FN()),
7353 "This floating point format does not support Inf");
7354 EXPECT_DEATH(APFloat::getNaN(APFloat::Float4E2M1FN()),
7355 "This floating point format does not support NaN");
7356 }
7357 #endif
7358 #endif
7359
7360 TEST(APFloatTest, Float6E3M2FNToDouble) {
7361 APFloat One(APFloat::Float6E3M2FN(), "1.0");
7362 EXPECT_EQ(1.0, One.convertToDouble());
7363 APFloat Two(APFloat::Float6E3M2FN(), "2.0");
7364 EXPECT_EQ(2.0, Two.convertToDouble());
7365 APFloat PosLargest = APFloat::getLargest(APFloat::Float6E3M2FN(), false);
7366 EXPECT_EQ(28., PosLargest.convertToDouble());
7367 APFloat NegLargest = APFloat::getLargest(APFloat::Float6E3M2FN(), true);
7368 EXPECT_EQ(-28., NegLargest.convertToDouble());
7369 APFloat PosSmallest =
7370 APFloat::getSmallestNormalized(APFloat::Float6E3M2FN(), false);
7371 EXPECT_EQ(0x1p-2, PosSmallest.convertToDouble());
7372 APFloat NegSmallest =
7373 APFloat::getSmallestNormalized(APFloat::Float6E3M2FN(), true);
7374 EXPECT_EQ(-0x1p-2, NegSmallest.convertToDouble());
7375
7376 APFloat SmallestDenorm = APFloat::getSmallest(APFloat::Float6E3M2FN(), false);
7377 EXPECT_TRUE(SmallestDenorm.isDenormal());
7378 EXPECT_EQ(0x0.1p0, SmallestDenorm.convertToDouble());
7379 }
7380
7381 TEST(APFloatTest, Float6E2M3FNToDouble) {
7382 APFloat One(APFloat::Float6E2M3FN(), "1.0");
7383 EXPECT_EQ(1.0, One.convertToDouble());
7384 APFloat Two(APFloat::Float6E2M3FN(), "2.0");
7385 EXPECT_EQ(2.0, Two.convertToDouble());
7386 APFloat PosLargest = APFloat::getLargest(APFloat::Float6E2M3FN(), false);
7387 EXPECT_EQ(7.5, PosLargest.convertToDouble());
7388 APFloat NegLargest = APFloat::getLargest(APFloat::Float6E2M3FN(), true);
7389 EXPECT_EQ(-7.5, NegLargest.convertToDouble());
7390 APFloat PosSmallest =
7391 APFloat::getSmallestNormalized(APFloat::Float6E2M3FN(), false);
7392 EXPECT_EQ(0x1p0, PosSmallest.convertToDouble());
7393 APFloat NegSmallest =
7394 APFloat::getSmallestNormalized(APFloat::Float6E2M3FN(), true);
7395 EXPECT_EQ(-0x1p0, NegSmallest.convertToDouble());
7396
7397 APFloat SmallestDenorm = APFloat::getSmallest(APFloat::Float6E2M3FN(), false);
7398 EXPECT_TRUE(SmallestDenorm.isDenormal());
7399 EXPECT_EQ(0x0.2p0, SmallestDenorm.convertToDouble());
7400 }
7401
7402 TEST(APFloatTest, Float4E2M1FNToDouble) {
7403 APFloat One(APFloat::Float4E2M1FN(), "1.0");
7404 EXPECT_EQ(1.0, One.convertToDouble());
7405 APFloat Two(APFloat::Float4E2M1FN(), "2.0");
7406 EXPECT_EQ(2.0, Two.convertToDouble());
7407 APFloat PosLargest = APFloat::getLargest(APFloat::Float4E2M1FN(), false);
7408 EXPECT_EQ(6, PosLargest.convertToDouble());
7409 APFloat NegLargest = APFloat::getLargest(APFloat::Float4E2M1FN(), true);
7410 EXPECT_EQ(-6, NegLargest.convertToDouble());
7411 APFloat PosSmallest =
7412 APFloat::getSmallestNormalized(APFloat::Float4E2M1FN(), false);
7413 EXPECT_EQ(0x1p0, PosSmallest.convertToDouble());
7414 APFloat NegSmallest =
7415 APFloat::getSmallestNormalized(APFloat::Float4E2M1FN(), true);
7416 EXPECT_EQ(-0x1p0, NegSmallest.convertToDouble());
7417
7418 APFloat SmallestDenorm = APFloat::getSmallest(APFloat::Float4E2M1FN(), false);
7419 EXPECT_TRUE(SmallestDenorm.isDenormal());
7420 EXPECT_EQ(0x0.8p0, SmallestDenorm.convertToDouble());
7421 }
7422
7423 TEST(APFloatTest, Float6E3M2FNToFloat) {
7424 APFloat PosZero = APFloat::getZero(APFloat::Float6E3M2FN());
7425 APFloat PosZeroToFloat(PosZero.convertToFloat());
7426 EXPECT_TRUE(PosZeroToFloat.isPosZero());
7427 APFloat NegZero = APFloat::getZero(APFloat::Float6E3M2FN(), true);
7428 APFloat NegZeroToFloat(NegZero.convertToFloat());
7429 EXPECT_TRUE(NegZeroToFloat.isNegZero());
7430
7431 APFloat One(APFloat::Float6E3M2FN(), "1.0");
7432 EXPECT_EQ(1.0F, One.convertToFloat());
7433 APFloat Two(APFloat::Float6E3M2FN(), "2.0");
7434 EXPECT_EQ(2.0F, Two.convertToFloat());
7435
7436 APFloat PosLargest = APFloat::getLargest(APFloat::Float6E3M2FN(), false);
7437 EXPECT_EQ(28., PosLargest.convertToFloat());
7438 APFloat NegLargest = APFloat::getLargest(APFloat::Float6E3M2FN(), true);
7439 EXPECT_EQ(-28, NegLargest.convertToFloat());
7440 APFloat PosSmallest =
7441 APFloat::getSmallestNormalized(APFloat::Float6E3M2FN(), false);
7442 EXPECT_EQ(0x1p-2, PosSmallest.convertToFloat());
7443 APFloat NegSmallest =
7444 APFloat::getSmallestNormalized(APFloat::Float6E3M2FN(), true);
7445 EXPECT_EQ(-0x1p-2, NegSmallest.convertToFloat());
7446
7447 APFloat SmallestDenorm = APFloat::getSmallest(APFloat::Float6E3M2FN(), false);
7448 EXPECT_TRUE(SmallestDenorm.isDenormal());
7449 EXPECT_EQ(0x0.1p0, SmallestDenorm.convertToFloat());
7450 }
7451
7452 TEST(APFloatTest, Float6E2M3FNToFloat) {
7453 APFloat PosZero = APFloat::getZero(APFloat::Float6E2M3FN());
7454 APFloat PosZeroToFloat(PosZero.convertToFloat());
7455 EXPECT_TRUE(PosZeroToFloat.isPosZero());
7456 APFloat NegZero = APFloat::getZero(APFloat::Float6E2M3FN(), true);
7457 APFloat NegZeroToFloat(NegZero.convertToFloat());
7458 EXPECT_TRUE(NegZeroToFloat.isNegZero());
7459
7460 APFloat One(APFloat::Float6E2M3FN(), "1.0");
7461 EXPECT_EQ(1.0F, One.convertToFloat());
7462 APFloat Two(APFloat::Float6E2M3FN(), "2.0");
7463 EXPECT_EQ(2.0F, Two.convertToFloat());
7464
7465 APFloat PosLargest = APFloat::getLargest(APFloat::Float6E2M3FN(), false);
7466 EXPECT_EQ(7.5, PosLargest.convertToFloat());
7467 APFloat NegLargest = APFloat::getLargest(APFloat::Float6E2M3FN(), true);
7468 EXPECT_EQ(-7.5, NegLargest.convertToFloat());
7469 APFloat PosSmallest =
7470 APFloat::getSmallestNormalized(APFloat::Float6E2M3FN(), false);
7471 EXPECT_EQ(0x1p0, PosSmallest.convertToFloat());
7472 APFloat NegSmallest =
7473 APFloat::getSmallestNormalized(APFloat::Float6E2M3FN(), true);
7474 EXPECT_EQ(-0x1p0, NegSmallest.convertToFloat());
7475
7476 APFloat SmallestDenorm = APFloat::getSmallest(APFloat::Float6E2M3FN(), false);
7477 EXPECT_TRUE(SmallestDenorm.isDenormal());
7478 EXPECT_EQ(0x0.2p0, SmallestDenorm.convertToFloat());
7479 }
7480
7481 TEST(APFloatTest, Float4E2M1FNToFloat) {
7482 APFloat PosZero = APFloat::getZero(APFloat::Float4E2M1FN());
7483 APFloat PosZeroToFloat(PosZero.convertToFloat());
7484 EXPECT_TRUE(PosZeroToFloat.isPosZero());
7485 APFloat NegZero = APFloat::getZero(APFloat::Float4E2M1FN(), true);
7486 APFloat NegZeroToFloat(NegZero.convertToFloat());
7487 EXPECT_TRUE(NegZeroToFloat.isNegZero());
7488
7489 APFloat One(APFloat::Float4E2M1FN(), "1.0");
7490 EXPECT_EQ(1.0F, One.convertToFloat());
7491 APFloat Two(APFloat::Float4E2M1FN(), "2.0");
7492 EXPECT_EQ(2.0F, Two.convertToFloat());
7493
7494 APFloat PosLargest = APFloat::getLargest(APFloat::Float4E2M1FN(), false);
7495 EXPECT_EQ(6, PosLargest.convertToFloat());
7496 APFloat NegLargest = APFloat::getLargest(APFloat::Float4E2M1FN(), true);
7497 EXPECT_EQ(-6, NegLargest.convertToFloat());
7498 APFloat PosSmallest =
7499 APFloat::getSmallestNormalized(APFloat::Float4E2M1FN(), false);
7500 EXPECT_EQ(0x1p0, PosSmallest.convertToFloat());
7501 APFloat NegSmallest =
7502 APFloat::getSmallestNormalized(APFloat::Float4E2M1FN(), true);
7503 EXPECT_EQ(-0x1p0, NegSmallest.convertToFloat());
7504
7505 APFloat SmallestDenorm = APFloat::getSmallest(APFloat::Float4E2M1FN(), false);
7506 EXPECT_TRUE(SmallestDenorm.isDenormal());
7507 EXPECT_EQ(0x0.8p0, SmallestDenorm.convertToFloat());
7508 }
7509 } // namespace
LLVM monorepo