Debian Codegraph @

llvm-project/llvm/unittests/ADT/APFloatTest.cpp

raw
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/SmallVector.h"
13 #include "llvm/Support/Error.h"
14 #include "llvm/Support/FormatVariadic.h"
15 #include "gtest/gtest.h"
16 #include <cmath>
17 #include <ostream>
18 #include <string>
19 #include <tuple>
20
21 using namespace llvm;
22
23 static std::string convertToErrorFromString(StringRef Str) {
24 llvm::APFloat F(0.0);
25 auto StatusOrErr =
26 F.convertFromString(Str, llvm::APFloat::rmNearestTiesToEven);
27 EXPECT_TRUE(!StatusOrErr);
28 return toString(StatusOrErr.takeError());
29 }
30
31 static double convertToDoubleFromString(StringRef Str) {
32 llvm::APFloat F(0.0);
33 auto StatusOrErr =
34 F.convertFromString(Str, llvm::APFloat::rmNearestTiesToEven);
35 EXPECT_FALSE(!StatusOrErr);
36 consumeError(StatusOrErr.takeError());
37 return F.convertToDouble();
38 }
39
40 static std::string convertToString(double d, unsigned Prec, unsigned Pad,
41 bool Tr = true) {
42 llvm::SmallVector<char, 100> Buffer;
43 llvm::APFloat F(d);
44 F.toString(Buffer, Prec, Pad, Tr);
45 return std::string(Buffer.data(), Buffer.size());
46 }
47
48 namespace {
49
50 TEST(APFloatTest, isSignaling) {
51 // We test qNaN, -qNaN, +sNaN, -sNaN with and without payloads. *NOTE* The
52 // positive/negative distinction is included only since the getQNaN/getSNaN
53 // API provides the option.
54 APInt payload = APInt::getOneBitSet(4, 2);
55 EXPECT_FALSE(APFloat::getQNaN(APFloat::IEEEsingle(), false).isSignaling());
56 EXPECT_FALSE(APFloat::getQNaN(APFloat::IEEEsingle(), true).isSignaling());
57 EXPECT_FALSE(APFloat::getQNaN(APFloat::IEEEsingle(), false, &payload).isSignaling());
58 EXPECT_FALSE(APFloat::getQNaN(APFloat::IEEEsingle(), true, &payload).isSignaling());
59 EXPECT_TRUE(APFloat::getSNaN(APFloat::IEEEsingle(), false).isSignaling());
60 EXPECT_TRUE(APFloat::getSNaN(APFloat::IEEEsingle(), true).isSignaling());
61 EXPECT_TRUE(APFloat::getSNaN(APFloat::IEEEsingle(), false, &payload).isSignaling());
62 EXPECT_TRUE(APFloat::getSNaN(APFloat::IEEEsingle(), true, &payload).isSignaling());
63 }
64
65 TEST(APFloatTest, next) {
66
67 APFloat test(APFloat::IEEEquad(), APFloat::uninitialized);
68 APFloat expected(APFloat::IEEEquad(), APFloat::uninitialized);
69
70 // 1. Test Special Cases Values.
71 //
72 // Test all special values for nextUp and nextDown perscribed by IEEE-754R
73 // 2008. These are:
74 // 1. +inf
75 // 2. -inf
76 // 3. getLargest()
77 // 4. -getLargest()
78 // 5. getSmallest()
79 // 6. -getSmallest()
80 // 7. qNaN
81 // 8. sNaN
82 // 9. +0
83 // 10. -0
84
85 // nextUp(+inf) = +inf.
86 test = APFloat::getInf(APFloat::IEEEquad(), false);
87 expected = APFloat::getInf(APFloat::IEEEquad(), false);
88 EXPECT_EQ(test.next(false), APFloat::opOK);
89 EXPECT_TRUE(test.isInfinity());
90 EXPECT_TRUE(!test.isNegative());
91 EXPECT_TRUE(test.bitwiseIsEqual(expected));
92
93 // nextDown(+inf) = -nextUp(-inf) = -(-getLargest()) = getLargest()
94 test = APFloat::getInf(APFloat::IEEEquad(), false);
95 expected = APFloat::getLargest(APFloat::IEEEquad(), false);
96 EXPECT_EQ(test.next(true), APFloat::opOK);
97 EXPECT_TRUE(!test.isNegative());
98 EXPECT_TRUE(test.bitwiseIsEqual(expected));
99
100 // nextUp(-inf) = -getLargest()
101 test = APFloat::getInf(APFloat::IEEEquad(), true);
102 expected = APFloat::getLargest(APFloat::IEEEquad(), true);
103 EXPECT_EQ(test.next(false), APFloat::opOK);
104 EXPECT_TRUE(test.isNegative());
105 EXPECT_TRUE(test.bitwiseIsEqual(expected));
106
107 // nextDown(-inf) = -nextUp(+inf) = -(+inf) = -inf.
108 test = APFloat::getInf(APFloat::IEEEquad(), true);
109 expected = APFloat::getInf(APFloat::IEEEquad(), true);
110 EXPECT_EQ(test.next(true), APFloat::opOK);
111 EXPECT_TRUE(test.isInfinity() && test.isNegative());
112 EXPECT_TRUE(test.bitwiseIsEqual(expected));
113
114 // nextUp(getLargest()) = +inf
115 test = APFloat::getLargest(APFloat::IEEEquad(), false);
116 expected = APFloat::getInf(APFloat::IEEEquad(), false);
117 EXPECT_EQ(test.next(false), APFloat::opOK);
118 EXPECT_TRUE(test.isInfinity() && !test.isNegative());
119 EXPECT_TRUE(test.bitwiseIsEqual(expected));
120
121 // nextDown(getLargest()) = -nextUp(-getLargest())
122 // = -(-getLargest() + inc)
123 // = getLargest() - inc.
124 test = APFloat::getLargest(APFloat::IEEEquad(), false);
125 expected = APFloat(APFloat::IEEEquad(),
126 "0x1.fffffffffffffffffffffffffffep+16383");
127 EXPECT_EQ(test.next(true), APFloat::opOK);
128 EXPECT_TRUE(!test.isInfinity() && !test.isNegative());
129 EXPECT_TRUE(test.bitwiseIsEqual(expected));
130
131 // nextUp(-getLargest()) = -getLargest() + inc.
132 test = APFloat::getLargest(APFloat::IEEEquad(), true);
133 expected = APFloat(APFloat::IEEEquad(),
134 "-0x1.fffffffffffffffffffffffffffep+16383");
135 EXPECT_EQ(test.next(false), APFloat::opOK);
136 EXPECT_TRUE(test.bitwiseIsEqual(expected));
137
138 // nextDown(-getLargest()) = -nextUp(getLargest()) = -(inf) = -inf.
139 test = APFloat::getLargest(APFloat::IEEEquad(), true);
140 expected = APFloat::getInf(APFloat::IEEEquad(), true);
141 EXPECT_EQ(test.next(true), APFloat::opOK);
142 EXPECT_TRUE(test.isInfinity() && test.isNegative());
143 EXPECT_TRUE(test.bitwiseIsEqual(expected));
144
145 // nextUp(getSmallest()) = getSmallest() + inc.
146 test = APFloat(APFloat::IEEEquad(), "0x0.0000000000000000000000000001p-16382");
147 expected = APFloat(APFloat::IEEEquad(),
148 "0x0.0000000000000000000000000002p-16382");
149 EXPECT_EQ(test.next(false), APFloat::opOK);
150 EXPECT_TRUE(test.bitwiseIsEqual(expected));
151
152 // nextDown(getSmallest()) = -nextUp(-getSmallest()) = -(-0) = +0.
153 test = APFloat(APFloat::IEEEquad(), "0x0.0000000000000000000000000001p-16382");
154 expected = APFloat::getZero(APFloat::IEEEquad(), false);
155 EXPECT_EQ(test.next(true), APFloat::opOK);
156 EXPECT_TRUE(test.isPosZero());
157 EXPECT_TRUE(test.bitwiseIsEqual(expected));
158
159 // nextUp(-getSmallest()) = -0.
160 test = APFloat(APFloat::IEEEquad(), "-0x0.0000000000000000000000000001p-16382");
161 expected = APFloat::getZero(APFloat::IEEEquad(), true);
162 EXPECT_EQ(test.next(false), APFloat::opOK);
163 EXPECT_TRUE(test.isNegZero());
164 EXPECT_TRUE(test.bitwiseIsEqual(expected));
165
166 // nextDown(-getSmallest()) = -nextUp(getSmallest()) = -getSmallest() - inc.
167 test = APFloat(APFloat::IEEEquad(), "-0x0.0000000000000000000000000001p-16382");
168 expected = APFloat(APFloat::IEEEquad(),
169 "-0x0.0000000000000000000000000002p-16382");
170 EXPECT_EQ(test.next(true), APFloat::opOK);
171 EXPECT_TRUE(test.bitwiseIsEqual(expected));
172
173 // nextUp(qNaN) = qNaN
174 test = APFloat::getQNaN(APFloat::IEEEquad(), false);
175 expected = APFloat::getQNaN(APFloat::IEEEquad(), false);
176 EXPECT_EQ(test.next(false), APFloat::opOK);
177 EXPECT_TRUE(test.bitwiseIsEqual(expected));
178
179 // nextDown(qNaN) = qNaN
180 test = APFloat::getQNaN(APFloat::IEEEquad(), false);
181 expected = APFloat::getQNaN(APFloat::IEEEquad(), false);
182 EXPECT_EQ(test.next(true), APFloat::opOK);
183 EXPECT_TRUE(test.bitwiseIsEqual(expected));
184
185 // nextUp(sNaN) = qNaN
186 test = APFloat::getSNaN(APFloat::IEEEquad(), false);
187 expected = APFloat::getQNaN(APFloat::IEEEquad(), false);
188 EXPECT_EQ(test.next(false), APFloat::opInvalidOp);
189 EXPECT_TRUE(test.bitwiseIsEqual(expected));
190
191 // nextDown(sNaN) = qNaN
192 test = APFloat::getSNaN(APFloat::IEEEquad(), false);
193 expected = APFloat::getQNaN(APFloat::IEEEquad(), false);
194 EXPECT_EQ(test.next(true), APFloat::opInvalidOp);
195 EXPECT_TRUE(test.bitwiseIsEqual(expected));
196
197 // nextUp(+0) = +getSmallest()
198 test = APFloat::getZero(APFloat::IEEEquad(), false);
199 expected = APFloat::getSmallest(APFloat::IEEEquad(), false);
200 EXPECT_EQ(test.next(false), APFloat::opOK);
201 EXPECT_TRUE(test.bitwiseIsEqual(expected));
202
203 // nextDown(+0) = -nextUp(-0) = -getSmallest()
204 test = APFloat::getZero(APFloat::IEEEquad(), false);
205 expected = APFloat::getSmallest(APFloat::IEEEquad(), true);
206 EXPECT_EQ(test.next(true), APFloat::opOK);
207 EXPECT_TRUE(test.bitwiseIsEqual(expected));
208
209 // nextUp(-0) = +getSmallest()
210 test = APFloat::getZero(APFloat::IEEEquad(), true);
211 expected = APFloat::getSmallest(APFloat::IEEEquad(), false);
212 EXPECT_EQ(test.next(false), APFloat::opOK);
213 EXPECT_TRUE(test.bitwiseIsEqual(expected));
214
215 // nextDown(-0) = -nextUp(0) = -getSmallest()
216 test = APFloat::getZero(APFloat::IEEEquad(), true);
217 expected = APFloat::getSmallest(APFloat::IEEEquad(), true);
218 EXPECT_EQ(test.next(true), APFloat::opOK);
219 EXPECT_TRUE(test.bitwiseIsEqual(expected));
220
221 // 2. Binade Boundary Tests.
222
223 // 2a. Test denormal <-> normal binade boundaries.
224 // * nextUp(+Largest Denormal) -> +Smallest Normal.
225 // * nextDown(-Largest Denormal) -> -Smallest Normal.
226 // * nextUp(-Smallest Normal) -> -Largest Denormal.
227 // * nextDown(+Smallest Normal) -> +Largest Denormal.
228
229 // nextUp(+Largest Denormal) -> +Smallest Normal.
230 test = APFloat(APFloat::IEEEquad(), "0x0.ffffffffffffffffffffffffffffp-16382");
231 expected = APFloat(APFloat::IEEEquad(),
232 "0x1.0000000000000000000000000000p-16382");
233 EXPECT_EQ(test.next(false), APFloat::opOK);
234 EXPECT_FALSE(test.isDenormal());
235 EXPECT_TRUE(test.bitwiseIsEqual(expected));
236
237 // nextDown(-Largest Denormal) -> -Smallest Normal.
238 test = APFloat(APFloat::IEEEquad(),
239 "-0x0.ffffffffffffffffffffffffffffp-16382");
240 expected = APFloat(APFloat::IEEEquad(),
241 "-0x1.0000000000000000000000000000p-16382");
242 EXPECT_EQ(test.next(true), APFloat::opOK);
243 EXPECT_FALSE(test.isDenormal());
244 EXPECT_TRUE(test.bitwiseIsEqual(expected));
245
246 // nextUp(-Smallest Normal) -> -LargestDenormal.
247 test = APFloat(APFloat::IEEEquad(),
248 "-0x1.0000000000000000000000000000p-16382");
249 expected = APFloat(APFloat::IEEEquad(),
250 "-0x0.ffffffffffffffffffffffffffffp-16382");
251 EXPECT_EQ(test.next(false), APFloat::opOK);
252 EXPECT_TRUE(test.isDenormal());
253 EXPECT_TRUE(test.bitwiseIsEqual(expected));
254
255 // nextDown(+Smallest Normal) -> +Largest Denormal.
256 test = APFloat(APFloat::IEEEquad(),
257 "+0x1.0000000000000000000000000000p-16382");
258 expected = APFloat(APFloat::IEEEquad(),
259 "+0x0.ffffffffffffffffffffffffffffp-16382");
260 EXPECT_EQ(test.next(true), APFloat::opOK);
261 EXPECT_TRUE(test.isDenormal());
262 EXPECT_TRUE(test.bitwiseIsEqual(expected));
263
264 // 2b. Test normal <-> normal binade boundaries.
265 // * nextUp(-Normal Binade Boundary) -> -Normal Binade Boundary + 1.
266 // * nextDown(+Normal Binade Boundary) -> +Normal Binade Boundary - 1.
267 // * nextUp(+Normal Binade Boundary - 1) -> +Normal Binade Boundary.
268 // * nextDown(-Normal Binade Boundary + 1) -> -Normal Binade Boundary.
269
270 // nextUp(-Normal Binade Boundary) -> -Normal Binade Boundary + 1.
271 test = APFloat(APFloat::IEEEquad(), "-0x1p+1");
272 expected = APFloat(APFloat::IEEEquad(),
273 "-0x1.ffffffffffffffffffffffffffffp+0");
274 EXPECT_EQ(test.next(false), APFloat::opOK);
275 EXPECT_TRUE(test.bitwiseIsEqual(expected));
276
277 // nextDown(+Normal Binade Boundary) -> +Normal Binade Boundary - 1.
278 test = APFloat(APFloat::IEEEquad(), "0x1p+1");
279 expected = APFloat(APFloat::IEEEquad(), "0x1.ffffffffffffffffffffffffffffp+0");
280 EXPECT_EQ(test.next(true), APFloat::opOK);
281 EXPECT_TRUE(test.bitwiseIsEqual(expected));
282
283 // nextUp(+Normal Binade Boundary - 1) -> +Normal Binade Boundary.
284 test = APFloat(APFloat::IEEEquad(), "0x1.ffffffffffffffffffffffffffffp+0");
285 expected = APFloat(APFloat::IEEEquad(), "0x1p+1");
286 EXPECT_EQ(test.next(false), APFloat::opOK);
287 EXPECT_TRUE(test.bitwiseIsEqual(expected));
288
289 // nextDown(-Normal Binade Boundary + 1) -> -Normal Binade Boundary.
290 test = APFloat(APFloat::IEEEquad(), "-0x1.ffffffffffffffffffffffffffffp+0");
291 expected = APFloat(APFloat::IEEEquad(), "-0x1p+1");
292 EXPECT_EQ(test.next(true), APFloat::opOK);
293 EXPECT_TRUE(test.bitwiseIsEqual(expected));
294
295 // 2c. Test using next at binade boundaries with a direction away from the
296 // binade boundary. Away from denormal <-> normal boundaries.
297 //
298 // This is to make sure that even though we are at a binade boundary, since
299 // we are rounding away, we do not trigger the binade boundary code. Thus we
300 // test:
301 // * nextUp(-Largest Denormal) -> -Largest Denormal + inc.
302 // * nextDown(+Largest Denormal) -> +Largest Denormal - inc.
303 // * nextUp(+Smallest Normal) -> +Smallest Normal + inc.
304 // * nextDown(-Smallest Normal) -> -Smallest Normal - inc.
305
306 // nextUp(-Largest Denormal) -> -Largest Denormal + inc.
307 test = APFloat(APFloat::IEEEquad(), "-0x0.ffffffffffffffffffffffffffffp-16382");
308 expected = APFloat(APFloat::IEEEquad(),
309 "-0x0.fffffffffffffffffffffffffffep-16382");
310 EXPECT_EQ(test.next(false), APFloat::opOK);
311 EXPECT_TRUE(test.isDenormal());
312 EXPECT_TRUE(test.isNegative());
313 EXPECT_TRUE(test.bitwiseIsEqual(expected));
314
315 // nextDown(+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(true), APFloat::opOK);
320 EXPECT_TRUE(test.isDenormal());
321 EXPECT_TRUE(!test.isNegative());
322 EXPECT_TRUE(test.bitwiseIsEqual(expected));
323
324 // nextUp(+Smallest Normal) -> +Smallest Normal + inc.
325 test = APFloat(APFloat::IEEEquad(), "0x1.0000000000000000000000000000p-16382");
326 expected = APFloat(APFloat::IEEEquad(),
327 "0x1.0000000000000000000000000001p-16382");
328 EXPECT_EQ(test.next(false), APFloat::opOK);
329 EXPECT_TRUE(!test.isDenormal());
330 EXPECT_TRUE(!test.isNegative());
331 EXPECT_TRUE(test.bitwiseIsEqual(expected));
332
333 // nextDown(-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(true), APFloat::opOK);
338 EXPECT_TRUE(!test.isDenormal());
339 EXPECT_TRUE(test.isNegative());
340 EXPECT_TRUE(test.bitwiseIsEqual(expected));
341
342 // 2d. Test values which cause our exponent to go to min exponent. This
343 // is to ensure that guards in the code to check for min exponent
344 // trigger properly.
345 // * nextUp(-0x1p-16381) -> -0x1.ffffffffffffffffffffffffffffp-16382
346 // * nextDown(-0x1.ffffffffffffffffffffffffffffp-16382) ->
347 // -0x1p-16381
348 // * nextUp(0x1.ffffffffffffffffffffffffffffp-16382) -> 0x1p-16382
349 // * nextDown(0x1p-16382) -> 0x1.ffffffffffffffffffffffffffffp-16382
350
351 // nextUp(-0x1p-16381) -> -0x1.ffffffffffffffffffffffffffffp-16382
352 test = APFloat(APFloat::IEEEquad(), "-0x1p-16381");
353 expected = APFloat(APFloat::IEEEquad(),
354 "-0x1.ffffffffffffffffffffffffffffp-16382");
355 EXPECT_EQ(test.next(false), APFloat::opOK);
356 EXPECT_TRUE(test.bitwiseIsEqual(expected));
357
358 // nextDown(-0x1.ffffffffffffffffffffffffffffp-16382) ->
359 // -0x1p-16381
360 test = APFloat(APFloat::IEEEquad(), "-0x1.ffffffffffffffffffffffffffffp-16382");
361 expected = APFloat(APFloat::IEEEquad(), "-0x1p-16381");
362 EXPECT_EQ(test.next(true), APFloat::opOK);
363 EXPECT_TRUE(test.bitwiseIsEqual(expected));
364
365 // nextUp(0x1.ffffffffffffffffffffffffffffp-16382) -> 0x1p-16381
366 test = APFloat(APFloat::IEEEquad(), "0x1.ffffffffffffffffffffffffffffp-16382");
367 expected = APFloat(APFloat::IEEEquad(), "0x1p-16381");
368 EXPECT_EQ(test.next(false), APFloat::opOK);
369 EXPECT_TRUE(test.bitwiseIsEqual(expected));
370
371 // nextDown(0x1p-16381) -> 0x1.ffffffffffffffffffffffffffffp-16382
372 test = APFloat(APFloat::IEEEquad(), "0x1p-16381");
373 expected = APFloat(APFloat::IEEEquad(),
374 "0x1.ffffffffffffffffffffffffffffp-16382");
375 EXPECT_EQ(test.next(true), APFloat::opOK);
376 EXPECT_TRUE(test.bitwiseIsEqual(expected));
377
378 // 3. Now we test both denormal/normal computation which will not cause us
379 // to go across binade boundaries. Specifically we test:
380 // * nextUp(+Denormal) -> +Denormal.
381 // * nextDown(+Denormal) -> +Denormal.
382 // * nextUp(-Denormal) -> -Denormal.
383 // * nextDown(-Denormal) -> -Denormal.
384 // * nextUp(+Normal) -> +Normal.
385 // * nextDown(+Normal) -> +Normal.
386 // * nextUp(-Normal) -> -Normal.
387 // * nextDown(-Normal) -> -Normal.
388
389 // nextUp(+Denormal) -> +Denormal.
390 test = APFloat(APFloat::IEEEquad(),
391 "0x0.ffffffffffffffffffffffff000cp-16382");
392 expected = APFloat(APFloat::IEEEquad(),
393 "0x0.ffffffffffffffffffffffff000dp-16382");
394 EXPECT_EQ(test.next(false), APFloat::opOK);
395 EXPECT_TRUE(test.isDenormal());
396 EXPECT_TRUE(!test.isNegative());
397 EXPECT_TRUE(test.bitwiseIsEqual(expected));
398
399 // nextDown(+Denormal) -> +Denormal.
400 test = APFloat(APFloat::IEEEquad(),
401 "0x0.ffffffffffffffffffffffff000cp-16382");
402 expected = APFloat(APFloat::IEEEquad(),
403 "0x0.ffffffffffffffffffffffff000bp-16382");
404 EXPECT_EQ(test.next(true), APFloat::opOK);
405 EXPECT_TRUE(test.isDenormal());
406 EXPECT_TRUE(!test.isNegative());
407 EXPECT_TRUE(test.bitwiseIsEqual(expected));
408
409 // nextUp(-Denormal) -> -Denormal.
410 test = APFloat(APFloat::IEEEquad(),
411 "-0x0.ffffffffffffffffffffffff000cp-16382");
412 expected = APFloat(APFloat::IEEEquad(),
413 "-0x0.ffffffffffffffffffffffff000bp-16382");
414 EXPECT_EQ(test.next(false), APFloat::opOK);
415 EXPECT_TRUE(test.isDenormal());
416 EXPECT_TRUE(test.isNegative());
417 EXPECT_TRUE(test.bitwiseIsEqual(expected));
418
419 // nextDown(-Denormal) -> -Denormal
420 test = APFloat(APFloat::IEEEquad(),
421 "-0x0.ffffffffffffffffffffffff000cp-16382");
422 expected = APFloat(APFloat::IEEEquad(),
423 "-0x0.ffffffffffffffffffffffff000dp-16382");
424 EXPECT_EQ(test.next(true), APFloat::opOK);
425 EXPECT_TRUE(test.isDenormal());
426 EXPECT_TRUE(test.isNegative());
427 EXPECT_TRUE(test.bitwiseIsEqual(expected));
428
429 // nextUp(+Normal) -> +Normal.
430 test = APFloat(APFloat::IEEEquad(),
431 "0x1.ffffffffffffffffffffffff000cp-16000");
432 expected = APFloat(APFloat::IEEEquad(),
433 "0x1.ffffffffffffffffffffffff000dp-16000");
434 EXPECT_EQ(test.next(false), APFloat::opOK);
435 EXPECT_TRUE(!test.isDenormal());
436 EXPECT_TRUE(!test.isNegative());
437 EXPECT_TRUE(test.bitwiseIsEqual(expected));
438
439 // nextDown(+Normal) -> +Normal.
440 test = APFloat(APFloat::IEEEquad(),
441 "0x1.ffffffffffffffffffffffff000cp-16000");
442 expected = APFloat(APFloat::IEEEquad(),
443 "0x1.ffffffffffffffffffffffff000bp-16000");
444 EXPECT_EQ(test.next(true), APFloat::opOK);
445 EXPECT_TRUE(!test.isDenormal());
446 EXPECT_TRUE(!test.isNegative());
447 EXPECT_TRUE(test.bitwiseIsEqual(expected));
448
449 // nextUp(-Normal) -> -Normal.
450 test = APFloat(APFloat::IEEEquad(),
451 "-0x1.ffffffffffffffffffffffff000cp-16000");
452 expected = APFloat(APFloat::IEEEquad(),
453 "-0x1.ffffffffffffffffffffffff000bp-16000");
454 EXPECT_EQ(test.next(false), APFloat::opOK);
455 EXPECT_TRUE(!test.isDenormal());
456 EXPECT_TRUE(test.isNegative());
457 EXPECT_TRUE(test.bitwiseIsEqual(expected));
458
459 // nextDown(-Normal) -> -Normal.
460 test = APFloat(APFloat::IEEEquad(),
461 "-0x1.ffffffffffffffffffffffff000cp-16000");
462 expected = APFloat(APFloat::IEEEquad(),
463 "-0x1.ffffffffffffffffffffffff000dp-16000");
464 EXPECT_EQ(test.next(true), APFloat::opOK);
465 EXPECT_TRUE(!test.isDenormal());
466 EXPECT_TRUE(test.isNegative());
467 EXPECT_TRUE(test.bitwiseIsEqual(expected));
468 }
469
470 TEST(APFloatTest, FMA) {
471 APFloat::roundingMode rdmd = APFloat::rmNearestTiesToEven;
472
473 {
474 APFloat f1(14.5f);
475 APFloat f2(-14.5f);
476 APFloat f3(225.0f);
477 f1.fusedMultiplyAdd(f2, f3, APFloat::rmNearestTiesToEven);
478 EXPECT_EQ(14.75f, f1.convertToFloat());
479 }
480
481 {
482 APFloat Val2(2.0f);
483 APFloat f1((float)1.17549435e-38F);
484 APFloat f2((float)1.17549435e-38F);
485 f1.divide(Val2, rdmd);
486 f2.divide(Val2, rdmd);
487 APFloat f3(12.0f);
488 f1.fusedMultiplyAdd(f2, f3, APFloat::rmNearestTiesToEven);
489 EXPECT_EQ(12.0f, f1.convertToFloat());
490 }
491
492 // Test for correct zero sign when answer is exactly zero.
493 // fma(1.0, -1.0, 1.0) -> +ve 0.
494 {
495 APFloat f1(1.0);
496 APFloat f2(-1.0);
497 APFloat f3(1.0);
498 f1.fusedMultiplyAdd(f2, f3, APFloat::rmNearestTiesToEven);
499 EXPECT_TRUE(!f1.isNegative() && f1.isZero());
500 }
501
502 // Test for correct zero sign when answer is exactly zero and rounding towards
503 // negative.
504 // fma(1.0, -1.0, 1.0) -> +ve 0.
505 {
506 APFloat f1(1.0);
507 APFloat f2(-1.0);
508 APFloat f3(1.0);
509 f1.fusedMultiplyAdd(f2, f3, APFloat::rmTowardNegative);
510 EXPECT_TRUE(f1.isNegative() && f1.isZero());
511 }
512
513 // Test for correct (in this case -ve) sign when adding like signed zeros.
514 // Test fma(0.0, -0.0, -0.0) -> -ve 0.
515 {
516 APFloat f1(0.0);
517 APFloat f2(-0.0);
518 APFloat f3(-0.0);
519 f1.fusedMultiplyAdd(f2, f3, APFloat::rmNearestTiesToEven);
520 EXPECT_TRUE(f1.isNegative() && f1.isZero());
521 }
522
523 // Test -ve sign preservation when small negative results underflow.
524 {
525 APFloat f1(APFloat::IEEEdouble(), "-0x1p-1074");
526 APFloat f2(APFloat::IEEEdouble(), "+0x1p-1074");
527 APFloat f3(0.0);
528 f1.fusedMultiplyAdd(f2, f3, APFloat::rmNearestTiesToEven);
529 EXPECT_TRUE(f1.isNegative() && f1.isZero());
530 }
531
532 // Test x87 extended precision case from http://llvm.org/PR20728.
533 {
534 APFloat M1(APFloat::x87DoubleExtended(), 1);
535 APFloat M2(APFloat::x87DoubleExtended(), 1);
536 APFloat A(APFloat::x87DoubleExtended(), 3);
537
538 bool losesInfo = false;
539 M1.fusedMultiplyAdd(M1, A, APFloat::rmNearestTiesToEven);
540 M1.convert(APFloat::IEEEsingle(), APFloat::rmNearestTiesToEven, &losesInfo);
541 EXPECT_FALSE(losesInfo);
542 EXPECT_EQ(4.0f, M1.convertToFloat());
543 }
544
545 // Regression test that failed an assertion.
546 {
547 APFloat f1(-8.85242279E-41f);
548 APFloat f2(2.0f);
549 APFloat f3(8.85242279E-41f);
550 f1.fusedMultiplyAdd(f2, f3, APFloat::rmNearestTiesToEven);
551 EXPECT_EQ(-8.85242279E-41f, f1.convertToFloat());
552 }
553
554 // Test using only a single instance of APFloat.
555 {
556 APFloat F(1.5);
557
558 F.fusedMultiplyAdd(F, F, APFloat::rmNearestTiesToEven);
559 EXPECT_EQ(3.75, F.convertToDouble());
560 }
561 }
562
563 TEST(APFloatTest, MinNum) {
564 APFloat f1(1.0);
565 APFloat f2(2.0);
566 APFloat nan = APFloat::getNaN(APFloat::IEEEdouble());
567
568 EXPECT_EQ(1.0, minnum(f1, f2).convertToDouble());
569 EXPECT_EQ(1.0, minnum(f2, f1).convertToDouble());
570 EXPECT_EQ(1.0, minnum(f1, nan).convertToDouble());
571 EXPECT_EQ(1.0, minnum(nan, f1).convertToDouble());
572 }
573
574 TEST(APFloatTest, MaxNum) {
575 APFloat f1(1.0);
576 APFloat f2(2.0);
577 APFloat nan = APFloat::getNaN(APFloat::IEEEdouble());
578
579 EXPECT_EQ(2.0, maxnum(f1, f2).convertToDouble());
580 EXPECT_EQ(2.0, maxnum(f2, f1).convertToDouble());
581 EXPECT_EQ(1.0, maxnum(f1, nan).convertToDouble());
582 EXPECT_EQ(1.0, maxnum(nan, f1).convertToDouble());
583 }
584
585 TEST(APFloatTest, Minimum) {
586 APFloat f1(1.0);
587 APFloat f2(2.0);
588 APFloat zp(0.0);
589 APFloat zn(-0.0);
590 APFloat nan = APFloat::getNaN(APFloat::IEEEdouble());
591
592 EXPECT_EQ(1.0, minimum(f1, f2).convertToDouble());
593 EXPECT_EQ(1.0, minimum(f2, f1).convertToDouble());
594 EXPECT_EQ(-0.0, minimum(zp, zn).convertToDouble());
595 EXPECT_EQ(-0.0, minimum(zn, zp).convertToDouble());
596 EXPECT_TRUE(std::isnan(minimum(f1, nan).convertToDouble()));
597 EXPECT_TRUE(std::isnan(minimum(nan, f1).convertToDouble()));
598 }
599
600 TEST(APFloatTest, Maximum) {
601 APFloat f1(1.0);
602 APFloat f2(2.0);
603 APFloat zp(0.0);
604 APFloat zn(-0.0);
605 APFloat nan = APFloat::getNaN(APFloat::IEEEdouble());
606
607 EXPECT_EQ(2.0, maximum(f1, f2).convertToDouble());
608 EXPECT_EQ(2.0, maximum(f2, f1).convertToDouble());
609 EXPECT_EQ(0.0, maximum(zp, zn).convertToDouble());
610 EXPECT_EQ(0.0, maximum(zn, zp).convertToDouble());
611 EXPECT_TRUE(std::isnan(maximum(f1, nan).convertToDouble()));
612 EXPECT_TRUE(std::isnan(maximum(nan, f1).convertToDouble()));
613 }
614
615 TEST(APFloatTest, Denormal) {
616 APFloat::roundingMode rdmd = APFloat::rmNearestTiesToEven;
617
618 // Test single precision
619 {
620 const char *MinNormalStr = "1.17549435082228750797e-38";
621 EXPECT_FALSE(APFloat(APFloat::IEEEsingle(), MinNormalStr).isDenormal());
622 EXPECT_FALSE(APFloat(APFloat::IEEEsingle(), 0).isDenormal());
623
624 APFloat Val2(APFloat::IEEEsingle(), 2);
625 APFloat T(APFloat::IEEEsingle(), MinNormalStr);
626 T.divide(Val2, rdmd);
627 EXPECT_TRUE(T.isDenormal());
628 }
629
630 // Test double precision
631 {
632 const char *MinNormalStr = "2.22507385850720138309e-308";
633 EXPECT_FALSE(APFloat(APFloat::IEEEdouble(), MinNormalStr).isDenormal());
634 EXPECT_FALSE(APFloat(APFloat::IEEEdouble(), 0).isDenormal());
635
636 APFloat Val2(APFloat::IEEEdouble(), 2);
637 APFloat T(APFloat::IEEEdouble(), MinNormalStr);
638 T.divide(Val2, rdmd);
639 EXPECT_TRUE(T.isDenormal());
640 }
641
642 // Test Intel double-ext
643 {
644 const char *MinNormalStr = "3.36210314311209350626e-4932";
645 EXPECT_FALSE(APFloat(APFloat::x87DoubleExtended(), MinNormalStr).isDenormal());
646 EXPECT_FALSE(APFloat(APFloat::x87DoubleExtended(), 0).isDenormal());
647
648 APFloat Val2(APFloat::x87DoubleExtended(), 2);
649 APFloat T(APFloat::x87DoubleExtended(), MinNormalStr);
650 T.divide(Val2, rdmd);
651 EXPECT_TRUE(T.isDenormal());
652 }
653
654 // Test quadruple precision
655 {
656 const char *MinNormalStr = "3.36210314311209350626267781732175260e-4932";
657 EXPECT_FALSE(APFloat(APFloat::IEEEquad(), MinNormalStr).isDenormal());
658 EXPECT_FALSE(APFloat(APFloat::IEEEquad(), 0).isDenormal());
659
660 APFloat Val2(APFloat::IEEEquad(), 2);
661 APFloat T(APFloat::IEEEquad(), MinNormalStr);
662 T.divide(Val2, rdmd);
663 EXPECT_TRUE(T.isDenormal());
664 }
665 }
666
667 TEST(APFloatTest, IsSmallestNormalized) {
668 for (unsigned I = 0; I != APFloat::S_MaxSemantics + 1; ++I) {
669 const fltSemantics &Semantics =
670 APFloat::EnumToSemantics(static_cast<APFloat::Semantics>(I));
671
672 EXPECT_FALSE(APFloat::getZero(Semantics, false).isSmallestNormalized());
673 EXPECT_FALSE(APFloat::getZero(Semantics, true).isSmallestNormalized());
674
675 EXPECT_FALSE(APFloat::getInf(Semantics, false).isSmallestNormalized());
676 EXPECT_FALSE(APFloat::getInf(Semantics, true).isSmallestNormalized());
677
678 EXPECT_FALSE(APFloat::getQNaN(Semantics).isSmallestNormalized());
679 EXPECT_FALSE(APFloat::getSNaN(Semantics).isSmallestNormalized());
680
681 EXPECT_FALSE(APFloat::getLargest(Semantics).isSmallestNormalized());
682 EXPECT_FALSE(APFloat::getLargest(Semantics, true).isSmallestNormalized());
683
684 EXPECT_FALSE(APFloat::getSmallest(Semantics).isSmallestNormalized());
685 EXPECT_FALSE(APFloat::getSmallest(Semantics, true).isSmallestNormalized());
686
687 EXPECT_FALSE(APFloat::getAllOnesValue(Semantics).isSmallestNormalized());
688
689 APFloat PosSmallestNormalized =
690 APFloat::getSmallestNormalized(Semantics, false);
691 APFloat NegSmallestNormalized =
692 APFloat::getSmallestNormalized(Semantics, true);
693 EXPECT_TRUE(PosSmallestNormalized.isSmallestNormalized());
694 EXPECT_TRUE(NegSmallestNormalized.isSmallestNormalized());
695
696 for (APFloat *Val : {&PosSmallestNormalized, &NegSmallestNormalized}) {
697 bool OldSign = Val->isNegative();
698
699 // Step down, make sure it's still not smallest normalized.
700 EXPECT_EQ(APFloat::opOK, Val->next(false));
701 EXPECT_EQ(OldSign, Val->isNegative());
702 EXPECT_FALSE(Val->isSmallestNormalized());
703 EXPECT_EQ(OldSign, Val->isNegative());
704
705 // Step back up should restore it to being smallest normalized.
706 EXPECT_EQ(APFloat::opOK, Val->next(true));
707 EXPECT_TRUE(Val->isSmallestNormalized());
708 EXPECT_EQ(OldSign, Val->isNegative());
709
710 // Step beyond should no longer smallest normalized.
711 EXPECT_EQ(APFloat::opOK, Val->next(true));
712 EXPECT_FALSE(Val->isSmallestNormalized());
713 EXPECT_EQ(OldSign, Val->isNegative());
714 }
715 }
716 }
717
718 TEST(APFloatTest, Zero) {
719 EXPECT_EQ(0.0f, APFloat(0.0f).convertToFloat());
720 EXPECT_EQ(-0.0f, APFloat(-0.0f).convertToFloat());
721 EXPECT_TRUE(APFloat(-0.0f).isNegative());
722
723 EXPECT_EQ(0.0, APFloat(0.0).convertToDouble());
724 EXPECT_EQ(-0.0, APFloat(-0.0).convertToDouble());
725 EXPECT_TRUE(APFloat(-0.0).isNegative());
726 }
727
728 TEST(APFloatTest, DecimalStringsWithoutNullTerminators) {
729 // Make sure that we can parse strings without null terminators.
730 // rdar://14323230.
731 EXPECT_EQ(convertToDoubleFromString(StringRef("0.00", 3)), 0.0);
732 EXPECT_EQ(convertToDoubleFromString(StringRef("0.01", 3)), 0.0);
733 EXPECT_EQ(convertToDoubleFromString(StringRef("0.09", 3)), 0.0);
734 EXPECT_EQ(convertToDoubleFromString(StringRef("0.095", 4)), 0.09);
735 EXPECT_EQ(convertToDoubleFromString(StringRef("0.00e+3", 7)), 0.00);
736 EXPECT_EQ(convertToDoubleFromString(StringRef("0e+3", 4)), 0.00);
737 }
738
739 TEST(APFloatTest, fromZeroDecimalString) {
740 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0").convertToDouble());
741 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0").convertToDouble());
742 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0").convertToDouble());
743
744 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0.").convertToDouble());
745 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0.").convertToDouble());
746 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0.").convertToDouble());
747
748 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), ".0").convertToDouble());
749 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+.0").convertToDouble());
750 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-.0").convertToDouble());
751
752 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0.0").convertToDouble());
753 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0.0").convertToDouble());
754 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0.0").convertToDouble());
755
756 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "00000.").convertToDouble());
757 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+00000.").convertToDouble());
758 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-00000.").convertToDouble());
759
760 EXPECT_EQ(0.0, APFloat(APFloat::IEEEdouble(), ".00000").convertToDouble());
761 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+.00000").convertToDouble());
762 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-.00000").convertToDouble());
763
764 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0000.00000").convertToDouble());
765 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0000.00000").convertToDouble());
766 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0000.00000").convertToDouble());
767 }
768
769 TEST(APFloatTest, fromZeroDecimalSingleExponentString) {
770 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0e1").convertToDouble());
771 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0e1").convertToDouble());
772 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0e1").convertToDouble());
773
774 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0e+1").convertToDouble());
775 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0e+1").convertToDouble());
776 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0e+1").convertToDouble());
777
778 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0e-1").convertToDouble());
779 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0e-1").convertToDouble());
780 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0e-1").convertToDouble());
781
782
783 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0.e1").convertToDouble());
784 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0.e1").convertToDouble());
785 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0.e1").convertToDouble());
786
787 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0.e+1").convertToDouble());
788 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0.e+1").convertToDouble());
789 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0.e+1").convertToDouble());
790
791 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0.e-1").convertToDouble());
792 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0.e-1").convertToDouble());
793 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0.e-1").convertToDouble());
794
795 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), ".0e1").convertToDouble());
796 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+.0e1").convertToDouble());
797 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-.0e1").convertToDouble());
798
799 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), ".0e+1").convertToDouble());
800 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+.0e+1").convertToDouble());
801 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-.0e+1").convertToDouble());
802
803 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), ".0e-1").convertToDouble());
804 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+.0e-1").convertToDouble());
805 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-.0e-1").convertToDouble());
806
807
808 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0.0e1").convertToDouble());
809 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0.0e1").convertToDouble());
810 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0.0e1").convertToDouble());
811
812 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0.0e+1").convertToDouble());
813 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0.0e+1").convertToDouble());
814 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0.0e+1").convertToDouble());
815
816 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0.0e-1").convertToDouble());
817 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0.0e-1").convertToDouble());
818 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0.0e-1").convertToDouble());
819
820
821 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "000.0000e1").convertToDouble());
822 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+000.0000e+1").convertToDouble());
823 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-000.0000e+1").convertToDouble());
824 }
825
826 TEST(APFloatTest, fromZeroDecimalLargeExponentString) {
827 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0e1234").convertToDouble());
828 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0e1234").convertToDouble());
829 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0e1234").convertToDouble());
830
831 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0e+1234").convertToDouble());
832 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0e+1234").convertToDouble());
833 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0e+1234").convertToDouble());
834
835 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0e-1234").convertToDouble());
836 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0e-1234").convertToDouble());
837 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0e-1234").convertToDouble());
838
839 EXPECT_EQ(0.0, APFloat(APFloat::IEEEdouble(), "000.0000e1234").convertToDouble());
840 EXPECT_EQ(0.0, APFloat(APFloat::IEEEdouble(), "000.0000e-1234").convertToDouble());
841
842 EXPECT_EQ(0.0, APFloat(APFloat::IEEEdouble(), StringRef("0e1234" "\0" "2", 6)).convertToDouble());
843 }
844
845 TEST(APFloatTest, fromZeroHexadecimalString) {
846 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x0p1").convertToDouble());
847 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0x0p1").convertToDouble());
848 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0x0p1").convertToDouble());
849
850 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x0p+1").convertToDouble());
851 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0x0p+1").convertToDouble());
852 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0x0p+1").convertToDouble());
853
854 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x0p-1").convertToDouble());
855 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0x0p-1").convertToDouble());
856 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0x0p-1").convertToDouble());
857
858
859 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x0.p1").convertToDouble());
860 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0x0.p1").convertToDouble());
861 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0x0.p1").convertToDouble());
862
863 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x0.p+1").convertToDouble());
864 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0x0.p+1").convertToDouble());
865 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0x0.p+1").convertToDouble());
866
867 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x0.p-1").convertToDouble());
868 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0x0.p-1").convertToDouble());
869 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0x0.p-1").convertToDouble());
870
871
872 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x.0p1").convertToDouble());
873 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0x.0p1").convertToDouble());
874 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0x.0p1").convertToDouble());
875
876 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x.0p+1").convertToDouble());
877 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0x.0p+1").convertToDouble());
878 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0x.0p+1").convertToDouble());
879
880 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x.0p-1").convertToDouble());
881 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0x.0p-1").convertToDouble());
882 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0x.0p-1").convertToDouble());
883
884
885 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x0.0p1").convertToDouble());
886 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0x0.0p1").convertToDouble());
887 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0x0.0p1").convertToDouble());
888
889 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x0.0p+1").convertToDouble());
890 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0x0.0p+1").convertToDouble());
891 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0x0.0p+1").convertToDouble());
892
893 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x0.0p-1").convertToDouble());
894 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0x0.0p-1").convertToDouble());
895 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0x0.0p-1").convertToDouble());
896
897
898 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x00000.p1").convertToDouble());
899 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x0000.00000p1").convertToDouble());
900 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x.00000p1").convertToDouble());
901 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x0.p1").convertToDouble());
902 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x0p1234").convertToDouble());
903 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0x0p1234").convertToDouble());
904 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x00000.p1234").convertToDouble());
905 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x0000.00000p1234").convertToDouble());
906 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x.00000p1234").convertToDouble());
907 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x0.p1234").convertToDouble());
908 }
909
910 TEST(APFloatTest, fromDecimalString) {
911 EXPECT_EQ(1.0, APFloat(APFloat::IEEEdouble(), "1").convertToDouble());
912 EXPECT_EQ(2.0, APFloat(APFloat::IEEEdouble(), "2.").convertToDouble());
913 EXPECT_EQ(0.5, APFloat(APFloat::IEEEdouble(), ".5").convertToDouble());
914 EXPECT_EQ(1.0, APFloat(APFloat::IEEEdouble(), "1.0").convertToDouble());
915 EXPECT_EQ(-2.0, APFloat(APFloat::IEEEdouble(), "-2").convertToDouble());
916 EXPECT_EQ(-4.0, APFloat(APFloat::IEEEdouble(), "-4.").convertToDouble());
917 EXPECT_EQ(-0.5, APFloat(APFloat::IEEEdouble(), "-.5").convertToDouble());
918 EXPECT_EQ(-1.5, APFloat(APFloat::IEEEdouble(), "-1.5").convertToDouble());
919 EXPECT_EQ(1.25e12, APFloat(APFloat::IEEEdouble(), "1.25e12").convertToDouble());
920 EXPECT_EQ(1.25e+12, APFloat(APFloat::IEEEdouble(), "1.25e+12").convertToDouble());
921 EXPECT_EQ(1.25e-12, APFloat(APFloat::IEEEdouble(), "1.25e-12").convertToDouble());
922 EXPECT_EQ(1024.0, APFloat(APFloat::IEEEdouble(), "1024.").convertToDouble());
923 EXPECT_EQ(1024.05, APFloat(APFloat::IEEEdouble(), "1024.05000").convertToDouble());
924 EXPECT_EQ(0.05, APFloat(APFloat::IEEEdouble(), ".05000").convertToDouble());
925 EXPECT_EQ(2.0, APFloat(APFloat::IEEEdouble(), "2.").convertToDouble());
926 EXPECT_EQ(2.0e2, APFloat(APFloat::IEEEdouble(), "2.e2").convertToDouble());
927 EXPECT_EQ(2.0e+2, APFloat(APFloat::IEEEdouble(), "2.e+2").convertToDouble());
928 EXPECT_EQ(2.0e-2, APFloat(APFloat::IEEEdouble(), "2.e-2").convertToDouble());
929 EXPECT_EQ(2.05e2, APFloat(APFloat::IEEEdouble(), "002.05000e2").convertToDouble());
930 EXPECT_EQ(2.05e+2, APFloat(APFloat::IEEEdouble(), "002.05000e+2").convertToDouble());
931 EXPECT_EQ(2.05e-2, APFloat(APFloat::IEEEdouble(), "002.05000e-2").convertToDouble());
932 EXPECT_EQ(2.05e12, APFloat(APFloat::IEEEdouble(), "002.05000e12").convertToDouble());
933 EXPECT_EQ(2.05e+12, APFloat(APFloat::IEEEdouble(), "002.05000e+12").convertToDouble());
934 EXPECT_EQ(2.05e-12, APFloat(APFloat::IEEEdouble(), "002.05000e-12").convertToDouble());
935
936 EXPECT_EQ(1.0, APFloat(APFloat::IEEEdouble(), "1e").convertToDouble());
937 EXPECT_EQ(1.0, APFloat(APFloat::IEEEdouble(), "+1e").convertToDouble());
938 EXPECT_EQ(-1.0, APFloat(APFloat::IEEEdouble(), "-1e").convertToDouble());
939
940 EXPECT_EQ(1.0, APFloat(APFloat::IEEEdouble(), "1.e").convertToDouble());
941 EXPECT_EQ(1.0, APFloat(APFloat::IEEEdouble(), "+1.e").convertToDouble());
942 EXPECT_EQ(-1.0, APFloat(APFloat::IEEEdouble(), "-1.e").convertToDouble());
943
944 EXPECT_EQ(0.1, APFloat(APFloat::IEEEdouble(), ".1e").convertToDouble());
945 EXPECT_EQ(0.1, APFloat(APFloat::IEEEdouble(), "+.1e").convertToDouble());
946 EXPECT_EQ(-0.1, APFloat(APFloat::IEEEdouble(), "-.1e").convertToDouble());
947
948 EXPECT_EQ(1.1, APFloat(APFloat::IEEEdouble(), "1.1e").convertToDouble());
949 EXPECT_EQ(1.1, APFloat(APFloat::IEEEdouble(), "+1.1e").convertToDouble());
950 EXPECT_EQ(-1.1, APFloat(APFloat::IEEEdouble(), "-1.1e").convertToDouble());
951
952 EXPECT_EQ(1.0, APFloat(APFloat::IEEEdouble(), "1e+").convertToDouble());
953 EXPECT_EQ(1.0, APFloat(APFloat::IEEEdouble(), "1e-").convertToDouble());
954
955 EXPECT_EQ(0.1, APFloat(APFloat::IEEEdouble(), ".1e").convertToDouble());
956 EXPECT_EQ(0.1, APFloat(APFloat::IEEEdouble(), ".1e+").convertToDouble());
957 EXPECT_EQ(0.1, APFloat(APFloat::IEEEdouble(), ".1e-").convertToDouble());
958
959 EXPECT_EQ(1.0, APFloat(APFloat::IEEEdouble(), "1.0e").convertToDouble());
960 EXPECT_EQ(1.0, APFloat(APFloat::IEEEdouble(), "1.0e+").convertToDouble());
961 EXPECT_EQ(1.0, APFloat(APFloat::IEEEdouble(), "1.0e-").convertToDouble());
962
963 // These are "carefully selected" to overflow the fast log-base
964 // calculations in APFloat.cpp
965 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "99e99999").isInfinity());
966 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "-99e99999").isInfinity());
967 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "1e-99999").isPosZero());
968 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "-1e-99999").isNegZero());
969
970 EXPECT_EQ(2.71828, convertToDoubleFromString("2.71828"));
971 }
972
973 TEST(APFloatTest, fromStringSpecials) {
974 const fltSemantics &Sem = APFloat::IEEEdouble();
975 const unsigned Precision = 53;
976 const unsigned PayloadBits = Precision - 2;
977 uint64_t PayloadMask = (uint64_t(1) << PayloadBits) - uint64_t(1);
978
979 uint64_t NaNPayloads[] = {
980 0,
981 1,
982 123,
983 0xDEADBEEF,
984 uint64_t(-2),
985 uint64_t(1) << PayloadBits, // overflow bit
986 uint64_t(1) << (PayloadBits - 1), // signaling bit
987 uint64_t(1) << (PayloadBits - 2) // highest possible bit
988 };
989
990 // Convert payload integer to decimal string representation.
991 std::string NaNPayloadDecStrings[std::size(NaNPayloads)];
992 for (size_t I = 0; I < std::size(NaNPayloads); ++I)
993 NaNPayloadDecStrings[I] = utostr(NaNPayloads[I]);
994
995 // Convert payload integer to hexadecimal string representation.
996 std::string NaNPayloadHexStrings[std::size(NaNPayloads)];
997 for (size_t I = 0; I < std::size(NaNPayloads); ++I)
998 NaNPayloadHexStrings[I] = "0x" + utohexstr(NaNPayloads[I]);
999
1000 // Fix payloads to expected result.
1001 for (uint64_t &Payload : NaNPayloads)
1002 Payload &= PayloadMask;
1003
1004 // Signaling NaN must have a non-zero payload. In case a zero payload is
1005 // requested, a default arbitrary payload is set instead. Save this payload
1006 // for testing.
1007 const uint64_t SNaNDefaultPayload =
1008 APFloat::getSNaN(Sem).bitcastToAPInt().getZExtValue() & PayloadMask;
1009
1010 // Negative sign prefix (or none - for positive).
1011 const char Signs[] = {0, '-'};
1012
1013 // "Signaling" prefix (or none - for "Quiet").
1014 const char NaNTypes[] = {0, 's', 'S'};
1015
1016 const StringRef NaNStrings[] = {"nan", "NaN"};
1017 for (StringRef NaNStr : NaNStrings)
1018 for (char TypeChar : NaNTypes) {
1019 bool Signaling = (TypeChar == 's' || TypeChar == 'S');
1020
1021 for (size_t J = 0; J < std::size(NaNPayloads); ++J) {
1022 uint64_t Payload = (Signaling && !NaNPayloads[J]) ? SNaNDefaultPayload
1023 : NaNPayloads[J];
1024 std::string &PayloadDec = NaNPayloadDecStrings[J];
1025 std::string &PayloadHex = NaNPayloadHexStrings[J];
1026
1027 for (char SignChar : Signs) {
1028 bool Negative = (SignChar == '-');
1029
1030 std::string TestStrings[5];
1031 size_t NumTestStrings = 0;
1032
1033 std::string Prefix;
1034 if (SignChar)
1035 Prefix += SignChar;
1036 if (TypeChar)
1037 Prefix += TypeChar;
1038 Prefix += NaNStr;
1039
1040 // Test without any paylod.
1041 if (!Payload)
1042 TestStrings[NumTestStrings++] = Prefix;
1043
1044 // Test with the payload as a suffix.
1045 TestStrings[NumTestStrings++] = Prefix + PayloadDec;
1046 TestStrings[NumTestStrings++] = Prefix + PayloadHex;
1047
1048 // Test with the payload inside parentheses.
1049 TestStrings[NumTestStrings++] = Prefix + '(' + PayloadDec + ')';
1050 TestStrings[NumTestStrings++] = Prefix + '(' + PayloadHex + ')';
1051
1052 for (size_t K = 0; K < NumTestStrings; ++K) {
1053 StringRef TestStr = TestStrings[K];
1054
1055 APFloat F(Sem);
1056 bool HasError = !F.convertFromString(
1057 TestStr, llvm::APFloat::rmNearestTiesToEven);
1058 EXPECT_FALSE(HasError);
1059 EXPECT_TRUE(F.isNaN());
1060 EXPECT_EQ(Signaling, F.isSignaling());
1061 EXPECT_EQ(Negative, F.isNegative());
1062 uint64_t PayloadResult =
1063 F.bitcastToAPInt().getZExtValue() & PayloadMask;
1064 EXPECT_EQ(Payload, PayloadResult);
1065 }
1066 }
1067 }
1068 }
1069
1070 const StringRef InfStrings[] = {"inf", "INFINITY", "+Inf",
1071 "-inf", "-INFINITY", "-Inf"};
1072 for (StringRef InfStr : InfStrings) {
1073 bool Negative = InfStr.front() == '-';
1074
1075 APFloat F(Sem);
1076 bool HasError =
1077 !F.convertFromString(InfStr, llvm::APFloat::rmNearestTiesToEven);
1078 EXPECT_FALSE(HasError);
1079 EXPECT_TRUE(F.isInfinity());
1080 EXPECT_EQ(Negative, F.isNegative());
1081 uint64_t PayloadResult = F.bitcastToAPInt().getZExtValue() & PayloadMask;
1082 EXPECT_EQ(UINT64_C(0), PayloadResult);
1083 }
1084 }
1085
1086 TEST(APFloatTest, fromToStringSpecials) {
1087 auto expects = [] (const char *first, const char *second) {
1088 std::string roundtrip = convertToString(convertToDoubleFromString(second), 0, 3);
1089 EXPECT_STREQ(first, roundtrip.c_str());
1090 };
1091 expects("+Inf", "+Inf");
1092 expects("+Inf", "INFINITY");
1093 expects("+Inf", "inf");
1094 expects("-Inf", "-Inf");
1095 expects("-Inf", "-INFINITY");
1096 expects("-Inf", "-inf");
1097 expects("NaN", "NaN");
1098 expects("NaN", "nan");
1099 expects("NaN", "-NaN");
1100 expects("NaN", "-nan");
1101 }
1102
1103 TEST(APFloatTest, fromHexadecimalString) {
1104 EXPECT_EQ( 1.0, APFloat(APFloat::IEEEdouble(), "0x1p0").convertToDouble());
1105 EXPECT_EQ(+1.0, APFloat(APFloat::IEEEdouble(), "+0x1p0").convertToDouble());
1106 EXPECT_EQ(-1.0, APFloat(APFloat::IEEEdouble(), "-0x1p0").convertToDouble());
1107
1108 EXPECT_EQ( 1.0, APFloat(APFloat::IEEEdouble(), "0x1p+0").convertToDouble());
1109 EXPECT_EQ(+1.0, APFloat(APFloat::IEEEdouble(), "+0x1p+0").convertToDouble());
1110 EXPECT_EQ(-1.0, APFloat(APFloat::IEEEdouble(), "-0x1p+0").convertToDouble());
1111
1112 EXPECT_EQ( 1.0, APFloat(APFloat::IEEEdouble(), "0x1p-0").convertToDouble());
1113 EXPECT_EQ(+1.0, APFloat(APFloat::IEEEdouble(), "+0x1p-0").convertToDouble());
1114 EXPECT_EQ(-1.0, APFloat(APFloat::IEEEdouble(), "-0x1p-0").convertToDouble());
1115
1116
1117 EXPECT_EQ( 2.0, APFloat(APFloat::IEEEdouble(), "0x1p1").convertToDouble());
1118 EXPECT_EQ(+2.0, APFloat(APFloat::IEEEdouble(), "+0x1p1").convertToDouble());
1119 EXPECT_EQ(-2.0, APFloat(APFloat::IEEEdouble(), "-0x1p1").convertToDouble());
1120
1121 EXPECT_EQ( 2.0, APFloat(APFloat::IEEEdouble(), "0x1p+1").convertToDouble());
1122 EXPECT_EQ(+2.0, APFloat(APFloat::IEEEdouble(), "+0x1p+1").convertToDouble());
1123 EXPECT_EQ(-2.0, APFloat(APFloat::IEEEdouble(), "-0x1p+1").convertToDouble());
1124
1125 EXPECT_EQ( 0.5, APFloat(APFloat::IEEEdouble(), "0x1p-1").convertToDouble());
1126 EXPECT_EQ(+0.5, APFloat(APFloat::IEEEdouble(), "+0x1p-1").convertToDouble());
1127 EXPECT_EQ(-0.5, APFloat(APFloat::IEEEdouble(), "-0x1p-1").convertToDouble());
1128
1129
1130 EXPECT_EQ( 3.0, APFloat(APFloat::IEEEdouble(), "0x1.8p1").convertToDouble());
1131 EXPECT_EQ(+3.0, APFloat(APFloat::IEEEdouble(), "+0x1.8p1").convertToDouble());
1132 EXPECT_EQ(-3.0, APFloat(APFloat::IEEEdouble(), "-0x1.8p1").convertToDouble());
1133
1134 EXPECT_EQ( 3.0, APFloat(APFloat::IEEEdouble(), "0x1.8p+1").convertToDouble());
1135 EXPECT_EQ(+3.0, APFloat(APFloat::IEEEdouble(), "+0x1.8p+1").convertToDouble());
1136 EXPECT_EQ(-3.0, APFloat(APFloat::IEEEdouble(), "-0x1.8p+1").convertToDouble());
1137
1138 EXPECT_EQ( 0.75, APFloat(APFloat::IEEEdouble(), "0x1.8p-1").convertToDouble());
1139 EXPECT_EQ(+0.75, APFloat(APFloat::IEEEdouble(), "+0x1.8p-1").convertToDouble());
1140 EXPECT_EQ(-0.75, APFloat(APFloat::IEEEdouble(), "-0x1.8p-1").convertToDouble());
1141
1142
1143 EXPECT_EQ( 8192.0, APFloat(APFloat::IEEEdouble(), "0x1000.000p1").convertToDouble());
1144 EXPECT_EQ(+8192.0, APFloat(APFloat::IEEEdouble(), "+0x1000.000p1").convertToDouble());
1145 EXPECT_EQ(-8192.0, APFloat(APFloat::IEEEdouble(), "-0x1000.000p1").convertToDouble());
1146
1147 EXPECT_EQ( 8192.0, APFloat(APFloat::IEEEdouble(), "0x1000.000p+1").convertToDouble());
1148 EXPECT_EQ(+8192.0, APFloat(APFloat::IEEEdouble(), "+0x1000.000p+1").convertToDouble());
1149 EXPECT_EQ(-8192.0, APFloat(APFloat::IEEEdouble(), "-0x1000.000p+1").convertToDouble());
1150
1151 EXPECT_EQ( 2048.0, APFloat(APFloat::IEEEdouble(), "0x1000.000p-1").convertToDouble());
1152 EXPECT_EQ(+2048.0, APFloat(APFloat::IEEEdouble(), "+0x1000.000p-1").convertToDouble());
1153 EXPECT_EQ(-2048.0, APFloat(APFloat::IEEEdouble(), "-0x1000.000p-1").convertToDouble());
1154
1155
1156 EXPECT_EQ( 8192.0, APFloat(APFloat::IEEEdouble(), "0x1000p1").convertToDouble());
1157 EXPECT_EQ(+8192.0, APFloat(APFloat::IEEEdouble(), "+0x1000p1").convertToDouble());
1158 EXPECT_EQ(-8192.0, APFloat(APFloat::IEEEdouble(), "-0x1000p1").convertToDouble());
1159
1160 EXPECT_EQ( 8192.0, APFloat(APFloat::IEEEdouble(), "0x1000p+1").convertToDouble());
1161 EXPECT_EQ(+8192.0, APFloat(APFloat::IEEEdouble(), "+0x1000p+1").convertToDouble());
1162 EXPECT_EQ(-8192.0, APFloat(APFloat::IEEEdouble(), "-0x1000p+1").convertToDouble());
1163
1164 EXPECT_EQ( 2048.0, APFloat(APFloat::IEEEdouble(), "0x1000p-1").convertToDouble());
1165 EXPECT_EQ(+2048.0, APFloat(APFloat::IEEEdouble(), "+0x1000p-1").convertToDouble());
1166 EXPECT_EQ(-2048.0, APFloat(APFloat::IEEEdouble(), "-0x1000p-1").convertToDouble());
1167
1168
1169 EXPECT_EQ( 16384.0, APFloat(APFloat::IEEEdouble(), "0x10p10").convertToDouble());
1170 EXPECT_EQ(+16384.0, APFloat(APFloat::IEEEdouble(), "+0x10p10").convertToDouble());
1171 EXPECT_EQ(-16384.0, APFloat(APFloat::IEEEdouble(), "-0x10p10").convertToDouble());
1172
1173 EXPECT_EQ( 16384.0, APFloat(APFloat::IEEEdouble(), "0x10p+10").convertToDouble());
1174 EXPECT_EQ(+16384.0, APFloat(APFloat::IEEEdouble(), "+0x10p+10").convertToDouble());
1175 EXPECT_EQ(-16384.0, APFloat(APFloat::IEEEdouble(), "-0x10p+10").convertToDouble());
1176
1177 EXPECT_EQ( 0.015625, APFloat(APFloat::IEEEdouble(), "0x10p-10").convertToDouble());
1178 EXPECT_EQ(+0.015625, APFloat(APFloat::IEEEdouble(), "+0x10p-10").convertToDouble());
1179 EXPECT_EQ(-0.015625, APFloat(APFloat::IEEEdouble(), "-0x10p-10").convertToDouble());
1180
1181 EXPECT_EQ(1.0625, APFloat(APFloat::IEEEdouble(), "0x1.1p0").convertToDouble());
1182 EXPECT_EQ(1.0, APFloat(APFloat::IEEEdouble(), "0x1p0").convertToDouble());
1183
1184 EXPECT_EQ(convertToDoubleFromString("0x1p-150"),
1185 convertToDoubleFromString("+0x800000000000000001.p-221"));
1186 EXPECT_EQ(2251799813685248.5,
1187 convertToDoubleFromString("0x80000000000004000000.010p-28"));
1188 }
1189
1190 TEST(APFloatTest, toString) {
1191 ASSERT_EQ("10", convertToString(10.0, 6, 3));
1192 ASSERT_EQ("1.0E+1", convertToString(10.0, 6, 0));
1193 ASSERT_EQ("10100", convertToString(1.01E+4, 5, 2));
1194 ASSERT_EQ("1.01E+4", convertToString(1.01E+4, 4, 2));
1195 ASSERT_EQ("1.01E+4", convertToString(1.01E+4, 5, 1));
1196 ASSERT_EQ("0.0101", convertToString(1.01E-2, 5, 2));
1197 ASSERT_EQ("0.0101", convertToString(1.01E-2, 4, 2));
1198 ASSERT_EQ("1.01E-2", convertToString(1.01E-2, 5, 1));
1199 ASSERT_EQ("0.78539816339744828", convertToString(0.78539816339744830961, 0, 3));
1200 ASSERT_EQ("4.9406564584124654E-324", convertToString(4.9406564584124654e-324, 0, 3));
1201 ASSERT_EQ("873.18340000000001", convertToString(873.1834, 0, 1));
1202 ASSERT_EQ("8.7318340000000001E+2", convertToString(873.1834, 0, 0));
1203 ASSERT_EQ("1.7976931348623157E+308", convertToString(1.7976931348623157E+308, 0, 0));
1204 ASSERT_EQ("10", convertToString(10.0, 6, 3, false));
1205 ASSERT_EQ("1.000000e+01", convertToString(10.0, 6, 0, false));
1206 ASSERT_EQ("10100", convertToString(1.01E+4, 5, 2, false));
1207 ASSERT_EQ("1.0100e+04", convertToString(1.01E+4, 4, 2, false));
1208 ASSERT_EQ("1.01000e+04", convertToString(1.01E+4, 5, 1, false));
1209 ASSERT_EQ("0.0101", convertToString(1.01E-2, 5, 2, false));
1210 ASSERT_EQ("0.0101", convertToString(1.01E-2, 4, 2, false));
1211 ASSERT_EQ("1.01000e-02", convertToString(1.01E-2, 5, 1, false));
1212 ASSERT_EQ("0.78539816339744828",
1213 convertToString(0.78539816339744830961, 0, 3, false));
1214 ASSERT_EQ("4.94065645841246540e-324",
1215 convertToString(4.9406564584124654e-324, 0, 3, false));
1216 ASSERT_EQ("873.18340000000001", convertToString(873.1834, 0, 1, false));
1217 ASSERT_EQ("8.73183400000000010e+02", convertToString(873.1834, 0, 0, false));
1218 ASSERT_EQ("1.79769313486231570e+308",
1219 convertToString(1.7976931348623157E+308, 0, 0, false));
1220
1221 {
1222 SmallString<64> Str;
1223 APFloat UnnormalZero(APFloat::x87DoubleExtended(), APInt(80, {0, 1}));
1224 UnnormalZero.toString(Str);
1225 ASSERT_EQ("NaN", Str);
1226 }
1227 }
1228
1229 TEST(APFloatTest, toInteger) {
1230 bool isExact = false;
1231 APSInt result(5, /*isUnsigned=*/true);
1232
1233 EXPECT_EQ(APFloat::opOK,
1234 APFloat(APFloat::IEEEdouble(), "10")
1235 .convertToInteger(result, APFloat::rmTowardZero, &isExact));
1236 EXPECT_TRUE(isExact);
1237 EXPECT_EQ(APSInt(APInt(5, 10), true), result);
1238
1239 EXPECT_EQ(APFloat::opInvalidOp,
1240 APFloat(APFloat::IEEEdouble(), "-10")
1241 .convertToInteger(result, APFloat::rmTowardZero, &isExact));
1242 EXPECT_FALSE(isExact);
1243 EXPECT_EQ(APSInt::getMinValue(5, true), result);
1244
1245 EXPECT_EQ(APFloat::opInvalidOp,
1246 APFloat(APFloat::IEEEdouble(), "32")
1247 .convertToInteger(result, APFloat::rmTowardZero, &isExact));
1248 EXPECT_FALSE(isExact);
1249 EXPECT_EQ(APSInt::getMaxValue(5, true), result);
1250
1251 EXPECT_EQ(APFloat::opInexact,
1252 APFloat(APFloat::IEEEdouble(), "7.9")
1253 .convertToInteger(result, APFloat::rmTowardZero, &isExact));
1254 EXPECT_FALSE(isExact);
1255 EXPECT_EQ(APSInt(APInt(5, 7), true), result);
1256
1257 result.setIsUnsigned(false);
1258 EXPECT_EQ(APFloat::opOK,
1259 APFloat(APFloat::IEEEdouble(), "-10")
1260 .convertToInteger(result, APFloat::rmTowardZero, &isExact));
1261 EXPECT_TRUE(isExact);
1262 EXPECT_EQ(APSInt(APInt(5, -10, true), false), result);
1263
1264 EXPECT_EQ(APFloat::opInvalidOp,
1265 APFloat(APFloat::IEEEdouble(), "-17")
1266 .convertToInteger(result, APFloat::rmTowardZero, &isExact));
1267 EXPECT_FALSE(isExact);
1268 EXPECT_EQ(APSInt::getMinValue(5, false), result);
1269
1270 EXPECT_EQ(APFloat::opInvalidOp,
1271 APFloat(APFloat::IEEEdouble(), "16")
1272 .convertToInteger(result, APFloat::rmTowardZero, &isExact));
1273 EXPECT_FALSE(isExact);
1274 EXPECT_EQ(APSInt::getMaxValue(5, false), result);
1275 }
1276
1277 static APInt nanbitsFromAPInt(const fltSemantics &Sem, bool SNaN, bool Negative,
1278 uint64_t payload) {
1279 APInt appayload(64, payload);
1280 if (SNaN)
1281 return APFloat::getSNaN(Sem, Negative, &appayload).bitcastToAPInt();
1282 else
1283 return APFloat::getQNaN(Sem, Negative, &appayload).bitcastToAPInt();
1284 }
1285
1286 TEST(APFloatTest, makeNaN) {
1287 const struct {
1288 uint64_t expected;
1289 const fltSemantics &semantics;
1290 bool SNaN;
1291 bool Negative;
1292 uint64_t payload;
1293 } tests[] = {
1294 /* expected semantics SNaN Neg payload */
1295 { 0x7fc00000ULL, APFloat::IEEEsingle(), false, false, 0x00000000ULL },
1296 { 0xffc00000ULL, APFloat::IEEEsingle(), false, true, 0x00000000ULL },
1297 { 0x7fc0ae72ULL, APFloat::IEEEsingle(), false, false, 0x0000ae72ULL },
1298 { 0x7fffae72ULL, APFloat::IEEEsingle(), false, false, 0xffffae72ULL },
1299 { 0x7fdaae72ULL, APFloat::IEEEsingle(), false, false, 0x00daae72ULL },
1300 { 0x7fa00000ULL, APFloat::IEEEsingle(), true, false, 0x00000000ULL },
1301 { 0xffa00000ULL, APFloat::IEEEsingle(), true, true, 0x00000000ULL },
1302 { 0x7f80ae72ULL, APFloat::IEEEsingle(), true, false, 0x0000ae72ULL },
1303 { 0x7fbfae72ULL, APFloat::IEEEsingle(), true, false, 0xffffae72ULL },
1304 { 0x7f9aae72ULL, APFloat::IEEEsingle(), true, false, 0x001aae72ULL },
1305 { 0x7ff8000000000000ULL, APFloat::IEEEdouble(), false, false, 0x0000000000000000ULL },
1306 { 0xfff8000000000000ULL, APFloat::IEEEdouble(), false, true, 0x0000000000000000ULL },
1307 { 0x7ff800000000ae72ULL, APFloat::IEEEdouble(), false, false, 0x000000000000ae72ULL },
1308 { 0x7fffffffffffae72ULL, APFloat::IEEEdouble(), false, false, 0xffffffffffffae72ULL },
1309 { 0x7ffdaaaaaaaaae72ULL, APFloat::IEEEdouble(), false, false, 0x000daaaaaaaaae72ULL },
1310 { 0x7ff4000000000000ULL, APFloat::IEEEdouble(), true, false, 0x0000000000000000ULL },
1311 { 0xfff4000000000000ULL, APFloat::IEEEdouble(), true, true, 0x0000000000000000ULL },
1312 { 0x7ff000000000ae72ULL, APFloat::IEEEdouble(), true, false, 0x000000000000ae72ULL },
1313 { 0x7ff7ffffffffae72ULL, APFloat::IEEEdouble(), true, false, 0xffffffffffffae72ULL },
1314 { 0x7ff1aaaaaaaaae72ULL, APFloat::IEEEdouble(), true, false, 0x0001aaaaaaaaae72ULL },
1315 };
1316
1317 for (const auto &t : tests) {
1318 ASSERT_EQ(t.expected, nanbitsFromAPInt(t.semantics, t.SNaN, t.Negative, t.payload));
1319 }
1320 }
1321
1322 #ifdef GTEST_HAS_DEATH_TEST
1323 #ifndef NDEBUG
1324 TEST(APFloatTest, SemanticsDeath) {
1325 EXPECT_DEATH(APFloat(APFloat::IEEEquad(), 0).convertToDouble(),
1326 "Float semantics is not representable by IEEEdouble");
1327 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), 0).convertToFloat(),
1328 "Float semantics is not representable by IEEEsingle");
1329 }
1330 #endif
1331 #endif
1332
1333 TEST(APFloatTest, StringDecimalError) {
1334 EXPECT_EQ("Invalid string length", convertToErrorFromString(""));
1335 EXPECT_EQ("String has no digits", convertToErrorFromString("+"));
1336 EXPECT_EQ("String has no digits", convertToErrorFromString("-"));
1337
1338 EXPECT_EQ("Invalid character in significand", convertToErrorFromString(StringRef("\0", 1)));
1339 EXPECT_EQ("Invalid character in significand", convertToErrorFromString(StringRef("1\0", 2)));
1340 EXPECT_EQ("Invalid character in significand", convertToErrorFromString(StringRef("1" "\0" "2", 3)));
1341 EXPECT_EQ("Invalid character in significand", convertToErrorFromString(StringRef("1" "\0" "2e1", 5)));
1342 EXPECT_EQ("Invalid character in exponent", convertToErrorFromString(StringRef("1e\0", 3)));
1343 EXPECT_EQ("Invalid character in exponent", convertToErrorFromString(StringRef("1e1\0", 4)));
1344 EXPECT_EQ("Invalid character in exponent", convertToErrorFromString(StringRef("1e1" "\0" "2", 5)));
1345
1346 EXPECT_EQ("Invalid character in significand", convertToErrorFromString("1.0f"));
1347
1348 EXPECT_EQ("String contains multiple dots", convertToErrorFromString(".."));
1349 EXPECT_EQ("String contains multiple dots", convertToErrorFromString("..0"));
1350 EXPECT_EQ("String contains multiple dots", convertToErrorFromString("1.0.0"));
1351 }
1352
1353 TEST(APFloatTest, StringDecimalSignificandError) {
1354 EXPECT_EQ("Significand has no digits", convertToErrorFromString( "."));
1355 EXPECT_EQ("Significand has no digits", convertToErrorFromString("+."));
1356 EXPECT_EQ("Significand has no digits", convertToErrorFromString("-."));
1357
1358
1359 EXPECT_EQ("Significand has no digits", convertToErrorFromString( "e"));
1360 EXPECT_EQ("Significand has no digits", convertToErrorFromString("+e"));
1361 EXPECT_EQ("Significand has no digits", convertToErrorFromString("-e"));
1362
1363 EXPECT_EQ("Significand has no digits", convertToErrorFromString( "e1"));
1364 EXPECT_EQ("Significand has no digits", convertToErrorFromString("+e1"));
1365 EXPECT_EQ("Significand has no digits", convertToErrorFromString("-e1"));
1366
1367 EXPECT_EQ("Significand has no digits", convertToErrorFromString( ".e1"));
1368 EXPECT_EQ("Significand has no digits", convertToErrorFromString("+.e1"));
1369 EXPECT_EQ("Significand has no digits", convertToErrorFromString("-.e1"));
1370
1371
1372 EXPECT_EQ("Significand has no digits", convertToErrorFromString( ".e"));
1373 EXPECT_EQ("Significand has no digits", convertToErrorFromString("+.e"));
1374 EXPECT_EQ("Significand has no digits", convertToErrorFromString("-.e"));
1375 }
1376
1377 TEST(APFloatTest, StringHexadecimalError) {
1378 EXPECT_EQ("Invalid string", convertToErrorFromString( "0x"));
1379 EXPECT_EQ("Invalid string", convertToErrorFromString("+0x"));
1380 EXPECT_EQ("Invalid string", convertToErrorFromString("-0x"));
1381
1382 EXPECT_EQ("Hex strings require an exponent", convertToErrorFromString( "0x0"));
1383 EXPECT_EQ("Hex strings require an exponent", convertToErrorFromString("+0x0"));
1384 EXPECT_EQ("Hex strings require an exponent", convertToErrorFromString("-0x0"));
1385
1386 EXPECT_EQ("Hex strings require an exponent", convertToErrorFromString( "0x0."));
1387 EXPECT_EQ("Hex strings require an exponent", convertToErrorFromString("+0x0."));
1388 EXPECT_EQ("Hex strings require an exponent", convertToErrorFromString("-0x0."));
1389
1390 EXPECT_EQ("Hex strings require an exponent", convertToErrorFromString( "0x.0"));
1391 EXPECT_EQ("Hex strings require an exponent", convertToErrorFromString("+0x.0"));
1392 EXPECT_EQ("Hex strings require an exponent", convertToErrorFromString("-0x.0"));
1393
1394 EXPECT_EQ("Hex strings require an exponent", convertToErrorFromString( "0x0.0"));
1395 EXPECT_EQ("Hex strings require an exponent", convertToErrorFromString("+0x0.0"));
1396 EXPECT_EQ("Hex strings require an exponent", convertToErrorFromString("-0x0.0"));
1397
1398 EXPECT_EQ("Invalid character in significand", convertToErrorFromString(StringRef("0x\0", 3)));
1399 EXPECT_EQ("Invalid character in significand", convertToErrorFromString(StringRef("0x1\0", 4)));
1400 EXPECT_EQ("Invalid character in significand", convertToErrorFromString(StringRef("0x1" "\0" "2", 5)));
1401 EXPECT_EQ("Invalid character in significand", convertToErrorFromString(StringRef("0x1" "\0" "2p1", 7)));
1402 EXPECT_EQ("Invalid character in exponent", convertToErrorFromString(StringRef("0x1p\0", 5)));
1403 EXPECT_EQ("Invalid character in exponent", convertToErrorFromString(StringRef("0x1p1\0", 6)));
1404 EXPECT_EQ("Invalid character in exponent", convertToErrorFromString(StringRef("0x1p1" "\0" "2", 7)));
1405
1406 EXPECT_EQ("Invalid character in exponent", convertToErrorFromString("0x1p0f"));
1407
1408 EXPECT_EQ("String contains multiple dots", convertToErrorFromString("0x..p1"));
1409 EXPECT_EQ("String contains multiple dots", convertToErrorFromString("0x..0p1"));
1410 EXPECT_EQ("String contains multiple dots", convertToErrorFromString("0x1.0.0p1"));
1411 }
1412
1413 TEST(APFloatTest, StringHexadecimalSignificandError) {
1414 EXPECT_EQ("Significand has no digits", convertToErrorFromString( "0x."));
1415 EXPECT_EQ("Significand has no digits", convertToErrorFromString("+0x."));
1416 EXPECT_EQ("Significand has no digits", convertToErrorFromString("-0x."));
1417
1418 EXPECT_EQ("Significand has no digits", convertToErrorFromString( "0xp"));
1419 EXPECT_EQ("Significand has no digits", convertToErrorFromString("+0xp"));
1420 EXPECT_EQ("Significand has no digits", convertToErrorFromString("-0xp"));
1421
1422 EXPECT_EQ("Significand has no digits", convertToErrorFromString( "0xp+"));
1423 EXPECT_EQ("Significand has no digits", convertToErrorFromString("+0xp+"));
1424 EXPECT_EQ("Significand has no digits", convertToErrorFromString("-0xp+"));
1425
1426 EXPECT_EQ("Significand has no digits", convertToErrorFromString( "0xp-"));
1427 EXPECT_EQ("Significand has no digits", convertToErrorFromString("+0xp-"));
1428 EXPECT_EQ("Significand has no digits", convertToErrorFromString("-0xp-"));
1429
1430
1431 EXPECT_EQ("Significand has no digits", convertToErrorFromString( "0x.p"));
1432 EXPECT_EQ("Significand has no digits", convertToErrorFromString("+0x.p"));
1433 EXPECT_EQ("Significand has no digits", convertToErrorFromString("-0x.p"));
1434
1435 EXPECT_EQ("Significand has no digits", convertToErrorFromString( "0x.p+"));
1436 EXPECT_EQ("Significand has no digits", convertToErrorFromString("+0x.p+"));
1437 EXPECT_EQ("Significand has no digits", convertToErrorFromString("-0x.p+"));
1438
1439 EXPECT_EQ("Significand has no digits", convertToErrorFromString( "0x.p-"));
1440 EXPECT_EQ("Significand has no digits", convertToErrorFromString("+0x.p-"));
1441 EXPECT_EQ("Significand has no digits", convertToErrorFromString("-0x.p-"));
1442 }
1443
1444 TEST(APFloatTest, StringHexadecimalExponentError) {
1445 EXPECT_EQ("Exponent has no digits", convertToErrorFromString( "0x1p"));
1446 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("+0x1p"));
1447 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("-0x1p"));
1448
1449 EXPECT_EQ("Exponent has no digits", convertToErrorFromString( "0x1p+"));
1450 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("+0x1p+"));
1451 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("-0x1p+"));
1452
1453 EXPECT_EQ("Exponent has no digits", convertToErrorFromString( "0x1p-"));
1454 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("+0x1p-"));
1455 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("-0x1p-"));
1456
1457
1458 EXPECT_EQ("Exponent has no digits", convertToErrorFromString( "0x1.p"));
1459 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("+0x1.p"));
1460 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("-0x1.p"));
1461
1462 EXPECT_EQ("Exponent has no digits", convertToErrorFromString( "0x1.p+"));
1463 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("+0x1.p+"));
1464 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("-0x1.p+"));
1465
1466 EXPECT_EQ("Exponent has no digits", convertToErrorFromString( "0x1.p-"));
1467 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("+0x1.p-"));
1468 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("-0x1.p-"));
1469
1470
1471 EXPECT_EQ("Exponent has no digits", convertToErrorFromString( "0x.1p"));
1472 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("+0x.1p"));
1473 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("-0x.1p"));
1474
1475 EXPECT_EQ("Exponent has no digits", convertToErrorFromString( "0x.1p+"));
1476 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("+0x.1p+"));
1477 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("-0x.1p+"));
1478
1479 EXPECT_EQ("Exponent has no digits", convertToErrorFromString( "0x.1p-"));
1480 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("+0x.1p-"));
1481 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("-0x.1p-"));
1482
1483
1484 EXPECT_EQ("Exponent has no digits", convertToErrorFromString( "0x1.1p"));
1485 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("+0x1.1p"));
1486 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("-0x1.1p"));
1487
1488 EXPECT_EQ("Exponent has no digits", convertToErrorFromString( "0x1.1p+"));
1489 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("+0x1.1p+"));
1490 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("-0x1.1p+"));
1491
1492 EXPECT_EQ("Exponent has no digits", convertToErrorFromString( "0x1.1p-"));
1493 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("+0x1.1p-"));
1494 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("-0x1.1p-"));
1495 }
1496
1497 TEST(APFloatTest, exactInverse) {
1498 APFloat inv(0.0f);
1499
1500 // Trivial operation.
1501 EXPECT_TRUE(APFloat(2.0).getExactInverse(&inv));
1502 EXPECT_TRUE(inv.bitwiseIsEqual(APFloat(0.5)));
1503 EXPECT_TRUE(APFloat(2.0f).getExactInverse(&inv));
1504 EXPECT_TRUE(inv.bitwiseIsEqual(APFloat(0.5f)));
1505 EXPECT_TRUE(APFloat(APFloat::IEEEquad(), "2.0").getExactInverse(&inv));
1506 EXPECT_TRUE(inv.bitwiseIsEqual(APFloat(APFloat::IEEEquad(), "0.5")));
1507 EXPECT_TRUE(APFloat(APFloat::PPCDoubleDouble(), "2.0").getExactInverse(&inv));
1508 EXPECT_TRUE(inv.bitwiseIsEqual(APFloat(APFloat::PPCDoubleDouble(), "0.5")));
1509 EXPECT_TRUE(APFloat(APFloat::x87DoubleExtended(), "2.0").getExactInverse(&inv));
1510 EXPECT_TRUE(inv.bitwiseIsEqual(APFloat(APFloat::x87DoubleExtended(), "0.5")));
1511
1512 // FLT_MIN
1513 EXPECT_TRUE(APFloat(1.17549435e-38f).getExactInverse(&inv));
1514 EXPECT_TRUE(inv.bitwiseIsEqual(APFloat(8.5070592e+37f)));
1515
1516 // Large float, inverse is a denormal.
1517 EXPECT_FALSE(APFloat(1.7014118e38f).getExactInverse(nullptr));
1518 // Zero
1519 EXPECT_FALSE(APFloat(0.0).getExactInverse(nullptr));
1520 // Denormalized float
1521 EXPECT_FALSE(APFloat(1.40129846e-45f).getExactInverse(nullptr));
1522 }
1523
1524 TEST(APFloatTest, roundToIntegral) {
1525 APFloat T(-0.5), S(3.14), R(APFloat::getLargest(APFloat::IEEEdouble())), P(0.0);
1526
1527 P = T;
1528 P.roundToIntegral(APFloat::rmTowardZero);
1529 EXPECT_EQ(-0.0, P.convertToDouble());
1530 P = T;
1531 P.roundToIntegral(APFloat::rmTowardNegative);
1532 EXPECT_EQ(-1.0, P.convertToDouble());
1533 P = T;
1534 P.roundToIntegral(APFloat::rmTowardPositive);
1535 EXPECT_EQ(-0.0, P.convertToDouble());
1536 P = T;
1537 P.roundToIntegral(APFloat::rmNearestTiesToEven);
1538 EXPECT_EQ(-0.0, P.convertToDouble());
1539
1540 P = S;
1541 P.roundToIntegral(APFloat::rmTowardZero);
1542 EXPECT_EQ(3.0, P.convertToDouble());
1543 P = S;
1544 P.roundToIntegral(APFloat::rmTowardNegative);
1545 EXPECT_EQ(3.0, P.convertToDouble());
1546 P = S;
1547 P.roundToIntegral(APFloat::rmTowardPositive);
1548 EXPECT_EQ(4.0, P.convertToDouble());
1549 P = S;
1550 P.roundToIntegral(APFloat::rmNearestTiesToEven);
1551 EXPECT_EQ(3.0, P.convertToDouble());
1552
1553 P = R;
1554 P.roundToIntegral(APFloat::rmTowardZero);
1555 EXPECT_EQ(R.convertToDouble(), P.convertToDouble());
1556 P = R;
1557 P.roundToIntegral(APFloat::rmTowardNegative);
1558 EXPECT_EQ(R.convertToDouble(), P.convertToDouble());
1559 P = R;
1560 P.roundToIntegral(APFloat::rmTowardPositive);
1561 EXPECT_EQ(R.convertToDouble(), P.convertToDouble());
1562 P = R;
1563 P.roundToIntegral(APFloat::rmNearestTiesToEven);
1564 EXPECT_EQ(R.convertToDouble(), P.convertToDouble());
1565
1566 P = APFloat::getZero(APFloat::IEEEdouble());
1567 P.roundToIntegral(APFloat::rmTowardZero);
1568 EXPECT_EQ(0.0, P.convertToDouble());
1569 P = APFloat::getZero(APFloat::IEEEdouble(), true);
1570 P.roundToIntegral(APFloat::rmTowardZero);
1571 EXPECT_EQ(-0.0, P.convertToDouble());
1572 P = APFloat::getNaN(APFloat::IEEEdouble());
1573 P.roundToIntegral(APFloat::rmTowardZero);
1574 EXPECT_TRUE(std::isnan(P.convertToDouble()));
1575 P = APFloat::getInf(APFloat::IEEEdouble());
1576 P.roundToIntegral(APFloat::rmTowardZero);
1577 EXPECT_TRUE(std::isinf(P.convertToDouble()) && P.convertToDouble() > 0.0);
1578 P = APFloat::getInf(APFloat::IEEEdouble(), true);
1579 P.roundToIntegral(APFloat::rmTowardZero);
1580 EXPECT_TRUE(std::isinf(P.convertToDouble()) && P.convertToDouble() < 0.0);
1581
1582 APFloat::opStatus St;
1583
1584 P = APFloat::getNaN(APFloat::IEEEdouble());
1585 St = P.roundToIntegral(APFloat::rmTowardZero);
1586 EXPECT_TRUE(P.isNaN());
1587 EXPECT_FALSE(P.isNegative());
1588 EXPECT_EQ(APFloat::opOK, St);
1589
1590 P = APFloat::getNaN(APFloat::IEEEdouble(), true);
1591 St = P.roundToIntegral(APFloat::rmTowardZero);
1592 EXPECT_TRUE(P.isNaN());
1593 EXPECT_TRUE(P.isNegative());
1594 EXPECT_EQ(APFloat::opOK, St);
1595
1596 P = APFloat::getSNaN(APFloat::IEEEdouble());
1597 St = P.roundToIntegral(APFloat::rmTowardZero);
1598 EXPECT_TRUE(P.isNaN());
1599 EXPECT_FALSE(P.isSignaling());
1600 EXPECT_FALSE(P.isNegative());
1601 EXPECT_EQ(APFloat::opInvalidOp, St);
1602
1603 P = APFloat::getSNaN(APFloat::IEEEdouble(), true);
1604 St = P.roundToIntegral(APFloat::rmTowardZero);
1605 EXPECT_TRUE(P.isNaN());
1606 EXPECT_FALSE(P.isSignaling());
1607 EXPECT_TRUE(P.isNegative());
1608 EXPECT_EQ(APFloat::opInvalidOp, St);
1609
1610 P = APFloat::getInf(APFloat::IEEEdouble());
1611 St = P.roundToIntegral(APFloat::rmTowardZero);
1612 EXPECT_TRUE(P.isInfinity());
1613 EXPECT_FALSE(P.isNegative());
1614 EXPECT_EQ(APFloat::opOK, St);
1615
1616 P = APFloat::getInf(APFloat::IEEEdouble(), true);
1617 St = P.roundToIntegral(APFloat::rmTowardZero);
1618 EXPECT_TRUE(P.isInfinity());
1619 EXPECT_TRUE(P.isNegative());
1620 EXPECT_EQ(APFloat::opOK, St);
1621
1622 P = APFloat::getZero(APFloat::IEEEdouble(), false);
1623 St = P.roundToIntegral(APFloat::rmTowardZero);
1624 EXPECT_TRUE(P.isZero());
1625 EXPECT_FALSE(P.isNegative());
1626 EXPECT_EQ(APFloat::opOK, St);
1627
1628 P = APFloat::getZero(APFloat::IEEEdouble(), false);
1629 St = P.roundToIntegral(APFloat::rmTowardNegative);
1630 EXPECT_TRUE(P.isZero());
1631 EXPECT_FALSE(P.isNegative());
1632 EXPECT_EQ(APFloat::opOK, St);
1633
1634 P = APFloat::getZero(APFloat::IEEEdouble(), true);
1635 St = P.roundToIntegral(APFloat::rmTowardZero);
1636 EXPECT_TRUE(P.isZero());
1637 EXPECT_TRUE(P.isNegative());
1638 EXPECT_EQ(APFloat::opOK, St);
1639
1640 P = APFloat::getZero(APFloat::IEEEdouble(), true);
1641 St = P.roundToIntegral(APFloat::rmTowardNegative);
1642 EXPECT_TRUE(P.isZero());
1643 EXPECT_TRUE(P.isNegative());
1644 EXPECT_EQ(APFloat::opOK, St);
1645
1646 P = APFloat(1E-100);
1647 St = P.roundToIntegral(APFloat::rmTowardNegative);
1648 EXPECT_TRUE(P.isZero());
1649 EXPECT_FALSE(P.isNegative());
1650 EXPECT_EQ(APFloat::opInexact, St);
1651
1652 P = APFloat(1E-100);
1653 St = P.roundToIntegral(APFloat::rmTowardPositive);
1654 EXPECT_EQ(1.0, P.convertToDouble());
1655 EXPECT_FALSE(P.isNegative());
1656 EXPECT_EQ(APFloat::opInexact, St);
1657
1658 P = APFloat(-1E-100);
1659 St = P.roundToIntegral(APFloat::rmTowardNegative);
1660 EXPECT_TRUE(P.isNegative());
1661 EXPECT_EQ(-1.0, P.convertToDouble());
1662 EXPECT_EQ(APFloat::opInexact, St);
1663
1664 P = APFloat(-1E-100);
1665 St = P.roundToIntegral(APFloat::rmTowardPositive);
1666 EXPECT_TRUE(P.isZero());
1667 EXPECT_TRUE(P.isNegative());
1668 EXPECT_EQ(APFloat::opInexact, St);
1669
1670 P = APFloat(10.0);
1671 St = P.roundToIntegral(APFloat::rmTowardZero);
1672 EXPECT_EQ(10.0, P.convertToDouble());
1673 EXPECT_EQ(APFloat::opOK, St);
1674
1675 P = APFloat(10.5);
1676 St = P.roundToIntegral(APFloat::rmTowardZero);
1677 EXPECT_EQ(10.0, P.convertToDouble());
1678 EXPECT_EQ(APFloat::opInexact, St);
1679
1680 P = APFloat(10.5);
1681 St = P.roundToIntegral(APFloat::rmTowardPositive);
1682 EXPECT_EQ(11.0, P.convertToDouble());
1683 EXPECT_EQ(APFloat::opInexact, St);
1684
1685 P = APFloat(10.5);
1686 St = P.roundToIntegral(APFloat::rmTowardNegative);
1687 EXPECT_EQ(10.0, P.convertToDouble());
1688 EXPECT_EQ(APFloat::opInexact, St);
1689
1690 P = APFloat(10.5);
1691 St = P.roundToIntegral(APFloat::rmNearestTiesToAway);
1692 EXPECT_EQ(11.0, P.convertToDouble());
1693 EXPECT_EQ(APFloat::opInexact, St);
1694
1695 P = APFloat(10.5);
1696 St = P.roundToIntegral(APFloat::rmNearestTiesToEven);
1697 EXPECT_EQ(10.0, P.convertToDouble());
1698 EXPECT_EQ(APFloat::opInexact, St);
1699 }
1700
1701 TEST(APFloatTest, isInteger) {
1702 APFloat T(-0.0);
1703 EXPECT_TRUE(T.isInteger());
1704 T = APFloat(3.14159);
1705 EXPECT_FALSE(T.isInteger());
1706 T = APFloat::getNaN(APFloat::IEEEdouble());
1707 EXPECT_FALSE(T.isInteger());
1708 T = APFloat::getInf(APFloat::IEEEdouble());
1709 EXPECT_FALSE(T.isInteger());
1710 T = APFloat::getInf(APFloat::IEEEdouble(), true);
1711 EXPECT_FALSE(T.isInteger());
1712 T = APFloat::getLargest(APFloat::IEEEdouble());
1713 EXPECT_TRUE(T.isInteger());
1714 }
1715
1716 TEST(DoubleAPFloatTest, isInteger) {
1717 APFloat F1(-0.0);
1718 APFloat F2(-0.0);
1719 llvm::detail::DoubleAPFloat T(APFloat::PPCDoubleDouble(), std::move(F1),
1720 std::move(F2));
1721 EXPECT_TRUE(T.isInteger());
1722 APFloat F3(3.14159);
1723 APFloat F4(-0.0);
1724 llvm::detail::DoubleAPFloat T2(APFloat::PPCDoubleDouble(), std::move(F3),
1725 std::move(F4));
1726 EXPECT_FALSE(T2.isInteger());
1727 APFloat F5(-0.0);
1728 APFloat F6(3.14159);
1729 llvm::detail::DoubleAPFloat T3(APFloat::PPCDoubleDouble(), std::move(F5),
1730 std::move(F6));
1731 EXPECT_FALSE(T3.isInteger());
1732 }
1733
1734 TEST(APFloatTest, getLargest) {
1735 EXPECT_EQ(3.402823466e+38f, APFloat::getLargest(APFloat::IEEEsingle()).convertToFloat());
1736 EXPECT_EQ(1.7976931348623158e+308, APFloat::getLargest(APFloat::IEEEdouble()).convertToDouble());
1737 EXPECT_EQ(448, APFloat::getLargest(APFloat::Float8E4M3FN()).convertToDouble());
1738 }
1739
1740 TEST(APFloatTest, getSmallest) {
1741 APFloat test = APFloat::getSmallest(APFloat::IEEEsingle(), false);
1742 APFloat expected = APFloat(APFloat::IEEEsingle(), "0x0.000002p-126");
1743 EXPECT_FALSE(test.isNegative());
1744 EXPECT_TRUE(test.isFiniteNonZero());
1745 EXPECT_TRUE(test.isDenormal());
1746 EXPECT_TRUE(test.bitwiseIsEqual(expected));
1747
1748 test = APFloat::getSmallest(APFloat::IEEEsingle(), true);
1749 expected = APFloat(APFloat::IEEEsingle(), "-0x0.000002p-126");
1750 EXPECT_TRUE(test.isNegative());
1751 EXPECT_TRUE(test.isFiniteNonZero());
1752 EXPECT_TRUE(test.isDenormal());
1753 EXPECT_TRUE(test.bitwiseIsEqual(expected));
1754
1755 test = APFloat::getSmallest(APFloat::IEEEquad(), false);
1756 expected = APFloat(APFloat::IEEEquad(), "0x0.0000000000000000000000000001p-16382");
1757 EXPECT_FALSE(test.isNegative());
1758 EXPECT_TRUE(test.isFiniteNonZero());
1759 EXPECT_TRUE(test.isDenormal());
1760 EXPECT_TRUE(test.bitwiseIsEqual(expected));
1761
1762 test = APFloat::getSmallest(APFloat::IEEEquad(), true);
1763 expected = APFloat(APFloat::IEEEquad(), "-0x0.0000000000000000000000000001p-16382");
1764 EXPECT_TRUE(test.isNegative());
1765 EXPECT_TRUE(test.isFiniteNonZero());
1766 EXPECT_TRUE(test.isDenormal());
1767 EXPECT_TRUE(test.bitwiseIsEqual(expected));
1768 }
1769
1770 TEST(APFloatTest, getSmallestNormalized) {
1771 APFloat test = APFloat::getSmallestNormalized(APFloat::IEEEsingle(), false);
1772 APFloat expected = APFloat(APFloat::IEEEsingle(), "0x1p-126");
1773 EXPECT_FALSE(test.isNegative());
1774 EXPECT_TRUE(test.isFiniteNonZero());
1775 EXPECT_FALSE(test.isDenormal());
1776 EXPECT_TRUE(test.bitwiseIsEqual(expected));
1777 EXPECT_TRUE(test.isSmallestNormalized());
1778
1779 test = APFloat::getSmallestNormalized(APFloat::IEEEsingle(), true);
1780 expected = APFloat(APFloat::IEEEsingle(), "-0x1p-126");
1781 EXPECT_TRUE(test.isNegative());
1782 EXPECT_TRUE(test.isFiniteNonZero());
1783 EXPECT_FALSE(test.isDenormal());
1784 EXPECT_TRUE(test.bitwiseIsEqual(expected));
1785 EXPECT_TRUE(test.isSmallestNormalized());
1786
1787 test = APFloat::getSmallestNormalized(APFloat::IEEEdouble(), false);
1788 expected = APFloat(APFloat::IEEEdouble(), "0x1p-1022");
1789 EXPECT_FALSE(test.isNegative());
1790 EXPECT_TRUE(test.isFiniteNonZero());
1791 EXPECT_FALSE(test.isDenormal());
1792 EXPECT_TRUE(test.bitwiseIsEqual(expected));
1793 EXPECT_TRUE(test.isSmallestNormalized());
1794
1795 test = APFloat::getSmallestNormalized(APFloat::IEEEdouble(), true);
1796 expected = APFloat(APFloat::IEEEdouble(), "-0x1p-1022");
1797 EXPECT_TRUE(test.isNegative());
1798 EXPECT_TRUE(test.isFiniteNonZero());
1799 EXPECT_FALSE(test.isDenormal());
1800 EXPECT_TRUE(test.bitwiseIsEqual(expected));
1801 EXPECT_TRUE(test.isSmallestNormalized());
1802
1803 test = APFloat::getSmallestNormalized(APFloat::IEEEquad(), false);
1804 expected = APFloat(APFloat::IEEEquad(), "0x1p-16382");
1805 EXPECT_FALSE(test.isNegative());
1806 EXPECT_TRUE(test.isFiniteNonZero());
1807 EXPECT_FALSE(test.isDenormal());
1808 EXPECT_TRUE(test.bitwiseIsEqual(expected));
1809 EXPECT_TRUE(test.isSmallestNormalized());
1810
1811 test = APFloat::getSmallestNormalized(APFloat::IEEEquad(), true);
1812 expected = APFloat(APFloat::IEEEquad(), "-0x1p-16382");
1813 EXPECT_TRUE(test.isNegative());
1814 EXPECT_TRUE(test.isFiniteNonZero());
1815 EXPECT_FALSE(test.isDenormal());
1816 EXPECT_TRUE(test.bitwiseIsEqual(expected));
1817 EXPECT_TRUE(test.isSmallestNormalized());
1818 }
1819
1820 TEST(APFloatTest, getZero) {
1821 struct {
1822 const fltSemantics *semantics;
1823 const bool sign;
1824 const unsigned long long bitPattern[2];
1825 const unsigned bitPatternLength;
1826 } const GetZeroTest[] = {
1827 {&APFloat::IEEEhalf(), false, {0, 0}, 1},
1828 {&APFloat::IEEEhalf(), true, {0x8000ULL, 0}, 1},
1829 {&APFloat::IEEEsingle(), false, {0, 0}, 1},
1830 {&APFloat::IEEEsingle(), true, {0x80000000ULL, 0}, 1},
1831 {&APFloat::IEEEdouble(), false, {0, 0}, 1},
1832 {&APFloat::IEEEdouble(), true, {0x8000000000000000ULL, 0}, 1},
1833 {&APFloat::IEEEquad(), false, {0, 0}, 2},
1834 {&APFloat::IEEEquad(), true, {0, 0x8000000000000000ULL}, 2},
1835 {&APFloat::PPCDoubleDouble(), false, {0, 0}, 2},
1836 {&APFloat::PPCDoubleDouble(), true, {0x8000000000000000ULL, 0}, 2},
1837 {&APFloat::x87DoubleExtended(), false, {0, 0}, 2},
1838 {&APFloat::x87DoubleExtended(), true, {0, 0x8000ULL}, 2},
1839 {&APFloat::Float8E5M2(), false, {0, 0}, 1},
1840 {&APFloat::Float8E5M2(), true, {0x80ULL, 0}, 1},
1841 {&APFloat::Float8E4M3FN(), false, {0, 0}, 1},
1842 {&APFloat::Float8E4M3FN(), true, {0x80ULL, 0}, 1},
1843 };
1844 const unsigned NumGetZeroTests = 12;
1845 for (unsigned i = 0; i < NumGetZeroTests; ++i) {
1846 APFloat test = APFloat::getZero(*GetZeroTest[i].semantics,
1847 GetZeroTest[i].sign);
1848 const char *pattern = GetZeroTest[i].sign? "-0x0p+0" : "0x0p+0";
1849 APFloat expected = APFloat(*GetZeroTest[i].semantics,
1850 pattern);
1851 EXPECT_TRUE(test.isZero());
1852 EXPECT_TRUE(GetZeroTest[i].sign? test.isNegative() : !test.isNegative());
1853 EXPECT_TRUE(test.bitwiseIsEqual(expected));
1854 for (unsigned j = 0, je = GetZeroTest[i].bitPatternLength; j < je; ++j) {
1855 EXPECT_EQ(GetZeroTest[i].bitPattern[j],
1856 test.bitcastToAPInt().getRawData()[j]);
1857 }
1858 }
1859 }
1860
1861 TEST(APFloatTest, copySign) {
1862 EXPECT_TRUE(APFloat(-42.0).bitwiseIsEqual(
1863 APFloat::copySign(APFloat(42.0), APFloat(-1.0))));
1864 EXPECT_TRUE(APFloat(42.0).bitwiseIsEqual(
1865 APFloat::copySign(APFloat(-42.0), APFloat(1.0))));
1866 EXPECT_TRUE(APFloat(-42.0).bitwiseIsEqual(
1867 APFloat::copySign(APFloat(-42.0), APFloat(-1.0))));
1868 EXPECT_TRUE(APFloat(42.0).bitwiseIsEqual(
1869 APFloat::copySign(APFloat(42.0), APFloat(1.0))));
1870 }
1871
1872 TEST(APFloatTest, convert) {
1873 bool losesInfo;
1874 APFloat test(APFloat::IEEEdouble(), "1.0");
1875 test.convert(APFloat::IEEEsingle(), APFloat::rmNearestTiesToEven, &losesInfo);
1876 EXPECT_EQ(1.0f, test.convertToFloat());
1877 EXPECT_FALSE(losesInfo);
1878
1879 test = APFloat(APFloat::x87DoubleExtended(), "0x1p-53");
1880 test.add(APFloat(APFloat::x87DoubleExtended(), "1.0"), APFloat::rmNearestTiesToEven);
1881 test.convert(APFloat::IEEEdouble(), APFloat::rmNearestTiesToEven, &losesInfo);
1882 EXPECT_EQ(1.0, test.convertToDouble());
1883 EXPECT_TRUE(losesInfo);
1884
1885 test = APFloat(APFloat::IEEEquad(), "0x1p-53");
1886 test.add(APFloat(APFloat::IEEEquad(), "1.0"), APFloat::rmNearestTiesToEven);
1887 test.convert(APFloat::IEEEdouble(), APFloat::rmNearestTiesToEven, &losesInfo);
1888 EXPECT_EQ(1.0, test.convertToDouble());
1889 EXPECT_TRUE(losesInfo);
1890
1891 test = APFloat(APFloat::x87DoubleExtended(), "0xf.fffffffp+28");
1892 test.convert(APFloat::IEEEdouble(), APFloat::rmNearestTiesToEven, &losesInfo);
1893 EXPECT_EQ(4294967295.0, test.convertToDouble());
1894 EXPECT_FALSE(losesInfo);
1895
1896 test = APFloat::getSNaN(APFloat::IEEEsingle());
1897 APFloat::opStatus status = test.convert(APFloat::x87DoubleExtended(), APFloat::rmNearestTiesToEven, &losesInfo);
1898 // Conversion quiets the SNAN, so now 2 bits of the 64-bit significand should be set.
1899 APInt topTwoBits(64, 0x6000000000000000);
1900 EXPECT_TRUE(test.bitwiseIsEqual(APFloat::getQNaN(APFloat::x87DoubleExtended(), false, &topTwoBits)));
1901 EXPECT_FALSE(losesInfo);
1902 EXPECT_EQ(status, APFloat::opInvalidOp);
1903
1904 test = APFloat::getQNaN(APFloat::IEEEsingle());
1905 APFloat X87QNaN = APFloat::getQNaN(APFloat::x87DoubleExtended());
1906 test.convert(APFloat::x87DoubleExtended(), APFloat::rmNearestTiesToEven,
1907 &losesInfo);
1908 EXPECT_TRUE(test.bitwiseIsEqual(X87QNaN));
1909 EXPECT_FALSE(losesInfo);
1910
1911 test = APFloat::getSNaN(APFloat::x87DoubleExtended());
1912 test.convert(APFloat::x87DoubleExtended(), APFloat::rmNearestTiesToEven,
1913 &losesInfo);
1914 APFloat X87SNaN = APFloat::getSNaN(APFloat::x87DoubleExtended());
1915 EXPECT_TRUE(test.bitwiseIsEqual(X87SNaN));
1916 EXPECT_FALSE(losesInfo);
1917
1918 test = APFloat::getQNaN(APFloat::x87DoubleExtended());
1919 test.convert(APFloat::x87DoubleExtended(), APFloat::rmNearestTiesToEven,
1920 &losesInfo);
1921 EXPECT_TRUE(test.bitwiseIsEqual(X87QNaN));
1922 EXPECT_FALSE(losesInfo);
1923
1924 // The payload is lost in truncation, but we retain NaN by setting the quiet bit.
1925 APInt payload(52, 1);
1926 test = APFloat::getSNaN(APFloat::IEEEdouble(), false, &payload);
1927 status = test.convert(APFloat::IEEEsingle(), APFloat::rmNearestTiesToEven, &losesInfo);
1928 EXPECT_EQ(0x7fc00000, test.bitcastToAPInt());
1929 EXPECT_TRUE(losesInfo);
1930 EXPECT_EQ(status, APFloat::opInvalidOp);
1931
1932 // The payload is lost in truncation. QNaN remains QNaN.
1933 test = APFloat::getQNaN(APFloat::IEEEdouble(), false, &payload);
1934 status = test.convert(APFloat::IEEEsingle(), APFloat::rmNearestTiesToEven, &losesInfo);
1935 EXPECT_EQ(0x7fc00000, test.bitcastToAPInt());
1936 EXPECT_TRUE(losesInfo);
1937 EXPECT_EQ(status, APFloat::opOK);
1938
1939 // Test that subnormals are handled correctly in double to float conversion
1940 test = APFloat(APFloat::IEEEdouble(), "0x0.0000010000000p-1022");
1941 test.convert(APFloat::IEEEsingle(), APFloat::rmNearestTiesToEven, &losesInfo);
1942 EXPECT_EQ(0.0f, test.convertToFloat());
1943 EXPECT_TRUE(losesInfo);
1944
1945 test = APFloat(APFloat::IEEEdouble(), "0x0.0000010000001p-1022");
1946 test.convert(APFloat::IEEEsingle(), APFloat::rmNearestTiesToEven, &losesInfo);
1947 EXPECT_EQ(0.0f, test.convertToFloat());
1948 EXPECT_TRUE(losesInfo);
1949
1950 test = APFloat(APFloat::IEEEdouble(), "-0x0.0000010000001p-1022");
1951 test.convert(APFloat::IEEEsingle(), APFloat::rmNearestTiesToEven, &losesInfo);
1952 EXPECT_EQ(0.0f, test.convertToFloat());
1953 EXPECT_TRUE(losesInfo);
1954
1955 test = APFloat(APFloat::IEEEdouble(), "0x0.0000020000000p-1022");
1956 test.convert(APFloat::IEEEsingle(), APFloat::rmNearestTiesToEven, &losesInfo);
1957 EXPECT_EQ(0.0f, test.convertToFloat());
1958 EXPECT_TRUE(losesInfo);
1959
1960 test = APFloat(APFloat::IEEEdouble(), "0x0.0000020000001p-1022");
1961 test.convert(APFloat::IEEEsingle(), APFloat::rmNearestTiesToEven, &losesInfo);
1962 EXPECT_EQ(0.0f, test.convertToFloat());
1963 EXPECT_TRUE(losesInfo);
1964
1965 // Test subnormal conversion to bfloat
1966 test = APFloat(APFloat::IEEEsingle(), "0x0.01p-126");
1967 test.convert(APFloat::BFloat(), APFloat::rmNearestTiesToEven, &losesInfo);
1968 EXPECT_EQ(0.0f, test.convertToFloat());
1969 EXPECT_TRUE(losesInfo);
1970
1971 test = APFloat(APFloat::IEEEsingle(), "0x0.02p-126");
1972 test.convert(APFloat::BFloat(), APFloat::rmNearestTiesToEven, &losesInfo);
1973 EXPECT_EQ(0x01, test.bitcastToAPInt());
1974 EXPECT_FALSE(losesInfo);
1975
1976 test = APFloat(APFloat::IEEEsingle(), "0x0.01p-126");
1977 test.convert(APFloat::BFloat(), APFloat::rmNearestTiesToAway, &losesInfo);
1978 EXPECT_EQ(0x01, test.bitcastToAPInt());
1979 EXPECT_TRUE(losesInfo);
1980 }
1981
1982 TEST(APFloatTest, PPCDoubleDouble) {
1983 APFloat test(APFloat::PPCDoubleDouble(), "1.0");
1984 EXPECT_EQ(0x3ff0000000000000ull, test.bitcastToAPInt().getRawData()[0]);
1985 EXPECT_EQ(0x0000000000000000ull, test.bitcastToAPInt().getRawData()[1]);
1986
1987 // LDBL_MAX
1988 test = APFloat(APFloat::PPCDoubleDouble(), "1.79769313486231580793728971405301e+308");
1989 EXPECT_EQ(0x7fefffffffffffffull, test.bitcastToAPInt().getRawData()[0]);
1990 EXPECT_EQ(0x7c8ffffffffffffeull, test.bitcastToAPInt().getRawData()[1]);
1991
1992 // LDBL_MIN
1993 test = APFloat(APFloat::PPCDoubleDouble(), "2.00416836000897277799610805135016e-292");
1994 EXPECT_EQ(0x0360000000000000ull, test.bitcastToAPInt().getRawData()[0]);
1995 EXPECT_EQ(0x0000000000000000ull, test.bitcastToAPInt().getRawData()[1]);
1996
1997 // PR30869
1998 {
1999 auto Result = APFloat(APFloat::PPCDoubleDouble(), "1.0") +
2000 APFloat(APFloat::PPCDoubleDouble(), "1.0");
2001 EXPECT_EQ(&APFloat::PPCDoubleDouble(), &Result.getSemantics());
2002
2003 Result = APFloat(APFloat::PPCDoubleDouble(), "1.0") -
2004 APFloat(APFloat::PPCDoubleDouble(), "1.0");
2005 EXPECT_EQ(&APFloat::PPCDoubleDouble(), &Result.getSemantics());
2006
2007 Result = APFloat(APFloat::PPCDoubleDouble(), "1.0") *
2008 APFloat(APFloat::PPCDoubleDouble(), "1.0");
2009 EXPECT_EQ(&APFloat::PPCDoubleDouble(), &Result.getSemantics());
2010
2011 Result = APFloat(APFloat::PPCDoubleDouble(), "1.0") /
2012 APFloat(APFloat::PPCDoubleDouble(), "1.0");
2013 EXPECT_EQ(&APFloat::PPCDoubleDouble(), &Result.getSemantics());
2014
2015 int Exp;
2016 Result = frexp(APFloat(APFloat::PPCDoubleDouble(), "1.0"), Exp,
2017 APFloat::rmNearestTiesToEven);
2018 EXPECT_EQ(&APFloat::PPCDoubleDouble(), &Result.getSemantics());
2019
2020 Result = scalbn(APFloat(APFloat::PPCDoubleDouble(), "1.0"), 1,
2021 APFloat::rmNearestTiesToEven);
2022 EXPECT_EQ(&APFloat::PPCDoubleDouble(), &Result.getSemantics());
2023 }
2024 }
2025
2026 TEST(APFloatTest, isNegative) {
2027 APFloat t(APFloat::IEEEsingle(), "0x1p+0");
2028 EXPECT_FALSE(t.isNegative());
2029 t = APFloat(APFloat::IEEEsingle(), "-0x1p+0");
2030 EXPECT_TRUE(t.isNegative());
2031
2032 EXPECT_FALSE(APFloat::getInf(APFloat::IEEEsingle(), false).isNegative());
2033 EXPECT_TRUE(APFloat::getInf(APFloat::IEEEsingle(), true).isNegative());
2034
2035 EXPECT_FALSE(APFloat::getZero(APFloat::IEEEsingle(), false).isNegative());
2036 EXPECT_TRUE(APFloat::getZero(APFloat::IEEEsingle(), true).isNegative());
2037
2038 EXPECT_FALSE(APFloat::getNaN(APFloat::IEEEsingle(), false).isNegative());
2039 EXPECT_TRUE(APFloat::getNaN(APFloat::IEEEsingle(), true).isNegative());
2040
2041 EXPECT_FALSE(APFloat::getSNaN(APFloat::IEEEsingle(), false).isNegative());
2042 EXPECT_TRUE(APFloat::getSNaN(APFloat::IEEEsingle(), true).isNegative());
2043 }
2044
2045 TEST(APFloatTest, isNormal) {
2046 APFloat t(APFloat::IEEEsingle(), "0x1p+0");
2047 EXPECT_TRUE(t.isNormal());
2048
2049 EXPECT_FALSE(APFloat::getInf(APFloat::IEEEsingle(), false).isNormal());
2050 EXPECT_FALSE(APFloat::getZero(APFloat::IEEEsingle(), false).isNormal());
2051 EXPECT_FALSE(APFloat::getNaN(APFloat::IEEEsingle(), false).isNormal());
2052 EXPECT_FALSE(APFloat::getSNaN(APFloat::IEEEsingle(), false).isNormal());
2053 EXPECT_FALSE(APFloat(APFloat::IEEEsingle(), "0x1p-149").isNormal());
2054 }
2055
2056 TEST(APFloatTest, isFinite) {
2057 APFloat t(APFloat::IEEEsingle(), "0x1p+0");
2058 EXPECT_TRUE(t.isFinite());
2059 EXPECT_FALSE(APFloat::getInf(APFloat::IEEEsingle(), false).isFinite());
2060 EXPECT_TRUE(APFloat::getZero(APFloat::IEEEsingle(), false).isFinite());
2061 EXPECT_FALSE(APFloat::getNaN(APFloat::IEEEsingle(), false).isFinite());
2062 EXPECT_FALSE(APFloat::getSNaN(APFloat::IEEEsingle(), false).isFinite());
2063 EXPECT_TRUE(APFloat(APFloat::IEEEsingle(), "0x1p-149").isFinite());
2064 }
2065
2066 TEST(APFloatTest, isInfinity) {
2067 APFloat t(APFloat::IEEEsingle(), "0x1p+0");
2068 EXPECT_FALSE(t.isInfinity());
2069
2070 APFloat PosInf = APFloat::getInf(APFloat::IEEEsingle(), false);
2071 APFloat NegInf = APFloat::getInf(APFloat::IEEEsingle(), true);
2072
2073 EXPECT_TRUE(PosInf.isInfinity());
2074 EXPECT_TRUE(PosInf.isPosInfinity());
2075 EXPECT_FALSE(PosInf.isNegInfinity());
2076 EXPECT_TRUE(NegInf.isInfinity());
2077 EXPECT_FALSE(NegInf.isPosInfinity());
2078 EXPECT_TRUE(NegInf.isNegInfinity());
2079
2080 EXPECT_FALSE(APFloat::getZero(APFloat::IEEEsingle(), false).isInfinity());
2081 EXPECT_FALSE(APFloat::getNaN(APFloat::IEEEsingle(), false).isInfinity());
2082 EXPECT_FALSE(APFloat::getSNaN(APFloat::IEEEsingle(), false).isInfinity());
2083 EXPECT_FALSE(APFloat(APFloat::IEEEsingle(), "0x1p-149").isInfinity());
2084 }
2085
2086 TEST(APFloatTest, isNaN) {
2087 APFloat t(APFloat::IEEEsingle(), "0x1p+0");
2088 EXPECT_FALSE(t.isNaN());
2089 EXPECT_FALSE(APFloat::getInf(APFloat::IEEEsingle(), false).isNaN());
2090 EXPECT_FALSE(APFloat::getZero(APFloat::IEEEsingle(), false).isNaN());
2091 EXPECT_TRUE(APFloat::getNaN(APFloat::IEEEsingle(), false).isNaN());
2092 EXPECT_TRUE(APFloat::getSNaN(APFloat::IEEEsingle(), false).isNaN());
2093 EXPECT_FALSE(APFloat(APFloat::IEEEsingle(), "0x1p-149").isNaN());
2094 }
2095
2096 TEST(APFloatTest, isFiniteNonZero) {
2097 // Test positive/negative normal value.
2098 EXPECT_TRUE(APFloat(APFloat::IEEEsingle(), "0x1p+0").isFiniteNonZero());
2099 EXPECT_TRUE(APFloat(APFloat::IEEEsingle(), "-0x1p+0").isFiniteNonZero());
2100
2101 // Test positive/negative denormal value.
2102 EXPECT_TRUE(APFloat(APFloat::IEEEsingle(), "0x1p-149").isFiniteNonZero());
2103 EXPECT_TRUE(APFloat(APFloat::IEEEsingle(), "-0x1p-149").isFiniteNonZero());
2104
2105 // Test +/- Infinity.
2106 EXPECT_FALSE(APFloat::getInf(APFloat::IEEEsingle(), false).isFiniteNonZero());
2107 EXPECT_FALSE(APFloat::getInf(APFloat::IEEEsingle(), true).isFiniteNonZero());
2108
2109 // Test +/- Zero.
2110 EXPECT_FALSE(APFloat::getZero(APFloat::IEEEsingle(), false).isFiniteNonZero());
2111 EXPECT_FALSE(APFloat::getZero(APFloat::IEEEsingle(), true).isFiniteNonZero());
2112
2113 // Test +/- qNaN. +/- dont mean anything with qNaN but paranoia can't hurt in
2114 // this instance.
2115 EXPECT_FALSE(APFloat::getNaN(APFloat::IEEEsingle(), false).isFiniteNonZero());
2116 EXPECT_FALSE(APFloat::getNaN(APFloat::IEEEsingle(), true).isFiniteNonZero());
2117
2118 // Test +/- sNaN. +/- dont mean anything with sNaN but paranoia can't hurt in
2119 // this instance.
2120 EXPECT_FALSE(APFloat::getSNaN(APFloat::IEEEsingle(), false).isFiniteNonZero());
2121 EXPECT_FALSE(APFloat::getSNaN(APFloat::IEEEsingle(), true).isFiniteNonZero());
2122 }
2123
2124 TEST(APFloatTest, add) {
2125 // Test Special Cases against each other and normal values.
2126
2127 APFloat PInf = APFloat::getInf(APFloat::IEEEsingle(), false);
2128 APFloat MInf = APFloat::getInf(APFloat::IEEEsingle(), true);
2129 APFloat PZero = APFloat::getZero(APFloat::IEEEsingle(), false);
2130 APFloat MZero = APFloat::getZero(APFloat::IEEEsingle(), true);
2131 APFloat QNaN = APFloat::getNaN(APFloat::IEEEsingle(), false);
2132 APFloat SNaN = APFloat(APFloat::IEEEsingle(), "snan123");
2133 APFloat PNormalValue = APFloat(APFloat::IEEEsingle(), "0x1p+0");
2134 APFloat MNormalValue = APFloat(APFloat::IEEEsingle(), "-0x1p+0");
2135 APFloat PLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), false);
2136 APFloat MLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), true);
2137 APFloat PSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), false);
2138 APFloat MSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), true);
2139 APFloat PSmallestNormalized =
2140 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), false);
2141 APFloat MSmallestNormalized =
2142 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), true);
2143
2144 const int OverflowStatus = APFloat::opOverflow | APFloat::opInexact;
2145
2146 struct {
2147 APFloat x;
2148 APFloat y;
2149 const char *result;
2150 int status;
2151 int category;
2152 } SpecialCaseTests[] = {
2153 { PInf, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2154 { PInf, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2155 { PInf, PZero, "inf", APFloat::opOK, APFloat::fcInfinity },
2156 { PInf, MZero, "inf", APFloat::opOK, APFloat::fcInfinity },
2157 { PInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2158 { PInf, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2159 { PInf, PNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2160 { PInf, MNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2161 { PInf, PLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2162 { PInf, MLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2163 { PInf, PSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2164 { PInf, MSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2165 { PInf, PSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity },
2166 { PInf, MSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity },
2167 { MInf, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2168 { MInf, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2169 { MInf, PZero, "-inf", APFloat::opOK, APFloat::fcInfinity },
2170 { MInf, MZero, "-inf", APFloat::opOK, APFloat::fcInfinity },
2171 { MInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2172 { MInf, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2173 { MInf, PNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2174 { MInf, MNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2175 { MInf, PLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2176 { MInf, MLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2177 { MInf, PSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2178 { MInf, MSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2179 { MInf, PSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity },
2180 { MInf, MSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity },
2181 { PZero, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2182 { PZero, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2183 { PZero, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2184 { PZero, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2185 { PZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2186 { PZero, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2187 { PZero, PNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2188 { PZero, MNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2189 { PZero, PLargestValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2190 { PZero, MLargestValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2191 { PZero, PSmallestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2192 { PZero, MSmallestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2193 { PZero, PSmallestNormalized, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2194 { PZero, MSmallestNormalized, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2195 { MZero, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2196 { MZero, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2197 { MZero, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2198 { MZero, MZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2199 { MZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2200 { MZero, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2201 { MZero, PNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2202 { MZero, MNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2203 { MZero, PLargestValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2204 { MZero, MLargestValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2205 { MZero, PSmallestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2206 { MZero, MSmallestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2207 { MZero, PSmallestNormalized, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2208 { MZero, MSmallestNormalized, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2209 { QNaN, PInf, "nan", APFloat::opOK, APFloat::fcNaN },
2210 { QNaN, MInf, "nan", APFloat::opOK, APFloat::fcNaN },
2211 { QNaN, PZero, "nan", APFloat::opOK, APFloat::fcNaN },
2212 { QNaN, MZero, "nan", APFloat::opOK, APFloat::fcNaN },
2213 { QNaN, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2214 { QNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2215 { QNaN, PNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
2216 { QNaN, MNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
2217 { QNaN, PLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2218 { QNaN, MLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2219 { QNaN, PSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2220 { QNaN, MSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2221 { QNaN, PSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
2222 { QNaN, MSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
2223 { SNaN, PInf, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2224 { SNaN, MInf, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2225 { SNaN, PZero, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2226 { SNaN, MZero, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2227 { SNaN, QNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2228 { SNaN, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2229 { SNaN, PNormalValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2230 { SNaN, MNormalValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2231 { SNaN, PLargestValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2232 { SNaN, MLargestValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2233 { SNaN, PSmallestValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2234 { SNaN, MSmallestValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2235 { SNaN, PSmallestNormalized, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2236 { SNaN, MSmallestNormalized, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2237 { PNormalValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2238 { PNormalValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2239 { PNormalValue, PZero, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2240 { PNormalValue, MZero, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2241 { PNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2242 { PNormalValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2243 { PNormalValue, PNormalValue, "0x1p+1", APFloat::opOK, APFloat::fcNormal },
2244 { PNormalValue, MNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2245 { PNormalValue, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2246 { PNormalValue, MLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2247 { PNormalValue, PSmallestValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2248 { PNormalValue, MSmallestValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2249 { PNormalValue, PSmallestNormalized, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2250 { PNormalValue, MSmallestNormalized, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2251 { MNormalValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2252 { MNormalValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2253 { MNormalValue, PZero, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2254 { MNormalValue, MZero, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2255 { MNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2256 { MNormalValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2257 { MNormalValue, PNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2258 { MNormalValue, MNormalValue, "-0x1p+1", APFloat::opOK, APFloat::fcNormal },
2259 { MNormalValue, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2260 { MNormalValue, MLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2261 { MNormalValue, PSmallestValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2262 { MNormalValue, MSmallestValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2263 { MNormalValue, PSmallestNormalized, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2264 { MNormalValue, MSmallestNormalized, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2265 { PLargestValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2266 { PLargestValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2267 { PLargestValue, PZero, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2268 { PLargestValue, MZero, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2269 { PLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2270 { PLargestValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2271 { PLargestValue, PNormalValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2272 { PLargestValue, MNormalValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2273 { PLargestValue, PLargestValue, "inf", OverflowStatus, APFloat::fcInfinity },
2274 { PLargestValue, MLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2275 { PLargestValue, PSmallestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2276 { PLargestValue, MSmallestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2277 { PLargestValue, PSmallestNormalized, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2278 { PLargestValue, MSmallestNormalized, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2279 { MLargestValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2280 { MLargestValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2281 { MLargestValue, PZero, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2282 { MLargestValue, MZero, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2283 { MLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2284 { MLargestValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2285 { MLargestValue, PNormalValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2286 { MLargestValue, MNormalValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2287 { MLargestValue, PLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2288 { MLargestValue, MLargestValue, "-inf", OverflowStatus, APFloat::fcInfinity },
2289 { MLargestValue, PSmallestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2290 { MLargestValue, MSmallestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2291 { MLargestValue, PSmallestNormalized, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2292 { MLargestValue, MSmallestNormalized, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2293 { PSmallestValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2294 { PSmallestValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2295 { PSmallestValue, PZero, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2296 { PSmallestValue, MZero, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2297 { PSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2298 { PSmallestValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2299 { PSmallestValue, PNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2300 { PSmallestValue, MNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2301 { PSmallestValue, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2302 { PSmallestValue, MLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2303 { PSmallestValue, PSmallestValue, "0x1p-148", APFloat::opOK, APFloat::fcNormal },
2304 { PSmallestValue, MSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2305 { PSmallestValue, PSmallestNormalized, "0x1.000002p-126", APFloat::opOK, APFloat::fcNormal },
2306 { PSmallestValue, MSmallestNormalized, "-0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal },
2307 { MSmallestValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2308 { MSmallestValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2309 { MSmallestValue, PZero, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2310 { MSmallestValue, MZero, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2311 { MSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2312 { MSmallestValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2313 { MSmallestValue, PNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2314 { MSmallestValue, MNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2315 { MSmallestValue, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2316 { MSmallestValue, MLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2317 { MSmallestValue, PSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2318 { MSmallestValue, MSmallestValue, "-0x1p-148", APFloat::opOK, APFloat::fcNormal },
2319 { MSmallestValue, PSmallestNormalized, "0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal },
2320 { MSmallestValue, MSmallestNormalized, "-0x1.000002p-126", APFloat::opOK, APFloat::fcNormal },
2321 { PSmallestNormalized, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2322 { PSmallestNormalized, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2323 { PSmallestNormalized, PZero, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2324 { PSmallestNormalized, MZero, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2325 { PSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2326 { PSmallestNormalized, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2327 { PSmallestNormalized, PNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2328 { PSmallestNormalized, MNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2329 { PSmallestNormalized, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2330 { PSmallestNormalized, MLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2331 { PSmallestNormalized, PSmallestValue, "0x1.000002p-126", APFloat::opOK, APFloat::fcNormal },
2332 { PSmallestNormalized, MSmallestValue, "0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal },
2333 { PSmallestNormalized, PSmallestNormalized, "0x1p-125", APFloat::opOK, APFloat::fcNormal },
2334 { PSmallestNormalized, MSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2335 { MSmallestNormalized, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2336 { MSmallestNormalized, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2337 { MSmallestNormalized, PZero, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2338 { MSmallestNormalized, MZero, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2339 { MSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2340 { MSmallestNormalized, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2341 { MSmallestNormalized, PNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2342 { MSmallestNormalized, MNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2343 { MSmallestNormalized, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2344 { MSmallestNormalized, MLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2345 { MSmallestNormalized, PSmallestValue, "-0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal },
2346 { MSmallestNormalized, MSmallestValue, "-0x1.000002p-126", APFloat::opOK, APFloat::fcNormal },
2347 { MSmallestNormalized, PSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2348 { MSmallestNormalized, MSmallestNormalized, "-0x1p-125", APFloat::opOK, APFloat::fcNormal }
2349 };
2350
2351 for (size_t i = 0; i < std::size(SpecialCaseTests); ++i) {
2352 APFloat x(SpecialCaseTests[i].x);
2353 APFloat y(SpecialCaseTests[i].y);
2354 APFloat::opStatus status = x.add(y, APFloat::rmNearestTiesToEven);
2355
2356 APFloat result(APFloat::IEEEsingle(), SpecialCaseTests[i].result);
2357
2358 EXPECT_TRUE(result.bitwiseIsEqual(x));
2359 EXPECT_EQ(SpecialCaseTests[i].status, (int)status);
2360 EXPECT_EQ(SpecialCaseTests[i].category, (int)x.getCategory());
2361 }
2362 }
2363
2364 TEST(APFloatTest, subtract) {
2365 // Test Special Cases against each other and normal values.
2366
2367 APFloat PInf = APFloat::getInf(APFloat::IEEEsingle(), false);
2368 APFloat MInf = APFloat::getInf(APFloat::IEEEsingle(), true);
2369 APFloat PZero = APFloat::getZero(APFloat::IEEEsingle(), false);
2370 APFloat MZero = APFloat::getZero(APFloat::IEEEsingle(), true);
2371 APFloat QNaN = APFloat::getNaN(APFloat::IEEEsingle(), false);
2372 APFloat SNaN = APFloat(APFloat::IEEEsingle(), "snan123");
2373 APFloat PNormalValue = APFloat(APFloat::IEEEsingle(), "0x1p+0");
2374 APFloat MNormalValue = APFloat(APFloat::IEEEsingle(), "-0x1p+0");
2375 APFloat PLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), false);
2376 APFloat MLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), true);
2377 APFloat PSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), false);
2378 APFloat MSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), true);
2379 APFloat PSmallestNormalized =
2380 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), false);
2381 APFloat MSmallestNormalized =
2382 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), true);
2383
2384 const int OverflowStatus = APFloat::opOverflow | APFloat::opInexact;
2385
2386 struct {
2387 APFloat x;
2388 APFloat y;
2389 const char *result;
2390 int status;
2391 int category;
2392 } SpecialCaseTests[] = {
2393 { PInf, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2394 { PInf, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2395 { PInf, PZero, "inf", APFloat::opOK, APFloat::fcInfinity },
2396 { PInf, MZero, "inf", APFloat::opOK, APFloat::fcInfinity },
2397 { PInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2398 { PInf, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2399 { PInf, PNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2400 { PInf, MNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2401 { PInf, PLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2402 { PInf, MLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2403 { PInf, PSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2404 { PInf, MSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2405 { PInf, PSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity },
2406 { PInf, MSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity },
2407 { MInf, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2408 { MInf, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2409 { MInf, PZero, "-inf", APFloat::opOK, APFloat::fcInfinity },
2410 { MInf, MZero, "-inf", APFloat::opOK, APFloat::fcInfinity },
2411 { MInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2412 { MInf, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2413 { MInf, PNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2414 { MInf, MNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2415 { MInf, PLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2416 { MInf, MLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2417 { MInf, PSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2418 { MInf, MSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2419 { MInf, PSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity },
2420 { MInf, MSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity },
2421 { PZero, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2422 { PZero, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2423 { PZero, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2424 { PZero, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2425 { PZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2426 { PZero, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2427 { PZero, PNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2428 { PZero, MNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2429 { PZero, PLargestValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2430 { PZero, MLargestValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2431 { PZero, PSmallestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2432 { PZero, MSmallestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2433 { PZero, PSmallestNormalized, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2434 { PZero, MSmallestNormalized, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2435 { MZero, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2436 { MZero, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2437 { MZero, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2438 { MZero, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2439 { MZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2440 { MZero, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2441 { MZero, PNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2442 { MZero, MNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2443 { MZero, PLargestValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2444 { MZero, MLargestValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2445 { MZero, PSmallestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2446 { MZero, MSmallestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2447 { MZero, PSmallestNormalized, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2448 { MZero, MSmallestNormalized, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2449 { QNaN, PInf, "nan", APFloat::opOK, APFloat::fcNaN },
2450 { QNaN, MInf, "nan", APFloat::opOK, APFloat::fcNaN },
2451 { QNaN, PZero, "nan", APFloat::opOK, APFloat::fcNaN },
2452 { QNaN, MZero, "nan", APFloat::opOK, APFloat::fcNaN },
2453 { QNaN, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2454 { QNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2455 { QNaN, PNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
2456 { QNaN, MNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
2457 { QNaN, PLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2458 { QNaN, MLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2459 { QNaN, PSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2460 { QNaN, MSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2461 { QNaN, PSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
2462 { QNaN, MSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
2463 { SNaN, PInf, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2464 { SNaN, MInf, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2465 { SNaN, PZero, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2466 { SNaN, MZero, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2467 { SNaN, QNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2468 { SNaN, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2469 { SNaN, PNormalValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2470 { SNaN, MNormalValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2471 { SNaN, PLargestValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2472 { SNaN, MLargestValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2473 { SNaN, PSmallestValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2474 { SNaN, MSmallestValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2475 { SNaN, PSmallestNormalized, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2476 { SNaN, MSmallestNormalized, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2477 { PNormalValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2478 { PNormalValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2479 { PNormalValue, PZero, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2480 { PNormalValue, MZero, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2481 { PNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2482 { PNormalValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2483 { PNormalValue, PNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2484 { PNormalValue, MNormalValue, "0x1p+1", APFloat::opOK, APFloat::fcNormal },
2485 { PNormalValue, PLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2486 { PNormalValue, MLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2487 { PNormalValue, PSmallestValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2488 { PNormalValue, MSmallestValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2489 { PNormalValue, PSmallestNormalized, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2490 { PNormalValue, MSmallestNormalized, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2491 { MNormalValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2492 { MNormalValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2493 { MNormalValue, PZero, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2494 { MNormalValue, MZero, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2495 { MNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2496 { MNormalValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2497 { MNormalValue, PNormalValue, "-0x1p+1", APFloat::opOK, APFloat::fcNormal },
2498 { MNormalValue, MNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2499 { MNormalValue, PLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2500 { MNormalValue, MLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2501 { MNormalValue, PSmallestValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2502 { MNormalValue, MSmallestValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2503 { MNormalValue, PSmallestNormalized, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2504 { MNormalValue, MSmallestNormalized, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2505 { PLargestValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2506 { PLargestValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2507 { PLargestValue, PZero, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2508 { PLargestValue, MZero, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2509 { PLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2510 { PLargestValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2511 { PLargestValue, PNormalValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2512 { PLargestValue, MNormalValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2513 { PLargestValue, PLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2514 { PLargestValue, MLargestValue, "inf", OverflowStatus, APFloat::fcInfinity },
2515 { PLargestValue, PSmallestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2516 { PLargestValue, MSmallestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2517 { PLargestValue, PSmallestNormalized, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2518 { PLargestValue, MSmallestNormalized, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2519 { MLargestValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2520 { MLargestValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2521 { MLargestValue, PZero, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2522 { MLargestValue, MZero, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2523 { MLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2524 { MLargestValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2525 { MLargestValue, PNormalValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2526 { MLargestValue, MNormalValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2527 { MLargestValue, PLargestValue, "-inf", OverflowStatus, APFloat::fcInfinity },
2528 { MLargestValue, MLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2529 { MLargestValue, PSmallestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2530 { MLargestValue, MSmallestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2531 { MLargestValue, PSmallestNormalized, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2532 { MLargestValue, MSmallestNormalized, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2533 { PSmallestValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2534 { PSmallestValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2535 { PSmallestValue, PZero, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2536 { PSmallestValue, MZero, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2537 { PSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2538 { PSmallestValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2539 { PSmallestValue, PNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2540 { PSmallestValue, MNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2541 { PSmallestValue, PLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2542 { PSmallestValue, MLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2543 { PSmallestValue, PSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2544 { PSmallestValue, MSmallestValue, "0x1p-148", APFloat::opOK, APFloat::fcNormal },
2545 { PSmallestValue, PSmallestNormalized, "-0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal },
2546 { PSmallestValue, MSmallestNormalized, "0x1.000002p-126", APFloat::opOK, APFloat::fcNormal },
2547 { MSmallestValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2548 { MSmallestValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2549 { MSmallestValue, PZero, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2550 { MSmallestValue, MZero, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2551 { MSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2552 { MSmallestValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2553 { MSmallestValue, PNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2554 { MSmallestValue, MNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2555 { MSmallestValue, PLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2556 { MSmallestValue, MLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2557 { MSmallestValue, PSmallestValue, "-0x1p-148", APFloat::opOK, APFloat::fcNormal },
2558 { MSmallestValue, MSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2559 { MSmallestValue, PSmallestNormalized, "-0x1.000002p-126", APFloat::opOK, APFloat::fcNormal },
2560 { MSmallestValue, MSmallestNormalized, "0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal },
2561 { PSmallestNormalized, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2562 { PSmallestNormalized, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2563 { PSmallestNormalized, PZero, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2564 { PSmallestNormalized, MZero, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2565 { PSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2566 { PSmallestNormalized, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2567 { PSmallestNormalized, PNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2568 { PSmallestNormalized, MNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2569 { PSmallestNormalized, PLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2570 { PSmallestNormalized, MLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2571 { PSmallestNormalized, PSmallestValue, "0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal },
2572 { PSmallestNormalized, MSmallestValue, "0x1.000002p-126", APFloat::opOK, APFloat::fcNormal },
2573 { PSmallestNormalized, PSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2574 { PSmallestNormalized, MSmallestNormalized, "0x1p-125", APFloat::opOK, APFloat::fcNormal },
2575 { MSmallestNormalized, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2576 { MSmallestNormalized, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2577 { MSmallestNormalized, PZero, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2578 { MSmallestNormalized, MZero, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2579 { MSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2580 { MSmallestNormalized, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2581 { MSmallestNormalized, PNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2582 { MSmallestNormalized, MNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2583 { MSmallestNormalized, PLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2584 { MSmallestNormalized, MLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2585 { MSmallestNormalized, PSmallestValue, "-0x1.000002p-126", APFloat::opOK, APFloat::fcNormal },
2586 { MSmallestNormalized, MSmallestValue, "-0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal },
2587 { MSmallestNormalized, PSmallestNormalized, "-0x1p-125", APFloat::opOK, APFloat::fcNormal },
2588 { MSmallestNormalized, MSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero }
2589 };
2590
2591 for (size_t i = 0; i < std::size(SpecialCaseTests); ++i) {
2592 APFloat x(SpecialCaseTests[i].x);
2593 APFloat y(SpecialCaseTests[i].y);
2594 APFloat::opStatus status = x.subtract(y, APFloat::rmNearestTiesToEven);
2595
2596 APFloat result(APFloat::IEEEsingle(), SpecialCaseTests[i].result);
2597
2598 EXPECT_TRUE(result.bitwiseIsEqual(x));
2599 EXPECT_EQ(SpecialCaseTests[i].status, (int)status);
2600 EXPECT_EQ(SpecialCaseTests[i].category, (int)x.getCategory());
2601 }
2602 }
2603
2604 TEST(APFloatTest, multiply) {
2605 // Test Special Cases against each other and normal values.
2606
2607 APFloat PInf = APFloat::getInf(APFloat::IEEEsingle(), false);
2608 APFloat MInf = APFloat::getInf(APFloat::IEEEsingle(), true);
2609 APFloat PZero = APFloat::getZero(APFloat::IEEEsingle(), false);
2610 APFloat MZero = APFloat::getZero(APFloat::IEEEsingle(), true);
2611 APFloat QNaN = APFloat::getNaN(APFloat::IEEEsingle(), false);
2612 APFloat SNaN = APFloat(APFloat::IEEEsingle(), "snan123");
2613 APFloat PNormalValue = APFloat(APFloat::IEEEsingle(), "0x1p+0");
2614 APFloat MNormalValue = APFloat(APFloat::IEEEsingle(), "-0x1p+0");
2615 APFloat PLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), false);
2616 APFloat MLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), true);
2617 APFloat PSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), false);
2618 APFloat MSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), true);
2619 APFloat PSmallestNormalized =
2620 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), false);
2621 APFloat MSmallestNormalized =
2622 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), true);
2623
2624 APFloat MaxQuad(APFloat::IEEEquad(),
2625 "0x1.ffffffffffffffffffffffffffffp+16383");
2626 APFloat MinQuad(APFloat::IEEEquad(),
2627 "0x0.0000000000000000000000000001p-16382");
2628 APFloat NMinQuad(APFloat::IEEEquad(),
2629 "-0x0.0000000000000000000000000001p-16382");
2630
2631 const int OverflowStatus = APFloat::opOverflow | APFloat::opInexact;
2632 const int UnderflowStatus = APFloat::opUnderflow | APFloat::opInexact;
2633
2634 struct {
2635 APFloat x;
2636 APFloat y;
2637 const char *result;
2638 int status;
2639 int category;
2640 APFloat::roundingMode roundingMode = APFloat::rmNearestTiesToEven;
2641 } SpecialCaseTests[] = {
2642 { PInf, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2643 { PInf, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2644 { PInf, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2645 { PInf, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2646 { PInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2647 { PInf, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2648 { PInf, PNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2649 { PInf, MNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2650 { PInf, PLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2651 { PInf, MLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2652 { PInf, PSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2653 { PInf, MSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2654 { PInf, PSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity },
2655 { PInf, MSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity },
2656 { MInf, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2657 { MInf, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2658 { MInf, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2659 { MInf, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2660 { MInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2661 { MInf, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2662 { MInf, PNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2663 { MInf, MNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2664 { MInf, PLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2665 { MInf, MLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2666 { MInf, PSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2667 { MInf, MSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2668 { MInf, PSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity },
2669 { MInf, MSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity },
2670 { PZero, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2671 { PZero, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2672 { PZero, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2673 { PZero, MZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2674 { PZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2675 { PZero, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2676 { PZero, PNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2677 { PZero, MNormalValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2678 { PZero, PLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2679 { PZero, MLargestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2680 { PZero, PSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2681 { PZero, MSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2682 { PZero, PSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2683 { PZero, MSmallestNormalized, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2684 { MZero, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2685 { MZero, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2686 { MZero, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2687 { MZero, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2688 { MZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2689 { MZero, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2690 { MZero, PNormalValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2691 { MZero, MNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2692 { MZero, PLargestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2693 { MZero, MLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2694 { MZero, PSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2695 { MZero, MSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2696 { MZero, PSmallestNormalized, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2697 { MZero, MSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2698 { QNaN, PInf, "nan", APFloat::opOK, APFloat::fcNaN },
2699 { QNaN, MInf, "nan", APFloat::opOK, APFloat::fcNaN },
2700 { QNaN, PZero, "nan", APFloat::opOK, APFloat::fcNaN },
2701 { QNaN, MZero, "nan", APFloat::opOK, APFloat::fcNaN },
2702 { QNaN, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2703 { QNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2704 { QNaN, PNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
2705 { QNaN, MNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
2706 { QNaN, PLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2707 { QNaN, MLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2708 { QNaN, PSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2709 { QNaN, MSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2710 { QNaN, PSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
2711 { QNaN, MSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
2712 { SNaN, PInf, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2713 { SNaN, MInf, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2714 { SNaN, PZero, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2715 { SNaN, MZero, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2716 { SNaN, QNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2717 { SNaN, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2718 { SNaN, PNormalValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2719 { SNaN, MNormalValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2720 { SNaN, PLargestValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2721 { SNaN, MLargestValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2722 { SNaN, PSmallestValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2723 { SNaN, MSmallestValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2724 { SNaN, PSmallestNormalized, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2725 { SNaN, MSmallestNormalized, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2726 { PNormalValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2727 { PNormalValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2728 { PNormalValue, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2729 { PNormalValue, MZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2730 { PNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2731 { PNormalValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2732 { PNormalValue, PNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2733 { PNormalValue, MNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2734 { PNormalValue, PLargestValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2735 { PNormalValue, MLargestValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2736 { PNormalValue, PSmallestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2737 { PNormalValue, MSmallestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2738 { PNormalValue, PSmallestNormalized, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2739 { PNormalValue, MSmallestNormalized, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2740 { MNormalValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2741 { MNormalValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2742 { MNormalValue, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2743 { MNormalValue, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2744 { MNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2745 { MNormalValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2746 { MNormalValue, PNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2747 { MNormalValue, MNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2748 { MNormalValue, PLargestValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2749 { MNormalValue, MLargestValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2750 { MNormalValue, PSmallestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2751 { MNormalValue, MSmallestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2752 { MNormalValue, PSmallestNormalized, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2753 { MNormalValue, MSmallestNormalized, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2754 { PLargestValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2755 { PLargestValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2756 { PLargestValue, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2757 { PLargestValue, MZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2758 { PLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2759 { PLargestValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2760 { PLargestValue, PNormalValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2761 { PLargestValue, MNormalValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2762 { PLargestValue, PLargestValue, "inf", OverflowStatus, APFloat::fcInfinity },
2763 { PLargestValue, MLargestValue, "-inf", OverflowStatus, APFloat::fcInfinity },
2764 { PLargestValue, PSmallestValue, "0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal },
2765 { PLargestValue, MSmallestValue, "-0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal },
2766 { PLargestValue, PSmallestNormalized, "0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal },
2767 { PLargestValue, MSmallestNormalized, "-0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal },
2768 { MLargestValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2769 { MLargestValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2770 { MLargestValue, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2771 { MLargestValue, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2772 { MLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2773 { MLargestValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2774 { MLargestValue, PNormalValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2775 { MLargestValue, MNormalValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2776 { MLargestValue, PLargestValue, "-inf", OverflowStatus, APFloat::fcInfinity },
2777 { MLargestValue, MLargestValue, "inf", OverflowStatus, APFloat::fcInfinity },
2778 { MLargestValue, PSmallestValue, "-0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal },
2779 { MLargestValue, MSmallestValue, "0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal },
2780 { MLargestValue, PSmallestNormalized, "-0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal },
2781 { MLargestValue, MSmallestNormalized, "0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal },
2782 { PSmallestValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2783 { PSmallestValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2784 { PSmallestValue, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2785 { PSmallestValue, MZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2786 { PSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2787 { PSmallestValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2788 { PSmallestValue, PNormalValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2789 { PSmallestValue, MNormalValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2790 { PSmallestValue, PLargestValue, "0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal },
2791 { PSmallestValue, MLargestValue, "-0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal },
2792 { PSmallestValue, PSmallestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero },
2793 { PSmallestValue, MSmallestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2794 { PSmallestValue, PSmallestNormalized, "0x0p+0", UnderflowStatus, APFloat::fcZero },
2795 { PSmallestValue, MSmallestNormalized, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2796 { MSmallestValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2797 { MSmallestValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2798 { MSmallestValue, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2799 { MSmallestValue, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2800 { MSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2801 { MSmallestValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2802 { MSmallestValue, PNormalValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2803 { MSmallestValue, MNormalValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2804 { MSmallestValue, PLargestValue, "-0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal },
2805 { MSmallestValue, MLargestValue, "0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal },
2806 { MSmallestValue, PSmallestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2807 { MSmallestValue, MSmallestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero },
2808 { MSmallestValue, PSmallestNormalized, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2809 { MSmallestValue, MSmallestNormalized, "0x0p+0", UnderflowStatus, APFloat::fcZero },
2810 { PSmallestNormalized, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2811 { PSmallestNormalized, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2812 { PSmallestNormalized, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2813 { PSmallestNormalized, MZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2814 { PSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2815 { PSmallestNormalized, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2816 { PSmallestNormalized, PNormalValue, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2817 { PSmallestNormalized, MNormalValue, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2818 { PSmallestNormalized, PLargestValue, "0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal },
2819 { PSmallestNormalized, MLargestValue, "-0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal },
2820 { PSmallestNormalized, PSmallestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero },
2821 { PSmallestNormalized, MSmallestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2822 { PSmallestNormalized, PSmallestNormalized, "0x0p+0", UnderflowStatus, APFloat::fcZero },
2823 { PSmallestNormalized, MSmallestNormalized, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2824 { MSmallestNormalized, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2825 { MSmallestNormalized, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2826 { MSmallestNormalized, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2827 { MSmallestNormalized, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2828 { MSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2829 { MSmallestNormalized, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2830 { MSmallestNormalized, PNormalValue, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2831 { MSmallestNormalized, MNormalValue, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2832 { MSmallestNormalized, PLargestValue, "-0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal },
2833 { MSmallestNormalized, MLargestValue, "0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal },
2834 { MSmallestNormalized, PSmallestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2835 { MSmallestNormalized, MSmallestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero },
2836 { MSmallestNormalized, PSmallestNormalized, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2837 { MSmallestNormalized, MSmallestNormalized, "0x0p+0", UnderflowStatus, APFloat::fcZero },
2838
2839 {MaxQuad, MinQuad, "0x1.ffffffffffffffffffffffffffffp-111", APFloat::opOK,
2840 APFloat::fcNormal, APFloat::rmNearestTiesToEven},
2841 {MaxQuad, MinQuad, "0x1.ffffffffffffffffffffffffffffp-111", APFloat::opOK,
2842 APFloat::fcNormal, APFloat::rmTowardPositive},
2843 {MaxQuad, MinQuad, "0x1.ffffffffffffffffffffffffffffp-111", APFloat::opOK,
2844 APFloat::fcNormal, APFloat::rmTowardNegative},
2845 {MaxQuad, MinQuad, "0x1.ffffffffffffffffffffffffffffp-111", APFloat::opOK,
2846 APFloat::fcNormal, APFloat::rmTowardZero},
2847 {MaxQuad, MinQuad, "0x1.ffffffffffffffffffffffffffffp-111", APFloat::opOK,
2848 APFloat::fcNormal, APFloat::rmNearestTiesToAway},
2849
2850 {MaxQuad, NMinQuad, "-0x1.ffffffffffffffffffffffffffffp-111", APFloat::opOK,
2851 APFloat::fcNormal, APFloat::rmNearestTiesToEven},
2852 {MaxQuad, NMinQuad, "-0x1.ffffffffffffffffffffffffffffp-111", APFloat::opOK,
2853 APFloat::fcNormal, APFloat::rmTowardPositive},
2854 {MaxQuad, NMinQuad, "-0x1.ffffffffffffffffffffffffffffp-111", APFloat::opOK,
2855 APFloat::fcNormal, APFloat::rmTowardNegative},
2856 {MaxQuad, NMinQuad, "-0x1.ffffffffffffffffffffffffffffp-111", APFloat::opOK,
2857 APFloat::fcNormal, APFloat::rmTowardZero},
2858 {MaxQuad, NMinQuad, "-0x1.ffffffffffffffffffffffffffffp-111", APFloat::opOK,
2859 APFloat::fcNormal, APFloat::rmNearestTiesToAway},
2860
2861 {MaxQuad, MaxQuad, "inf", OverflowStatus, APFloat::fcInfinity,
2862 APFloat::rmNearestTiesToEven},
2863 {MaxQuad, MaxQuad, "inf", OverflowStatus, APFloat::fcInfinity,
2864 APFloat::rmTowardPositive},
2865 {MaxQuad, MaxQuad, "0x1.ffffffffffffffffffffffffffffp+16383",
2866 APFloat::opInexact, APFloat::fcNormal, APFloat::rmTowardNegative},
2867 {MaxQuad, MaxQuad, "0x1.ffffffffffffffffffffffffffffp+16383",
2868 APFloat::opInexact, APFloat::fcNormal, APFloat::rmTowardZero},
2869 {MaxQuad, MaxQuad, "inf", OverflowStatus, APFloat::fcInfinity,
2870 APFloat::rmNearestTiesToAway},
2871
2872 {MinQuad, MinQuad, "0", UnderflowStatus, APFloat::fcZero,
2873 APFloat::rmNearestTiesToEven},
2874 {MinQuad, MinQuad, "0x0.0000000000000000000000000001p-16382",
2875 UnderflowStatus, APFloat::fcNormal, APFloat::rmTowardPositive},
2876 {MinQuad, MinQuad, "0", UnderflowStatus, APFloat::fcZero,
2877 APFloat::rmTowardNegative},
2878 {MinQuad, MinQuad, "0", UnderflowStatus, APFloat::fcZero,
2879 APFloat::rmTowardZero},
2880 {MinQuad, MinQuad, "0", UnderflowStatus, APFloat::fcZero,
2881 APFloat::rmNearestTiesToAway},
2882
2883 {MinQuad, NMinQuad, "-0", UnderflowStatus, APFloat::fcZero,
2884 APFloat::rmNearestTiesToEven},
2885 {MinQuad, NMinQuad, "-0", UnderflowStatus, APFloat::fcZero,
2886 APFloat::rmTowardPositive},
2887 {MinQuad, NMinQuad, "-0x0.0000000000000000000000000001p-16382",
2888 UnderflowStatus, APFloat::fcNormal, APFloat::rmTowardNegative},
2889 {MinQuad, NMinQuad, "-0", UnderflowStatus, APFloat::fcZero,
2890 APFloat::rmTowardZero},
2891 {MinQuad, NMinQuad, "-0", UnderflowStatus, APFloat::fcZero,
2892 APFloat::rmNearestTiesToAway},
2893 };
2894
2895 for (size_t i = 0; i < std::size(SpecialCaseTests); ++i) {
2896 APFloat x(SpecialCaseTests[i].x);
2897 APFloat y(SpecialCaseTests[i].y);
2898 APFloat::opStatus status = x.multiply(y, SpecialCaseTests[i].roundingMode);
2899
2900 APFloat result(x.getSemantics(), SpecialCaseTests[i].result);
2901
2902 EXPECT_TRUE(result.bitwiseIsEqual(x));
2903 EXPECT_EQ(SpecialCaseTests[i].status, (int)status);
2904 EXPECT_EQ(SpecialCaseTests[i].category, (int)x.getCategory());
2905 }
2906 }
2907
2908 TEST(APFloatTest, divide) {
2909 // Test Special Cases against each other and normal values.
2910
2911 APFloat PInf = APFloat::getInf(APFloat::IEEEsingle(), false);
2912 APFloat MInf = APFloat::getInf(APFloat::IEEEsingle(), true);
2913 APFloat PZero = APFloat::getZero(APFloat::IEEEsingle(), false);
2914 APFloat MZero = APFloat::getZero(APFloat::IEEEsingle(), true);
2915 APFloat QNaN = APFloat::getNaN(APFloat::IEEEsingle(), false);
2916 APFloat SNaN = APFloat(APFloat::IEEEsingle(), "snan123");
2917 APFloat PNormalValue = APFloat(APFloat::IEEEsingle(), "0x1p+0");
2918 APFloat MNormalValue = APFloat(APFloat::IEEEsingle(), "-0x1p+0");
2919 APFloat PLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), false);
2920 APFloat MLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), true);
2921 APFloat PSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), false);
2922 APFloat MSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), true);
2923 APFloat PSmallestNormalized =
2924 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), false);
2925 APFloat MSmallestNormalized =
2926 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), true);
2927
2928 APFloat MaxQuad(APFloat::IEEEquad(),
2929 "0x1.ffffffffffffffffffffffffffffp+16383");
2930 APFloat MinQuad(APFloat::IEEEquad(),
2931 "0x0.0000000000000000000000000001p-16382");
2932 APFloat NMinQuad(APFloat::IEEEquad(),
2933 "-0x0.0000000000000000000000000001p-16382");
2934
2935 const int OverflowStatus = APFloat::opOverflow | APFloat::opInexact;
2936 const int UnderflowStatus = APFloat::opUnderflow | APFloat::opInexact;
2937
2938 struct {
2939 APFloat x;
2940 APFloat y;
2941 const char *result;
2942 int status;
2943 int category;
2944 APFloat::roundingMode roundingMode = APFloat::rmNearestTiesToEven;
2945 } SpecialCaseTests[] = {
2946 { PInf, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2947 { PInf, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2948 { PInf, PZero, "inf", APFloat::opOK, APFloat::fcInfinity },
2949 { PInf, MZero, "-inf", APFloat::opOK, APFloat::fcInfinity },
2950 { PInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2951 { PInf, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2952 { PInf, PNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2953 { PInf, MNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2954 { PInf, PLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2955 { PInf, MLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2956 { PInf, PSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2957 { PInf, MSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2958 { PInf, PSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity },
2959 { PInf, MSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity },
2960 { MInf, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2961 { MInf, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2962 { MInf, PZero, "-inf", APFloat::opOK, APFloat::fcInfinity },
2963 { MInf, MZero, "inf", APFloat::opOK, APFloat::fcInfinity },
2964 { MInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2965 { MInf, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2966 { MInf, PNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2967 { MInf, MNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2968 { MInf, PLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2969 { MInf, MLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2970 { MInf, PSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2971 { MInf, MSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2972 { MInf, PSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity },
2973 { MInf, MSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity },
2974 { PZero, PInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2975 { PZero, MInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2976 { PZero, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2977 { PZero, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2978 { PZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2979 { PZero, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2980 { PZero, PNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2981 { PZero, MNormalValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2982 { PZero, PLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2983 { PZero, MLargestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2984 { PZero, PSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2985 { PZero, MSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2986 { PZero, PSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2987 { PZero, MSmallestNormalized, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2988 { MZero, PInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2989 { MZero, MInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2990 { MZero, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2991 { MZero, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2992 { MZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2993 { MZero, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2994 { MZero, PNormalValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2995 { MZero, MNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2996 { MZero, PLargestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2997 { MZero, MLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2998 { MZero, PSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2999 { MZero, MSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3000 { MZero, PSmallestNormalized, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3001 { MZero, MSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3002 { QNaN, PInf, "nan", APFloat::opOK, APFloat::fcNaN },
3003 { QNaN, MInf, "nan", APFloat::opOK, APFloat::fcNaN },
3004 { QNaN, PZero, "nan", APFloat::opOK, APFloat::fcNaN },
3005 { QNaN, MZero, "nan", APFloat::opOK, APFloat::fcNaN },
3006 { QNaN, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
3007 { QNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
3008 { QNaN, PNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
3009 { QNaN, MNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
3010 { QNaN, PLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
3011 { QNaN, MLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
3012 { QNaN, PSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
3013 { QNaN, MSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
3014 { QNaN, PSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
3015 { QNaN, MSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
3016 { SNaN, PInf, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3017 { SNaN, MInf, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3018 { SNaN, PZero, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3019 { SNaN, MZero, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3020 { SNaN, QNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3021 { SNaN, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3022 { SNaN, PNormalValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3023 { SNaN, MNormalValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3024 { SNaN, PLargestValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3025 { SNaN, MLargestValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3026 { SNaN, PSmallestValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3027 { SNaN, MSmallestValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3028 { SNaN, PSmallestNormalized, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3029 { SNaN, MSmallestNormalized, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3030 { PNormalValue, PInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3031 { PNormalValue, MInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3032 { PNormalValue, PZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
3033 { PNormalValue, MZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
3034 { PNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
3035 { PNormalValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3036 { PNormalValue, PNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
3037 { PNormalValue, MNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
3038 { PNormalValue, PLargestValue, "0x1p-128", UnderflowStatus, APFloat::fcNormal },
3039 { PNormalValue, MLargestValue, "-0x1p-128", UnderflowStatus, APFloat::fcNormal },
3040 { PNormalValue, PSmallestValue, "inf", OverflowStatus, APFloat::fcInfinity },
3041 { PNormalValue, MSmallestValue, "-inf", OverflowStatus, APFloat::fcInfinity },
3042 { PNormalValue, PSmallestNormalized, "0x1p+126", APFloat::opOK, APFloat::fcNormal },
3043 { PNormalValue, MSmallestNormalized, "-0x1p+126", APFloat::opOK, APFloat::fcNormal },
3044 { MNormalValue, PInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3045 { MNormalValue, MInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3046 { MNormalValue, PZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
3047 { MNormalValue, MZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
3048 { MNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
3049 { MNormalValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3050 { MNormalValue, PNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
3051 { MNormalValue, MNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
3052 { MNormalValue, PLargestValue, "-0x1p-128", UnderflowStatus, APFloat::fcNormal },
3053 { MNormalValue, MLargestValue, "0x1p-128", UnderflowStatus, APFloat::fcNormal },
3054 { MNormalValue, PSmallestValue, "-inf", OverflowStatus, APFloat::fcInfinity },
3055 { MNormalValue, MSmallestValue, "inf", OverflowStatus, APFloat::fcInfinity },
3056 { MNormalValue, PSmallestNormalized, "-0x1p+126", APFloat::opOK, APFloat::fcNormal },
3057 { MNormalValue, MSmallestNormalized, "0x1p+126", APFloat::opOK, APFloat::fcNormal },
3058 { PLargestValue, PInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3059 { PLargestValue, MInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3060 { PLargestValue, PZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
3061 { PLargestValue, MZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
3062 { PLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
3063 { PLargestValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3064 { PLargestValue, PNormalValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
3065 { PLargestValue, MNormalValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
3066 { PLargestValue, PLargestValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
3067 { PLargestValue, MLargestValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
3068 { PLargestValue, PSmallestValue, "inf", OverflowStatus, APFloat::fcInfinity },
3069 { PLargestValue, MSmallestValue, "-inf", OverflowStatus, APFloat::fcInfinity },
3070 { PLargestValue, PSmallestNormalized, "inf", OverflowStatus, APFloat::fcInfinity },
3071 { PLargestValue, MSmallestNormalized, "-inf", OverflowStatus, APFloat::fcInfinity },
3072 { MLargestValue, PInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3073 { MLargestValue, MInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3074 { MLargestValue, PZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
3075 { MLargestValue, MZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
3076 { MLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
3077 { MLargestValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3078 { MLargestValue, PNormalValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
3079 { MLargestValue, MNormalValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
3080 { MLargestValue, PLargestValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
3081 { MLargestValue, MLargestValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
3082 { MLargestValue, PSmallestValue, "-inf", OverflowStatus, APFloat::fcInfinity },
3083 { MLargestValue, MSmallestValue, "inf", OverflowStatus, APFloat::fcInfinity },
3084 { MLargestValue, PSmallestNormalized, "-inf", OverflowStatus, APFloat::fcInfinity },
3085 { MLargestValue, MSmallestNormalized, "inf", OverflowStatus, APFloat::fcInfinity },
3086 { PSmallestValue, PInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3087 { PSmallestValue, MInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3088 { PSmallestValue, PZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
3089 { PSmallestValue, MZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
3090 { PSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
3091 { PSmallestValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3092 { PSmallestValue, PNormalValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
3093 { PSmallestValue, MNormalValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
3094 { PSmallestValue, PLargestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero },
3095 { PSmallestValue, MLargestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
3096 { PSmallestValue, PSmallestValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
3097 { PSmallestValue, MSmallestValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
3098 { PSmallestValue, PSmallestNormalized, "0x1p-23", APFloat::opOK, APFloat::fcNormal },
3099 { PSmallestValue, MSmallestNormalized, "-0x1p-23", APFloat::opOK, APFloat::fcNormal },
3100 { MSmallestValue, PInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3101 { MSmallestValue, MInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3102 { MSmallestValue, PZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
3103 { MSmallestValue, MZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
3104 { MSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
3105 { MSmallestValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3106 { MSmallestValue, PNormalValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
3107 { MSmallestValue, MNormalValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
3108 { MSmallestValue, PLargestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
3109 { MSmallestValue, MLargestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero },
3110 { MSmallestValue, PSmallestValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
3111 { MSmallestValue, MSmallestValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
3112 { MSmallestValue, PSmallestNormalized, "-0x1p-23", APFloat::opOK, APFloat::fcNormal },
3113 { MSmallestValue, MSmallestNormalized, "0x1p-23", APFloat::opOK, APFloat::fcNormal },
3114 { PSmallestNormalized, PInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3115 { PSmallestNormalized, MInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3116 { PSmallestNormalized, PZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
3117 { PSmallestNormalized, MZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
3118 { PSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
3119 { PSmallestNormalized, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3120 { PSmallestNormalized, PNormalValue, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
3121 { PSmallestNormalized, MNormalValue, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
3122 { PSmallestNormalized, PLargestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero },
3123 { PSmallestNormalized, MLargestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
3124 { PSmallestNormalized, PSmallestValue, "0x1p+23", APFloat::opOK, APFloat::fcNormal },
3125 { PSmallestNormalized, MSmallestValue, "-0x1p+23", APFloat::opOK, APFloat::fcNormal },
3126 { PSmallestNormalized, PSmallestNormalized, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
3127 { PSmallestNormalized, MSmallestNormalized, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
3128 { MSmallestNormalized, PInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3129 { MSmallestNormalized, MInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3130 { MSmallestNormalized, PZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
3131 { MSmallestNormalized, MZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
3132 { MSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
3133 { MSmallestNormalized, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3134 { MSmallestNormalized, PNormalValue, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
3135 { MSmallestNormalized, MNormalValue, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
3136 { MSmallestNormalized, PLargestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
3137 { MSmallestNormalized, MLargestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero },
3138 { MSmallestNormalized, PSmallestValue, "-0x1p+23", APFloat::opOK, APFloat::fcNormal },
3139 { MSmallestNormalized, MSmallestValue, "0x1p+23", APFloat::opOK, APFloat::fcNormal },
3140 { MSmallestNormalized, PSmallestNormalized, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
3141 { MSmallestNormalized, MSmallestNormalized, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
3142
3143 {MaxQuad, NMinQuad, "-inf", OverflowStatus, APFloat::fcInfinity,
3144 APFloat::rmNearestTiesToEven},
3145 {MaxQuad, NMinQuad, "-0x1.ffffffffffffffffffffffffffffp+16383",
3146 APFloat::opInexact, APFloat::fcNormal, APFloat::rmTowardPositive},
3147 {MaxQuad, NMinQuad, "-inf", OverflowStatus, APFloat::fcInfinity,
3148 APFloat::rmTowardNegative},
3149 {MaxQuad, NMinQuad, "-0x1.ffffffffffffffffffffffffffffp+16383",
3150 APFloat::opInexact, APFloat::fcNormal, APFloat::rmTowardZero},
3151 {MaxQuad, NMinQuad, "-inf", OverflowStatus, APFloat::fcInfinity,
3152 APFloat::rmNearestTiesToAway},
3153
3154 {MinQuad, MaxQuad, "0", UnderflowStatus, APFloat::fcZero,
3155 APFloat::rmNearestTiesToEven},
3156 {MinQuad, MaxQuad, "0x0.0000000000000000000000000001p-16382",
3157 UnderflowStatus, APFloat::fcNormal, APFloat::rmTowardPositive},
3158 {MinQuad, MaxQuad, "0", UnderflowStatus, APFloat::fcZero,
3159 APFloat::rmTowardNegative},
3160 {MinQuad, MaxQuad, "0", UnderflowStatus, APFloat::fcZero,
3161 APFloat::rmTowardZero},
3162 {MinQuad, MaxQuad, "0", UnderflowStatus, APFloat::fcZero,
3163 APFloat::rmNearestTiesToAway},
3164
3165 {NMinQuad, MaxQuad, "-0", UnderflowStatus, APFloat::fcZero,
3166 APFloat::rmNearestTiesToEven},
3167 {NMinQuad, MaxQuad, "-0", UnderflowStatus, APFloat::fcZero,
3168 APFloat::rmTowardPositive},
3169 {NMinQuad, MaxQuad, "-0x0.0000000000000000000000000001p-16382",
3170 UnderflowStatus, APFloat::fcNormal, APFloat::rmTowardNegative},
3171 {NMinQuad, MaxQuad, "-0", UnderflowStatus, APFloat::fcZero,
3172 APFloat::rmTowardZero},
3173 {NMinQuad, MaxQuad, "-0", UnderflowStatus, APFloat::fcZero,
3174 APFloat::rmNearestTiesToAway},
3175 };
3176
3177 for (size_t i = 0; i < std::size(SpecialCaseTests); ++i) {
3178 APFloat x(SpecialCaseTests[i].x);
3179 APFloat y(SpecialCaseTests[i].y);
3180 APFloat::opStatus status = x.divide(y, SpecialCaseTests[i].roundingMode);
3181
3182 APFloat result(x.getSemantics(), SpecialCaseTests[i].result);
3183
3184 EXPECT_TRUE(result.bitwiseIsEqual(x));
3185 EXPECT_EQ(SpecialCaseTests[i].status, (int)status);
3186 EXPECT_EQ(SpecialCaseTests[i].category, (int)x.getCategory());
3187 }
3188 }
3189
3190 TEST(APFloatTest, operatorOverloads) {
3191 // This is mostly testing that these operator overloads compile.
3192 APFloat One = APFloat(APFloat::IEEEsingle(), "0x1p+0");
3193 APFloat Two = APFloat(APFloat::IEEEsingle(), "0x2p+0");
3194 EXPECT_TRUE(Two.bitwiseIsEqual(One + One));
3195 EXPECT_TRUE(One.bitwiseIsEqual(Two - One));
3196 EXPECT_TRUE(Two.bitwiseIsEqual(One * Two));
3197 EXPECT_TRUE(One.bitwiseIsEqual(Two / Two));
3198 }
3199
3200 TEST(APFloatTest, Comparisons) {
3201 enum {MNan, MInf, MBig, MOne, MZer, PZer, POne, PBig, PInf, PNan, NumVals};
3202 APFloat Vals[NumVals] = {
3203 APFloat::getNaN(APFloat::IEEEsingle(), true),
3204 APFloat::getInf(APFloat::IEEEsingle(), true),
3205 APFloat::getLargest(APFloat::IEEEsingle(), true),
3206 APFloat(APFloat::IEEEsingle(), "-0x1p+0"),
3207 APFloat::getZero(APFloat::IEEEsingle(), true),
3208 APFloat::getZero(APFloat::IEEEsingle(), false),
3209 APFloat(APFloat::IEEEsingle(), "0x1p+0"),
3210 APFloat::getLargest(APFloat::IEEEsingle(), false),
3211 APFloat::getInf(APFloat::IEEEsingle(), false),
3212 APFloat::getNaN(APFloat::IEEEsingle(), false),
3213 };
3214 using Relation = void (*)(const APFloat &, const APFloat &);
3215 Relation LT = [](const APFloat &LHS, const APFloat &RHS) {
3216 EXPECT_FALSE(LHS == RHS);
3217 EXPECT_TRUE(LHS != RHS);
3218 EXPECT_TRUE(LHS < RHS);
3219 EXPECT_FALSE(LHS > RHS);
3220 EXPECT_TRUE(LHS <= RHS);
3221 EXPECT_FALSE(LHS >= RHS);
3222 };
3223 Relation EQ = [](const APFloat &LHS, const APFloat &RHS) {
3224 EXPECT_TRUE(LHS == RHS);
3225 EXPECT_FALSE(LHS != RHS);
3226 EXPECT_FALSE(LHS < RHS);
3227 EXPECT_FALSE(LHS > RHS);
3228 EXPECT_TRUE(LHS <= RHS);
3229 EXPECT_TRUE(LHS >= RHS);
3230 };
3231 Relation GT = [](const APFloat &LHS, const APFloat &RHS) {
3232 EXPECT_FALSE(LHS == RHS);
3233 EXPECT_TRUE(LHS != RHS);
3234 EXPECT_FALSE(LHS < RHS);
3235 EXPECT_TRUE(LHS > RHS);
3236 EXPECT_FALSE(LHS <= RHS);
3237 EXPECT_TRUE(LHS >= RHS);
3238 };
3239 Relation UN = [](const APFloat &LHS, const APFloat &RHS) {
3240 EXPECT_FALSE(LHS == RHS);
3241 EXPECT_TRUE(LHS != RHS);
3242 EXPECT_FALSE(LHS < RHS);
3243 EXPECT_FALSE(LHS > RHS);
3244 EXPECT_FALSE(LHS <= RHS);
3245 EXPECT_FALSE(LHS >= RHS);
3246 };
3247 Relation Relations[NumVals][NumVals] = {
3248 // -N -I -B -1 -0 +0 +1 +B +I +N
3249 /* MNan */ {UN, UN, UN, UN, UN, UN, UN, UN, UN, UN},
3250 /* MInf */ {UN, EQ, LT, LT, LT, LT, LT, LT, LT, UN},
3251 /* MBig */ {UN, GT, EQ, LT, LT, LT, LT, LT, LT, UN},
3252 /* MOne */ {UN, GT, GT, EQ, LT, LT, LT, LT, LT, UN},
3253 /* MZer */ {UN, GT, GT, GT, EQ, EQ, LT, LT, LT, UN},
3254 /* PZer */ {UN, GT, GT, GT, EQ, EQ, LT, LT, LT, UN},
3255 /* POne */ {UN, GT, GT, GT, GT, GT, EQ, LT, LT, UN},
3256 /* PBig */ {UN, GT, GT, GT, GT, GT, GT, EQ, LT, UN},
3257 /* PInf */ {UN, GT, GT, GT, GT, GT, GT, GT, EQ, UN},
3258 /* PNan */ {UN, UN, UN, UN, UN, UN, UN, UN, UN, UN},
3259 };
3260 for (unsigned I = 0; I < NumVals; ++I)
3261 for (unsigned J = 0; J < NumVals; ++J)
3262 Relations[I][J](Vals[I], Vals[J]);
3263 }
3264
3265 TEST(APFloatTest, abs) {
3266 APFloat PInf = APFloat::getInf(APFloat::IEEEsingle(), false);
3267 APFloat MInf = APFloat::getInf(APFloat::IEEEsingle(), true);
3268 APFloat PZero = APFloat::getZero(APFloat::IEEEsingle(), false);
3269 APFloat MZero = APFloat::getZero(APFloat::IEEEsingle(), true);
3270 APFloat PQNaN = APFloat::getNaN(APFloat::IEEEsingle(), false);
3271 APFloat MQNaN = APFloat::getNaN(APFloat::IEEEsingle(), true);
3272 APFloat PSNaN = APFloat::getSNaN(APFloat::IEEEsingle(), false);
3273 APFloat MSNaN = APFloat::getSNaN(APFloat::IEEEsingle(), true);
3274 APFloat PNormalValue = APFloat(APFloat::IEEEsingle(), "0x1p+0");
3275 APFloat MNormalValue = APFloat(APFloat::IEEEsingle(), "-0x1p+0");
3276 APFloat PLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), false);
3277 APFloat MLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), true);
3278 APFloat PSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), false);
3279 APFloat MSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), true);
3280 APFloat PSmallestNormalized =
3281 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), false);
3282 APFloat MSmallestNormalized =
3283 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), true);
3284
3285 EXPECT_TRUE(PInf.bitwiseIsEqual(abs(PInf)));
3286 EXPECT_TRUE(PInf.bitwiseIsEqual(abs(MInf)));
3287 EXPECT_TRUE(PZero.bitwiseIsEqual(abs(PZero)));
3288 EXPECT_TRUE(PZero.bitwiseIsEqual(abs(MZero)));
3289 EXPECT_TRUE(PQNaN.bitwiseIsEqual(abs(PQNaN)));
3290 EXPECT_TRUE(PQNaN.bitwiseIsEqual(abs(MQNaN)));
3291 EXPECT_TRUE(PSNaN.bitwiseIsEqual(abs(PSNaN)));
3292 EXPECT_TRUE(PSNaN.bitwiseIsEqual(abs(MSNaN)));
3293 EXPECT_TRUE(PNormalValue.bitwiseIsEqual(abs(PNormalValue)));
3294 EXPECT_TRUE(PNormalValue.bitwiseIsEqual(abs(MNormalValue)));
3295 EXPECT_TRUE(PLargestValue.bitwiseIsEqual(abs(PLargestValue)));
3296 EXPECT_TRUE(PLargestValue.bitwiseIsEqual(abs(MLargestValue)));
3297 EXPECT_TRUE(PSmallestValue.bitwiseIsEqual(abs(PSmallestValue)));
3298 EXPECT_TRUE(PSmallestValue.bitwiseIsEqual(abs(MSmallestValue)));
3299 EXPECT_TRUE(PSmallestNormalized.bitwiseIsEqual(abs(PSmallestNormalized)));
3300 EXPECT_TRUE(PSmallestNormalized.bitwiseIsEqual(abs(MSmallestNormalized)));
3301 }
3302
3303 TEST(APFloatTest, neg) {
3304 APFloat One = APFloat(APFloat::IEEEsingle(), "1.0");
3305 APFloat NegOne = APFloat(APFloat::IEEEsingle(), "-1.0");
3306 APFloat Zero = APFloat::getZero(APFloat::IEEEsingle(), false);
3307 APFloat NegZero = APFloat::getZero(APFloat::IEEEsingle(), true);
3308 APFloat Inf = APFloat::getInf(APFloat::IEEEsingle(), false);
3309 APFloat NegInf = APFloat::getInf(APFloat::IEEEsingle(), true);
3310 APFloat QNaN = APFloat::getNaN(APFloat::IEEEsingle(), false);
3311 APFloat NegQNaN = APFloat::getNaN(APFloat::IEEEsingle(), true);
3312
3313 EXPECT_TRUE(NegOne.bitwiseIsEqual(neg(One)));
3314 EXPECT_TRUE(One.bitwiseIsEqual(neg(NegOne)));
3315 EXPECT_TRUE(NegZero.bitwiseIsEqual(neg(Zero)));
3316 EXPECT_TRUE(Zero.bitwiseIsEqual(neg(NegZero)));
3317 EXPECT_TRUE(NegInf.bitwiseIsEqual(neg(Inf)));
3318 EXPECT_TRUE(Inf.bitwiseIsEqual(neg(NegInf)));
3319 EXPECT_TRUE(NegInf.bitwiseIsEqual(neg(Inf)));
3320 EXPECT_TRUE(Inf.bitwiseIsEqual(neg(NegInf)));
3321 EXPECT_TRUE(NegQNaN.bitwiseIsEqual(neg(QNaN)));
3322 EXPECT_TRUE(QNaN.bitwiseIsEqual(neg(NegQNaN)));
3323
3324 EXPECT_TRUE(NegOne.bitwiseIsEqual(-One));
3325 EXPECT_TRUE(One.bitwiseIsEqual(-NegOne));
3326 EXPECT_TRUE(NegZero.bitwiseIsEqual(-Zero));
3327 EXPECT_TRUE(Zero.bitwiseIsEqual(-NegZero));
3328 EXPECT_TRUE(NegInf.bitwiseIsEqual(-Inf));
3329 EXPECT_TRUE(Inf.bitwiseIsEqual(-NegInf));
3330 EXPECT_TRUE(NegInf.bitwiseIsEqual(-Inf));
3331 EXPECT_TRUE(Inf.bitwiseIsEqual(-NegInf));
3332 EXPECT_TRUE(NegQNaN.bitwiseIsEqual(-QNaN));
3333 EXPECT_TRUE(QNaN.bitwiseIsEqual(-NegQNaN));
3334 }
3335
3336 TEST(APFloatTest, ilogb) {
3337 EXPECT_EQ(-1074, ilogb(APFloat::getSmallest(APFloat::IEEEdouble(), false)));
3338 EXPECT_EQ(-1074, ilogb(APFloat::getSmallest(APFloat::IEEEdouble(), true)));
3339 EXPECT_EQ(-1023, ilogb(APFloat(APFloat::IEEEdouble(), "0x1.ffffffffffffep-1024")));
3340 EXPECT_EQ(-1023, ilogb(APFloat(APFloat::IEEEdouble(), "0x1.ffffffffffffep-1023")));
3341 EXPECT_EQ(-1023, ilogb(APFloat(APFloat::IEEEdouble(), "-0x1.ffffffffffffep-1023")));
3342 EXPECT_EQ(-51, ilogb(APFloat(APFloat::IEEEdouble(), "0x1p-51")));
3343 EXPECT_EQ(-1023, ilogb(APFloat(APFloat::IEEEdouble(), "0x1.c60f120d9f87cp-1023")));
3344 EXPECT_EQ(-2, ilogb(APFloat(APFloat::IEEEdouble(), "0x0.ffffp-1")));
3345 EXPECT_EQ(-1023, ilogb(APFloat(APFloat::IEEEdouble(), "0x1.fffep-1023")));
3346 EXPECT_EQ(1023, ilogb(APFloat::getLargest(APFloat::IEEEdouble(), false)));
3347 EXPECT_EQ(1023, ilogb(APFloat::getLargest(APFloat::IEEEdouble(), true)));
3348
3349
3350 EXPECT_EQ(0, ilogb(APFloat(APFloat::IEEEsingle(), "0x1p+0")));
3351 EXPECT_EQ(0, ilogb(APFloat(APFloat::IEEEsingle(), "-0x1p+0")));
3352 EXPECT_EQ(42, ilogb(APFloat(APFloat::IEEEsingle(), "0x1p+42")));
3353 EXPECT_EQ(-42, ilogb(APFloat(APFloat::IEEEsingle(), "0x1p-42")));
3354
3355 EXPECT_EQ(APFloat::IEK_Inf,
3356 ilogb(APFloat::getInf(APFloat::IEEEsingle(), false)));
3357 EXPECT_EQ(APFloat::IEK_Inf,
3358 ilogb(APFloat::getInf(APFloat::IEEEsingle(), true)));
3359 EXPECT_EQ(APFloat::IEK_Zero,
3360 ilogb(APFloat::getZero(APFloat::IEEEsingle(), false)));
3361 EXPECT_EQ(APFloat::IEK_Zero,
3362 ilogb(APFloat::getZero(APFloat::IEEEsingle(), true)));
3363 EXPECT_EQ(APFloat::IEK_NaN,
3364 ilogb(APFloat::getNaN(APFloat::IEEEsingle(), false)));
3365 EXPECT_EQ(APFloat::IEK_NaN,
3366 ilogb(APFloat::getSNaN(APFloat::IEEEsingle(), false)));
3367
3368 EXPECT_EQ(127, ilogb(APFloat::getLargest(APFloat::IEEEsingle(), false)));
3369 EXPECT_EQ(127, ilogb(APFloat::getLargest(APFloat::IEEEsingle(), true)));
3370
3371 EXPECT_EQ(-149, ilogb(APFloat::getSmallest(APFloat::IEEEsingle(), false)));
3372 EXPECT_EQ(-149, ilogb(APFloat::getSmallest(APFloat::IEEEsingle(), true)));
3373 EXPECT_EQ(-126,
3374 ilogb(APFloat::getSmallestNormalized(APFloat::IEEEsingle(), false)));
3375 EXPECT_EQ(-126,
3376 ilogb(APFloat::getSmallestNormalized(APFloat::IEEEsingle(), true)));
3377 }
3378
3379 TEST(APFloatTest, scalbn) {
3380
3381 const APFloat::roundingMode RM = APFloat::rmNearestTiesToEven;
3382 EXPECT_TRUE(
3383 APFloat(APFloat::IEEEsingle(), "0x1p+0")
3384 .bitwiseIsEqual(scalbn(APFloat(APFloat::IEEEsingle(), "0x1p+0"), 0, RM)));
3385 EXPECT_TRUE(
3386 APFloat(APFloat::IEEEsingle(), "0x1p+42")
3387 .bitwiseIsEqual(scalbn(APFloat(APFloat::IEEEsingle(), "0x1p+0"), 42, RM)));
3388 EXPECT_TRUE(
3389 APFloat(APFloat::IEEEsingle(), "0x1p-42")
3390 .bitwiseIsEqual(scalbn(APFloat(APFloat::IEEEsingle(), "0x1p+0"), -42, RM)));
3391
3392 APFloat PInf = APFloat::getInf(APFloat::IEEEsingle(), false);
3393 APFloat MInf = APFloat::getInf(APFloat::IEEEsingle(), true);
3394 APFloat PZero = APFloat::getZero(APFloat::IEEEsingle(), false);
3395 APFloat MZero = APFloat::getZero(APFloat::IEEEsingle(), true);
3396 APFloat QPNaN = APFloat::getNaN(APFloat::IEEEsingle(), false);
3397 APFloat QMNaN = APFloat::getNaN(APFloat::IEEEsingle(), true);
3398 APFloat SNaN = APFloat::getSNaN(APFloat::IEEEsingle(), false);
3399
3400 EXPECT_TRUE(PInf.bitwiseIsEqual(scalbn(PInf, 0, RM)));
3401 EXPECT_TRUE(MInf.bitwiseIsEqual(scalbn(MInf, 0, RM)));
3402 EXPECT_TRUE(PZero.bitwiseIsEqual(scalbn(PZero, 0, RM)));
3403 EXPECT_TRUE(MZero.bitwiseIsEqual(scalbn(MZero, 0, RM)));
3404 EXPECT_TRUE(QPNaN.bitwiseIsEqual(scalbn(QPNaN, 0, RM)));
3405 EXPECT_TRUE(QMNaN.bitwiseIsEqual(scalbn(QMNaN, 0, RM)));
3406 EXPECT_FALSE(scalbn(SNaN, 0, RM).isSignaling());
3407
3408 APFloat ScalbnSNaN = scalbn(SNaN, 1, RM);
3409 EXPECT_TRUE(ScalbnSNaN.isNaN() && !ScalbnSNaN.isSignaling());
3410
3411 // Make sure highest bit of payload is preserved.
3412 const APInt Payload(64, (UINT64_C(1) << 50) |
3413 (UINT64_C(1) << 49) |
3414 (UINT64_C(1234) << 32) |
3415 1);
3416
3417 APFloat SNaNWithPayload = APFloat::getSNaN(APFloat::IEEEdouble(), false,
3418 &Payload);
3419 APFloat QuietPayload = scalbn(SNaNWithPayload, 1, RM);
3420 EXPECT_TRUE(QuietPayload.isNaN() && !QuietPayload.isSignaling());
3421 EXPECT_EQ(Payload, QuietPayload.bitcastToAPInt().getLoBits(51));
3422
3423 EXPECT_TRUE(PInf.bitwiseIsEqual(
3424 scalbn(APFloat(APFloat::IEEEsingle(), "0x1p+0"), 128, RM)));
3425 EXPECT_TRUE(MInf.bitwiseIsEqual(
3426 scalbn(APFloat(APFloat::IEEEsingle(), "-0x1p+0"), 128, RM)));
3427 EXPECT_TRUE(PInf.bitwiseIsEqual(
3428 scalbn(APFloat(APFloat::IEEEsingle(), "0x1p+127"), 1, RM)));
3429 EXPECT_TRUE(PZero.bitwiseIsEqual(
3430 scalbn(APFloat(APFloat::IEEEsingle(), "0x1p-127"), -127, RM)));
3431 EXPECT_TRUE(MZero.bitwiseIsEqual(
3432 scalbn(APFloat(APFloat::IEEEsingle(), "-0x1p-127"), -127, RM)));
3433 EXPECT_TRUE(APFloat(APFloat::IEEEsingle(), "-0x1p-149").bitwiseIsEqual(
3434 scalbn(APFloat(APFloat::IEEEsingle(), "-0x1p-127"), -22, RM)));
3435 EXPECT_TRUE(PZero.bitwiseIsEqual(
3436 scalbn(APFloat(APFloat::IEEEsingle(), "0x1p-126"), -24, RM)));
3437
3438
3439 APFloat SmallestF64 = APFloat::getSmallest(APFloat::IEEEdouble(), false);
3440 APFloat NegSmallestF64 = APFloat::getSmallest(APFloat::IEEEdouble(), true);
3441
3442 APFloat LargestF64 = APFloat::getLargest(APFloat::IEEEdouble(), false);
3443 APFloat NegLargestF64 = APFloat::getLargest(APFloat::IEEEdouble(), true);
3444
3445 APFloat SmallestNormalizedF64
3446 = APFloat::getSmallestNormalized(APFloat::IEEEdouble(), false);
3447 APFloat NegSmallestNormalizedF64
3448 = APFloat::getSmallestNormalized(APFloat::IEEEdouble(), true);
3449
3450 APFloat LargestDenormalF64(APFloat::IEEEdouble(), "0x1.ffffffffffffep-1023");
3451 APFloat NegLargestDenormalF64(APFloat::IEEEdouble(), "-0x1.ffffffffffffep-1023");
3452
3453
3454 EXPECT_TRUE(SmallestF64.bitwiseIsEqual(
3455 scalbn(APFloat(APFloat::IEEEdouble(), "0x1p-1074"), 0, RM)));
3456 EXPECT_TRUE(NegSmallestF64.bitwiseIsEqual(
3457 scalbn(APFloat(APFloat::IEEEdouble(), "-0x1p-1074"), 0, RM)));
3458
3459 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1p+1023")
3460 .bitwiseIsEqual(scalbn(SmallestF64, 2097, RM)));
3461
3462 EXPECT_TRUE(scalbn(SmallestF64, -2097, RM).isPosZero());
3463 EXPECT_TRUE(scalbn(SmallestF64, -2098, RM).isPosZero());
3464 EXPECT_TRUE(scalbn(SmallestF64, -2099, RM).isPosZero());
3465 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1p+1022")
3466 .bitwiseIsEqual(scalbn(SmallestF64, 2096, RM)));
3467 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1p+1023")
3468 .bitwiseIsEqual(scalbn(SmallestF64, 2097, RM)));
3469 EXPECT_TRUE(scalbn(SmallestF64, 2098, RM).isInfinity());
3470 EXPECT_TRUE(scalbn(SmallestF64, 2099, RM).isInfinity());
3471
3472 // Test for integer overflows when adding to exponent.
3473 EXPECT_TRUE(scalbn(SmallestF64, -INT_MAX, RM).isPosZero());
3474 EXPECT_TRUE(scalbn(LargestF64, INT_MAX, RM).isInfinity());
3475
3476 EXPECT_TRUE(LargestDenormalF64
3477 .bitwiseIsEqual(scalbn(LargestDenormalF64, 0, RM)));
3478 EXPECT_TRUE(NegLargestDenormalF64
3479 .bitwiseIsEqual(scalbn(NegLargestDenormalF64, 0, RM)));
3480
3481 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.ffffffffffffep-1022")
3482 .bitwiseIsEqual(scalbn(LargestDenormalF64, 1, RM)));
3483 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "-0x1.ffffffffffffep-1021")
3484 .bitwiseIsEqual(scalbn(NegLargestDenormalF64, 2, RM)));
3485
3486 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.ffffffffffffep+1")
3487 .bitwiseIsEqual(scalbn(LargestDenormalF64, 1024, RM)));
3488 EXPECT_TRUE(scalbn(LargestDenormalF64, -1023, RM).isPosZero());
3489 EXPECT_TRUE(scalbn(LargestDenormalF64, -1024, RM).isPosZero());
3490 EXPECT_TRUE(scalbn(LargestDenormalF64, -2048, RM).isPosZero());
3491 EXPECT_TRUE(scalbn(LargestDenormalF64, 2047, RM).isInfinity());
3492 EXPECT_TRUE(scalbn(LargestDenormalF64, 2098, RM).isInfinity());
3493 EXPECT_TRUE(scalbn(LargestDenormalF64, 2099, RM).isInfinity());
3494
3495 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.ffffffffffffep-2")
3496 .bitwiseIsEqual(scalbn(LargestDenormalF64, 1021, RM)));
3497 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.ffffffffffffep-1")
3498 .bitwiseIsEqual(scalbn(LargestDenormalF64, 1022, RM)));
3499 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.ffffffffffffep+0")
3500 .bitwiseIsEqual(scalbn(LargestDenormalF64, 1023, RM)));
3501 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.ffffffffffffep+1023")
3502 .bitwiseIsEqual(scalbn(LargestDenormalF64, 2046, RM)));
3503 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1p+974")
3504 .bitwiseIsEqual(scalbn(SmallestF64, 2048, RM)));
3505
3506 APFloat RandomDenormalF64(APFloat::IEEEdouble(), "0x1.c60f120d9f87cp+51");
3507 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.c60f120d9f87cp-972")
3508 .bitwiseIsEqual(scalbn(RandomDenormalF64, -1023, RM)));
3509 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.c60f120d9f87cp-1")
3510 .bitwiseIsEqual(scalbn(RandomDenormalF64, -52, RM)));
3511 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.c60f120d9f87cp-2")
3512 .bitwiseIsEqual(scalbn(RandomDenormalF64, -53, RM)));
3513 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.c60f120d9f87cp+0")
3514 .bitwiseIsEqual(scalbn(RandomDenormalF64, -51, RM)));
3515
3516 EXPECT_TRUE(scalbn(RandomDenormalF64, -2097, RM).isPosZero());
3517 EXPECT_TRUE(scalbn(RandomDenormalF64, -2090, RM).isPosZero());
3518
3519
3520 EXPECT_TRUE(
3521 APFloat(APFloat::IEEEdouble(), "-0x1p-1073")
3522 .bitwiseIsEqual(scalbn(NegLargestF64, -2097, RM)));
3523
3524 EXPECT_TRUE(
3525 APFloat(APFloat::IEEEdouble(), "-0x1p-1024")
3526 .bitwiseIsEqual(scalbn(NegLargestF64, -2048, RM)));
3527
3528 EXPECT_TRUE(
3529 APFloat(APFloat::IEEEdouble(), "0x1p-1073")
3530 .bitwiseIsEqual(scalbn(LargestF64, -2097, RM)));
3531
3532 EXPECT_TRUE(
3533 APFloat(APFloat::IEEEdouble(), "0x1p-1074")
3534 .bitwiseIsEqual(scalbn(LargestF64, -2098, RM)));
3535 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "-0x1p-1074")
3536 .bitwiseIsEqual(scalbn(NegLargestF64, -2098, RM)));
3537 EXPECT_TRUE(scalbn(NegLargestF64, -2099, RM).isNegZero());
3538 EXPECT_TRUE(scalbn(LargestF64, 1, RM).isInfinity());
3539
3540
3541 EXPECT_TRUE(
3542 APFloat(APFloat::IEEEdouble(), "0x1p+0")
3543 .bitwiseIsEqual(scalbn(APFloat(APFloat::IEEEdouble(), "0x1p+52"), -52, RM)));
3544
3545 EXPECT_TRUE(
3546 APFloat(APFloat::IEEEdouble(), "0x1p-103")
3547 .bitwiseIsEqual(scalbn(APFloat(APFloat::IEEEdouble(), "0x1p-51"), -52, RM)));
3548 }
3549
3550 TEST(APFloatTest, frexp) {
3551 const APFloat::roundingMode RM = APFloat::rmNearestTiesToEven;
3552
3553 APFloat PZero = APFloat::getZero(APFloat::IEEEdouble(), false);
3554 APFloat MZero = APFloat::getZero(APFloat::IEEEdouble(), true);
3555 APFloat One(1.0);
3556 APFloat MOne(-1.0);
3557 APFloat Two(2.0);
3558 APFloat MTwo(-2.0);
3559
3560 APFloat LargestDenormal(APFloat::IEEEdouble(), "0x1.ffffffffffffep-1023");
3561 APFloat NegLargestDenormal(APFloat::IEEEdouble(), "-0x1.ffffffffffffep-1023");
3562
3563 APFloat Smallest = APFloat::getSmallest(APFloat::IEEEdouble(), false);
3564 APFloat NegSmallest = APFloat::getSmallest(APFloat::IEEEdouble(), true);
3565
3566 APFloat Largest = APFloat::getLargest(APFloat::IEEEdouble(), false);
3567 APFloat NegLargest = APFloat::getLargest(APFloat::IEEEdouble(), true);
3568
3569 APFloat PInf = APFloat::getInf(APFloat::IEEEdouble(), false);
3570 APFloat MInf = APFloat::getInf(APFloat::IEEEdouble(), true);
3571
3572 APFloat QPNaN = APFloat::getNaN(APFloat::IEEEdouble(), false);
3573 APFloat QMNaN = APFloat::getNaN(APFloat::IEEEdouble(), true);
3574 APFloat SNaN = APFloat::getSNaN(APFloat::IEEEdouble(), false);
3575
3576 // Make sure highest bit of payload is preserved.
3577 const APInt Payload(64, (UINT64_C(1) << 50) |
3578 (UINT64_C(1) << 49) |
3579 (UINT64_C(1234) << 32) |
3580 1);
3581
3582 APFloat SNaNWithPayload = APFloat::getSNaN(APFloat::IEEEdouble(), false,
3583 &Payload);
3584
3585 APFloat SmallestNormalized
3586 = APFloat::getSmallestNormalized(APFloat::IEEEdouble(), false);
3587 APFloat NegSmallestNormalized
3588 = APFloat::getSmallestNormalized(APFloat::IEEEdouble(), true);
3589
3590 int Exp;
3591 APFloat Frac(APFloat::IEEEdouble());
3592
3593
3594 Frac = frexp(PZero, Exp, RM);
3595 EXPECT_EQ(0, Exp);
3596 EXPECT_TRUE(Frac.isPosZero());
3597
3598 Frac = frexp(MZero, Exp, RM);
3599 EXPECT_EQ(0, Exp);
3600 EXPECT_TRUE(Frac.isNegZero());
3601
3602
3603 Frac = frexp(One, Exp, RM);
3604 EXPECT_EQ(1, Exp);
3605 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1p-1").bitwiseIsEqual(Frac));
3606
3607 Frac = frexp(MOne, Exp, RM);
3608 EXPECT_EQ(1, Exp);
3609 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "-0x1p-1").bitwiseIsEqual(Frac));
3610
3611 Frac = frexp(LargestDenormal, Exp, RM);
3612 EXPECT_EQ(-1022, Exp);
3613 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.ffffffffffffep-1").bitwiseIsEqual(Frac));
3614
3615 Frac = frexp(NegLargestDenormal, Exp, RM);
3616 EXPECT_EQ(-1022, Exp);
3617 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "-0x1.ffffffffffffep-1").bitwiseIsEqual(Frac));
3618
3619
3620 Frac = frexp(Smallest, Exp, RM);
3621 EXPECT_EQ(-1073, Exp);
3622 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1p-1").bitwiseIsEqual(Frac));
3623
3624 Frac = frexp(NegSmallest, Exp, RM);
3625 EXPECT_EQ(-1073, Exp);
3626 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "-0x1p-1").bitwiseIsEqual(Frac));
3627
3628
3629 Frac = frexp(Largest, Exp, RM);
3630 EXPECT_EQ(1024, Exp);
3631 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.fffffffffffffp-1").bitwiseIsEqual(Frac));
3632
3633 Frac = frexp(NegLargest, Exp, RM);
3634 EXPECT_EQ(1024, Exp);
3635 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "-0x1.fffffffffffffp-1").bitwiseIsEqual(Frac));
3636
3637
3638 Frac = frexp(PInf, Exp, RM);
3639 EXPECT_EQ(INT_MAX, Exp);
3640 EXPECT_TRUE(Frac.isInfinity() && !Frac.isNegative());
3641
3642 Frac = frexp(MInf, Exp, RM);
3643 EXPECT_EQ(INT_MAX, Exp);
3644 EXPECT_TRUE(Frac.isInfinity() && Frac.isNegative());
3645
3646 Frac = frexp(QPNaN, Exp, RM);
3647 EXPECT_EQ(INT_MIN, Exp);
3648 EXPECT_TRUE(Frac.isNaN());
3649
3650 Frac = frexp(QMNaN, Exp, RM);
3651 EXPECT_EQ(INT_MIN, Exp);
3652 EXPECT_TRUE(Frac.isNaN());
3653
3654 Frac = frexp(SNaN, Exp, RM);
3655 EXPECT_EQ(INT_MIN, Exp);
3656 EXPECT_TRUE(Frac.isNaN() && !Frac.isSignaling());
3657
3658 Frac = frexp(SNaNWithPayload, Exp, RM);
3659 EXPECT_EQ(INT_MIN, Exp);
3660 EXPECT_TRUE(Frac.isNaN() && !Frac.isSignaling());
3661 EXPECT_EQ(Payload, Frac.bitcastToAPInt().getLoBits(51));
3662
3663 Frac = frexp(APFloat(APFloat::IEEEdouble(), "0x0.ffffp-1"), Exp, RM);
3664 EXPECT_EQ(-1, Exp);
3665 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.fffep-1").bitwiseIsEqual(Frac));
3666
3667 Frac = frexp(APFloat(APFloat::IEEEdouble(), "0x1p-51"), Exp, RM);
3668 EXPECT_EQ(-50, Exp);
3669 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1p-1").bitwiseIsEqual(Frac));
3670
3671 Frac = frexp(APFloat(APFloat::IEEEdouble(), "0x1.c60f120d9f87cp+51"), Exp, RM);
3672 EXPECT_EQ(52, Exp);
3673 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.c60f120d9f87cp-1").bitwiseIsEqual(Frac));
3674 }
3675
3676 TEST(APFloatTest, mod) {
3677 {
3678 APFloat f1(APFloat::IEEEdouble(), "1.5");
3679 APFloat f2(APFloat::IEEEdouble(), "1.0");
3680 APFloat expected(APFloat::IEEEdouble(), "0.5");
3681 EXPECT_EQ(f1.mod(f2), APFloat::opOK);
3682 EXPECT_TRUE(f1.bitwiseIsEqual(expected));
3683 }
3684 {
3685 APFloat f1(APFloat::IEEEdouble(), "0.5");
3686 APFloat f2(APFloat::IEEEdouble(), "1.0");
3687 APFloat expected(APFloat::IEEEdouble(), "0.5");
3688 EXPECT_EQ(f1.mod(f2), APFloat::opOK);
3689 EXPECT_TRUE(f1.bitwiseIsEqual(expected));
3690 }
3691 {
3692 APFloat f1(APFloat::IEEEdouble(), "0x1.3333333333333p-2"); // 0.3
3693 APFloat f2(APFloat::IEEEdouble(), "0x1.47ae147ae147bp-7"); // 0.01
3694 APFloat expected(APFloat::IEEEdouble(),
3695 "0x1.47ae147ae1471p-7"); // 0.009999999999999983
3696 EXPECT_EQ(f1.mod(f2), APFloat::opOK);
3697 EXPECT_TRUE(f1.bitwiseIsEqual(expected));
3698 }
3699 {
3700 APFloat f1(APFloat::IEEEdouble(), "0x1p64"); // 1.8446744073709552e19
3701 APFloat f2(APFloat::IEEEdouble(), "1.5");
3702 APFloat expected(APFloat::IEEEdouble(), "1.0");
3703 EXPECT_EQ(f1.mod(f2), APFloat::opOK);
3704 EXPECT_TRUE(f1.bitwiseIsEqual(expected));
3705 }
3706 {
3707 APFloat f1(APFloat::IEEEdouble(), "0x1p1000");
3708 APFloat f2(APFloat::IEEEdouble(), "0x1p-1000");
3709 APFloat expected(APFloat::IEEEdouble(), "0.0");
3710 EXPECT_EQ(f1.mod(f2), APFloat::opOK);
3711 EXPECT_TRUE(f1.bitwiseIsEqual(expected));
3712 }
3713 {
3714 APFloat f1(APFloat::IEEEdouble(), "0.0");
3715 APFloat f2(APFloat::IEEEdouble(), "1.0");
3716 APFloat expected(APFloat::IEEEdouble(), "0.0");
3717 EXPECT_EQ(f1.mod(f2), APFloat::opOK);
3718 EXPECT_TRUE(f1.bitwiseIsEqual(expected));
3719 }
3720 {
3721 APFloat f1(APFloat::IEEEdouble(), "1.0");
3722 APFloat f2(APFloat::IEEEdouble(), "0.0");
3723 EXPECT_EQ(f1.mod(f2), APFloat::opInvalidOp);
3724 EXPECT_TRUE(f1.isNaN());
3725 }
3726 {
3727 APFloat f1(APFloat::IEEEdouble(), "0.0");
3728 APFloat f2(APFloat::IEEEdouble(), "0.0");
3729 EXPECT_EQ(f1.mod(f2), APFloat::opInvalidOp);
3730 EXPECT_TRUE(f1.isNaN());
3731 }
3732 {
3733 APFloat f1 = APFloat::getInf(APFloat::IEEEdouble(), false);
3734 APFloat f2(APFloat::IEEEdouble(), "1.0");
3735 EXPECT_EQ(f1.mod(f2), APFloat::opInvalidOp);
3736 EXPECT_TRUE(f1.isNaN());
3737 }
3738 {
3739 APFloat f1(APFloat::IEEEdouble(), "-4.0");
3740 APFloat f2(APFloat::IEEEdouble(), "-2.0");
3741 APFloat expected(APFloat::IEEEdouble(), "-0.0");
3742 EXPECT_EQ(f1.mod(f2), APFloat::opOK);
3743 EXPECT_TRUE(f1.bitwiseIsEqual(expected));
3744 }
3745 {
3746 APFloat f1(APFloat::IEEEdouble(), "-4.0");
3747 APFloat f2(APFloat::IEEEdouble(), "2.0");
3748 APFloat expected(APFloat::IEEEdouble(), "-0.0");
3749 EXPECT_EQ(f1.mod(f2), APFloat::opOK);
3750 EXPECT_TRUE(f1.bitwiseIsEqual(expected));
3751 }
3752 {
3753 // Test E4M3FN mod where the LHS exponent is maxExponent (8) and the RHS is
3754 // the max value whose exponent is minExponent (-6). This requires special
3755 // logic in the mod implementation to prevent overflow to NaN.
3756 APFloat f1(APFloat::Float8E4M3FN(), "0x1p8"); // 256
3757 APFloat f2(APFloat::Float8E4M3FN(), "0x1.ep-6"); // 0.029296875
3758 APFloat expected(APFloat::Float8E4M3FN(), "0x1p-8"); // 0.00390625
3759 EXPECT_EQ(f1.mod(f2), APFloat::opOK);
3760 EXPECT_TRUE(f1.bitwiseIsEqual(expected));
3761 }
3762 }
3763
3764 TEST(APFloatTest, remainder) {
3765 // Test Special Cases against each other and normal values.
3766
3767 APFloat PInf = APFloat::getInf(APFloat::IEEEsingle(), false);
3768 APFloat MInf = APFloat::getInf(APFloat::IEEEsingle(), true);
3769 APFloat PZero = APFloat::getZero(APFloat::IEEEsingle(), false);
3770 APFloat MZero = APFloat::getZero(APFloat::IEEEsingle(), true);
3771 APFloat QNaN = APFloat::getNaN(APFloat::IEEEsingle(), false);
3772 APFloat SNaN = APFloat(APFloat::IEEEsingle(), "snan123");
3773 APFloat PNormalValue = APFloat(APFloat::IEEEsingle(), "0x1p+0");
3774 APFloat MNormalValue = APFloat(APFloat::IEEEsingle(), "-0x1p+0");
3775 APFloat PLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), false);
3776 APFloat MLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), true);
3777 APFloat PSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), false);
3778 APFloat MSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), true);
3779 APFloat PSmallestNormalized =
3780 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), false);
3781 APFloat MSmallestNormalized =
3782 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), true);
3783
3784 APFloat PVal1(APFloat::IEEEsingle(), "0x1.fffffep+126");
3785 APFloat MVal1(APFloat::IEEEsingle(), "-0x1.fffffep+126");
3786 APFloat PVal2(APFloat::IEEEsingle(), "0x1.fffffep-126");
3787 APFloat MVal2(APFloat::IEEEsingle(), "-0x1.fffffep-126");
3788 APFloat PVal3(APFloat::IEEEsingle(), "0x1p-125");
3789 APFloat MVal3(APFloat::IEEEsingle(), "-0x1p-125");
3790 APFloat PVal4(APFloat::IEEEsingle(), "0x1p+127");
3791 APFloat MVal4(APFloat::IEEEsingle(), "-0x1p+127");
3792 APFloat PVal5(APFloat::IEEEsingle(), "1.5");
3793 APFloat MVal5(APFloat::IEEEsingle(), "-1.5");
3794 APFloat PVal6(APFloat::IEEEsingle(), "1");
3795 APFloat MVal6(APFloat::IEEEsingle(), "-1");
3796
3797 struct {
3798 APFloat x;
3799 APFloat y;
3800 const char *result;
3801 int status;
3802 int category;
3803 } SpecialCaseTests[] = {
3804 { PInf, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
3805 { PInf, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
3806 { PInf, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
3807 { PInf, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
3808 { PInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
3809 { PInf, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3810 { PInf, PNormalValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
3811 { PInf, MNormalValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
3812 { PInf, PLargestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
3813 { PInf, MLargestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
3814 { PInf, PSmallestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
3815 { PInf, MSmallestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
3816 { PInf, PSmallestNormalized, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
3817 { PInf, MSmallestNormalized, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
3818 { MInf, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
3819 { MInf, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
3820 { MInf, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
3821 { MInf, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
3822 { MInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
3823 { MInf, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3824 { MInf, PNormalValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
3825 { MInf, MNormalValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
3826 { MInf, PLargestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
3827 { MInf, MLargestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
3828 { MInf, PSmallestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
3829 { MInf, MSmallestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
3830 { MInf, PSmallestNormalized, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
3831 { MInf, MSmallestNormalized, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
3832 { PZero, PInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3833 { PZero, MInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3834 { PZero, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
3835 { PZero, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
3836 { PZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
3837 { PZero, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3838 { PZero, PNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3839 { PZero, MNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3840 { PZero, PLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3841 { PZero, MLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3842 { PZero, PSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3843 { PZero, MSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3844 { PZero, PSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3845 { PZero, MSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3846 { MZero, PInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3847 { MZero, MInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3848 { MZero, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
3849 { MZero, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
3850 { MZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
3851 { MZero, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3852 { MZero, PNormalValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3853 { MZero, MNormalValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3854 { MZero, PLargestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3855 { MZero, MLargestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3856 { MZero, PSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3857 { MZero, MSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3858 { MZero, PSmallestNormalized, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3859 { MZero, MSmallestNormalized, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3860 { QNaN, PInf, "nan", APFloat::opOK, APFloat::fcNaN },
3861 { QNaN, MInf, "nan", APFloat::opOK, APFloat::fcNaN },
3862 { QNaN, PZero, "nan", APFloat::opOK, APFloat::fcNaN },
3863 { QNaN, MZero, "nan", APFloat::opOK, APFloat::fcNaN },
3864 { QNaN, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
3865 { QNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
3866 { QNaN, PNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
3867 { QNaN, MNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
3868 { QNaN, PLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
3869 { QNaN, MLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
3870 { QNaN, PSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
3871 { QNaN, MSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
3872 { QNaN, PSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
3873 { QNaN, MSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
3874 { SNaN, PInf, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3875 { SNaN, MInf, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3876 { SNaN, PZero, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3877 { SNaN, MZero, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3878 { SNaN, QNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3879 { SNaN, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3880 { SNaN, PNormalValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3881 { SNaN, MNormalValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3882 { SNaN, PLargestValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3883 { SNaN, MLargestValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3884 { SNaN, PSmallestValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3885 { SNaN, MSmallestValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3886 { SNaN, PSmallestNormalized, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3887 { SNaN, MSmallestNormalized, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3888 { PNormalValue, PInf, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
3889 { PNormalValue, MInf, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
3890 { PNormalValue, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
3891 { PNormalValue, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
3892 { PNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
3893 { PNormalValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3894 { PNormalValue, PNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3895 { PNormalValue, MNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3896 { PNormalValue, PLargestValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
3897 { PNormalValue, MLargestValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
3898 { PNormalValue, PSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3899 { PNormalValue, MSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3900 { PNormalValue, PSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3901 { PNormalValue, MSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3902 { MNormalValue, PInf, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
3903 { MNormalValue, MInf, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
3904 { MNormalValue, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
3905 { MNormalValue, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
3906 { MNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
3907 { MNormalValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3908 { MNormalValue, PNormalValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3909 { MNormalValue, MNormalValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3910 { MNormalValue, PLargestValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
3911 { MNormalValue, MLargestValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
3912 { MNormalValue, PSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3913 { MNormalValue, MSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3914 { MNormalValue, PSmallestNormalized, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3915 { MNormalValue, MSmallestNormalized, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3916 { PLargestValue, PInf, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
3917 { PLargestValue, MInf, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
3918 { PLargestValue, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
3919 { PLargestValue, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
3920 { PLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
3921 { PLargestValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3922 { PLargestValue, PNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3923 { PLargestValue, MNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3924 { PLargestValue, PLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3925 { PLargestValue, MLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3926 { PLargestValue, PSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3927 { PLargestValue, MSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3928 { PLargestValue, PSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3929 { PLargestValue, MSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3930 { MLargestValue, PInf, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
3931 { MLargestValue, MInf, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
3932 { MLargestValue, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
3933 { MLargestValue, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
3934 { MLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
3935 { MLargestValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3936 { MLargestValue, PNormalValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3937 { MLargestValue, MNormalValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3938 { MLargestValue, PLargestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3939 { MLargestValue, MLargestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3940 { MLargestValue, PSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3941 { MLargestValue, MSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3942 { MLargestValue, PSmallestNormalized, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3943 { MLargestValue, MSmallestNormalized, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3944 { PSmallestValue, PInf, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
3945 { PSmallestValue, MInf, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
3946 { PSmallestValue, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
3947 { PSmallestValue, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
3948 { PSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
3949 { PSmallestValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3950 { PSmallestValue, PNormalValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
3951 { PSmallestValue, MNormalValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
3952 { PSmallestValue, PLargestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
3953 { PSmallestValue, MLargestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
3954 { PSmallestValue, PSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3955 { PSmallestValue, MSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3956 { PSmallestValue, PSmallestNormalized, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
3957 { PSmallestValue, MSmallestNormalized, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
3958 { MSmallestValue, PInf, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
3959 { MSmallestValue, MInf, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
3960 { MSmallestValue, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
3961 { MSmallestValue, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
3962 { MSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
3963 { MSmallestValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3964 { MSmallestValue, PNormalValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
3965 { MSmallestValue, MNormalValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
3966 { MSmallestValue, PLargestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
3967 { MSmallestValue, MLargestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
3968 { MSmallestValue, PSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3969 { MSmallestValue, MSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3970 { MSmallestValue, PSmallestNormalized, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
3971 { MSmallestValue, MSmallestNormalized, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
3972 { PSmallestNormalized, PInf, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
3973 { PSmallestNormalized, MInf, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
3974 { PSmallestNormalized, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
3975 { PSmallestNormalized, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
3976 { PSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
3977 { PSmallestNormalized, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3978 { PSmallestNormalized, PNormalValue, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
3979 { PSmallestNormalized, MNormalValue, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
3980 { PSmallestNormalized, PLargestValue, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
3981 { PSmallestNormalized, MLargestValue, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
3982 { PSmallestNormalized, PSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3983 { PSmallestNormalized, MSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3984 { PSmallestNormalized, PSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3985 { PSmallestNormalized, MSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3986 { MSmallestNormalized, PInf, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
3987 { MSmallestNormalized, MInf, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
3988 { MSmallestNormalized, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
3989 { MSmallestNormalized, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
3990 { MSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
3991 { MSmallestNormalized, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3992 { MSmallestNormalized, PNormalValue, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
3993 { MSmallestNormalized, MNormalValue, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
3994 { MSmallestNormalized, PLargestValue, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
3995 { MSmallestNormalized, MLargestValue, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
3996 { MSmallestNormalized, PSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3997 { MSmallestNormalized, MSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3998 { MSmallestNormalized, PSmallestNormalized, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3999 { MSmallestNormalized, MSmallestNormalized, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
4000
4001 { PVal1, PVal1, "0x0p+0", APFloat::opOK, APFloat::fcZero },
4002 { PVal1, MVal1, "0x0p+0", APFloat::opOK, APFloat::fcZero },
4003 { PVal1, PVal2, "0x0p+0", APFloat::opOK, APFloat::fcZero },
4004 { PVal1, MVal2, "0x0p+0", APFloat::opOK, APFloat::fcZero },
4005 { PVal1, PVal3, "0x0p+0", APFloat::opOK, APFloat::fcZero },
4006 { PVal1, MVal3, "0x0p+0", APFloat::opOK, APFloat::fcZero },
4007 { PVal1, PVal4, "-0x1p+103", APFloat::opOK, APFloat::fcNormal },
4008 { PVal1, MVal4, "-0x1p+103", APFloat::opOK, APFloat::fcNormal },
4009 { PVal1, PVal5, "0x0p+0", APFloat::opOK, APFloat::fcZero },
4010 { PVal1, MVal5, "0x0p+0", APFloat::opOK, APFloat::fcZero },
4011 { PVal1, PVal6, "0x0p+0", APFloat::opOK, APFloat::fcZero },
4012 { PVal1, MVal6, "0x0p+0", APFloat::opOK, APFloat::fcZero },
4013 { MVal1, PVal1, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
4014 { MVal1, MVal1, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
4015 { MVal1, PVal2, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
4016 { MVal1, MVal2, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
4017 { MVal1, PVal3, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
4018 { MVal1, MVal3, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
4019 { MVal1, PVal4, "0x1p+103", APFloat::opOK, APFloat::fcNormal },
4020 { MVal1, MVal4, "0x1p+103", APFloat::opOK, APFloat::fcNormal },
4021 { MVal1, PVal5, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
4022 { MVal1, MVal5, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
4023 { MVal1, PVal6, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
4024 { MVal1, MVal6, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
4025 { PVal2, PVal1, "0x1.fffffep-126", APFloat::opOK, APFloat::fcNormal },
4026 { PVal2, MVal1, "0x1.fffffep-126", APFloat::opOK, APFloat::fcNormal },
4027 { PVal2, PVal2, "0x0p+0", APFloat::opOK, APFloat::fcZero },
4028 { PVal2, MVal2, "0x0p+0", APFloat::opOK, APFloat::fcZero },
4029 { PVal2, PVal3, "-0x0.000002p-126", APFloat::opOK, APFloat::fcNormal },
4030 { PVal2, MVal3, "-0x0.000002p-126", APFloat::opOK, APFloat::fcNormal },
4031 { PVal2, PVal4, "0x1.fffffep-126", APFloat::opOK, APFloat::fcNormal },
4032 { PVal2, MVal4, "0x1.fffffep-126", APFloat::opOK, APFloat::fcNormal },
4033 { PVal2, PVal5, "0x1.fffffep-126", APFloat::opOK, APFloat::fcNormal },
4034 { PVal2, MVal5, "0x1.fffffep-126", APFloat::opOK, APFloat::fcNormal },
4035 { PVal2, PVal6, "0x1.fffffep-126", APFloat::opOK, APFloat::fcNormal },
4036 { PVal2, MVal6, "0x1.fffffep-126", APFloat::opOK, APFloat::fcNormal },
4037 { MVal2, PVal1, "-0x1.fffffep-126", APFloat::opOK, APFloat::fcNormal },
4038 { MVal2, MVal1, "-0x1.fffffep-126", APFloat::opOK, APFloat::fcNormal },
4039 { MVal2, PVal2, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
4040 { MVal2, MVal2, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
4041 { MVal2, PVal3, "0x0.000002p-126", APFloat::opOK, APFloat::fcNormal },
4042 { MVal2, MVal3, "0x0.000002p-126", APFloat::opOK, APFloat::fcNormal },
4043 { MVal2, PVal4, "-0x1.fffffep-126", APFloat::opOK, APFloat::fcNormal },
4044 { MVal2, MVal4, "-0x1.fffffep-126", APFloat::opOK, APFloat::fcNormal },
4045 { MVal2, PVal5, "-0x1.fffffep-126", APFloat::opOK, APFloat::fcNormal },
4046 { MVal2, MVal5, "-0x1.fffffep-126", APFloat::opOK, APFloat::fcNormal },
4047 { MVal2, PVal6, "-0x1.fffffep-126", APFloat::opOK, APFloat::fcNormal },
4048 { MVal2, MVal6, "-0x1.fffffep-126", APFloat::opOK, APFloat::fcNormal },
4049 { PVal3, PVal1, "0x1p-125", APFloat::opOK, APFloat::fcNormal },
4050 { PVal3, MVal1, "0x1p-125", APFloat::opOK, APFloat::fcNormal },
4051 { PVal3, PVal2, "0x0.000002p-126", APFloat::opOK, APFloat::fcNormal },
4052 { PVal3, MVal2, "0x0.000002p-126", APFloat::opOK, APFloat::fcNormal },
4053 { PVal3, PVal3, "0x0p+0", APFloat::opOK, APFloat::fcZero },
4054 { PVal3, MVal3, "0x0p+0", APFloat::opOK, APFloat::fcZero },
4055 { PVal3, PVal4, "0x1p-125", APFloat::opOK, APFloat::fcNormal },
4056 { PVal3, MVal4, "0x1p-125", APFloat::opOK, APFloat::fcNormal },
4057 { PVal3, PVal5, "0x1p-125", APFloat::opOK, APFloat::fcNormal },
4058 { PVal3, MVal5, "0x1p-125", APFloat::opOK, APFloat::fcNormal },
4059 { PVal3, PVal6, "0x1p-125", APFloat::opOK, APFloat::fcNormal },
4060 { PVal3, MVal6, "0x1p-125", APFloat::opOK, APFloat::fcNormal },
4061 { MVal3, PVal1, "-0x1p-125", APFloat::opOK, APFloat::fcNormal },
4062 { MVal3, MVal1, "-0x1p-125", APFloat::opOK, APFloat::fcNormal },
4063 { MVal3, PVal2, "-0x0.000002p-126", APFloat::opOK, APFloat::fcNormal },
4064 { MVal3, MVal2, "-0x0.000002p-126", APFloat::opOK, APFloat::fcNormal },
4065 { MVal3, PVal3, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
4066 { MVal3, MVal3, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
4067 { MVal3, PVal4, "-0x1p-125", APFloat::opOK, APFloat::fcNormal },
4068 { MVal3, MVal4, "-0x1p-125", APFloat::opOK, APFloat::fcNormal },
4069 { MVal3, PVal5, "-0x1p-125", APFloat::opOK, APFloat::fcNormal },
4070 { MVal3, MVal5, "-0x1p-125", APFloat::opOK, APFloat::fcNormal },
4071 { MVal3, PVal6, "-0x1p-125", APFloat::opOK, APFloat::fcNormal },
4072 { MVal3, MVal6, "-0x1p-125", APFloat::opOK, APFloat::fcNormal },
4073 { PVal4, PVal1, "0x1p+103", APFloat::opOK, APFloat::fcNormal },
4074 { PVal4, MVal1, "0x1p+103", APFloat::opOK, APFloat::fcNormal },
4075 { PVal4, PVal2, "0x0.002p-126", APFloat::opOK, APFloat::fcNormal },
4076 { PVal4, MVal2, "0x0.002p-126", APFloat::opOK, APFloat::fcNormal },
4077 { PVal4, PVal3, "0x0p+0", APFloat::opOK, APFloat::fcZero },
4078 { PVal4, MVal3, "0x0p+0", APFloat::opOK, APFloat::fcZero },
4079 { PVal4, PVal4, "0x0p+0", APFloat::opOK, APFloat::fcZero },
4080 { PVal4, MVal4, "0x0p+0", APFloat::opOK, APFloat::fcZero },
4081 { PVal4, PVal5, "0.5", APFloat::opOK, APFloat::fcNormal },
4082 { PVal4, MVal5, "0.5", APFloat::opOK, APFloat::fcNormal },
4083 { PVal4, PVal6, "0x0p+0", APFloat::opOK, APFloat::fcZero },
4084 { PVal4, MVal6, "0x0p+0", APFloat::opOK, APFloat::fcZero },
4085 { MVal4, PVal1, "-0x1p+103", APFloat::opOK, APFloat::fcNormal },
4086 { MVal4, MVal1, "-0x1p+103", APFloat::opOK, APFloat::fcNormal },
4087 { MVal4, PVal2, "-0x0.002p-126", APFloat::opOK, APFloat::fcNormal },
4088 { MVal4, MVal2, "-0x0.002p-126", APFloat::opOK, APFloat::fcNormal },
4089 { MVal4, PVal3, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
4090 { MVal4, MVal3, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
4091 { MVal4, PVal4, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
4092 { MVal4, MVal4, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
4093 { MVal4, PVal5, "-0.5", APFloat::opOK, APFloat::fcNormal },
4094 { MVal4, MVal5, "-0.5", APFloat::opOK, APFloat::fcNormal },
4095 { MVal4, PVal6, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
4096 { MVal4, MVal6, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
4097 { PVal5, PVal1, "1.5", APFloat::opOK, APFloat::fcNormal },
4098 { PVal5, MVal1, "1.5", APFloat::opOK, APFloat::fcNormal },
4099 { PVal5, PVal2, "0x0.00006p-126", APFloat::opOK, APFloat::fcNormal },
4100 { PVal5, MVal2, "0x0.00006p-126", APFloat::opOK, APFloat::fcNormal },
4101 { PVal5, PVal3, "0x0p+0", APFloat::opOK, APFloat::fcZero },
4102 { PVal5, MVal3, "0x0p+0", APFloat::opOK, APFloat::fcZero },
4103 { PVal5, PVal4, "1.5", APFloat::opOK, APFloat::fcNormal },
4104 { PVal5, MVal4, "1.5", APFloat::opOK, APFloat::fcNormal },
4105 { PVal5, PVal5, "0x0p+0", APFloat::opOK, APFloat::fcZero },
4106 { PVal5, MVal5, "0x0p+0", APFloat::opOK, APFloat::fcZero },
4107 { PVal5, PVal6, "-0.5", APFloat::opOK, APFloat::fcNormal },
4108 { PVal5, MVal6, "-0.5", APFloat::opOK, APFloat::fcNormal },
4109 { MVal5, PVal1, "-1.5", APFloat::opOK, APFloat::fcNormal },
4110 { MVal5, MVal1, "-1.5", APFloat::opOK, APFloat::fcNormal },
4111 { MVal5, PVal2, "-0x0.00006p-126", APFloat::opOK, APFloat::fcNormal },
4112 { MVal5, MVal2, "-0x0.00006p-126", APFloat::opOK, APFloat::fcNormal },
4113 { MVal5, PVal3, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
4114 { MVal5, MVal3, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
4115 { MVal5, PVal4, "-1.5", APFloat::opOK, APFloat::fcNormal },
4116 { MVal5, MVal4, "-1.5", APFloat::opOK, APFloat::fcNormal },
4117 { MVal5, PVal5, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
4118 { MVal5, MVal5, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
4119 { MVal5, PVal6, "0.5", APFloat::opOK, APFloat::fcNormal },
4120 { MVal5, MVal6, "0.5", APFloat::opOK, APFloat::fcNormal },
4121 { PVal6, PVal1, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
4122 { PVal6, MVal1, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
4123 { PVal6, PVal2, "0x0.00004p-126", APFloat::opOK, APFloat::fcNormal },
4124 { PVal6, MVal2, "0x0.00004p-126", APFloat::opOK, APFloat::fcNormal },
4125 { PVal6, PVal3, "0x0p+0", APFloat::opOK, APFloat::fcZero },
4126 { PVal6, MVal3, "0x0p+0", APFloat::opOK, APFloat::fcZero },
4127 { PVal6, PVal4, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
4128 { PVal6, MVal4, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
4129 { PVal6, PVal5, "-0.5", APFloat::opOK, APFloat::fcNormal },
4130 { PVal6, MVal5, "-0.5", APFloat::opOK, APFloat::fcNormal },
4131 { PVal6, PVal6, "0x0p+0", APFloat::opOK, APFloat::fcZero },
4132 { PVal6, MVal6, "0x0p+0", APFloat::opOK, APFloat::fcZero },
4133 { MVal6, PVal1, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
4134 { MVal6, MVal1, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
4135 { MVal6, PVal2, "-0x0.00004p-126", APFloat::opOK, APFloat::fcNormal },
4136 { MVal6, MVal2, "-0x0.00004p-126", APFloat::opOK, APFloat::fcNormal },
4137 { MVal6, PVal3, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
4138 { MVal6, MVal3, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
4139 { MVal6, PVal4, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
4140 { MVal6, MVal4, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
4141 { MVal6, PVal5, "0.5", APFloat::opOK, APFloat::fcNormal },
4142 { MVal6, MVal5, "0.5", APFloat::opOK, APFloat::fcNormal },
4143 { MVal6, PVal6, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
4144 { MVal6, MVal6, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
4145 };
4146
4147 for (size_t i = 0; i < std::size(SpecialCaseTests); ++i) {
4148 APFloat x(SpecialCaseTests[i].x);
4149 APFloat y(SpecialCaseTests[i].y);
4150 APFloat::opStatus status = x.remainder(y);
4151
4152 APFloat result(x.getSemantics(), SpecialCaseTests[i].result);
4153
4154 EXPECT_TRUE(result.bitwiseIsEqual(x));
4155 EXPECT_EQ(SpecialCaseTests[i].status, (int)status);
4156 EXPECT_EQ(SpecialCaseTests[i].category, (int)x.getCategory());
4157 }
4158
4159 {
4160 APFloat f1(APFloat::IEEEdouble(), "0x1.3333333333333p-2"); // 0.3
4161 APFloat f2(APFloat::IEEEdouble(), "0x1.47ae147ae147bp-7"); // 0.01
4162 APFloat expected(APFloat::IEEEdouble(), "-0x1.4p-56");
4163 EXPECT_EQ(APFloat::opOK, f1.remainder(f2));
4164 EXPECT_TRUE(f1.bitwiseIsEqual(expected));
4165 }
4166 {
4167 APFloat f1(APFloat::IEEEdouble(), "0x1p64"); // 1.8446744073709552e19
4168 APFloat f2(APFloat::IEEEdouble(), "1.5");
4169 APFloat expected(APFloat::IEEEdouble(), "-0.5");
4170 EXPECT_EQ(APFloat::opOK, f1.remainder(f2));
4171 EXPECT_TRUE(f1.bitwiseIsEqual(expected));
4172 }
4173 {
4174 APFloat f1(APFloat::IEEEdouble(), "0x1p1000");
4175 APFloat f2(APFloat::IEEEdouble(), "0x1p-1000");
4176 APFloat expected(APFloat::IEEEdouble(), "0.0");
4177 EXPECT_EQ(APFloat::opOK, f1.remainder(f2));
4178 EXPECT_TRUE(f1.bitwiseIsEqual(expected));
4179 }
4180 {
4181 APFloat f1 = APFloat::getInf(APFloat::IEEEdouble(), false);
4182 APFloat f2(APFloat::IEEEdouble(), "1.0");
4183 EXPECT_EQ(f1.remainder(f2), APFloat::opInvalidOp);
4184 EXPECT_TRUE(f1.isNaN());
4185 }
4186 {
4187 APFloat f1(APFloat::IEEEdouble(), "-4.0");
4188 APFloat f2(APFloat::IEEEdouble(), "-2.0");
4189 APFloat expected(APFloat::IEEEdouble(), "-0.0");
4190 EXPECT_EQ(APFloat::opOK, f1.remainder(f2));
4191 EXPECT_TRUE(f1.bitwiseIsEqual(expected));
4192 }
4193 {
4194 APFloat f1(APFloat::IEEEdouble(), "-4.0");
4195 APFloat f2(APFloat::IEEEdouble(), "2.0");
4196 APFloat expected(APFloat::IEEEdouble(), "-0.0");
4197 EXPECT_EQ(APFloat::opOK, f1.remainder(f2));
4198 EXPECT_TRUE(f1.bitwiseIsEqual(expected));
4199 }
4200 }
4201
4202 TEST(APFloatTest, PPCDoubleDoubleAddSpecial) {
4203 using DataType = std::tuple<uint64_t, uint64_t, uint64_t, uint64_t,
4204 APFloat::fltCategory, APFloat::roundingMode>;
4205 DataType Data[] = {
4206 // (1 + 0) + (-1 + 0) = fcZero
4207 std::make_tuple(0x3ff0000000000000ull, 0, 0xbff0000000000000ull, 0,
4208 APFloat::fcZero, APFloat::rmNearestTiesToEven),
4209 // LDBL_MAX + (1.1 >> (1023 - 106) + 0)) = fcInfinity
4210 std::make_tuple(0x7fefffffffffffffull, 0x7c8ffffffffffffeull,
4211 0x7948000000000000ull, 0ull, APFloat::fcInfinity,
4212 APFloat::rmNearestTiesToEven),
4213 // TODO: change the 4th 0x75effffffffffffe to 0x75efffffffffffff when
4214 // semPPCDoubleDoubleLegacy is gone.
4215 // LDBL_MAX + (1.011111... >> (1023 - 106) + (1.1111111...0 >> (1023 -
4216 // 160))) = fcNormal
4217 std::make_tuple(0x7fefffffffffffffull, 0x7c8ffffffffffffeull,
4218 0x7947ffffffffffffull, 0x75effffffffffffeull,
4219 APFloat::fcNormal, APFloat::rmNearestTiesToEven),
4220 // LDBL_MAX + (1.1 >> (1023 - 106) + 0)) = fcInfinity
4221 std::make_tuple(0x7fefffffffffffffull, 0x7c8ffffffffffffeull,
4222 0x7fefffffffffffffull, 0x7c8ffffffffffffeull,
4223 APFloat::fcInfinity, APFloat::rmNearestTiesToEven),
4224 // NaN + (1 + 0) = fcNaN
4225 std::make_tuple(0x7ff8000000000000ull, 0, 0x3ff0000000000000ull, 0,
4226 APFloat::fcNaN, APFloat::rmNearestTiesToEven),
4227 };
4228
4229 for (auto Tp : Data) {
4230 uint64_t Op1[2], Op2[2];
4231 APFloat::fltCategory Expected;
4232 APFloat::roundingMode RM;
4233 std::tie(Op1[0], Op1[1], Op2[0], Op2[1], Expected, RM) = Tp;
4234
4235 {
4236 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
4237 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
4238 A1.add(A2, RM);
4239
4240 EXPECT_EQ(Expected, A1.getCategory())
4241 << formatv("({0:x} + {1:x}) + ({2:x} + {3:x})", Op1[0], Op1[1],
4242 Op2[0], Op2[1])
4243 .str();
4244 }
4245 {
4246 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
4247 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
4248 A2.add(A1, RM);
4249
4250 EXPECT_EQ(Expected, A2.getCategory())
4251 << formatv("({0:x} + {1:x}) + ({2:x} + {3:x})", Op2[0], Op2[1],
4252 Op1[0], Op1[1])
4253 .str();
4254 }
4255 }
4256 }
4257
4258 TEST(APFloatTest, PPCDoubleDoubleAdd) {
4259 using DataType = std::tuple<uint64_t, uint64_t, uint64_t, uint64_t, uint64_t,
4260 uint64_t, APFloat::roundingMode>;
4261 DataType Data[] = {
4262 // (1 + 0) + (1e-105 + 0) = (1 + 1e-105)
4263 std::make_tuple(0x3ff0000000000000ull, 0, 0x3960000000000000ull, 0,
4264 0x3ff0000000000000ull, 0x3960000000000000ull,
4265 APFloat::rmNearestTiesToEven),
4266 // (1 + 0) + (1e-106 + 0) = (1 + 1e-106)
4267 std::make_tuple(0x3ff0000000000000ull, 0, 0x3950000000000000ull, 0,
4268 0x3ff0000000000000ull, 0x3950000000000000ull,
4269 APFloat::rmNearestTiesToEven),
4270 // (1 + 1e-106) + (1e-106 + 0) = (1 + 1e-105)
4271 std::make_tuple(0x3ff0000000000000ull, 0x3950000000000000ull,
4272 0x3950000000000000ull, 0, 0x3ff0000000000000ull,
4273 0x3960000000000000ull, APFloat::rmNearestTiesToEven),
4274 // (1 + 0) + (epsilon + 0) = (1 + epsilon)
4275 std::make_tuple(0x3ff0000000000000ull, 0, 0x0000000000000001ull, 0,
4276 0x3ff0000000000000ull, 0x0000000000000001ull,
4277 APFloat::rmNearestTiesToEven),
4278 // TODO: change 0xf950000000000000 to 0xf940000000000000, when
4279 // semPPCDoubleDoubleLegacy is gone.
4280 // (DBL_MAX - 1 << (1023 - 105)) + (1 << (1023 - 53) + 0) = DBL_MAX +
4281 // 1.11111... << (1023 - 52)
4282 std::make_tuple(0x7fefffffffffffffull, 0xf950000000000000ull,
4283 0x7c90000000000000ull, 0, 0x7fefffffffffffffull,
4284 0x7c8ffffffffffffeull, APFloat::rmNearestTiesToEven),
4285 // TODO: change 0xf950000000000000 to 0xf940000000000000, when
4286 // semPPCDoubleDoubleLegacy is gone.
4287 // (1 << (1023 - 53) + 0) + (DBL_MAX - 1 << (1023 - 105)) = DBL_MAX +
4288 // 1.11111... << (1023 - 52)
4289 std::make_tuple(0x7c90000000000000ull, 0, 0x7fefffffffffffffull,
4290 0xf950000000000000ull, 0x7fefffffffffffffull,
4291 0x7c8ffffffffffffeull, APFloat::rmNearestTiesToEven),
4292 };
4293
4294 for (auto Tp : Data) {
4295 uint64_t Op1[2], Op2[2], Expected[2];
4296 APFloat::roundingMode RM;
4297 std::tie(Op1[0], Op1[1], Op2[0], Op2[1], Expected[0], Expected[1], RM) = Tp;
4298
4299 {
4300 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
4301 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
4302 A1.add(A2, RM);
4303
4304 EXPECT_EQ(Expected[0], A1.bitcastToAPInt().getRawData()[0])
4305 << formatv("({0:x} + {1:x}) + ({2:x} + {3:x})", Op1[0], Op1[1],
4306 Op2[0], Op2[1])
4307 .str();
4308 EXPECT_EQ(Expected[1], A1.bitcastToAPInt().getRawData()[1])
4309 << formatv("({0:x} + {1:x}) + ({2:x} + {3:x})", Op1[0], Op1[1],
4310 Op2[0], Op2[1])
4311 .str();
4312 }
4313 {
4314 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
4315 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
4316 A2.add(A1, RM);
4317
4318 EXPECT_EQ(Expected[0], A2.bitcastToAPInt().getRawData()[0])
4319 << formatv("({0:x} + {1:x}) + ({2:x} + {3:x})", Op2[0], Op2[1],
4320 Op1[0], Op1[1])
4321 .str();
4322 EXPECT_EQ(Expected[1], A2.bitcastToAPInt().getRawData()[1])
4323 << formatv("({0:x} + {1:x}) + ({2:x} + {3:x})", Op2[0], Op2[1],
4324 Op1[0], Op1[1])
4325 .str();
4326 }
4327 }
4328 }
4329
4330 TEST(APFloatTest, PPCDoubleDoubleSubtract) {
4331 using DataType = std::tuple<uint64_t, uint64_t, uint64_t, uint64_t, uint64_t,
4332 uint64_t, APFloat::roundingMode>;
4333 DataType Data[] = {
4334 // (1 + 0) - (-1e-105 + 0) = (1 + 1e-105)
4335 std::make_tuple(0x3ff0000000000000ull, 0, 0xb960000000000000ull, 0,
4336 0x3ff0000000000000ull, 0x3960000000000000ull,
4337 APFloat::rmNearestTiesToEven),
4338 // (1 + 0) - (-1e-106 + 0) = (1 + 1e-106)
4339 std::make_tuple(0x3ff0000000000000ull, 0, 0xb950000000000000ull, 0,
4340 0x3ff0000000000000ull, 0x3950000000000000ull,
4341 APFloat::rmNearestTiesToEven),
4342 };
4343
4344 for (auto Tp : Data) {
4345 uint64_t Op1[2], Op2[2], Expected[2];
4346 APFloat::roundingMode RM;
4347 std::tie(Op1[0], Op1[1], Op2[0], Op2[1], Expected[0], Expected[1], RM) = Tp;
4348
4349 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
4350 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
4351 A1.subtract(A2, RM);
4352
4353 EXPECT_EQ(Expected[0], A1.bitcastToAPInt().getRawData()[0])
4354 << formatv("({0:x} + {1:x}) - ({2:x} + {3:x})", Op1[0], Op1[1], Op2[0],
4355 Op2[1])
4356 .str();
4357 EXPECT_EQ(Expected[1], A1.bitcastToAPInt().getRawData()[1])
4358 << formatv("({0:x} + {1:x}) - ({2:x} + {3:x})", Op1[0], Op1[1], Op2[0],
4359 Op2[1])
4360 .str();
4361 }
4362 }
4363
4364 TEST(APFloatTest, PPCDoubleDoubleMultiplySpecial) {
4365 using DataType = std::tuple<uint64_t, uint64_t, uint64_t, uint64_t,
4366 APFloat::fltCategory, APFloat::roundingMode>;
4367 DataType Data[] = {
4368 // fcNaN * fcNaN = fcNaN
4369 std::make_tuple(0x7ff8000000000000ull, 0, 0x7ff8000000000000ull, 0,
4370 APFloat::fcNaN, APFloat::rmNearestTiesToEven),
4371 // fcNaN * fcZero = fcNaN
4372 std::make_tuple(0x7ff8000000000000ull, 0, 0, 0, APFloat::fcNaN,
4373 APFloat::rmNearestTiesToEven),
4374 // fcNaN * fcInfinity = fcNaN
4375 std::make_tuple(0x7ff8000000000000ull, 0, 0x7ff0000000000000ull, 0,
4376 APFloat::fcNaN, APFloat::rmNearestTiesToEven),
4377 // fcNaN * fcNormal = fcNaN
4378 std::make_tuple(0x7ff8000000000000ull, 0, 0x3ff0000000000000ull, 0,
4379 APFloat::fcNaN, APFloat::rmNearestTiesToEven),
4380 // fcInfinity * fcInfinity = fcInfinity
4381 std::make_tuple(0x7ff0000000000000ull, 0, 0x7ff0000000000000ull, 0,
4382 APFloat::fcInfinity, APFloat::rmNearestTiesToEven),
4383 // fcInfinity * fcZero = fcNaN
4384 std::make_tuple(0x7ff0000000000000ull, 0, 0, 0, APFloat::fcNaN,
4385 APFloat::rmNearestTiesToEven),
4386 // fcInfinity * fcNormal = fcInfinity
4387 std::make_tuple(0x7ff0000000000000ull, 0, 0x3ff0000000000000ull, 0,
4388 APFloat::fcInfinity, APFloat::rmNearestTiesToEven),
4389 // fcZero * fcZero = fcZero
4390 std::make_tuple(0, 0, 0, 0, APFloat::fcZero,
4391 APFloat::rmNearestTiesToEven),
4392 // fcZero * fcNormal = fcZero
4393 std::make_tuple(0, 0, 0x3ff0000000000000ull, 0, APFloat::fcZero,
4394 APFloat::rmNearestTiesToEven),
4395 };
4396
4397 for (auto Tp : Data) {
4398 uint64_t Op1[2], Op2[2];
4399 APFloat::fltCategory Expected;
4400 APFloat::roundingMode RM;
4401 std::tie(Op1[0], Op1[1], Op2[0], Op2[1], Expected, RM) = Tp;
4402
4403 {
4404 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
4405 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
4406 A1.multiply(A2, RM);
4407
4408 EXPECT_EQ(Expected, A1.getCategory())
4409 << formatv("({0:x} + {1:x}) * ({2:x} + {3:x})", Op1[0], Op1[1],
4410 Op2[0], Op2[1])
4411 .str();
4412 }
4413 {
4414 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
4415 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
4416 A2.multiply(A1, RM);
4417
4418 EXPECT_EQ(Expected, A2.getCategory())
4419 << formatv("({0:x} + {1:x}) * ({2:x} + {3:x})", Op2[0], Op2[1],
4420 Op1[0], Op1[1])
4421 .str();
4422 }
4423 }
4424 }
4425
4426 TEST(APFloatTest, PPCDoubleDoubleMultiply) {
4427 using DataType = std::tuple<uint64_t, uint64_t, uint64_t, uint64_t, uint64_t,
4428 uint64_t, APFloat::roundingMode>;
4429 DataType Data[] = {
4430 // 1/3 * 3 = 1.0
4431 std::make_tuple(0x3fd5555555555555ull, 0x3c75555555555556ull,
4432 0x4008000000000000ull, 0, 0x3ff0000000000000ull, 0,
4433 APFloat::rmNearestTiesToEven),
4434 // (1 + epsilon) * (1 + 0) = fcZero
4435 std::make_tuple(0x3ff0000000000000ull, 0x0000000000000001ull,
4436 0x3ff0000000000000ull, 0, 0x3ff0000000000000ull,
4437 0x0000000000000001ull, APFloat::rmNearestTiesToEven),
4438 // (1 + epsilon) * (1 + epsilon) = 1 + 2 * epsilon
4439 std::make_tuple(0x3ff0000000000000ull, 0x0000000000000001ull,
4440 0x3ff0000000000000ull, 0x0000000000000001ull,
4441 0x3ff0000000000000ull, 0x0000000000000002ull,
4442 APFloat::rmNearestTiesToEven),
4443 // -(1 + epsilon) * (1 + epsilon) = -1
4444 std::make_tuple(0xbff0000000000000ull, 0x0000000000000001ull,
4445 0x3ff0000000000000ull, 0x0000000000000001ull,
4446 0xbff0000000000000ull, 0, APFloat::rmNearestTiesToEven),
4447 // (0.5 + 0) * (1 + 2 * epsilon) = 0.5 + epsilon
4448 std::make_tuple(0x3fe0000000000000ull, 0, 0x3ff0000000000000ull,
4449 0x0000000000000002ull, 0x3fe0000000000000ull,
4450 0x0000000000000001ull, APFloat::rmNearestTiesToEven),
4451 // (0.5 + 0) * (1 + epsilon) = 0.5
4452 std::make_tuple(0x3fe0000000000000ull, 0, 0x3ff0000000000000ull,
4453 0x0000000000000001ull, 0x3fe0000000000000ull, 0,
4454 APFloat::rmNearestTiesToEven),
4455 // __LDBL_MAX__ * (1 + 1 << 106) = inf
4456 std::make_tuple(0x7fefffffffffffffull, 0x7c8ffffffffffffeull,
4457 0x3ff0000000000000ull, 0x3950000000000000ull,
4458 0x7ff0000000000000ull, 0, APFloat::rmNearestTiesToEven),
4459 // __LDBL_MAX__ * (1 + 1 << 107) > __LDBL_MAX__, but not inf, yes =_=|||
4460 std::make_tuple(0x7fefffffffffffffull, 0x7c8ffffffffffffeull,
4461 0x3ff0000000000000ull, 0x3940000000000000ull,
4462 0x7fefffffffffffffull, 0x7c8fffffffffffffull,
4463 APFloat::rmNearestTiesToEven),
4464 // __LDBL_MAX__ * (1 + 1 << 108) = __LDBL_MAX__
4465 std::make_tuple(0x7fefffffffffffffull, 0x7c8ffffffffffffeull,
4466 0x3ff0000000000000ull, 0x3930000000000000ull,
4467 0x7fefffffffffffffull, 0x7c8ffffffffffffeull,
4468 APFloat::rmNearestTiesToEven),
4469 };
4470
4471 for (auto Tp : Data) {
4472 uint64_t Op1[2], Op2[2], Expected[2];
4473 APFloat::roundingMode RM;
4474 std::tie(Op1[0], Op1[1], Op2[0], Op2[1], Expected[0], Expected[1], RM) = Tp;
4475
4476 {
4477 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
4478 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
4479 A1.multiply(A2, RM);
4480
4481 EXPECT_EQ(Expected[0], A1.bitcastToAPInt().getRawData()[0])
4482 << formatv("({0:x} + {1:x}) * ({2:x} + {3:x})", Op1[0], Op1[1],
4483 Op2[0], Op2[1])
4484 .str();
4485 EXPECT_EQ(Expected[1], A1.bitcastToAPInt().getRawData()[1])
4486 << formatv("({0:x} + {1:x}) * ({2:x} + {3:x})", Op1[0], Op1[1],
4487 Op2[0], Op2[1])
4488 .str();
4489 }
4490 {
4491 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
4492 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
4493 A2.multiply(A1, RM);
4494
4495 EXPECT_EQ(Expected[0], A2.bitcastToAPInt().getRawData()[0])
4496 << formatv("({0:x} + {1:x}) * ({2:x} + {3:x})", Op2[0], Op2[1],
4497 Op1[0], Op1[1])
4498 .str();
4499 EXPECT_EQ(Expected[1], A2.bitcastToAPInt().getRawData()[1])
4500 << formatv("({0:x} + {1:x}) * ({2:x} + {3:x})", Op2[0], Op2[1],
4501 Op1[0], Op1[1])
4502 .str();
4503 }
4504 }
4505 }
4506
4507 TEST(APFloatTest, PPCDoubleDoubleDivide) {
4508 using DataType = std::tuple<uint64_t, uint64_t, uint64_t, uint64_t, uint64_t,
4509 uint64_t, APFloat::roundingMode>;
4510 // TODO: Only a sanity check for now. Add more edge cases when the
4511 // double-double algorithm is implemented.
4512 DataType Data[] = {
4513 // 1 / 3 = 1/3
4514 std::make_tuple(0x3ff0000000000000ull, 0, 0x4008000000000000ull, 0,
4515 0x3fd5555555555555ull, 0x3c75555555555556ull,
4516 APFloat::rmNearestTiesToEven),
4517 };
4518
4519 for (auto Tp : Data) {
4520 uint64_t Op1[2], Op2[2], Expected[2];
4521 APFloat::roundingMode RM;
4522 std::tie(Op1[0], Op1[1], Op2[0], Op2[1], Expected[0], Expected[1], RM) = Tp;
4523
4524 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
4525 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
4526 A1.divide(A2, RM);
4527
4528 EXPECT_EQ(Expected[0], A1.bitcastToAPInt().getRawData()[0])
4529 << formatv("({0:x} + {1:x}) / ({2:x} + {3:x})", Op1[0], Op1[1], Op2[0],
4530 Op2[1])
4531 .str();
4532 EXPECT_EQ(Expected[1], A1.bitcastToAPInt().getRawData()[1])
4533 << formatv("({0:x} + {1:x}) / ({2:x} + {3:x})", Op1[0], Op1[1], Op2[0],
4534 Op2[1])
4535 .str();
4536 }
4537 }
4538
4539 TEST(APFloatTest, PPCDoubleDoubleRemainder) {
4540 using DataType =
4541 std::tuple<uint64_t, uint64_t, uint64_t, uint64_t, uint64_t, uint64_t>;
4542 DataType Data[] = {
4543 // remainder(3.0 + 3.0 << 53, 1.25 + 1.25 << 53) = (0.5 + 0.5 << 53)
4544 std::make_tuple(0x4008000000000000ull, 0x3cb8000000000000ull,
4545 0x3ff4000000000000ull, 0x3ca4000000000000ull,
4546 0x3fe0000000000000ull, 0x3c90000000000000ull),
4547 // remainder(3.0 + 3.0 << 53, 1.75 + 1.75 << 53) = (-0.5 - 0.5 << 53)
4548 std::make_tuple(0x4008000000000000ull, 0x3cb8000000000000ull,
4549 0x3ffc000000000000ull, 0x3cac000000000000ull,
4550 0xbfe0000000000000ull, 0xbc90000000000000ull),
4551 };
4552
4553 for (auto Tp : Data) {
4554 uint64_t Op1[2], Op2[2], Expected[2];
4555 std::tie(Op1[0], Op1[1], Op2[0], Op2[1], Expected[0], Expected[1]) = Tp;
4556
4557 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
4558 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
4559 A1.remainder(A2);
4560
4561 EXPECT_EQ(Expected[0], A1.bitcastToAPInt().getRawData()[0])
4562 << formatv("remainder({0:x} + {1:x}), ({2:x} + {3:x}))", Op1[0], Op1[1],
4563 Op2[0], Op2[1])
4564 .str();
4565 EXPECT_EQ(Expected[1], A1.bitcastToAPInt().getRawData()[1])
4566 << formatv("remainder(({0:x} + {1:x}), ({2:x} + {3:x}))", Op1[0],
4567 Op1[1], Op2[0], Op2[1])
4568 .str();
4569 }
4570 }
4571
4572 TEST(APFloatTest, PPCDoubleDoubleMod) {
4573 using DataType =
4574 std::tuple<uint64_t, uint64_t, uint64_t, uint64_t, uint64_t, uint64_t>;
4575 DataType Data[] = {
4576 // mod(3.0 + 3.0 << 53, 1.25 + 1.25 << 53) = (0.5 + 0.5 << 53)
4577 std::make_tuple(0x4008000000000000ull, 0x3cb8000000000000ull,
4578 0x3ff4000000000000ull, 0x3ca4000000000000ull,
4579 0x3fe0000000000000ull, 0x3c90000000000000ull),
4580 // mod(3.0 + 3.0 << 53, 1.75 + 1.75 << 53) = (1.25 + 1.25 << 53)
4581 // 0xbc98000000000000 doesn't seem right, but it's what we currently have.
4582 // TODO: investigate
4583 std::make_tuple(0x4008000000000000ull, 0x3cb8000000000000ull,
4584 0x3ffc000000000000ull, 0x3cac000000000000ull,
4585 0x3ff4000000000001ull, 0xbc98000000000000ull),
4586 };
4587
4588 for (auto Tp : Data) {
4589 uint64_t Op1[2], Op2[2], Expected[2];
4590 std::tie(Op1[0], Op1[1], Op2[0], Op2[1], Expected[0], Expected[1]) = Tp;
4591
4592 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
4593 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
4594 A1.mod(A2);
4595
4596 EXPECT_EQ(Expected[0], A1.bitcastToAPInt().getRawData()[0])
4597 << formatv("fmod(({0:x} + {1:x}), ({2:x} + {3:x}))", Op1[0], Op1[1],
4598 Op2[0], Op2[1])
4599 .str();
4600 EXPECT_EQ(Expected[1], A1.bitcastToAPInt().getRawData()[1])
4601 << formatv("fmod(({0:x} + {1:x}), ({2:x} + {3:x}))", Op1[0], Op1[1],
4602 Op2[0], Op2[1])
4603 .str();
4604 }
4605 }
4606
4607 TEST(APFloatTest, PPCDoubleDoubleFMA) {
4608 // Sanity check for now.
4609 APFloat A(APFloat::PPCDoubleDouble(), "2");
4610 A.fusedMultiplyAdd(APFloat(APFloat::PPCDoubleDouble(), "3"),
4611 APFloat(APFloat::PPCDoubleDouble(), "4"),
4612 APFloat::rmNearestTiesToEven);
4613 EXPECT_EQ(APFloat::cmpEqual,
4614 APFloat(APFloat::PPCDoubleDouble(), "10").compare(A));
4615 }
4616
4617 TEST(APFloatTest, PPCDoubleDoubleRoundToIntegral) {
4618 {
4619 APFloat A(APFloat::PPCDoubleDouble(), "1.5");
4620 A.roundToIntegral(APFloat::rmNearestTiesToEven);
4621 EXPECT_EQ(APFloat::cmpEqual,
4622 APFloat(APFloat::PPCDoubleDouble(), "2").compare(A));
4623 }
4624 {
4625 APFloat A(APFloat::PPCDoubleDouble(), "2.5");
4626 A.roundToIntegral(APFloat::rmNearestTiesToEven);
4627 EXPECT_EQ(APFloat::cmpEqual,
4628 APFloat(APFloat::PPCDoubleDouble(), "2").compare(A));
4629 }
4630 }
4631
4632 TEST(APFloatTest, PPCDoubleDoubleCompare) {
4633 using DataType =
4634 std::tuple<uint64_t, uint64_t, uint64_t, uint64_t, APFloat::cmpResult>;
4635
4636 DataType Data[] = {
4637 // (1 + 0) = (1 + 0)
4638 std::make_tuple(0x3ff0000000000000ull, 0, 0x3ff0000000000000ull, 0,
4639 APFloat::cmpEqual),
4640 // (1 + 0) < (1.00...1 + 0)
4641 std::make_tuple(0x3ff0000000000000ull, 0, 0x3ff0000000000001ull, 0,
4642 APFloat::cmpLessThan),
4643 // (1.00...1 + 0) > (1 + 0)
4644 std::make_tuple(0x3ff0000000000001ull, 0, 0x3ff0000000000000ull, 0,
4645 APFloat::cmpGreaterThan),
4646 // (1 + 0) < (1 + epsilon)
4647 std::make_tuple(0x3ff0000000000000ull, 0, 0x3ff0000000000001ull,
4648 0x0000000000000001ull, APFloat::cmpLessThan),
4649 // NaN != NaN
4650 std::make_tuple(0x7ff8000000000000ull, 0, 0x7ff8000000000000ull, 0,
4651 APFloat::cmpUnordered),
4652 // (1 + 0) != NaN
4653 std::make_tuple(0x3ff0000000000000ull, 0, 0x7ff8000000000000ull, 0,
4654 APFloat::cmpUnordered),
4655 // Inf = Inf
4656 std::make_tuple(0x7ff0000000000000ull, 0, 0x7ff0000000000000ull, 0,
4657 APFloat::cmpEqual),
4658 };
4659
4660 for (auto Tp : Data) {
4661 uint64_t Op1[2], Op2[2];
4662 APFloat::cmpResult Expected;
4663 std::tie(Op1[0], Op1[1], Op2[0], Op2[1], Expected) = Tp;
4664
4665 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
4666 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
4667 EXPECT_EQ(Expected, A1.compare(A2))
4668 << formatv("compare(({0:x} + {1:x}), ({2:x} + {3:x}))", Op1[0], Op1[1],
4669 Op2[0], Op2[1])
4670 .str();
4671 }
4672 }
4673
4674 TEST(APFloatTest, PPCDoubleDoubleBitwiseIsEqual) {
4675 using DataType = std::tuple<uint64_t, uint64_t, uint64_t, uint64_t, bool>;
4676
4677 DataType Data[] = {
4678 // (1 + 0) = (1 + 0)
4679 std::make_tuple(0x3ff0000000000000ull, 0, 0x3ff0000000000000ull, 0, true),
4680 // (1 + 0) != (1.00...1 + 0)
4681 std::make_tuple(0x3ff0000000000000ull, 0, 0x3ff0000000000001ull, 0,
4682 false),
4683 // NaN = NaN
4684 std::make_tuple(0x7ff8000000000000ull, 0, 0x7ff8000000000000ull, 0, true),
4685 // NaN != NaN with a different bit pattern
4686 std::make_tuple(0x7ff8000000000000ull, 0, 0x7ff8000000000000ull,
4687 0x3ff0000000000000ull, false),
4688 // Inf = Inf
4689 std::make_tuple(0x7ff0000000000000ull, 0, 0x7ff0000000000000ull, 0, true),
4690 };
4691
4692 for (auto Tp : Data) {
4693 uint64_t Op1[2], Op2[2];
4694 bool Expected;
4695 std::tie(Op1[0], Op1[1], Op2[0], Op2[1], Expected) = Tp;
4696
4697 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
4698 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
4699 EXPECT_EQ(Expected, A1.bitwiseIsEqual(A2))
4700 << formatv("({0:x} + {1:x}) = ({2:x} + {3:x})", Op1[0], Op1[1], Op2[0],
4701 Op2[1])
4702 .str();
4703 }
4704 }
4705
4706 TEST(APFloatTest, PPCDoubleDoubleHashValue) {
4707 uint64_t Data1[] = {0x3ff0000000000001ull, 0x0000000000000001ull};
4708 uint64_t Data2[] = {0x3ff0000000000001ull, 0};
4709 // The hash values are *hopefully* different.
4710 EXPECT_NE(
4711 hash_value(APFloat(APFloat::PPCDoubleDouble(), APInt(128, 2, Data1))),
4712 hash_value(APFloat(APFloat::PPCDoubleDouble(), APInt(128, 2, Data2))));
4713 }
4714
4715 TEST(APFloatTest, PPCDoubleDoubleChangeSign) {
4716 uint64_t Data[] = {
4717 0x400f000000000000ull, 0xbcb0000000000000ull,
4718 };
4719 APFloat Float(APFloat::PPCDoubleDouble(), APInt(128, 2, Data));
4720 {
4721 APFloat Actual =
4722 APFloat::copySign(Float, APFloat(APFloat::IEEEdouble(), "1"));
4723 EXPECT_EQ(0x400f000000000000ull, Actual.bitcastToAPInt().getRawData()[0]);
4724 EXPECT_EQ(0xbcb0000000000000ull, Actual.bitcastToAPInt().getRawData()[1]);
4725 }
4726 {
4727 APFloat Actual =
4728 APFloat::copySign(Float, APFloat(APFloat::IEEEdouble(), "-1"));
4729 EXPECT_EQ(0xc00f000000000000ull, Actual.bitcastToAPInt().getRawData()[0]);
4730 EXPECT_EQ(0x3cb0000000000000ull, Actual.bitcastToAPInt().getRawData()[1]);
4731 }
4732 }
4733
4734 TEST(APFloatTest, PPCDoubleDoubleFactories) {
4735 {
4736 uint64_t Data[] = {
4737 0, 0,
4738 };
4739 EXPECT_EQ(APInt(128, 2, Data),
4740 APFloat::getZero(APFloat::PPCDoubleDouble()).bitcastToAPInt());
4741 }
4742 {
4743 uint64_t Data[] = {
4744 0x7fefffffffffffffull, 0x7c8ffffffffffffeull,
4745 };
4746 EXPECT_EQ(APInt(128, 2, Data),
4747 APFloat::getLargest(APFloat::PPCDoubleDouble()).bitcastToAPInt());
4748 }
4749 {
4750 uint64_t Data[] = {
4751 0x0000000000000001ull, 0,
4752 };
4753 EXPECT_EQ(
4754 APInt(128, 2, Data),
4755 APFloat::getSmallest(APFloat::PPCDoubleDouble()).bitcastToAPInt());
4756 }
4757 {
4758 uint64_t Data[] = {0x0360000000000000ull, 0};
4759 EXPECT_EQ(APInt(128, 2, Data),
4760 APFloat::getSmallestNormalized(APFloat::PPCDoubleDouble())
4761 .bitcastToAPInt());
4762 }
4763 {
4764 uint64_t Data[] = {
4765 0x8000000000000000ull, 0x0000000000000000ull,
4766 };
4767 EXPECT_EQ(
4768 APInt(128, 2, Data),
4769 APFloat::getZero(APFloat::PPCDoubleDouble(), true).bitcastToAPInt());
4770 }
4771 {
4772 uint64_t Data[] = {
4773 0xffefffffffffffffull, 0xfc8ffffffffffffeull,
4774 };
4775 EXPECT_EQ(
4776 APInt(128, 2, Data),
4777 APFloat::getLargest(APFloat::PPCDoubleDouble(), true).bitcastToAPInt());
4778 }
4779 {
4780 uint64_t Data[] = {
4781 0x8000000000000001ull, 0x0000000000000000ull,
4782 };
4783 EXPECT_EQ(APInt(128, 2, Data),
4784 APFloat::getSmallest(APFloat::PPCDoubleDouble(), true)
4785 .bitcastToAPInt());
4786 }
4787 {
4788 uint64_t Data[] = {
4789 0x8360000000000000ull, 0x0000000000000000ull,
4790 };
4791 EXPECT_EQ(APInt(128, 2, Data),
4792 APFloat::getSmallestNormalized(APFloat::PPCDoubleDouble(), true)
4793 .bitcastToAPInt());
4794 }
4795 EXPECT_TRUE(APFloat::getSmallest(APFloat::PPCDoubleDouble()).isSmallest());
4796 EXPECT_TRUE(APFloat::getLargest(APFloat::PPCDoubleDouble()).isLargest());
4797 }
4798
4799 TEST(APFloatTest, PPCDoubleDoubleIsDenormal) {
4800 EXPECT_TRUE(APFloat::getSmallest(APFloat::PPCDoubleDouble()).isDenormal());
4801 EXPECT_FALSE(APFloat::getLargest(APFloat::PPCDoubleDouble()).isDenormal());
4802 EXPECT_FALSE(
4803 APFloat::getSmallestNormalized(APFloat::PPCDoubleDouble()).isDenormal());
4804 {
4805 // (4 + 3) is not normalized
4806 uint64_t Data[] = {
4807 0x4010000000000000ull, 0x4008000000000000ull,
4808 };
4809 EXPECT_TRUE(
4810 APFloat(APFloat::PPCDoubleDouble(), APInt(128, 2, Data)).isDenormal());
4811 }
4812 }
4813
4814 TEST(APFloatTest, PPCDoubleDoubleScalbn) {
4815 // 3.0 + 3.0 << 53
4816 uint64_t Input[] = {
4817 0x4008000000000000ull, 0x3cb8000000000000ull,
4818 };
4819 APFloat Result =
4820 scalbn(APFloat(APFloat::PPCDoubleDouble(), APInt(128, 2, Input)), 1,
4821 APFloat::rmNearestTiesToEven);
4822 // 6.0 + 6.0 << 53
4823 EXPECT_EQ(0x4018000000000000ull, Result.bitcastToAPInt().getRawData()[0]);
4824 EXPECT_EQ(0x3cc8000000000000ull, Result.bitcastToAPInt().getRawData()[1]);
4825 }
4826
4827 TEST(APFloatTest, PPCDoubleDoubleFrexp) {
4828 // 3.0 + 3.0 << 53
4829 uint64_t Input[] = {
4830 0x4008000000000000ull, 0x3cb8000000000000ull,
4831 };
4832 int Exp;
4833 // 0.75 + 0.75 << 53
4834 APFloat Result =
4835 frexp(APFloat(APFloat::PPCDoubleDouble(), APInt(128, 2, Input)), Exp,
4836 APFloat::rmNearestTiesToEven);
4837 EXPECT_EQ(2, Exp);
4838 EXPECT_EQ(0x3fe8000000000000ull, Result.bitcastToAPInt().getRawData()[0]);
4839 EXPECT_EQ(0x3c98000000000000ull, Result.bitcastToAPInt().getRawData()[1]);
4840 }
4841
4842 TEST(APFloatTest, x87Largest) {
4843 APFloat MaxX87Val = APFloat::getLargest(APFloat::x87DoubleExtended());
4844 EXPECT_TRUE(MaxX87Val.isLargest());
4845 }
4846
4847 TEST(APFloatTest, x87Next) {
4848 APFloat F(APFloat::x87DoubleExtended(), "-1.0");
4849 F.next(false);
4850 EXPECT_TRUE(ilogb(F) == -1);
4851 }
4852
4853 TEST(APFloatTest, ConvertE4M3FNToE5M2) {
4854 bool losesInfo;
4855 APFloat test(APFloat::Float8E4M3FN(), "1.0");
4856 APFloat::opStatus status = test.convert(
4857 APFloat::Float8E5M2(), APFloat::rmNearestTiesToEven, &losesInfo);
4858 EXPECT_EQ(1.0f, test.convertToFloat());
4859 EXPECT_FALSE(losesInfo);
4860 EXPECT_EQ(status, APFloat::opOK);
4861
4862 test = APFloat(APFloat::Float8E4M3FN(), "0.0");
4863 status = test.convert(APFloat::Float8E5M2(), APFloat::rmNearestTiesToEven,
4864 &losesInfo);
4865 EXPECT_EQ(0.0f, test.convertToFloat());
4866 EXPECT_FALSE(losesInfo);
4867 EXPECT_EQ(status, APFloat::opOK);
4868
4869 test = APFloat(APFloat::Float8E4M3FN(), "0x1.2p0"); // 1.125
4870 status = test.convert(APFloat::Float8E5M2(), APFloat::rmNearestTiesToEven,
4871 &losesInfo);
4872 EXPECT_EQ(0x1.0p0 /* 1.0 */, test.convertToFloat());
4873 EXPECT_TRUE(losesInfo);
4874 EXPECT_EQ(status, APFloat::opInexact);
4875
4876 test = APFloat(APFloat::Float8E4M3FN(), "0x1.6p0"); // 1.375
4877 status = test.convert(APFloat::Float8E5M2(), APFloat::rmNearestTiesToEven,
4878 &losesInfo);
4879 EXPECT_EQ(0x1.8p0 /* 1.5 */, test.convertToFloat());
4880 EXPECT_TRUE(losesInfo);
4881 EXPECT_EQ(status, APFloat::opInexact);
4882
4883 // Convert E4M3 denormal to E5M2 normal. Should not be truncated, despite the
4884 // destination format having one fewer significand bit
4885 test = APFloat(APFloat::Float8E4M3FN(), "0x1.Cp-7");
4886 status = test.convert(APFloat::Float8E5M2(), APFloat::rmNearestTiesToEven,
4887 &losesInfo);
4888 EXPECT_EQ(0x1.Cp-7, test.convertToFloat());
4889 EXPECT_FALSE(losesInfo);
4890 EXPECT_EQ(status, APFloat::opOK);
4891
4892 // Test convert from NaN
4893 test = APFloat(APFloat::Float8E4M3FN(), "nan");
4894 status = test.convert(APFloat::Float8E5M2(), APFloat::rmNearestTiesToEven,
4895 &losesInfo);
4896 EXPECT_TRUE(std::isnan(test.convertToFloat()));
4897 EXPECT_FALSE(losesInfo);
4898 EXPECT_EQ(status, APFloat::opOK);
4899 }
4900
4901 TEST(APFloatTest, ConvertE5M2ToE4M3FN) {
4902 bool losesInfo;
4903 APFloat test(APFloat::Float8E5M2(), "1.0");
4904 APFloat::opStatus status = test.convert(
4905 APFloat::Float8E4M3FN(), APFloat::rmNearestTiesToEven, &losesInfo);
4906 EXPECT_EQ(1.0f, test.convertToFloat());
4907 EXPECT_FALSE(losesInfo);
4908 EXPECT_EQ(status, APFloat::opOK);
4909
4910 test = APFloat(APFloat::Float8E5M2(), "0.0");
4911 status = test.convert(APFloat::Float8E4M3FN(), APFloat::rmNearestTiesToEven,
4912 &losesInfo);
4913 EXPECT_EQ(0.0f, test.convertToFloat());
4914 EXPECT_FALSE(losesInfo);
4915 EXPECT_EQ(status, APFloat::opOK);
4916
4917 test = APFloat(APFloat::Float8E5M2(), "0x1.Cp8"); // 448
4918 status = test.convert(APFloat::Float8E4M3FN(), APFloat::rmNearestTiesToEven,
4919 &losesInfo);
4920 EXPECT_EQ(0x1.Cp8 /* 448 */, test.convertToFloat());
4921 EXPECT_FALSE(losesInfo);
4922 EXPECT_EQ(status, APFloat::opOK);
4923
4924 // Test overflow
4925 test = APFloat(APFloat::Float8E5M2(), "0x1.0p9"); // 512
4926 status = test.convert(APFloat::Float8E4M3FN(), APFloat::rmNearestTiesToEven,
4927 &losesInfo);
4928 EXPECT_TRUE(std::isnan(test.convertToFloat()));
4929 EXPECT_TRUE(losesInfo);
4930 EXPECT_EQ(status, APFloat::opOverflow | APFloat::opInexact);
4931
4932 // Test underflow
4933 test = APFloat(APFloat::Float8E5M2(), "0x1.0p-10");
4934 status = test.convert(APFloat::Float8E4M3FN(), APFloat::rmNearestTiesToEven,
4935 &losesInfo);
4936 EXPECT_EQ(0., test.convertToFloat());
4937 EXPECT_TRUE(losesInfo);
4938 EXPECT_EQ(status, APFloat::opUnderflow | APFloat::opInexact);
4939
4940 // Test rounding up to smallest denormal number
4941 test = APFloat(APFloat::Float8E5M2(), "0x1.8p-10");
4942 status = test.convert(APFloat::Float8E4M3FN(), APFloat::rmNearestTiesToEven,
4943 &losesInfo);
4944 EXPECT_EQ(0x1.0p-9, test.convertToFloat());
4945 EXPECT_TRUE(losesInfo);
4946 EXPECT_EQ(status, APFloat::opUnderflow | APFloat::opInexact);
4947
4948 // Testing inexact rounding to denormal number
4949 test = APFloat(APFloat::Float8E5M2(), "0x1.8p-9");
4950 status = test.convert(APFloat::Float8E4M3FN(), APFloat::rmNearestTiesToEven,
4951 &losesInfo);
4952 EXPECT_EQ(0x1.0p-8, test.convertToFloat());
4953 EXPECT_TRUE(losesInfo);
4954 EXPECT_EQ(status, APFloat::opUnderflow | APFloat::opInexact);
4955
4956 APFloat nan = APFloat(APFloat::Float8E4M3FN(), "nan");
4957
4958 // Testing convert from Inf
4959 test = APFloat(APFloat::Float8E5M2(), "inf");
4960 status = test.convert(APFloat::Float8E4M3FN(), APFloat::rmNearestTiesToEven,
4961 &losesInfo);
4962 EXPECT_TRUE(std::isnan(test.convertToFloat()));
4963 EXPECT_TRUE(losesInfo);
4964 EXPECT_EQ(status, APFloat::opInexact);
4965 EXPECT_TRUE(test.bitwiseIsEqual(nan));
4966
4967 // Testing convert from quiet NaN
4968 test = APFloat(APFloat::Float8E5M2(), "nan");
4969 status = test.convert(APFloat::Float8E4M3FN(), APFloat::rmNearestTiesToEven,
4970 &losesInfo);
4971 EXPECT_TRUE(std::isnan(test.convertToFloat()));
4972 EXPECT_TRUE(losesInfo);
4973 EXPECT_EQ(status, APFloat::opOK);
4974 EXPECT_TRUE(test.bitwiseIsEqual(nan));
4975
4976 // Testing convert from signaling NaN
4977 test = APFloat(APFloat::Float8E5M2(), "snan");
4978 status = test.convert(APFloat::Float8E4M3FN(), APFloat::rmNearestTiesToEven,
4979 &losesInfo);
4980 EXPECT_TRUE(std::isnan(test.convertToFloat()));
4981 EXPECT_TRUE(losesInfo);
4982 EXPECT_EQ(status, APFloat::opInvalidOp);
4983 EXPECT_TRUE(test.bitwiseIsEqual(nan));
4984 }
4985
4986 TEST(APFloatTest, Float8E4M3FNGetInf) {
4987 APFloat t = APFloat::getInf(APFloat::Float8E4M3FN());
4988 EXPECT_TRUE(t.isNaN());
4989 EXPECT_FALSE(t.isInfinity());
4990 }
4991
4992 TEST(APFloatTest, Float8E4M3FNFromString) {
4993 // Exactly representable
4994 EXPECT_EQ(448, APFloat(APFloat::Float8E4M3FN(), "448").convertToDouble());
4995 // Round down to maximum value
4996 EXPECT_EQ(448, APFloat(APFloat::Float8E4M3FN(), "464").convertToDouble());
4997 // Round up, causing overflow to NaN
4998 EXPECT_TRUE(APFloat(APFloat::Float8E4M3FN(), "465").isNaN());
4999 // Overflow without rounding
5000 EXPECT_TRUE(APFloat(APFloat::Float8E4M3FN(), "480").isNaN());
5001 // Inf converted to NaN
5002 EXPECT_TRUE(APFloat(APFloat::Float8E4M3FN(), "inf").isNaN());
5003 // NaN converted to NaN
5004 EXPECT_TRUE(APFloat(APFloat::Float8E4M3FN(), "nan").isNaN());
5005 }
5006
5007 TEST(APFloatTest, Float8E4M3FNAdd) {
5008 APFloat QNaN = APFloat::getNaN(APFloat::Float8E4M3FN(), false);
5009
5010 auto FromStr = [](StringRef S) {
5011 return APFloat(APFloat::Float8E4M3FN(), S);
5012 };
5013
5014 struct {
5015 APFloat x;
5016 APFloat y;
5017 const char *result;
5018 int status;
5019 int category;
5020 APFloat::roundingMode roundingMode = APFloat::rmNearestTiesToEven;
5021 } AdditionTests[] = {
5022 // Test addition operations involving NaN, overflow, and the max E4M3
5023 // value (448) because E4M3 differs from IEEE-754 types in these regards
5024 {FromStr("448"), FromStr("16"), "448", APFloat::opInexact,
5025 APFloat::fcNormal},
5026 {FromStr("448"), FromStr("18"), "NaN",
5027 APFloat::opOverflow | APFloat::opInexact, APFloat::fcNaN},
5028 {FromStr("448"), FromStr("32"), "NaN",
5029 APFloat::opOverflow | APFloat::opInexact, APFloat::fcNaN},
5030 {FromStr("-448"), FromStr("-32"), "-NaN",
5031 APFloat::opOverflow | APFloat::opInexact, APFloat::fcNaN},
5032 {QNaN, FromStr("-448"), "NaN", APFloat::opOK, APFloat::fcNaN},
5033 {FromStr("448"), FromStr("-32"), "416", APFloat::opOK, APFloat::fcNormal},
5034 {FromStr("448"), FromStr("0"), "448", APFloat::opOK, APFloat::fcNormal},
5035 {FromStr("448"), FromStr("32"), "448", APFloat::opInexact,
5036 APFloat::fcNormal, APFloat::rmTowardZero},
5037 {FromStr("448"), FromStr("448"), "448", APFloat::opInexact,
5038 APFloat::fcNormal, APFloat::rmTowardZero},
5039 };
5040
5041 for (size_t i = 0; i < std::size(AdditionTests); ++i) {
5042 APFloat x(AdditionTests[i].x);
5043 APFloat y(AdditionTests[i].y);
5044 APFloat::opStatus status = x.add(y, AdditionTests[i].roundingMode);
5045
5046 APFloat result(APFloat::Float8E4M3FN(), AdditionTests[i].result);
5047
5048 EXPECT_TRUE(result.bitwiseIsEqual(x));
5049 EXPECT_EQ(AdditionTests[i].status, (int)status);
5050 EXPECT_EQ(AdditionTests[i].category, (int)x.getCategory());
5051 }
5052 }
5053
5054 TEST(APFloatTest, Float8E4M3FNDivideByZero) {
5055 APFloat x(APFloat::Float8E4M3FN(), "1");
5056 APFloat zero(APFloat::Float8E4M3FN(), "0");
5057 EXPECT_EQ(x.divide(zero, APFloat::rmNearestTiesToEven), APFloat::opDivByZero);
5058 EXPECT_TRUE(x.isNaN());
5059 }
5060
5061 TEST(APFloatTest, Float8E4M3FNNext) {
5062 APFloat test(APFloat::Float8E4M3FN(), APFloat::uninitialized);
5063 APFloat expected(APFloat::Float8E4M3FN(), APFloat::uninitialized);
5064
5065 // nextUp on positive numbers
5066 for (int i = 0; i < 127; i++) {
5067 test = APFloat(APFloat::Float8E4M3FN(), APInt(8, i));
5068 expected = APFloat(APFloat::Float8E4M3FN(), APInt(8, i + 1));
5069 EXPECT_EQ(test.next(false), APFloat::opOK);
5070 EXPECT_TRUE(test.bitwiseIsEqual(expected));
5071 }
5072
5073 // nextUp on negative zero
5074 test = APFloat::getZero(APFloat::Float8E4M3FN(), true);
5075 expected = APFloat::getSmallest(APFloat::Float8E4M3FN(), false);
5076 EXPECT_EQ(test.next(false), APFloat::opOK);
5077 EXPECT_TRUE(test.bitwiseIsEqual(expected));
5078
5079 // nextUp on negative nonzero numbers
5080 for (int i = 129; i < 255; i++) {
5081 test = APFloat(APFloat::Float8E4M3FN(), APInt(8, i));
5082 expected = APFloat(APFloat::Float8E4M3FN(), APInt(8, i - 1));
5083 EXPECT_EQ(test.next(false), APFloat::opOK);
5084 EXPECT_TRUE(test.bitwiseIsEqual(expected));
5085 }
5086
5087 // nextUp on NaN
5088 test = APFloat::getQNaN(APFloat::Float8E4M3FN(), false);
5089 expected = APFloat::getQNaN(APFloat::Float8E4M3FN(), false);
5090 EXPECT_EQ(test.next(false), APFloat::opOK);
5091 EXPECT_TRUE(test.bitwiseIsEqual(expected));
5092
5093 // nextDown on positive nonzero finite numbers
5094 for (int i = 1; i < 127; i++) {
5095 test = APFloat(APFloat::Float8E4M3FN(), APInt(8, i));
5096 expected = APFloat(APFloat::Float8E4M3FN(), APInt(8, i - 1));
5097 EXPECT_EQ(test.next(true), APFloat::opOK);
5098 EXPECT_TRUE(test.bitwiseIsEqual(expected));
5099 }
5100
5101 // nextDown on positive zero
5102 test = APFloat::getZero(APFloat::Float8E4M3FN(), true);
5103 expected = APFloat::getSmallest(APFloat::Float8E4M3FN(), true);
5104 EXPECT_EQ(test.next(true), APFloat::opOK);
5105 EXPECT_TRUE(test.bitwiseIsEqual(expected));
5106
5107 // nextDown on negative finite numbers
5108 for (int i = 128; i < 255; i++) {
5109 test = APFloat(APFloat::Float8E4M3FN(), APInt(8, i));
5110 expected = APFloat(APFloat::Float8E4M3FN(), APInt(8, i + 1));
5111 EXPECT_EQ(test.next(true), APFloat::opOK);
5112 EXPECT_TRUE(test.bitwiseIsEqual(expected));
5113 }
5114
5115 // nextDown on NaN
5116 test = APFloat::getQNaN(APFloat::Float8E4M3FN(), false);
5117 expected = APFloat::getQNaN(APFloat::Float8E4M3FN(), false);
5118 EXPECT_EQ(test.next(true), APFloat::opOK);
5119 EXPECT_TRUE(test.bitwiseIsEqual(expected));
5120 }
5121
5122 TEST(APFloatTest, Float8E4M3FNExhaustive) {
5123 // Test each of the 256 Float8E4M3FN values.
5124 for (int i = 0; i < 256; i++) {
5125 APFloat test(APFloat::Float8E4M3FN(), APInt(8, i));
5126 SCOPED_TRACE("i=" + std::to_string(i));
5127
5128 // isLargest
5129 if (i == 126 || i == 254) {
5130 EXPECT_TRUE(test.isLargest());
5131 EXPECT_EQ(abs(test).convertToDouble(), 448.);
5132 } else {
5133 EXPECT_FALSE(test.isLargest());
5134 }
5135
5136 // isSmallest
5137 if (i == 1 || i == 129) {
5138 EXPECT_TRUE(test.isSmallest());
5139 EXPECT_EQ(abs(test).convertToDouble(), 0x1p-9);
5140 } else {
5141 EXPECT_FALSE(test.isSmallest());
5142 }
5143
5144 // convert to BFloat
5145 APFloat test2 = test;
5146 bool loses_info;
5147 APFloat::opStatus status = test2.convert(
5148 APFloat::BFloat(), APFloat::rmNearestTiesToEven, &loses_info);
5149 EXPECT_EQ(status, APFloat::opOK);
5150 EXPECT_FALSE(loses_info);
5151 if (i == 127 || i == 255)
5152 EXPECT_TRUE(test2.isNaN());
5153 else
5154 EXPECT_EQ(test.convertToFloat(), test2.convertToFloat());
5155
5156 // bitcastToAPInt
5157 EXPECT_EQ(i, test.bitcastToAPInt());
5158 }
5159 }
5160
5161 TEST(APFloatTest, Float8E4M3FNExhaustivePair) {
5162 // Test each pair of Float8E4M3FN values.
5163 for (int i = 0; i < 256; i++) {
5164 for (int j = 0; j < 256; j++) {
5165 SCOPED_TRACE("i=" + std::to_string(i) + ",j=" + std::to_string(j));
5166 APFloat x(APFloat::Float8E4M3FN(), APInt(8, i));
5167 APFloat y(APFloat::Float8E4M3FN(), APInt(8, j));
5168
5169 bool losesInfo;
5170 APFloat x16 = x;
5171 x16.convert(APFloat::IEEEhalf(), APFloat::rmNearestTiesToEven,
5172 &losesInfo);
5173 EXPECT_FALSE(losesInfo);
5174 APFloat y16 = y;
5175 y16.convert(APFloat::IEEEhalf(), APFloat::rmNearestTiesToEven,
5176 &losesInfo);
5177 EXPECT_FALSE(losesInfo);
5178
5179 // Add
5180 APFloat z = x;
5181 z.add(y, APFloat::rmNearestTiesToEven);
5182 APFloat z16 = x16;
5183 z16.add(y16, APFloat::rmNearestTiesToEven);
5184 z16.convert(APFloat::Float8E4M3FN(), APFloat::rmNearestTiesToEven,
5185 &losesInfo);
5186 EXPECT_TRUE(z.bitwiseIsEqual(z16));
5187
5188 // Subtract
5189 z = x;
5190 z.subtract(y, APFloat::rmNearestTiesToEven);
5191 z16 = x16;
5192 z16.subtract(y16, APFloat::rmNearestTiesToEven);
5193 z16.convert(APFloat::Float8E4M3FN(), APFloat::rmNearestTiesToEven,
5194 &losesInfo);
5195 EXPECT_TRUE(z.bitwiseIsEqual(z16));
5196
5197 // Multiply
5198 z = x;
5199 z.multiply(y, APFloat::rmNearestTiesToEven);
5200 z16 = x16;
5201 z16.multiply(y16, APFloat::rmNearestTiesToEven);
5202 z16.convert(APFloat::Float8E4M3FN(), APFloat::rmNearestTiesToEven,
5203 &losesInfo);
5204 EXPECT_TRUE(z.bitwiseIsEqual(z16)) << "i=" << i << ", j=" << j;
5205
5206 // Divide
5207 z = x;
5208 z.divide(y, APFloat::rmNearestTiesToEven);
5209 z16 = x16;
5210 z16.divide(y16, APFloat::rmNearestTiesToEven);
5211 z16.convert(APFloat::Float8E4M3FN(), APFloat::rmNearestTiesToEven,
5212 &losesInfo);
5213 EXPECT_TRUE(z.bitwiseIsEqual(z16)) << "i=" << i << ", j=" << j;
5214
5215 // Mod
5216 z = x;
5217 z.mod(y);
5218 z16 = x16;
5219 z16.mod(y16);
5220 z16.convert(APFloat::Float8E4M3FN(), APFloat::rmNearestTiesToEven,
5221 &losesInfo);
5222 EXPECT_TRUE(z.bitwiseIsEqual(z16)) << "i=" << i << ", j=" << j;
5223
5224 // Remainder
5225 z = x;
5226 z.remainder(y);
5227 z16 = x16;
5228 z16.remainder(y16);
5229 z16.convert(APFloat::Float8E4M3FN(), APFloat::rmNearestTiesToEven,
5230 &losesInfo);
5231 EXPECT_TRUE(z.bitwiseIsEqual(z16)) << "i=" << i << ", j=" << j;
5232 }
5233 }
5234 }
5235
5236 TEST(APFloatTest, F8ToString) {
5237 for (APFloat::Semantics S :
5238 {APFloat::S_Float8E5M2, APFloat::S_Float8E4M3FN}) {
5239 SCOPED_TRACE("Semantics=" + std::to_string(S));
5240 for (int i = 0; i < 256; i++) {
5241 SCOPED_TRACE("i=" + std::to_string(i));
5242 APFloat test(APFloat::Float8E5M2(), APInt(8, i));
5243 llvm::SmallString<128> str;
5244 test.toString(str);
5245
5246 if (test.isNaN()) {
5247 EXPECT_EQ(str, "NaN");
5248 } else {
5249 APFloat test2(APFloat::Float8E5M2(), str);
5250 EXPECT_TRUE(test.bitwiseIsEqual(test2));
5251 }
5252 }
5253 }
5254 }
5255
5256 TEST(APFloatTest, IEEEdoubleToDouble) {
5257 APFloat DPosZero(0.0);
5258 APFloat DPosZeroToDouble(DPosZero.convertToDouble());
5259 EXPECT_TRUE(DPosZeroToDouble.isPosZero());
5260 APFloat DNegZero(-0.0);
5261 APFloat DNegZeroToDouble(DNegZero.convertToDouble());
5262 EXPECT_TRUE(DNegZeroToDouble.isNegZero());
5263
5264 APFloat DOne(1.0);
5265 EXPECT_EQ(1.0, DOne.convertToDouble());
5266 APFloat DPosLargest = APFloat::getLargest(APFloat::IEEEdouble(), false);
5267 EXPECT_EQ(std::numeric_limits<double>::max(), DPosLargest.convertToDouble());
5268 APFloat DNegLargest = APFloat::getLargest(APFloat::IEEEdouble(), true);
5269 EXPECT_EQ(-std::numeric_limits<double>::max(), DNegLargest.convertToDouble());
5270 APFloat DPosSmallest =
5271 APFloat::getSmallestNormalized(APFloat::IEEEdouble(), false);
5272 EXPECT_EQ(std::numeric_limits<double>::min(), DPosSmallest.convertToDouble());
5273 APFloat DNegSmallest =
5274 APFloat::getSmallestNormalized(APFloat::IEEEdouble(), true);
5275 EXPECT_EQ(-std::numeric_limits<double>::min(),
5276 DNegSmallest.convertToDouble());
5277
5278 APFloat DSmallestDenorm = APFloat::getSmallest(APFloat::IEEEdouble(), false);
5279 EXPECT_EQ(std::numeric_limits<double>::denorm_min(),
5280 DSmallestDenorm.convertToDouble());
5281 APFloat DLargestDenorm(APFloat::IEEEdouble(), "0x0.FFFFFFFFFFFFFp-1022");
5282 EXPECT_EQ(/*0x0.FFFFFFFFFFFFFp-1022*/ 2.225073858507201e-308,
5283 DLargestDenorm.convertToDouble());
5284
5285 APFloat DPosInf = APFloat::getInf(APFloat::IEEEdouble());
5286 EXPECT_EQ(std::numeric_limits<double>::infinity(), DPosInf.convertToDouble());
5287 APFloat DNegInf = APFloat::getInf(APFloat::IEEEdouble(), true);
5288 EXPECT_EQ(-std::numeric_limits<double>::infinity(),
5289 DNegInf.convertToDouble());
5290 APFloat DQNaN = APFloat::getQNaN(APFloat::IEEEdouble());
5291 EXPECT_TRUE(std::isnan(DQNaN.convertToDouble()));
5292 }
5293
5294 TEST(APFloatTest, IEEEsingleToDouble) {
5295 APFloat FPosZero(0.0F);
5296 APFloat FPosZeroToDouble(FPosZero.convertToDouble());
5297 EXPECT_TRUE(FPosZeroToDouble.isPosZero());
5298 APFloat FNegZero(-0.0F);
5299 APFloat FNegZeroToDouble(FNegZero.convertToDouble());
5300 EXPECT_TRUE(FNegZeroToDouble.isNegZero());
5301
5302 APFloat FOne(1.0F);
5303 EXPECT_EQ(1.0, FOne.convertToDouble());
5304 APFloat FPosLargest = APFloat::getLargest(APFloat::IEEEsingle(), false);
5305 EXPECT_EQ(std::numeric_limits<float>::max(), FPosLargest.convertToDouble());
5306 APFloat FNegLargest = APFloat::getLargest(APFloat::IEEEsingle(), true);
5307 EXPECT_EQ(-std::numeric_limits<float>::max(), FNegLargest.convertToDouble());
5308 APFloat FPosSmallest =
5309 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), false);
5310 EXPECT_EQ(std::numeric_limits<float>::min(), FPosSmallest.convertToDouble());
5311 APFloat FNegSmallest =
5312 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), true);
5313 EXPECT_EQ(-std::numeric_limits<float>::min(), FNegSmallest.convertToDouble());
5314
5315 APFloat FSmallestDenorm = APFloat::getSmallest(APFloat::IEEEsingle(), false);
5316 EXPECT_EQ(std::numeric_limits<float>::denorm_min(),
5317 FSmallestDenorm.convertToDouble());
5318 APFloat FLargestDenorm(APFloat::IEEEdouble(), "0x0.FFFFFEp-126");
5319 EXPECT_EQ(/*0x0.FFFFFEp-126*/ 1.1754942106924411e-38,
5320 FLargestDenorm.convertToDouble());
5321
5322 APFloat FPosInf = APFloat::getInf(APFloat::IEEEsingle());
5323 EXPECT_EQ(std::numeric_limits<double>::infinity(), FPosInf.convertToDouble());
5324 APFloat FNegInf = APFloat::getInf(APFloat::IEEEsingle(), true);
5325 EXPECT_EQ(-std::numeric_limits<double>::infinity(),
5326 FNegInf.convertToDouble());
5327 APFloat FQNaN = APFloat::getQNaN(APFloat::IEEEsingle());
5328 EXPECT_TRUE(std::isnan(FQNaN.convertToDouble()));
5329 }
5330
5331 TEST(APFloatTest, IEEEhalfToDouble) {
5332 APFloat HPosZero = APFloat::getZero(APFloat::IEEEhalf());
5333 APFloat HPosZeroToDouble(HPosZero.convertToDouble());
5334 EXPECT_TRUE(HPosZeroToDouble.isPosZero());
5335 APFloat HNegZero = APFloat::getZero(APFloat::IEEEhalf(), true);
5336 APFloat HNegZeroToDouble(HNegZero.convertToDouble());
5337 EXPECT_TRUE(HNegZeroToDouble.isNegZero());
5338
5339 APFloat HOne(APFloat::IEEEhalf(), "1.0");
5340 EXPECT_EQ(1.0, HOne.convertToDouble());
5341 APFloat HPosLargest = APFloat::getLargest(APFloat::IEEEhalf(), false);
5342 EXPECT_EQ(65504.0, HPosLargest.convertToDouble());
5343 APFloat HNegLargest = APFloat::getLargest(APFloat::IEEEhalf(), true);
5344 EXPECT_EQ(-65504.0, HNegLargest.convertToDouble());
5345 APFloat HPosSmallest =
5346 APFloat::getSmallestNormalized(APFloat::IEEEhalf(), false);
5347 EXPECT_EQ(/*0x1.p-14*/ 6.103515625e-05, HPosSmallest.convertToDouble());
5348 APFloat HNegSmallest =
5349 APFloat::getSmallestNormalized(APFloat::IEEEhalf(), true);
5350 EXPECT_EQ(/*-0x1.p-14*/ -6.103515625e-05, HNegSmallest.convertToDouble());
5351
5352 APFloat HSmallestDenorm = APFloat::getSmallest(APFloat::IEEEhalf(), false);
5353 EXPECT_EQ(/*0x1.p-24*/ 5.960464477539063e-08,
5354 HSmallestDenorm.convertToDouble());
5355 APFloat HLargestDenorm(APFloat::IEEEhalf(), "0x1.FFCp-14");
5356 EXPECT_EQ(/*0x1.FFCp-14*/ 0.00012201070785522461,
5357 HLargestDenorm.convertToDouble());
5358
5359 APFloat HPosInf = APFloat::getInf(APFloat::IEEEhalf());
5360 EXPECT_EQ(std::numeric_limits<double>::infinity(), HPosInf.convertToDouble());
5361 APFloat HNegInf = APFloat::getInf(APFloat::IEEEhalf(), true);
5362 EXPECT_EQ(-std::numeric_limits<double>::infinity(),
5363 HNegInf.convertToDouble());
5364 APFloat HQNaN = APFloat::getQNaN(APFloat::IEEEhalf());
5365 EXPECT_TRUE(std::isnan(HQNaN.convertToDouble()));
5366
5367 APFloat BPosZero = APFloat::getZero(APFloat::IEEEhalf());
5368 APFloat BPosZeroToDouble(BPosZero.convertToDouble());
5369 EXPECT_TRUE(BPosZeroToDouble.isPosZero());
5370 APFloat BNegZero = APFloat::getZero(APFloat::IEEEhalf(), true);
5371 APFloat BNegZeroToDouble(BNegZero.convertToDouble());
5372 EXPECT_TRUE(BNegZeroToDouble.isNegZero());
5373 }
5374
5375 TEST(APFloatTest, BFloatToDouble) {
5376 APFloat BOne(APFloat::BFloat(), "1.0");
5377 EXPECT_EQ(1.0, BOne.convertToDouble());
5378 APFloat BPosLargest = APFloat::getLargest(APFloat::BFloat(), false);
5379 EXPECT_EQ(/*0x1.FEp127*/ 3.3895313892515355e+38,
5380 BPosLargest.convertToDouble());
5381 APFloat BNegLargest = APFloat::getLargest(APFloat::BFloat(), true);
5382 EXPECT_EQ(/*-0x1.FEp127*/ -3.3895313892515355e+38,
5383 BNegLargest.convertToDouble());
5384 APFloat BPosSmallest =
5385 APFloat::getSmallestNormalized(APFloat::BFloat(), false);
5386 EXPECT_EQ(/*0x1.p-126*/ 1.1754943508222875e-38,
5387 BPosSmallest.convertToDouble());
5388 APFloat BNegSmallest =
5389 APFloat::getSmallestNormalized(APFloat::BFloat(), true);
5390 EXPECT_EQ(/*-0x1.p-126*/ -1.1754943508222875e-38,
5391 BNegSmallest.convertToDouble());
5392
5393 APFloat BSmallestDenorm = APFloat::getSmallest(APFloat::BFloat(), false);
5394 EXPECT_EQ(/*0x1.p-133*/ 9.183549615799121e-41,
5395 BSmallestDenorm.convertToDouble());
5396 APFloat BLargestDenorm(APFloat::BFloat(), "0x1.FCp-127");
5397 EXPECT_EQ(/*0x1.FCp-127*/ 1.1663108012064884e-38,
5398 BLargestDenorm.convertToDouble());
5399
5400 APFloat BPosInf = APFloat::getInf(APFloat::BFloat());
5401 EXPECT_EQ(std::numeric_limits<double>::infinity(), BPosInf.convertToDouble());
5402 APFloat BNegInf = APFloat::getInf(APFloat::BFloat(), true);
5403 EXPECT_EQ(-std::numeric_limits<double>::infinity(),
5404 BNegInf.convertToDouble());
5405 APFloat BQNaN = APFloat::getQNaN(APFloat::BFloat());
5406 EXPECT_TRUE(std::isnan(BQNaN.convertToDouble()));
5407 }
5408
5409 TEST(APFloatTest, Float8E5M2ToDouble) {
5410 APFloat One(APFloat::Float8E5M2(), "1.0");
5411 EXPECT_EQ(1.0, One.convertToDouble());
5412 APFloat Two(APFloat::Float8E5M2(), "2.0");
5413 EXPECT_EQ(2.0, Two.convertToDouble());
5414 APFloat PosLargest = APFloat::getLargest(APFloat::Float8E5M2(), false);
5415 EXPECT_EQ(5.734400e+04, PosLargest.convertToDouble());
5416 APFloat NegLargest = APFloat::getLargest(APFloat::Float8E5M2(), true);
5417 EXPECT_EQ(-5.734400e+04, NegLargest.convertToDouble());
5418 APFloat PosSmallest =
5419 APFloat::getSmallestNormalized(APFloat::Float8E5M2(), false);
5420 EXPECT_EQ(0x1.p-14, PosSmallest.convertToDouble());
5421 APFloat NegSmallest =
5422 APFloat::getSmallestNormalized(APFloat::Float8E5M2(), true);
5423 EXPECT_EQ(-0x1.p-14, NegSmallest.convertToDouble());
5424
5425 APFloat SmallestDenorm = APFloat::getSmallest(APFloat::Float8E5M2(), false);
5426 EXPECT_TRUE(SmallestDenorm.isDenormal());
5427 EXPECT_EQ(0x1p-16, SmallestDenorm.convertToDouble());
5428
5429 APFloat PosInf = APFloat::getInf(APFloat::Float8E5M2());
5430 EXPECT_EQ(std::numeric_limits<double>::infinity(), PosInf.convertToDouble());
5431 APFloat NegInf = APFloat::getInf(APFloat::Float8E5M2(), true);
5432 EXPECT_EQ(-std::numeric_limits<double>::infinity(), NegInf.convertToDouble());
5433 APFloat QNaN = APFloat::getQNaN(APFloat::Float8E5M2());
5434 EXPECT_TRUE(std::isnan(QNaN.convertToDouble()));
5435 }
5436
5437 TEST(APFloatTest, Float8E4M3FNToDouble) {
5438 APFloat One(APFloat::Float8E4M3FN(), "1.0");
5439 EXPECT_EQ(1.0, One.convertToDouble());
5440 APFloat Two(APFloat::Float8E4M3FN(), "2.0");
5441 EXPECT_EQ(2.0, Two.convertToDouble());
5442 APFloat PosLargest = APFloat::getLargest(APFloat::Float8E4M3FN(), false);
5443 EXPECT_EQ(448., PosLargest.convertToDouble());
5444 APFloat NegLargest = APFloat::getLargest(APFloat::Float8E4M3FN(), true);
5445 EXPECT_EQ(-448., NegLargest.convertToDouble());
5446 APFloat PosSmallest =
5447 APFloat::getSmallestNormalized(APFloat::Float8E4M3FN(), false);
5448 EXPECT_EQ(0x1.p-6, PosSmallest.convertToDouble());
5449 APFloat NegSmallest =
5450 APFloat::getSmallestNormalized(APFloat::Float8E4M3FN(), true);
5451 EXPECT_EQ(-0x1.p-6, NegSmallest.convertToDouble());
5452
5453 APFloat SmallestDenorm = APFloat::getSmallest(APFloat::Float8E4M3FN(), false);
5454 EXPECT_TRUE(SmallestDenorm.isDenormal());
5455 EXPECT_EQ(0x1p-9, SmallestDenorm.convertToDouble());
5456
5457 APFloat QNaN = APFloat::getQNaN(APFloat::Float8E4M3FN());
5458 EXPECT_TRUE(std::isnan(QNaN.convertToDouble()));
5459 }
5460
5461 TEST(APFloatTest, IEEEsingleToFloat) {
5462 APFloat FPosZero(0.0F);
5463 APFloat FPosZeroToFloat(FPosZero.convertToFloat());
5464 EXPECT_TRUE(FPosZeroToFloat.isPosZero());
5465 APFloat FNegZero(-0.0F);
5466 APFloat FNegZeroToFloat(FNegZero.convertToFloat());
5467 EXPECT_TRUE(FNegZeroToFloat.isNegZero());
5468
5469 APFloat FOne(1.0F);
5470 EXPECT_EQ(1.0F, FOne.convertToFloat());
5471 APFloat FPosLargest = APFloat::getLargest(APFloat::IEEEsingle(), false);
5472 EXPECT_EQ(std::numeric_limits<float>::max(), FPosLargest.convertToFloat());
5473 APFloat FNegLargest = APFloat::getLargest(APFloat::IEEEsingle(), true);
5474 EXPECT_EQ(-std::numeric_limits<float>::max(), FNegLargest.convertToFloat());
5475 APFloat FPosSmallest =
5476 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), false);
5477 EXPECT_EQ(std::numeric_limits<float>::min(), FPosSmallest.convertToFloat());
5478 APFloat FNegSmallest =
5479 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), true);
5480 EXPECT_EQ(-std::numeric_limits<float>::min(), FNegSmallest.convertToFloat());
5481
5482 APFloat FSmallestDenorm = APFloat::getSmallest(APFloat::IEEEsingle(), false);
5483 EXPECT_EQ(std::numeric_limits<float>::denorm_min(),
5484 FSmallestDenorm.convertToFloat());
5485 APFloat FLargestDenorm(APFloat::IEEEsingle(), "0x1.FFFFFEp-126");
5486 EXPECT_EQ(/*0x1.FFFFFEp-126*/ 2.3509885615147286e-38F,
5487 FLargestDenorm.convertToFloat());
5488
5489 APFloat FPosInf = APFloat::getInf(APFloat::IEEEsingle());
5490 EXPECT_EQ(std::numeric_limits<float>::infinity(), FPosInf.convertToFloat());
5491 APFloat FNegInf = APFloat::getInf(APFloat::IEEEsingle(), true);
5492 EXPECT_EQ(-std::numeric_limits<float>::infinity(), FNegInf.convertToFloat());
5493 APFloat FQNaN = APFloat::getQNaN(APFloat::IEEEsingle());
5494 EXPECT_TRUE(std::isnan(FQNaN.convertToFloat()));
5495 }
5496
5497 TEST(APFloatTest, IEEEhalfToFloat) {
5498 APFloat HPosZero = APFloat::getZero(APFloat::IEEEhalf());
5499 APFloat HPosZeroToFloat(HPosZero.convertToFloat());
5500 EXPECT_TRUE(HPosZeroToFloat.isPosZero());
5501 APFloat HNegZero = APFloat::getZero(APFloat::IEEEhalf(), true);
5502 APFloat HNegZeroToFloat(HNegZero.convertToFloat());
5503 EXPECT_TRUE(HNegZeroToFloat.isNegZero());
5504
5505 APFloat HOne(APFloat::IEEEhalf(), "1.0");
5506 EXPECT_EQ(1.0F, HOne.convertToFloat());
5507 APFloat HPosLargest = APFloat::getLargest(APFloat::IEEEhalf(), false);
5508 EXPECT_EQ(/*0x1.FFCp15*/ 65504.0F, HPosLargest.convertToFloat());
5509 APFloat HNegLargest = APFloat::getLargest(APFloat::IEEEhalf(), true);
5510 EXPECT_EQ(/*-0x1.FFCp15*/ -65504.0F, HNegLargest.convertToFloat());
5511 APFloat HPosSmallest =
5512 APFloat::getSmallestNormalized(APFloat::IEEEhalf(), false);
5513 EXPECT_EQ(/*0x1.p-14*/ 6.103515625e-05F, HPosSmallest.convertToFloat());
5514 APFloat HNegSmallest =
5515 APFloat::getSmallestNormalized(APFloat::IEEEhalf(), true);
5516 EXPECT_EQ(/*-0x1.p-14*/ -6.103515625e-05F, HNegSmallest.convertToFloat());
5517
5518 APFloat HSmallestDenorm = APFloat::getSmallest(APFloat::IEEEhalf(), false);
5519 EXPECT_EQ(/*0x1.p-24*/ 5.960464477539063e-08F,
5520 HSmallestDenorm.convertToFloat());
5521 APFloat HLargestDenorm(APFloat::IEEEhalf(), "0x1.FFCp-14");
5522 EXPECT_EQ(/*0x1.FFCp-14*/ 0.00012201070785522461F,
5523 HLargestDenorm.convertToFloat());
5524
5525 APFloat HPosInf = APFloat::getInf(APFloat::IEEEhalf());
5526 EXPECT_EQ(std::numeric_limits<float>::infinity(), HPosInf.convertToFloat());
5527 APFloat HNegInf = APFloat::getInf(APFloat::IEEEhalf(), true);
5528 EXPECT_EQ(-std::numeric_limits<float>::infinity(), HNegInf.convertToFloat());
5529 APFloat HQNaN = APFloat::getQNaN(APFloat::IEEEhalf());
5530 EXPECT_TRUE(std::isnan(HQNaN.convertToFloat()));
5531 }
5532
5533 TEST(APFloatTest, BFloatToFloat) {
5534 APFloat BPosZero = APFloat::getZero(APFloat::BFloat());
5535 APFloat BPosZeroToDouble(BPosZero.convertToFloat());
5536 EXPECT_TRUE(BPosZeroToDouble.isPosZero());
5537 APFloat BNegZero = APFloat::getZero(APFloat::BFloat(), true);
5538 APFloat BNegZeroToDouble(BNegZero.convertToFloat());
5539 EXPECT_TRUE(BNegZeroToDouble.isNegZero());
5540
5541 APFloat BOne(APFloat::BFloat(), "1.0");
5542 EXPECT_EQ(1.0F, BOne.convertToFloat());
5543 APFloat BPosLargest = APFloat::getLargest(APFloat::BFloat(), false);
5544 EXPECT_EQ(/*0x1.FEp127*/ 3.3895313892515355e+38F,
5545 BPosLargest.convertToFloat());
5546 APFloat BNegLargest = APFloat::getLargest(APFloat::BFloat(), true);
5547 EXPECT_EQ(/*-0x1.FEp127*/ -3.3895313892515355e+38F,
5548 BNegLargest.convertToFloat());
5549 APFloat BPosSmallest =
5550 APFloat::getSmallestNormalized(APFloat::BFloat(), false);
5551 EXPECT_EQ(/*0x1.p-126*/ 1.1754943508222875e-38F,
5552 BPosSmallest.convertToFloat());
5553 APFloat BNegSmallest =
5554 APFloat::getSmallestNormalized(APFloat::BFloat(), true);
5555 EXPECT_EQ(/*-0x1.p-126*/ -1.1754943508222875e-38F,
5556 BNegSmallest.convertToFloat());
5557
5558 APFloat BSmallestDenorm = APFloat::getSmallest(APFloat::BFloat(), false);
5559 EXPECT_EQ(/*0x1.p-133*/ 9.183549615799121e-41F,
5560 BSmallestDenorm.convertToFloat());
5561 APFloat BLargestDenorm(APFloat::BFloat(), "0x1.FCp-127");
5562 EXPECT_EQ(/*0x1.FCp-127*/ 1.1663108012064884e-38F,
5563 BLargestDenorm.convertToFloat());
5564
5565 APFloat BPosInf = APFloat::getInf(APFloat::BFloat());
5566 EXPECT_EQ(std::numeric_limits<float>::infinity(), BPosInf.convertToFloat());
5567 APFloat BNegInf = APFloat::getInf(APFloat::BFloat(), true);
5568 EXPECT_EQ(-std::numeric_limits<float>::infinity(), BNegInf.convertToFloat());
5569 APFloat BQNaN = APFloat::getQNaN(APFloat::BFloat());
5570 EXPECT_TRUE(std::isnan(BQNaN.convertToFloat()));
5571 }
5572
5573 TEST(APFloatTest, Float8E5M2ToFloat) {
5574 APFloat PosZero = APFloat::getZero(APFloat::Float8E5M2());
5575 APFloat PosZeroToFloat(PosZero.convertToFloat());
5576 EXPECT_TRUE(PosZeroToFloat.isPosZero());
5577 APFloat NegZero = APFloat::getZero(APFloat::Float8E5M2(), true);
5578 APFloat NegZeroToFloat(NegZero.convertToFloat());
5579 EXPECT_TRUE(NegZeroToFloat.isNegZero());
5580
5581 APFloat One(APFloat::Float8E5M2(), "1.0");
5582 EXPECT_EQ(1.0F, One.convertToFloat());
5583 APFloat Two(APFloat::Float8E5M2(), "2.0");
5584 EXPECT_EQ(2.0F, Two.convertToFloat());
5585
5586 APFloat PosLargest = APFloat::getLargest(APFloat::Float8E5M2(), false);
5587 EXPECT_EQ(5.734400e+04, PosLargest.convertToFloat());
5588 APFloat NegLargest = APFloat::getLargest(APFloat::Float8E5M2(), true);
5589 EXPECT_EQ(-5.734400e+04, NegLargest.convertToFloat());
5590 APFloat PosSmallest =
5591 APFloat::getSmallestNormalized(APFloat::Float8E5M2(), false);
5592 EXPECT_EQ(0x1.p-14, PosSmallest.convertToFloat());
5593 APFloat NegSmallest =
5594 APFloat::getSmallestNormalized(APFloat::Float8E5M2(), true);
5595 EXPECT_EQ(-0x1.p-14, NegSmallest.convertToFloat());
5596
5597 APFloat SmallestDenorm = APFloat::getSmallest(APFloat::Float8E5M2(), false);
5598 EXPECT_TRUE(SmallestDenorm.isDenormal());
5599 EXPECT_EQ(0x1.p-16, SmallestDenorm.convertToFloat());
5600
5601 APFloat PosInf = APFloat::getInf(APFloat::Float8E5M2());
5602 EXPECT_EQ(std::numeric_limits<float>::infinity(), PosInf.convertToFloat());
5603 APFloat NegInf = APFloat::getInf(APFloat::Float8E5M2(), true);
5604 EXPECT_EQ(-std::numeric_limits<float>::infinity(), NegInf.convertToFloat());
5605 APFloat QNaN = APFloat::getQNaN(APFloat::Float8E5M2());
5606 EXPECT_TRUE(std::isnan(QNaN.convertToFloat()));
5607 }
5608
5609 TEST(APFloatTest, Float8E4M3FNToFloat) {
5610 APFloat PosZero = APFloat::getZero(APFloat::Float8E4M3FN());
5611 APFloat PosZeroToFloat(PosZero.convertToFloat());
5612 EXPECT_TRUE(PosZeroToFloat.isPosZero());
5613 APFloat NegZero = APFloat::getZero(APFloat::Float8E4M3FN(), true);
5614 APFloat NegZeroToFloat(NegZero.convertToFloat());
5615 EXPECT_TRUE(NegZeroToFloat.isNegZero());
5616
5617 APFloat One(APFloat::Float8E4M3FN(), "1.0");
5618 EXPECT_EQ(1.0F, One.convertToFloat());
5619 APFloat Two(APFloat::Float8E4M3FN(), "2.0");
5620 EXPECT_EQ(2.0F, Two.convertToFloat());
5621
5622 APFloat PosLargest = APFloat::getLargest(APFloat::Float8E4M3FN(), false);
5623 EXPECT_EQ(448., PosLargest.convertToFloat());
5624 APFloat NegLargest = APFloat::getLargest(APFloat::Float8E4M3FN(), true);
5625 EXPECT_EQ(-448, NegLargest.convertToFloat());
5626 APFloat PosSmallest =
5627 APFloat::getSmallestNormalized(APFloat::Float8E4M3FN(), false);
5628 EXPECT_EQ(0x1.p-6, PosSmallest.convertToFloat());
5629 APFloat NegSmallest =
5630 APFloat::getSmallestNormalized(APFloat::Float8E4M3FN(), true);
5631 EXPECT_EQ(-0x1.p-6, NegSmallest.convertToFloat());
5632
5633 APFloat SmallestDenorm = APFloat::getSmallest(APFloat::Float8E4M3FN(), false);
5634 EXPECT_TRUE(SmallestDenorm.isDenormal());
5635 EXPECT_EQ(0x1.p-9, SmallestDenorm.convertToFloat());
5636
5637 APFloat QNaN = APFloat::getQNaN(APFloat::Float8E4M3FN());
5638 EXPECT_TRUE(std::isnan(QNaN.convertToFloat()));
5639 }
5640
5641 } // namespace