?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[docs] Fix build-docs.sh
[llvm-project.git] / llvm / unittests / ADT / APFloatTest.cpp
blob3caa09f364ff412059ca659aa1b954af7659cdbf
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, Zero) {
668 EXPECT_EQ(0.0f, APFloat(0.0f).convertToFloat());
669 EXPECT_EQ(-0.0f, APFloat(-0.0f).convertToFloat());
670 EXPECT_TRUE(APFloat(-0.0f).isNegative());
671
672 EXPECT_EQ(0.0, APFloat(0.0).convertToDouble());
673 EXPECT_EQ(-0.0, APFloat(-0.0).convertToDouble());
674 EXPECT_TRUE(APFloat(-0.0).isNegative());
675 }
676
677 TEST(APFloatTest, DecimalStringsWithoutNullTerminators) {
678 // Make sure that we can parse strings without null terminators.
679 // rdar://14323230.
680 EXPECT_EQ(convertToDoubleFromString(StringRef("0.00", 3)), 0.0);
681 EXPECT_EQ(convertToDoubleFromString(StringRef("0.01", 3)), 0.0);
682 EXPECT_EQ(convertToDoubleFromString(StringRef("0.09", 3)), 0.0);
683 EXPECT_EQ(convertToDoubleFromString(StringRef("0.095", 4)), 0.09);
684 EXPECT_EQ(convertToDoubleFromString(StringRef("0.00e+3", 7)), 0.00);
685 EXPECT_EQ(convertToDoubleFromString(StringRef("0e+3", 4)), 0.00);
686 }
687
688 TEST(APFloatTest, fromZeroDecimalString) {
689 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0").convertToDouble());
690 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0").convertToDouble());
691 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0").convertToDouble());
692
693 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0.").convertToDouble());
694 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0.").convertToDouble());
695 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0.").convertToDouble());
696
697 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), ".0").convertToDouble());
698 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+.0").convertToDouble());
699 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-.0").convertToDouble());
700
701 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0.0").convertToDouble());
702 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0.0").convertToDouble());
703 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0.0").convertToDouble());
704
705 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "00000.").convertToDouble());
706 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+00000.").convertToDouble());
707 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-00000.").convertToDouble());
708
709 EXPECT_EQ(0.0, APFloat(APFloat::IEEEdouble(), ".00000").convertToDouble());
710 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+.00000").convertToDouble());
711 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-.00000").convertToDouble());
712
713 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0000.00000").convertToDouble());
714 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0000.00000").convertToDouble());
715 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0000.00000").convertToDouble());
716 }
717
718 TEST(APFloatTest, fromZeroDecimalSingleExponentString) {
719 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0e1").convertToDouble());
720 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0e1").convertToDouble());
721 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0e1").convertToDouble());
722
723 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0e+1").convertToDouble());
724 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0e+1").convertToDouble());
725 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0e+1").convertToDouble());
726
727 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0e-1").convertToDouble());
728 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0e-1").convertToDouble());
729 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0e-1").convertToDouble());
730
731
732 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0.e1").convertToDouble());
733 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0.e1").convertToDouble());
734 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0.e1").convertToDouble());
735
736 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0.e+1").convertToDouble());
737 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0.e+1").convertToDouble());
738 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0.e+1").convertToDouble());
739
740 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0.e-1").convertToDouble());
741 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0.e-1").convertToDouble());
742 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0.e-1").convertToDouble());
743
744 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), ".0e1").convertToDouble());
745 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+.0e1").convertToDouble());
746 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-.0e1").convertToDouble());
747
748 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), ".0e+1").convertToDouble());
749 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+.0e+1").convertToDouble());
750 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-.0e+1").convertToDouble());
751
752 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), ".0e-1").convertToDouble());
753 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+.0e-1").convertToDouble());
754 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-.0e-1").convertToDouble());
755
756
757 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0.0e1").convertToDouble());
758 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0.0e1").convertToDouble());
759 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0.0e1").convertToDouble());
760
761 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0.0e+1").convertToDouble());
762 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0.0e+1").convertToDouble());
763 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0.0e+1").convertToDouble());
764
765 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0.0e-1").convertToDouble());
766 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0.0e-1").convertToDouble());
767 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0.0e-1").convertToDouble());
768
769
770 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "000.0000e1").convertToDouble());
771 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+000.0000e+1").convertToDouble());
772 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-000.0000e+1").convertToDouble());
773 }
774
775 TEST(APFloatTest, fromZeroDecimalLargeExponentString) {
776 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0e1234").convertToDouble());
777 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0e1234").convertToDouble());
778 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0e1234").convertToDouble());
779
780 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0e+1234").convertToDouble());
781 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0e+1234").convertToDouble());
782 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0e+1234").convertToDouble());
783
784 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0e-1234").convertToDouble());
785 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0e-1234").convertToDouble());
786 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0e-1234").convertToDouble());
787
788 EXPECT_EQ(0.0, APFloat(APFloat::IEEEdouble(), "000.0000e1234").convertToDouble());
789 EXPECT_EQ(0.0, APFloat(APFloat::IEEEdouble(), "000.0000e-1234").convertToDouble());
790
791 EXPECT_EQ(0.0, APFloat(APFloat::IEEEdouble(), StringRef("0e1234" "\0" "2", 6)).convertToDouble());
792 }
793
794 TEST(APFloatTest, fromZeroHexadecimalString) {
795 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x0p1").convertToDouble());
796 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0x0p1").convertToDouble());
797 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0x0p1").convertToDouble());
798
799 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x0p+1").convertToDouble());
800 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0x0p+1").convertToDouble());
801 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0x0p+1").convertToDouble());
802
803 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x0p-1").convertToDouble());
804 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0x0p-1").convertToDouble());
805 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0x0p-1").convertToDouble());
806
807
808 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x0.p1").convertToDouble());
809 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0x0.p1").convertToDouble());
810 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0x0.p1").convertToDouble());
811
812 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x0.p+1").convertToDouble());
813 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0x0.p+1").convertToDouble());
814 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0x0.p+1").convertToDouble());
815
816 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x0.p-1").convertToDouble());
817 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0x0.p-1").convertToDouble());
818 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0x0.p-1").convertToDouble());
819
820
821 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x.0p1").convertToDouble());
822 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0x.0p1").convertToDouble());
823 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0x.0p1").convertToDouble());
824
825 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x.0p+1").convertToDouble());
826 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0x.0p+1").convertToDouble());
827 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0x.0p+1").convertToDouble());
828
829 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x.0p-1").convertToDouble());
830 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0x.0p-1").convertToDouble());
831 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0x.0p-1").convertToDouble());
832
833
834 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x0.0p1").convertToDouble());
835 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0x0.0p1").convertToDouble());
836 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0x0.0p1").convertToDouble());
837
838 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x0.0p+1").convertToDouble());
839 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0x0.0p+1").convertToDouble());
840 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0x0.0p+1").convertToDouble());
841
842 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x0.0p-1").convertToDouble());
843 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0x0.0p-1").convertToDouble());
844 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0x0.0p-1").convertToDouble());
845
846
847 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x00000.p1").convertToDouble());
848 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x0000.00000p1").convertToDouble());
849 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x.00000p1").convertToDouble());
850 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x0.p1").convertToDouble());
851 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x0p1234").convertToDouble());
852 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0x0p1234").convertToDouble());
853 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x00000.p1234").convertToDouble());
854 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x0000.00000p1234").convertToDouble());
855 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x.00000p1234").convertToDouble());
856 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x0.p1234").convertToDouble());
857 }
858
859 TEST(APFloatTest, fromDecimalString) {
860 EXPECT_EQ(1.0, APFloat(APFloat::IEEEdouble(), "1").convertToDouble());
861 EXPECT_EQ(2.0, APFloat(APFloat::IEEEdouble(), "2.").convertToDouble());
862 EXPECT_EQ(0.5, APFloat(APFloat::IEEEdouble(), ".5").convertToDouble());
863 EXPECT_EQ(1.0, APFloat(APFloat::IEEEdouble(), "1.0").convertToDouble());
864 EXPECT_EQ(-2.0, APFloat(APFloat::IEEEdouble(), "-2").convertToDouble());
865 EXPECT_EQ(-4.0, APFloat(APFloat::IEEEdouble(), "-4.").convertToDouble());
866 EXPECT_EQ(-0.5, APFloat(APFloat::IEEEdouble(), "-.5").convertToDouble());
867 EXPECT_EQ(-1.5, APFloat(APFloat::IEEEdouble(), "-1.5").convertToDouble());
868 EXPECT_EQ(1.25e12, APFloat(APFloat::IEEEdouble(), "1.25e12").convertToDouble());
869 EXPECT_EQ(1.25e+12, APFloat(APFloat::IEEEdouble(), "1.25e+12").convertToDouble());
870 EXPECT_EQ(1.25e-12, APFloat(APFloat::IEEEdouble(), "1.25e-12").convertToDouble());
871 EXPECT_EQ(1024.0, APFloat(APFloat::IEEEdouble(), "1024.").convertToDouble());
872 EXPECT_EQ(1024.05, APFloat(APFloat::IEEEdouble(), "1024.05000").convertToDouble());
873 EXPECT_EQ(0.05, APFloat(APFloat::IEEEdouble(), ".05000").convertToDouble());
874 EXPECT_EQ(2.0, APFloat(APFloat::IEEEdouble(), "2.").convertToDouble());
875 EXPECT_EQ(2.0e2, APFloat(APFloat::IEEEdouble(), "2.e2").convertToDouble());
876 EXPECT_EQ(2.0e+2, APFloat(APFloat::IEEEdouble(), "2.e+2").convertToDouble());
877 EXPECT_EQ(2.0e-2, APFloat(APFloat::IEEEdouble(), "2.e-2").convertToDouble());
878 EXPECT_EQ(2.05e2, APFloat(APFloat::IEEEdouble(), "002.05000e2").convertToDouble());
879 EXPECT_EQ(2.05e+2, APFloat(APFloat::IEEEdouble(), "002.05000e+2").convertToDouble());
880 EXPECT_EQ(2.05e-2, APFloat(APFloat::IEEEdouble(), "002.05000e-2").convertToDouble());
881 EXPECT_EQ(2.05e12, APFloat(APFloat::IEEEdouble(), "002.05000e12").convertToDouble());
882 EXPECT_EQ(2.05e+12, APFloat(APFloat::IEEEdouble(), "002.05000e+12").convertToDouble());
883 EXPECT_EQ(2.05e-12, APFloat(APFloat::IEEEdouble(), "002.05000e-12").convertToDouble());
884
885 EXPECT_EQ(1.0, APFloat(APFloat::IEEEdouble(), "1e").convertToDouble());
886 EXPECT_EQ(1.0, APFloat(APFloat::IEEEdouble(), "+1e").convertToDouble());
887 EXPECT_EQ(-1.0, APFloat(APFloat::IEEEdouble(), "-1e").convertToDouble());
888
889 EXPECT_EQ(1.0, APFloat(APFloat::IEEEdouble(), "1.e").convertToDouble());
890 EXPECT_EQ(1.0, APFloat(APFloat::IEEEdouble(), "+1.e").convertToDouble());
891 EXPECT_EQ(-1.0, APFloat(APFloat::IEEEdouble(), "-1.e").convertToDouble());
892
893 EXPECT_EQ(0.1, APFloat(APFloat::IEEEdouble(), ".1e").convertToDouble());
894 EXPECT_EQ(0.1, APFloat(APFloat::IEEEdouble(), "+.1e").convertToDouble());
895 EXPECT_EQ(-0.1, APFloat(APFloat::IEEEdouble(), "-.1e").convertToDouble());
896
897 EXPECT_EQ(1.1, APFloat(APFloat::IEEEdouble(), "1.1e").convertToDouble());
898 EXPECT_EQ(1.1, APFloat(APFloat::IEEEdouble(), "+1.1e").convertToDouble());
899 EXPECT_EQ(-1.1, APFloat(APFloat::IEEEdouble(), "-1.1e").convertToDouble());
900
901 EXPECT_EQ(1.0, APFloat(APFloat::IEEEdouble(), "1e+").convertToDouble());
902 EXPECT_EQ(1.0, APFloat(APFloat::IEEEdouble(), "1e-").convertToDouble());
903
904 EXPECT_EQ(0.1, APFloat(APFloat::IEEEdouble(), ".1e").convertToDouble());
905 EXPECT_EQ(0.1, APFloat(APFloat::IEEEdouble(), ".1e+").convertToDouble());
906 EXPECT_EQ(0.1, APFloat(APFloat::IEEEdouble(), ".1e-").convertToDouble());
907
908 EXPECT_EQ(1.0, APFloat(APFloat::IEEEdouble(), "1.0e").convertToDouble());
909 EXPECT_EQ(1.0, APFloat(APFloat::IEEEdouble(), "1.0e+").convertToDouble());
910 EXPECT_EQ(1.0, APFloat(APFloat::IEEEdouble(), "1.0e-").convertToDouble());
911
912 // These are "carefully selected" to overflow the fast log-base
913 // calculations in APFloat.cpp
914 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "99e99999").isInfinity());
915 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "-99e99999").isInfinity());
916 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "1e-99999").isPosZero());
917 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "-1e-99999").isNegZero());
918
919 EXPECT_EQ(2.71828, convertToDoubleFromString("2.71828"));
920 }
921
922 TEST(APFloatTest, fromStringSpecials) {
923 const fltSemantics &Sem = APFloat::IEEEdouble();
924 const unsigned Precision = 53;
925 const unsigned PayloadBits = Precision - 2;
926 uint64_t PayloadMask = (uint64_t(1) << PayloadBits) - uint64_t(1);
927
928 uint64_t NaNPayloads[] = {
929 0,
930 1,
931 123,
932 0xDEADBEEF,
933 uint64_t(-2),
934 uint64_t(1) << PayloadBits, // overflow bit
935 uint64_t(1) << (PayloadBits - 1), // signaling bit
936 uint64_t(1) << (PayloadBits - 2) // highest possible bit
937 };
938
939 // Convert payload integer to decimal string representation.
940 std::string NaNPayloadDecStrings[std::size(NaNPayloads)];
941 for (size_t I = 0; I < std::size(NaNPayloads); ++I)
942 NaNPayloadDecStrings[I] = utostr(NaNPayloads[I]);
943
944 // Convert payload integer to hexadecimal string representation.
945 std::string NaNPayloadHexStrings[std::size(NaNPayloads)];
946 for (size_t I = 0; I < std::size(NaNPayloads); ++I)
947 NaNPayloadHexStrings[I] = "0x" + utohexstr(NaNPayloads[I]);
948
949 // Fix payloads to expected result.
950 for (uint64_t &Payload : NaNPayloads)
951 Payload &= PayloadMask;
952
953 // Signaling NaN must have a non-zero payload. In case a zero payload is
954 // requested, a default arbitrary payload is set instead. Save this payload
955 // for testing.
956 const uint64_t SNaNDefaultPayload =
957 APFloat::getSNaN(Sem).bitcastToAPInt().getZExtValue() & PayloadMask;
958
959 // Negative sign prefix (or none - for positive).
960 const char Signs[] = {0, '-'};
961
962 // "Signaling" prefix (or none - for "Quiet").
963 const char NaNTypes[] = {0, 's', 'S'};
964
965 const StringRef NaNStrings[] = {"nan", "NaN"};
966 for (StringRef NaNStr : NaNStrings)
967 for (char TypeChar : NaNTypes) {
968 bool Signaling = (TypeChar == 's' || TypeChar == 'S');
969
970 for (size_t J = 0; J < std::size(NaNPayloads); ++J) {
971 uint64_t Payload = (Signaling && !NaNPayloads[J]) ? SNaNDefaultPayload
972 : NaNPayloads[J];
973 std::string &PayloadDec = NaNPayloadDecStrings[J];
974 std::string &PayloadHex = NaNPayloadHexStrings[J];
975
976 for (char SignChar : Signs) {
977 bool Negative = (SignChar == '-');
978
979 std::string TestStrings[5];
980 size_t NumTestStrings = 0;
981
982 std::string Prefix;
983 if (SignChar)
984 Prefix += SignChar;
985 if (TypeChar)
986 Prefix += TypeChar;
987 Prefix += NaNStr;
988
989 // Test without any paylod.
990 if (!Payload)
991 TestStrings[NumTestStrings++] = Prefix;
992
993 // Test with the payload as a suffix.
994 TestStrings[NumTestStrings++] = Prefix + PayloadDec;
995 TestStrings[NumTestStrings++] = Prefix + PayloadHex;
996
997 // Test with the payload inside parentheses.
998 TestStrings[NumTestStrings++] = Prefix + '(' + PayloadDec + ')';
999 TestStrings[NumTestStrings++] = Prefix + '(' + PayloadHex + ')';
1000
1001 for (size_t K = 0; K < NumTestStrings; ++K) {
1002 StringRef TestStr = TestStrings[K];
1003
1004 APFloat F(Sem);
1005 bool HasError = !F.convertFromString(
1006 TestStr, llvm::APFloat::rmNearestTiesToEven);
1007 EXPECT_FALSE(HasError);
1008 EXPECT_TRUE(F.isNaN());
1009 EXPECT_EQ(Signaling, F.isSignaling());
1010 EXPECT_EQ(Negative, F.isNegative());
1011 uint64_t PayloadResult =
1012 F.bitcastToAPInt().getZExtValue() & PayloadMask;
1013 EXPECT_EQ(Payload, PayloadResult);
1014 }
1015 }
1016 }
1017 }
1018
1019 const StringRef InfStrings[] = {"inf", "INFINITY", "+Inf",
1020 "-inf", "-INFINITY", "-Inf"};
1021 for (StringRef InfStr : InfStrings) {
1022 bool Negative = InfStr.front() == '-';
1023
1024 APFloat F(Sem);
1025 bool HasError =
1026 !F.convertFromString(InfStr, llvm::APFloat::rmNearestTiesToEven);
1027 EXPECT_FALSE(HasError);
1028 EXPECT_TRUE(F.isInfinity());
1029 EXPECT_EQ(Negative, F.isNegative());
1030 uint64_t PayloadResult = F.bitcastToAPInt().getZExtValue() & PayloadMask;
1031 EXPECT_EQ(UINT64_C(0), PayloadResult);
1032 }
1033 }
1034
1035 TEST(APFloatTest, fromToStringSpecials) {
1036 auto expects = [] (const char *first, const char *second) {
1037 std::string roundtrip = convertToString(convertToDoubleFromString(second), 0, 3);
1038 EXPECT_STREQ(first, roundtrip.c_str());
1039 };
1040 expects("+Inf", "+Inf");
1041 expects("+Inf", "INFINITY");
1042 expects("+Inf", "inf");
1043 expects("-Inf", "-Inf");
1044 expects("-Inf", "-INFINITY");
1045 expects("-Inf", "-inf");
1046 expects("NaN", "NaN");
1047 expects("NaN", "nan");
1048 expects("NaN", "-NaN");
1049 expects("NaN", "-nan");
1050 }
1051
1052 TEST(APFloatTest, fromHexadecimalString) {
1053 EXPECT_EQ( 1.0, APFloat(APFloat::IEEEdouble(), "0x1p0").convertToDouble());
1054 EXPECT_EQ(+1.0, APFloat(APFloat::IEEEdouble(), "+0x1p0").convertToDouble());
1055 EXPECT_EQ(-1.0, APFloat(APFloat::IEEEdouble(), "-0x1p0").convertToDouble());
1056
1057 EXPECT_EQ( 1.0, APFloat(APFloat::IEEEdouble(), "0x1p+0").convertToDouble());
1058 EXPECT_EQ(+1.0, APFloat(APFloat::IEEEdouble(), "+0x1p+0").convertToDouble());
1059 EXPECT_EQ(-1.0, APFloat(APFloat::IEEEdouble(), "-0x1p+0").convertToDouble());
1060
1061 EXPECT_EQ( 1.0, APFloat(APFloat::IEEEdouble(), "0x1p-0").convertToDouble());
1062 EXPECT_EQ(+1.0, APFloat(APFloat::IEEEdouble(), "+0x1p-0").convertToDouble());
1063 EXPECT_EQ(-1.0, APFloat(APFloat::IEEEdouble(), "-0x1p-0").convertToDouble());
1064
1065
1066 EXPECT_EQ( 2.0, APFloat(APFloat::IEEEdouble(), "0x1p1").convertToDouble());
1067 EXPECT_EQ(+2.0, APFloat(APFloat::IEEEdouble(), "+0x1p1").convertToDouble());
1068 EXPECT_EQ(-2.0, APFloat(APFloat::IEEEdouble(), "-0x1p1").convertToDouble());
1069
1070 EXPECT_EQ( 2.0, APFloat(APFloat::IEEEdouble(), "0x1p+1").convertToDouble());
1071 EXPECT_EQ(+2.0, APFloat(APFloat::IEEEdouble(), "+0x1p+1").convertToDouble());
1072 EXPECT_EQ(-2.0, APFloat(APFloat::IEEEdouble(), "-0x1p+1").convertToDouble());
1073
1074 EXPECT_EQ( 0.5, APFloat(APFloat::IEEEdouble(), "0x1p-1").convertToDouble());
1075 EXPECT_EQ(+0.5, APFloat(APFloat::IEEEdouble(), "+0x1p-1").convertToDouble());
1076 EXPECT_EQ(-0.5, APFloat(APFloat::IEEEdouble(), "-0x1p-1").convertToDouble());
1077
1078
1079 EXPECT_EQ( 3.0, APFloat(APFloat::IEEEdouble(), "0x1.8p1").convertToDouble());
1080 EXPECT_EQ(+3.0, APFloat(APFloat::IEEEdouble(), "+0x1.8p1").convertToDouble());
1081 EXPECT_EQ(-3.0, APFloat(APFloat::IEEEdouble(), "-0x1.8p1").convertToDouble());
1082
1083 EXPECT_EQ( 3.0, APFloat(APFloat::IEEEdouble(), "0x1.8p+1").convertToDouble());
1084 EXPECT_EQ(+3.0, APFloat(APFloat::IEEEdouble(), "+0x1.8p+1").convertToDouble());
1085 EXPECT_EQ(-3.0, APFloat(APFloat::IEEEdouble(), "-0x1.8p+1").convertToDouble());
1086
1087 EXPECT_EQ( 0.75, APFloat(APFloat::IEEEdouble(), "0x1.8p-1").convertToDouble());
1088 EXPECT_EQ(+0.75, APFloat(APFloat::IEEEdouble(), "+0x1.8p-1").convertToDouble());
1089 EXPECT_EQ(-0.75, APFloat(APFloat::IEEEdouble(), "-0x1.8p-1").convertToDouble());
1090
1091
1092 EXPECT_EQ( 8192.0, APFloat(APFloat::IEEEdouble(), "0x1000.000p1").convertToDouble());
1093 EXPECT_EQ(+8192.0, APFloat(APFloat::IEEEdouble(), "+0x1000.000p1").convertToDouble());
1094 EXPECT_EQ(-8192.0, APFloat(APFloat::IEEEdouble(), "-0x1000.000p1").convertToDouble());
1095
1096 EXPECT_EQ( 8192.0, APFloat(APFloat::IEEEdouble(), "0x1000.000p+1").convertToDouble());
1097 EXPECT_EQ(+8192.0, APFloat(APFloat::IEEEdouble(), "+0x1000.000p+1").convertToDouble());
1098 EXPECT_EQ(-8192.0, APFloat(APFloat::IEEEdouble(), "-0x1000.000p+1").convertToDouble());
1099
1100 EXPECT_EQ( 2048.0, APFloat(APFloat::IEEEdouble(), "0x1000.000p-1").convertToDouble());
1101 EXPECT_EQ(+2048.0, APFloat(APFloat::IEEEdouble(), "+0x1000.000p-1").convertToDouble());
1102 EXPECT_EQ(-2048.0, APFloat(APFloat::IEEEdouble(), "-0x1000.000p-1").convertToDouble());
1103
1104
1105 EXPECT_EQ( 8192.0, APFloat(APFloat::IEEEdouble(), "0x1000p1").convertToDouble());
1106 EXPECT_EQ(+8192.0, APFloat(APFloat::IEEEdouble(), "+0x1000p1").convertToDouble());
1107 EXPECT_EQ(-8192.0, APFloat(APFloat::IEEEdouble(), "-0x1000p1").convertToDouble());
1108
1109 EXPECT_EQ( 8192.0, APFloat(APFloat::IEEEdouble(), "0x1000p+1").convertToDouble());
1110 EXPECT_EQ(+8192.0, APFloat(APFloat::IEEEdouble(), "+0x1000p+1").convertToDouble());
1111 EXPECT_EQ(-8192.0, APFloat(APFloat::IEEEdouble(), "-0x1000p+1").convertToDouble());
1112
1113 EXPECT_EQ( 2048.0, APFloat(APFloat::IEEEdouble(), "0x1000p-1").convertToDouble());
1114 EXPECT_EQ(+2048.0, APFloat(APFloat::IEEEdouble(), "+0x1000p-1").convertToDouble());
1115 EXPECT_EQ(-2048.0, APFloat(APFloat::IEEEdouble(), "-0x1000p-1").convertToDouble());
1116
1117
1118 EXPECT_EQ( 16384.0, APFloat(APFloat::IEEEdouble(), "0x10p10").convertToDouble());
1119 EXPECT_EQ(+16384.0, APFloat(APFloat::IEEEdouble(), "+0x10p10").convertToDouble());
1120 EXPECT_EQ(-16384.0, APFloat(APFloat::IEEEdouble(), "-0x10p10").convertToDouble());
1121
1122 EXPECT_EQ( 16384.0, APFloat(APFloat::IEEEdouble(), "0x10p+10").convertToDouble());
1123 EXPECT_EQ(+16384.0, APFloat(APFloat::IEEEdouble(), "+0x10p+10").convertToDouble());
1124 EXPECT_EQ(-16384.0, APFloat(APFloat::IEEEdouble(), "-0x10p+10").convertToDouble());
1125
1126 EXPECT_EQ( 0.015625, APFloat(APFloat::IEEEdouble(), "0x10p-10").convertToDouble());
1127 EXPECT_EQ(+0.015625, APFloat(APFloat::IEEEdouble(), "+0x10p-10").convertToDouble());
1128 EXPECT_EQ(-0.015625, APFloat(APFloat::IEEEdouble(), "-0x10p-10").convertToDouble());
1129
1130 EXPECT_EQ(1.0625, APFloat(APFloat::IEEEdouble(), "0x1.1p0").convertToDouble());
1131 EXPECT_EQ(1.0, APFloat(APFloat::IEEEdouble(), "0x1p0").convertToDouble());
1132
1133 EXPECT_EQ(convertToDoubleFromString("0x1p-150"),
1134 convertToDoubleFromString("+0x800000000000000001.p-221"));
1135 EXPECT_EQ(2251799813685248.5,
1136 convertToDoubleFromString("0x80000000000004000000.010p-28"));
1137 }
1138
1139 TEST(APFloatTest, toString) {
1140 ASSERT_EQ("10", convertToString(10.0, 6, 3));
1141 ASSERT_EQ("1.0E+1", convertToString(10.0, 6, 0));
1142 ASSERT_EQ("10100", convertToString(1.01E+4, 5, 2));
1143 ASSERT_EQ("1.01E+4", convertToString(1.01E+4, 4, 2));
1144 ASSERT_EQ("1.01E+4", convertToString(1.01E+4, 5, 1));
1145 ASSERT_EQ("0.0101", convertToString(1.01E-2, 5, 2));
1146 ASSERT_EQ("0.0101", convertToString(1.01E-2, 4, 2));
1147 ASSERT_EQ("1.01E-2", convertToString(1.01E-2, 5, 1));
1148 ASSERT_EQ("0.78539816339744828", convertToString(0.78539816339744830961, 0, 3));
1149 ASSERT_EQ("4.9406564584124654E-324", convertToString(4.9406564584124654e-324, 0, 3));
1150 ASSERT_EQ("873.18340000000001", convertToString(873.1834, 0, 1));
1151 ASSERT_EQ("8.7318340000000001E+2", convertToString(873.1834, 0, 0));
1152 ASSERT_EQ("1.7976931348623157E+308", convertToString(1.7976931348623157E+308, 0, 0));
1153 ASSERT_EQ("10", convertToString(10.0, 6, 3, false));
1154 ASSERT_EQ("1.000000e+01", convertToString(10.0, 6, 0, false));
1155 ASSERT_EQ("10100", convertToString(1.01E+4, 5, 2, false));
1156 ASSERT_EQ("1.0100e+04", convertToString(1.01E+4, 4, 2, false));
1157 ASSERT_EQ("1.01000e+04", convertToString(1.01E+4, 5, 1, false));
1158 ASSERT_EQ("0.0101", convertToString(1.01E-2, 5, 2, false));
1159 ASSERT_EQ("0.0101", convertToString(1.01E-2, 4, 2, false));
1160 ASSERT_EQ("1.01000e-02", convertToString(1.01E-2, 5, 1, false));
1161 ASSERT_EQ("0.78539816339744828",
1162 convertToString(0.78539816339744830961, 0, 3, false));
1163 ASSERT_EQ("4.94065645841246540e-324",
1164 convertToString(4.9406564584124654e-324, 0, 3, false));
1165 ASSERT_EQ("873.18340000000001", convertToString(873.1834, 0, 1, false));
1166 ASSERT_EQ("8.73183400000000010e+02", convertToString(873.1834, 0, 0, false));
1167 ASSERT_EQ("1.79769313486231570e+308",
1168 convertToString(1.7976931348623157E+308, 0, 0, false));
1169
1170 {
1171 SmallString<64> Str;
1172 APFloat UnnormalZero(APFloat::x87DoubleExtended(), APInt(80, {0, 1}));
1173 UnnormalZero.toString(Str);
1174 ASSERT_EQ("NaN", Str);
1175 }
1176 }
1177
1178 TEST(APFloatTest, toInteger) {
1179 bool isExact = false;
1180 APSInt result(5, /*isUnsigned=*/true);
1181
1182 EXPECT_EQ(APFloat::opOK,
1183 APFloat(APFloat::IEEEdouble(), "10")
1184 .convertToInteger(result, APFloat::rmTowardZero, &isExact));
1185 EXPECT_TRUE(isExact);
1186 EXPECT_EQ(APSInt(APInt(5, 10), true), result);
1187
1188 EXPECT_EQ(APFloat::opInvalidOp,
1189 APFloat(APFloat::IEEEdouble(), "-10")
1190 .convertToInteger(result, APFloat::rmTowardZero, &isExact));
1191 EXPECT_FALSE(isExact);
1192 EXPECT_EQ(APSInt::getMinValue(5, true), result);
1193
1194 EXPECT_EQ(APFloat::opInvalidOp,
1195 APFloat(APFloat::IEEEdouble(), "32")
1196 .convertToInteger(result, APFloat::rmTowardZero, &isExact));
1197 EXPECT_FALSE(isExact);
1198 EXPECT_EQ(APSInt::getMaxValue(5, true), result);
1199
1200 EXPECT_EQ(APFloat::opInexact,
1201 APFloat(APFloat::IEEEdouble(), "7.9")
1202 .convertToInteger(result, APFloat::rmTowardZero, &isExact));
1203 EXPECT_FALSE(isExact);
1204 EXPECT_EQ(APSInt(APInt(5, 7), true), result);
1205
1206 result.setIsUnsigned(false);
1207 EXPECT_EQ(APFloat::opOK,
1208 APFloat(APFloat::IEEEdouble(), "-10")
1209 .convertToInteger(result, APFloat::rmTowardZero, &isExact));
1210 EXPECT_TRUE(isExact);
1211 EXPECT_EQ(APSInt(APInt(5, -10, true), false), result);
1212
1213 EXPECT_EQ(APFloat::opInvalidOp,
1214 APFloat(APFloat::IEEEdouble(), "-17")
1215 .convertToInteger(result, APFloat::rmTowardZero, &isExact));
1216 EXPECT_FALSE(isExact);
1217 EXPECT_EQ(APSInt::getMinValue(5, false), result);
1218
1219 EXPECT_EQ(APFloat::opInvalidOp,
1220 APFloat(APFloat::IEEEdouble(), "16")
1221 .convertToInteger(result, APFloat::rmTowardZero, &isExact));
1222 EXPECT_FALSE(isExact);
1223 EXPECT_EQ(APSInt::getMaxValue(5, false), result);
1224 }
1225
1226 static APInt nanbitsFromAPInt(const fltSemantics &Sem, bool SNaN, bool Negative,
1227 uint64_t payload) {
1228 APInt appayload(64, payload);
1229 if (SNaN)
1230 return APFloat::getSNaN(Sem, Negative, &appayload).bitcastToAPInt();
1231 else
1232 return APFloat::getQNaN(Sem, Negative, &appayload).bitcastToAPInt();
1233 }
1234
1235 TEST(APFloatTest, makeNaN) {
1236 const struct {
1237 uint64_t expected;
1238 const fltSemantics &semantics;
1239 bool SNaN;
1240 bool Negative;
1241 uint64_t payload;
1242 } tests[] = {
1243 /* expected semantics SNaN Neg payload */
1244 { 0x7fc00000ULL, APFloat::IEEEsingle(), false, false, 0x00000000ULL },
1245 { 0xffc00000ULL, APFloat::IEEEsingle(), false, true, 0x00000000ULL },
1246 { 0x7fc0ae72ULL, APFloat::IEEEsingle(), false, false, 0x0000ae72ULL },
1247 { 0x7fffae72ULL, APFloat::IEEEsingle(), false, false, 0xffffae72ULL },
1248 { 0x7fdaae72ULL, APFloat::IEEEsingle(), false, false, 0x00daae72ULL },
1249 { 0x7fa00000ULL, APFloat::IEEEsingle(), true, false, 0x00000000ULL },
1250 { 0xffa00000ULL, APFloat::IEEEsingle(), true, true, 0x00000000ULL },
1251 { 0x7f80ae72ULL, APFloat::IEEEsingle(), true, false, 0x0000ae72ULL },
1252 { 0x7fbfae72ULL, APFloat::IEEEsingle(), true, false, 0xffffae72ULL },
1253 { 0x7f9aae72ULL, APFloat::IEEEsingle(), true, false, 0x001aae72ULL },
1254 { 0x7ff8000000000000ULL, APFloat::IEEEdouble(), false, false, 0x0000000000000000ULL },
1255 { 0xfff8000000000000ULL, APFloat::IEEEdouble(), false, true, 0x0000000000000000ULL },
1256 { 0x7ff800000000ae72ULL, APFloat::IEEEdouble(), false, false, 0x000000000000ae72ULL },
1257 { 0x7fffffffffffae72ULL, APFloat::IEEEdouble(), false, false, 0xffffffffffffae72ULL },
1258 { 0x7ffdaaaaaaaaae72ULL, APFloat::IEEEdouble(), false, false, 0x000daaaaaaaaae72ULL },
1259 { 0x7ff4000000000000ULL, APFloat::IEEEdouble(), true, false, 0x0000000000000000ULL },
1260 { 0xfff4000000000000ULL, APFloat::IEEEdouble(), true, true, 0x0000000000000000ULL },
1261 { 0x7ff000000000ae72ULL, APFloat::IEEEdouble(), true, false, 0x000000000000ae72ULL },
1262 { 0x7ff7ffffffffae72ULL, APFloat::IEEEdouble(), true, false, 0xffffffffffffae72ULL },
1263 { 0x7ff1aaaaaaaaae72ULL, APFloat::IEEEdouble(), true, false, 0x0001aaaaaaaaae72ULL },
1264 };
1265
1266 for (const auto &t : tests) {
1267 ASSERT_EQ(t.expected, nanbitsFromAPInt(t.semantics, t.SNaN, t.Negative, t.payload));
1268 }
1269 }
1270
1271 #ifdef GTEST_HAS_DEATH_TEST
1272 #ifndef NDEBUG
1273 TEST(APFloatTest, SemanticsDeath) {
1274 EXPECT_DEATH(APFloat(APFloat::IEEEquad(), 0).convertToDouble(),
1275 "Float semantics is not representable by IEEEdouble");
1276 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), 0).convertToFloat(),
1277 "Float semantics is not representable by IEEEsingle");
1278 }
1279 #endif
1280 #endif
1281
1282 TEST(APFloatTest, StringDecimalError) {
1283 EXPECT_EQ("Invalid string length", convertToErrorFromString(""));
1284 EXPECT_EQ("String has no digits", convertToErrorFromString("+"));
1285 EXPECT_EQ("String has no digits", convertToErrorFromString("-"));
1286
1287 EXPECT_EQ("Invalid character in significand", convertToErrorFromString(StringRef("\0", 1)));
1288 EXPECT_EQ("Invalid character in significand", convertToErrorFromString(StringRef("1\0", 2)));
1289 EXPECT_EQ("Invalid character in significand", convertToErrorFromString(StringRef("1" "\0" "2", 3)));
1290 EXPECT_EQ("Invalid character in significand", convertToErrorFromString(StringRef("1" "\0" "2e1", 5)));
1291 EXPECT_EQ("Invalid character in exponent", convertToErrorFromString(StringRef("1e\0", 3)));
1292 EXPECT_EQ("Invalid character in exponent", convertToErrorFromString(StringRef("1e1\0", 4)));
1293 EXPECT_EQ("Invalid character in exponent", convertToErrorFromString(StringRef("1e1" "\0" "2", 5)));
1294
1295 EXPECT_EQ("Invalid character in significand", convertToErrorFromString("1.0f"));
1296
1297 EXPECT_EQ("String contains multiple dots", convertToErrorFromString(".."));
1298 EXPECT_EQ("String contains multiple dots", convertToErrorFromString("..0"));
1299 EXPECT_EQ("String contains multiple dots", convertToErrorFromString("1.0.0"));
1300 }
1301
1302 TEST(APFloatTest, StringDecimalSignificandError) {
1303 EXPECT_EQ("Significand has no digits", convertToErrorFromString( "."));
1304 EXPECT_EQ("Significand has no digits", convertToErrorFromString("+."));
1305 EXPECT_EQ("Significand has no digits", convertToErrorFromString("-."));
1306
1307
1308 EXPECT_EQ("Significand has no digits", convertToErrorFromString( "e"));
1309 EXPECT_EQ("Significand has no digits", convertToErrorFromString("+e"));
1310 EXPECT_EQ("Significand has no digits", convertToErrorFromString("-e"));
1311
1312 EXPECT_EQ("Significand has no digits", convertToErrorFromString( "e1"));
1313 EXPECT_EQ("Significand has no digits", convertToErrorFromString("+e1"));
1314 EXPECT_EQ("Significand has no digits", convertToErrorFromString("-e1"));
1315
1316 EXPECT_EQ("Significand has no digits", convertToErrorFromString( ".e1"));
1317 EXPECT_EQ("Significand has no digits", convertToErrorFromString("+.e1"));
1318 EXPECT_EQ("Significand has no digits", convertToErrorFromString("-.e1"));
1319
1320
1321 EXPECT_EQ("Significand has no digits", convertToErrorFromString( ".e"));
1322 EXPECT_EQ("Significand has no digits", convertToErrorFromString("+.e"));
1323 EXPECT_EQ("Significand has no digits", convertToErrorFromString("-.e"));
1324 }
1325
1326 TEST(APFloatTest, StringHexadecimalError) {
1327 EXPECT_EQ("Invalid string", convertToErrorFromString( "0x"));
1328 EXPECT_EQ("Invalid string", convertToErrorFromString("+0x"));
1329 EXPECT_EQ("Invalid string", convertToErrorFromString("-0x"));
1330
1331 EXPECT_EQ("Hex strings require an exponent", convertToErrorFromString( "0x0"));
1332 EXPECT_EQ("Hex strings require an exponent", convertToErrorFromString("+0x0"));
1333 EXPECT_EQ("Hex strings require an exponent", convertToErrorFromString("-0x0"));
1334
1335 EXPECT_EQ("Hex strings require an exponent", convertToErrorFromString( "0x0."));
1336 EXPECT_EQ("Hex strings require an exponent", convertToErrorFromString("+0x0."));
1337 EXPECT_EQ("Hex strings require an exponent", convertToErrorFromString("-0x0."));
1338
1339 EXPECT_EQ("Hex strings require an exponent", convertToErrorFromString( "0x.0"));
1340 EXPECT_EQ("Hex strings require an exponent", convertToErrorFromString("+0x.0"));
1341 EXPECT_EQ("Hex strings require an exponent", convertToErrorFromString("-0x.0"));
1342
1343 EXPECT_EQ("Hex strings require an exponent", convertToErrorFromString( "0x0.0"));
1344 EXPECT_EQ("Hex strings require an exponent", convertToErrorFromString("+0x0.0"));
1345 EXPECT_EQ("Hex strings require an exponent", convertToErrorFromString("-0x0.0"));
1346
1347 EXPECT_EQ("Invalid character in significand", convertToErrorFromString(StringRef("0x\0", 3)));
1348 EXPECT_EQ("Invalid character in significand", convertToErrorFromString(StringRef("0x1\0", 4)));
1349 EXPECT_EQ("Invalid character in significand", convertToErrorFromString(StringRef("0x1" "\0" "2", 5)));
1350 EXPECT_EQ("Invalid character in significand", convertToErrorFromString(StringRef("0x1" "\0" "2p1", 7)));
1351 EXPECT_EQ("Invalid character in exponent", convertToErrorFromString(StringRef("0x1p\0", 5)));
1352 EXPECT_EQ("Invalid character in exponent", convertToErrorFromString(StringRef("0x1p1\0", 6)));
1353 EXPECT_EQ("Invalid character in exponent", convertToErrorFromString(StringRef("0x1p1" "\0" "2", 7)));
1354
1355 EXPECT_EQ("Invalid character in exponent", convertToErrorFromString("0x1p0f"));
1356
1357 EXPECT_EQ("String contains multiple dots", convertToErrorFromString("0x..p1"));
1358 EXPECT_EQ("String contains multiple dots", convertToErrorFromString("0x..0p1"));
1359 EXPECT_EQ("String contains multiple dots", convertToErrorFromString("0x1.0.0p1"));
1360 }
1361
1362 TEST(APFloatTest, StringHexadecimalSignificandError) {
1363 EXPECT_EQ("Significand has no digits", convertToErrorFromString( "0x."));
1364 EXPECT_EQ("Significand has no digits", convertToErrorFromString("+0x."));
1365 EXPECT_EQ("Significand has no digits", convertToErrorFromString("-0x."));
1366
1367 EXPECT_EQ("Significand has no digits", convertToErrorFromString( "0xp"));
1368 EXPECT_EQ("Significand has no digits", convertToErrorFromString("+0xp"));
1369 EXPECT_EQ("Significand has no digits", convertToErrorFromString("-0xp"));
1370
1371 EXPECT_EQ("Significand has no digits", convertToErrorFromString( "0xp+"));
1372 EXPECT_EQ("Significand has no digits", convertToErrorFromString("+0xp+"));
1373 EXPECT_EQ("Significand has no digits", convertToErrorFromString("-0xp+"));
1374
1375 EXPECT_EQ("Significand has no digits", convertToErrorFromString( "0xp-"));
1376 EXPECT_EQ("Significand has no digits", convertToErrorFromString("+0xp-"));
1377 EXPECT_EQ("Significand has no digits", convertToErrorFromString("-0xp-"));
1378
1379
1380 EXPECT_EQ("Significand has no digits", convertToErrorFromString( "0x.p"));
1381 EXPECT_EQ("Significand has no digits", convertToErrorFromString("+0x.p"));
1382 EXPECT_EQ("Significand has no digits", convertToErrorFromString("-0x.p"));
1383
1384 EXPECT_EQ("Significand has no digits", convertToErrorFromString( "0x.p+"));
1385 EXPECT_EQ("Significand has no digits", convertToErrorFromString("+0x.p+"));
1386 EXPECT_EQ("Significand has no digits", convertToErrorFromString("-0x.p+"));
1387
1388 EXPECT_EQ("Significand has no digits", convertToErrorFromString( "0x.p-"));
1389 EXPECT_EQ("Significand has no digits", convertToErrorFromString("+0x.p-"));
1390 EXPECT_EQ("Significand has no digits", convertToErrorFromString("-0x.p-"));
1391 }
1392
1393 TEST(APFloatTest, StringHexadecimalExponentError) {
1394 EXPECT_EQ("Exponent has no digits", convertToErrorFromString( "0x1p"));
1395 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("+0x1p"));
1396 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("-0x1p"));
1397
1398 EXPECT_EQ("Exponent has no digits", convertToErrorFromString( "0x1p+"));
1399 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("+0x1p+"));
1400 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("-0x1p+"));
1401
1402 EXPECT_EQ("Exponent has no digits", convertToErrorFromString( "0x1p-"));
1403 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("+0x1p-"));
1404 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("-0x1p-"));
1405
1406
1407 EXPECT_EQ("Exponent has no digits", convertToErrorFromString( "0x1.p"));
1408 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("+0x1.p"));
1409 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("-0x1.p"));
1410
1411 EXPECT_EQ("Exponent has no digits", convertToErrorFromString( "0x1.p+"));
1412 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("+0x1.p+"));
1413 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("-0x1.p+"));
1414
1415 EXPECT_EQ("Exponent has no digits", convertToErrorFromString( "0x1.p-"));
1416 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("+0x1.p-"));
1417 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("-0x1.p-"));
1418
1419
1420 EXPECT_EQ("Exponent has no digits", convertToErrorFromString( "0x.1p"));
1421 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("+0x.1p"));
1422 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("-0x.1p"));
1423
1424 EXPECT_EQ("Exponent has no digits", convertToErrorFromString( "0x.1p+"));
1425 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("+0x.1p+"));
1426 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("-0x.1p+"));
1427
1428 EXPECT_EQ("Exponent has no digits", convertToErrorFromString( "0x.1p-"));
1429 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("+0x.1p-"));
1430 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("-0x.1p-"));
1431
1432
1433 EXPECT_EQ("Exponent has no digits", convertToErrorFromString( "0x1.1p"));
1434 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("+0x1.1p"));
1435 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("-0x1.1p"));
1436
1437 EXPECT_EQ("Exponent has no digits", convertToErrorFromString( "0x1.1p+"));
1438 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("+0x1.1p+"));
1439 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("-0x1.1p+"));
1440
1441 EXPECT_EQ("Exponent has no digits", convertToErrorFromString( "0x1.1p-"));
1442 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("+0x1.1p-"));
1443 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("-0x1.1p-"));
1444 }
1445
1446 TEST(APFloatTest, exactInverse) {
1447 APFloat inv(0.0f);
1448
1449 // Trivial operation.
1450 EXPECT_TRUE(APFloat(2.0).getExactInverse(&inv));
1451 EXPECT_TRUE(inv.bitwiseIsEqual(APFloat(0.5)));
1452 EXPECT_TRUE(APFloat(2.0f).getExactInverse(&inv));
1453 EXPECT_TRUE(inv.bitwiseIsEqual(APFloat(0.5f)));
1454 EXPECT_TRUE(APFloat(APFloat::IEEEquad(), "2.0").getExactInverse(&inv));
1455 EXPECT_TRUE(inv.bitwiseIsEqual(APFloat(APFloat::IEEEquad(), "0.5")));
1456 EXPECT_TRUE(APFloat(APFloat::PPCDoubleDouble(), "2.0").getExactInverse(&inv));
1457 EXPECT_TRUE(inv.bitwiseIsEqual(APFloat(APFloat::PPCDoubleDouble(), "0.5")));
1458 EXPECT_TRUE(APFloat(APFloat::x87DoubleExtended(), "2.0").getExactInverse(&inv));
1459 EXPECT_TRUE(inv.bitwiseIsEqual(APFloat(APFloat::x87DoubleExtended(), "0.5")));
1460
1461 // FLT_MIN
1462 EXPECT_TRUE(APFloat(1.17549435e-38f).getExactInverse(&inv));
1463 EXPECT_TRUE(inv.bitwiseIsEqual(APFloat(8.5070592e+37f)));
1464
1465 // Large float, inverse is a denormal.
1466 EXPECT_FALSE(APFloat(1.7014118e38f).getExactInverse(nullptr));
1467 // Zero
1468 EXPECT_FALSE(APFloat(0.0).getExactInverse(nullptr));
1469 // Denormalized float
1470 EXPECT_FALSE(APFloat(1.40129846e-45f).getExactInverse(nullptr));
1471 }
1472
1473 TEST(APFloatTest, roundToIntegral) {
1474 APFloat T(-0.5), S(3.14), R(APFloat::getLargest(APFloat::IEEEdouble())), P(0.0);
1475
1476 P = T;
1477 P.roundToIntegral(APFloat::rmTowardZero);
1478 EXPECT_EQ(-0.0, P.convertToDouble());
1479 P = T;
1480 P.roundToIntegral(APFloat::rmTowardNegative);
1481 EXPECT_EQ(-1.0, P.convertToDouble());
1482 P = T;
1483 P.roundToIntegral(APFloat::rmTowardPositive);
1484 EXPECT_EQ(-0.0, P.convertToDouble());
1485 P = T;
1486 P.roundToIntegral(APFloat::rmNearestTiesToEven);
1487 EXPECT_EQ(-0.0, P.convertToDouble());
1488
1489 P = S;
1490 P.roundToIntegral(APFloat::rmTowardZero);
1491 EXPECT_EQ(3.0, P.convertToDouble());
1492 P = S;
1493 P.roundToIntegral(APFloat::rmTowardNegative);
1494 EXPECT_EQ(3.0, P.convertToDouble());
1495 P = S;
1496 P.roundToIntegral(APFloat::rmTowardPositive);
1497 EXPECT_EQ(4.0, P.convertToDouble());
1498 P = S;
1499 P.roundToIntegral(APFloat::rmNearestTiesToEven);
1500 EXPECT_EQ(3.0, P.convertToDouble());
1501
1502 P = R;
1503 P.roundToIntegral(APFloat::rmTowardZero);
1504 EXPECT_EQ(R.convertToDouble(), P.convertToDouble());
1505 P = R;
1506 P.roundToIntegral(APFloat::rmTowardNegative);
1507 EXPECT_EQ(R.convertToDouble(), P.convertToDouble());
1508 P = R;
1509 P.roundToIntegral(APFloat::rmTowardPositive);
1510 EXPECT_EQ(R.convertToDouble(), P.convertToDouble());
1511 P = R;
1512 P.roundToIntegral(APFloat::rmNearestTiesToEven);
1513 EXPECT_EQ(R.convertToDouble(), P.convertToDouble());
1514
1515 P = APFloat::getZero(APFloat::IEEEdouble());
1516 P.roundToIntegral(APFloat::rmTowardZero);
1517 EXPECT_EQ(0.0, P.convertToDouble());
1518 P = APFloat::getZero(APFloat::IEEEdouble(), true);
1519 P.roundToIntegral(APFloat::rmTowardZero);
1520 EXPECT_EQ(-0.0, P.convertToDouble());
1521 P = APFloat::getNaN(APFloat::IEEEdouble());
1522 P.roundToIntegral(APFloat::rmTowardZero);
1523 EXPECT_TRUE(std::isnan(P.convertToDouble()));
1524 P = APFloat::getInf(APFloat::IEEEdouble());
1525 P.roundToIntegral(APFloat::rmTowardZero);
1526 EXPECT_TRUE(std::isinf(P.convertToDouble()) && P.convertToDouble() > 0.0);
1527 P = APFloat::getInf(APFloat::IEEEdouble(), true);
1528 P.roundToIntegral(APFloat::rmTowardZero);
1529 EXPECT_TRUE(std::isinf(P.convertToDouble()) && P.convertToDouble() < 0.0);
1530
1531 APFloat::opStatus St;
1532
1533 P = APFloat::getNaN(APFloat::IEEEdouble());
1534 St = P.roundToIntegral(APFloat::rmTowardZero);
1535 EXPECT_TRUE(P.isNaN());
1536 EXPECT_FALSE(P.isNegative());
1537 EXPECT_EQ(APFloat::opOK, St);
1538
1539 P = APFloat::getNaN(APFloat::IEEEdouble(), true);
1540 St = P.roundToIntegral(APFloat::rmTowardZero);
1541 EXPECT_TRUE(P.isNaN());
1542 EXPECT_TRUE(P.isNegative());
1543 EXPECT_EQ(APFloat::opOK, St);
1544
1545 P = APFloat::getSNaN(APFloat::IEEEdouble());
1546 St = P.roundToIntegral(APFloat::rmTowardZero);
1547 EXPECT_TRUE(P.isNaN());
1548 EXPECT_FALSE(P.isSignaling());
1549 EXPECT_FALSE(P.isNegative());
1550 EXPECT_EQ(APFloat::opInvalidOp, St);
1551
1552 P = APFloat::getSNaN(APFloat::IEEEdouble(), true);
1553 St = P.roundToIntegral(APFloat::rmTowardZero);
1554 EXPECT_TRUE(P.isNaN());
1555 EXPECT_FALSE(P.isSignaling());
1556 EXPECT_TRUE(P.isNegative());
1557 EXPECT_EQ(APFloat::opInvalidOp, St);
1558
1559 P = APFloat::getInf(APFloat::IEEEdouble());
1560 St = P.roundToIntegral(APFloat::rmTowardZero);
1561 EXPECT_TRUE(P.isInfinity());
1562 EXPECT_FALSE(P.isNegative());
1563 EXPECT_EQ(APFloat::opOK, St);
1564
1565 P = APFloat::getInf(APFloat::IEEEdouble(), true);
1566 St = P.roundToIntegral(APFloat::rmTowardZero);
1567 EXPECT_TRUE(P.isInfinity());
1568 EXPECT_TRUE(P.isNegative());
1569 EXPECT_EQ(APFloat::opOK, St);
1570
1571 P = APFloat::getZero(APFloat::IEEEdouble(), false);
1572 St = P.roundToIntegral(APFloat::rmTowardZero);
1573 EXPECT_TRUE(P.isZero());
1574 EXPECT_FALSE(P.isNegative());
1575 EXPECT_EQ(APFloat::opOK, St);
1576
1577 P = APFloat::getZero(APFloat::IEEEdouble(), false);
1578 St = P.roundToIntegral(APFloat::rmTowardNegative);
1579 EXPECT_TRUE(P.isZero());
1580 EXPECT_FALSE(P.isNegative());
1581 EXPECT_EQ(APFloat::opOK, St);
1582
1583 P = APFloat::getZero(APFloat::IEEEdouble(), true);
1584 St = P.roundToIntegral(APFloat::rmTowardZero);
1585 EXPECT_TRUE(P.isZero());
1586 EXPECT_TRUE(P.isNegative());
1587 EXPECT_EQ(APFloat::opOK, St);
1588
1589 P = APFloat::getZero(APFloat::IEEEdouble(), true);
1590 St = P.roundToIntegral(APFloat::rmTowardNegative);
1591 EXPECT_TRUE(P.isZero());
1592 EXPECT_TRUE(P.isNegative());
1593 EXPECT_EQ(APFloat::opOK, St);
1594
1595 P = APFloat(1E-100);
1596 St = P.roundToIntegral(APFloat::rmTowardNegative);
1597 EXPECT_TRUE(P.isZero());
1598 EXPECT_FALSE(P.isNegative());
1599 EXPECT_EQ(APFloat::opInexact, St);
1600
1601 P = APFloat(1E-100);
1602 St = P.roundToIntegral(APFloat::rmTowardPositive);
1603 EXPECT_EQ(1.0, P.convertToDouble());
1604 EXPECT_FALSE(P.isNegative());
1605 EXPECT_EQ(APFloat::opInexact, St);
1606
1607 P = APFloat(-1E-100);
1608 St = P.roundToIntegral(APFloat::rmTowardNegative);
1609 EXPECT_TRUE(P.isNegative());
1610 EXPECT_EQ(-1.0, P.convertToDouble());
1611 EXPECT_EQ(APFloat::opInexact, St);
1612
1613 P = APFloat(-1E-100);
1614 St = P.roundToIntegral(APFloat::rmTowardPositive);
1615 EXPECT_TRUE(P.isZero());
1616 EXPECT_TRUE(P.isNegative());
1617 EXPECT_EQ(APFloat::opInexact, St);
1618
1619 P = APFloat(10.0);
1620 St = P.roundToIntegral(APFloat::rmTowardZero);
1621 EXPECT_EQ(10.0, P.convertToDouble());
1622 EXPECT_EQ(APFloat::opOK, St);
1623
1624 P = APFloat(10.5);
1625 St = P.roundToIntegral(APFloat::rmTowardZero);
1626 EXPECT_EQ(10.0, P.convertToDouble());
1627 EXPECT_EQ(APFloat::opInexact, St);
1628
1629 P = APFloat(10.5);
1630 St = P.roundToIntegral(APFloat::rmTowardPositive);
1631 EXPECT_EQ(11.0, P.convertToDouble());
1632 EXPECT_EQ(APFloat::opInexact, St);
1633
1634 P = APFloat(10.5);
1635 St = P.roundToIntegral(APFloat::rmTowardNegative);
1636 EXPECT_EQ(10.0, P.convertToDouble());
1637 EXPECT_EQ(APFloat::opInexact, St);
1638
1639 P = APFloat(10.5);
1640 St = P.roundToIntegral(APFloat::rmNearestTiesToAway);
1641 EXPECT_EQ(11.0, P.convertToDouble());
1642 EXPECT_EQ(APFloat::opInexact, St);
1643
1644 P = APFloat(10.5);
1645 St = P.roundToIntegral(APFloat::rmNearestTiesToEven);
1646 EXPECT_EQ(10.0, P.convertToDouble());
1647 EXPECT_EQ(APFloat::opInexact, St);
1648 }
1649
1650 TEST(APFloatTest, isInteger) {
1651 APFloat T(-0.0);
1652 EXPECT_TRUE(T.isInteger());
1653 T = APFloat(3.14159);
1654 EXPECT_FALSE(T.isInteger());
1655 T = APFloat::getNaN(APFloat::IEEEdouble());
1656 EXPECT_FALSE(T.isInteger());
1657 T = APFloat::getInf(APFloat::IEEEdouble());
1658 EXPECT_FALSE(T.isInteger());
1659 T = APFloat::getInf(APFloat::IEEEdouble(), true);
1660 EXPECT_FALSE(T.isInteger());
1661 T = APFloat::getLargest(APFloat::IEEEdouble());
1662 EXPECT_TRUE(T.isInteger());
1663 }
1664
1665 TEST(DoubleAPFloatTest, isInteger) {
1666 APFloat F1(-0.0);
1667 APFloat F2(-0.0);
1668 llvm::detail::DoubleAPFloat T(APFloat::PPCDoubleDouble(), std::move(F1),
1669 std::move(F2));
1670 EXPECT_TRUE(T.isInteger());
1671 APFloat F3(3.14159);
1672 APFloat F4(-0.0);
1673 llvm::detail::DoubleAPFloat T2(APFloat::PPCDoubleDouble(), std::move(F3),
1674 std::move(F4));
1675 EXPECT_FALSE(T2.isInteger());
1676 APFloat F5(-0.0);
1677 APFloat F6(3.14159);
1678 llvm::detail::DoubleAPFloat T3(APFloat::PPCDoubleDouble(), std::move(F5),
1679 std::move(F6));
1680 EXPECT_FALSE(T3.isInteger());
1681 }
1682
1683 TEST(APFloatTest, getLargest) {
1684 EXPECT_EQ(3.402823466e+38f, APFloat::getLargest(APFloat::IEEEsingle()).convertToFloat());
1685 EXPECT_EQ(1.7976931348623158e+308, APFloat::getLargest(APFloat::IEEEdouble()).convertToDouble());
1686 }
1687
1688 TEST(APFloatTest, getSmallest) {
1689 APFloat test = APFloat::getSmallest(APFloat::IEEEsingle(), false);
1690 APFloat expected = APFloat(APFloat::IEEEsingle(), "0x0.000002p-126");
1691 EXPECT_FALSE(test.isNegative());
1692 EXPECT_TRUE(test.isFiniteNonZero());
1693 EXPECT_TRUE(test.isDenormal());
1694 EXPECT_TRUE(test.bitwiseIsEqual(expected));
1695
1696 test = APFloat::getSmallest(APFloat::IEEEsingle(), true);
1697 expected = APFloat(APFloat::IEEEsingle(), "-0x0.000002p-126");
1698 EXPECT_TRUE(test.isNegative());
1699 EXPECT_TRUE(test.isFiniteNonZero());
1700 EXPECT_TRUE(test.isDenormal());
1701 EXPECT_TRUE(test.bitwiseIsEqual(expected));
1702
1703 test = APFloat::getSmallest(APFloat::IEEEquad(), false);
1704 expected = APFloat(APFloat::IEEEquad(), "0x0.0000000000000000000000000001p-16382");
1705 EXPECT_FALSE(test.isNegative());
1706 EXPECT_TRUE(test.isFiniteNonZero());
1707 EXPECT_TRUE(test.isDenormal());
1708 EXPECT_TRUE(test.bitwiseIsEqual(expected));
1709
1710 test = APFloat::getSmallest(APFloat::IEEEquad(), true);
1711 expected = APFloat(APFloat::IEEEquad(), "-0x0.0000000000000000000000000001p-16382");
1712 EXPECT_TRUE(test.isNegative());
1713 EXPECT_TRUE(test.isFiniteNonZero());
1714 EXPECT_TRUE(test.isDenormal());
1715 EXPECT_TRUE(test.bitwiseIsEqual(expected));
1716 }
1717
1718 TEST(APFloatTest, getSmallestNormalized) {
1719 APFloat test = APFloat::getSmallestNormalized(APFloat::IEEEsingle(), false);
1720 APFloat expected = APFloat(APFloat::IEEEsingle(), "0x1p-126");
1721 EXPECT_FALSE(test.isNegative());
1722 EXPECT_TRUE(test.isFiniteNonZero());
1723 EXPECT_FALSE(test.isDenormal());
1724 EXPECT_TRUE(test.bitwiseIsEqual(expected));
1725
1726 test = APFloat::getSmallestNormalized(APFloat::IEEEsingle(), true);
1727 expected = APFloat(APFloat::IEEEsingle(), "-0x1p-126");
1728 EXPECT_TRUE(test.isNegative());
1729 EXPECT_TRUE(test.isFiniteNonZero());
1730 EXPECT_FALSE(test.isDenormal());
1731 EXPECT_TRUE(test.bitwiseIsEqual(expected));
1732
1733 test = APFloat::getSmallestNormalized(APFloat::IEEEquad(), false);
1734 expected = APFloat(APFloat::IEEEquad(), "0x1p-16382");
1735 EXPECT_FALSE(test.isNegative());
1736 EXPECT_TRUE(test.isFiniteNonZero());
1737 EXPECT_FALSE(test.isDenormal());
1738 EXPECT_TRUE(test.bitwiseIsEqual(expected));
1739
1740 test = APFloat::getSmallestNormalized(APFloat::IEEEquad(), true);
1741 expected = APFloat(APFloat::IEEEquad(), "-0x1p-16382");
1742 EXPECT_TRUE(test.isNegative());
1743 EXPECT_TRUE(test.isFiniteNonZero());
1744 EXPECT_FALSE(test.isDenormal());
1745 EXPECT_TRUE(test.bitwiseIsEqual(expected));
1746 }
1747
1748 TEST(APFloatTest, getZero) {
1749 struct {
1750 const fltSemantics *semantics;
1751 const bool sign;
1752 const unsigned long long bitPattern[2];
1753 const unsigned bitPatternLength;
1754 } const GetZeroTest[] = {
1755 { &APFloat::IEEEhalf(), false, {0, 0}, 1},
1756 { &APFloat::IEEEhalf(), true, {0x8000ULL, 0}, 1},
1757 { &APFloat::IEEEsingle(), false, {0, 0}, 1},
1758 { &APFloat::IEEEsingle(), true, {0x80000000ULL, 0}, 1},
1759 { &APFloat::IEEEdouble(), false, {0, 0}, 1},
1760 { &APFloat::IEEEdouble(), true, {0x8000000000000000ULL, 0}, 1},
1761 { &APFloat::IEEEquad(), false, {0, 0}, 2},
1762 { &APFloat::IEEEquad(), true, {0, 0x8000000000000000ULL}, 2},
1763 { &APFloat::PPCDoubleDouble(), false, {0, 0}, 2},
1764 { &APFloat::PPCDoubleDouble(), true, {0x8000000000000000ULL, 0}, 2},
1765 { &APFloat::x87DoubleExtended(), false, {0, 0}, 2},
1766 { &APFloat::x87DoubleExtended(), true, {0, 0x8000ULL}, 2},
1767 };
1768 const unsigned NumGetZeroTests = 12;
1769 for (unsigned i = 0; i < NumGetZeroTests; ++i) {
1770 APFloat test = APFloat::getZero(*GetZeroTest[i].semantics,
1771 GetZeroTest[i].sign);
1772 const char *pattern = GetZeroTest[i].sign? "-0x0p+0" : "0x0p+0";
1773 APFloat expected = APFloat(*GetZeroTest[i].semantics,
1774 pattern);
1775 EXPECT_TRUE(test.isZero());
1776 EXPECT_TRUE(GetZeroTest[i].sign? test.isNegative() : !test.isNegative());
1777 EXPECT_TRUE(test.bitwiseIsEqual(expected));
1778 for (unsigned j = 0, je = GetZeroTest[i].bitPatternLength; j < je; ++j) {
1779 EXPECT_EQ(GetZeroTest[i].bitPattern[j],
1780 test.bitcastToAPInt().getRawData()[j]);
1781 }
1782 }
1783 }
1784
1785 TEST(APFloatTest, copySign) {
1786 EXPECT_TRUE(APFloat(-42.0).bitwiseIsEqual(
1787 APFloat::copySign(APFloat(42.0), APFloat(-1.0))));
1788 EXPECT_TRUE(APFloat(42.0).bitwiseIsEqual(
1789 APFloat::copySign(APFloat(-42.0), APFloat(1.0))));
1790 EXPECT_TRUE(APFloat(-42.0).bitwiseIsEqual(
1791 APFloat::copySign(APFloat(-42.0), APFloat(-1.0))));
1792 EXPECT_TRUE(APFloat(42.0).bitwiseIsEqual(
1793 APFloat::copySign(APFloat(42.0), APFloat(1.0))));
1794 }
1795
1796 TEST(APFloatTest, convert) {
1797 bool losesInfo;
1798 APFloat test(APFloat::IEEEdouble(), "1.0");
1799 test.convert(APFloat::IEEEsingle(), APFloat::rmNearestTiesToEven, &losesInfo);
1800 EXPECT_EQ(1.0f, test.convertToFloat());
1801 EXPECT_FALSE(losesInfo);
1802
1803 test = APFloat(APFloat::x87DoubleExtended(), "0x1p-53");
1804 test.add(APFloat(APFloat::x87DoubleExtended(), "1.0"), APFloat::rmNearestTiesToEven);
1805 test.convert(APFloat::IEEEdouble(), APFloat::rmNearestTiesToEven, &losesInfo);
1806 EXPECT_EQ(1.0, test.convertToDouble());
1807 EXPECT_TRUE(losesInfo);
1808
1809 test = APFloat(APFloat::IEEEquad(), "0x1p-53");
1810 test.add(APFloat(APFloat::IEEEquad(), "1.0"), APFloat::rmNearestTiesToEven);
1811 test.convert(APFloat::IEEEdouble(), APFloat::rmNearestTiesToEven, &losesInfo);
1812 EXPECT_EQ(1.0, test.convertToDouble());
1813 EXPECT_TRUE(losesInfo);
1814
1815 test = APFloat(APFloat::x87DoubleExtended(), "0xf.fffffffp+28");
1816 test.convert(APFloat::IEEEdouble(), APFloat::rmNearestTiesToEven, &losesInfo);
1817 EXPECT_EQ(4294967295.0, test.convertToDouble());
1818 EXPECT_FALSE(losesInfo);
1819
1820 test = APFloat::getSNaN(APFloat::IEEEsingle());
1821 APFloat::opStatus status = test.convert(APFloat::x87DoubleExtended(), APFloat::rmNearestTiesToEven, &losesInfo);
1822 // Conversion quiets the SNAN, so now 2 bits of the 64-bit significand should be set.
1823 APInt topTwoBits(64, 0x6000000000000000);
1824 EXPECT_TRUE(test.bitwiseIsEqual(APFloat::getQNaN(APFloat::x87DoubleExtended(), false, &topTwoBits)));
1825 EXPECT_FALSE(losesInfo);
1826 EXPECT_EQ(status, APFloat::opInvalidOp);
1827
1828 test = APFloat::getQNaN(APFloat::IEEEsingle());
1829 APFloat X87QNaN = APFloat::getQNaN(APFloat::x87DoubleExtended());
1830 test.convert(APFloat::x87DoubleExtended(), APFloat::rmNearestTiesToEven,
1831 &losesInfo);
1832 EXPECT_TRUE(test.bitwiseIsEqual(X87QNaN));
1833 EXPECT_FALSE(losesInfo);
1834
1835 test = APFloat::getSNaN(APFloat::x87DoubleExtended());
1836 test.convert(APFloat::x87DoubleExtended(), APFloat::rmNearestTiesToEven,
1837 &losesInfo);
1838 APFloat X87SNaN = APFloat::getSNaN(APFloat::x87DoubleExtended());
1839 EXPECT_TRUE(test.bitwiseIsEqual(X87SNaN));
1840 EXPECT_FALSE(losesInfo);
1841
1842 test = APFloat::getQNaN(APFloat::x87DoubleExtended());
1843 test.convert(APFloat::x87DoubleExtended(), APFloat::rmNearestTiesToEven,
1844 &losesInfo);
1845 EXPECT_TRUE(test.bitwiseIsEqual(X87QNaN));
1846 EXPECT_FALSE(losesInfo);
1847
1848 // The payload is lost in truncation, but we retain NaN by setting the quiet bit.
1849 APInt payload(52, 1);
1850 test = APFloat::getSNaN(APFloat::IEEEdouble(), false, &payload);
1851 status = test.convert(APFloat::IEEEsingle(), APFloat::rmNearestTiesToEven, &losesInfo);
1852 EXPECT_EQ(0x7fc00000, test.bitcastToAPInt());
1853 EXPECT_TRUE(losesInfo);
1854 EXPECT_EQ(status, APFloat::opInvalidOp);
1855
1856 // The payload is lost in truncation. QNaN remains QNaN.
1857 test = APFloat::getQNaN(APFloat::IEEEdouble(), false, &payload);
1858 status = test.convert(APFloat::IEEEsingle(), APFloat::rmNearestTiesToEven, &losesInfo);
1859 EXPECT_EQ(0x7fc00000, test.bitcastToAPInt());
1860 EXPECT_TRUE(losesInfo);
1861 EXPECT_EQ(status, APFloat::opOK);
1862
1863 // Test that subnormals are handled correctly in double to float conversion
1864 test = APFloat(APFloat::IEEEdouble(), "0x0.0000010000000p-1022");
1865 test.convert(APFloat::IEEEsingle(), APFloat::rmNearestTiesToEven, &losesInfo);
1866 EXPECT_EQ(0.0f, test.convertToFloat());
1867 EXPECT_TRUE(losesInfo);
1868
1869 test = APFloat(APFloat::IEEEdouble(), "0x0.0000010000001p-1022");
1870 test.convert(APFloat::IEEEsingle(), APFloat::rmNearestTiesToEven, &losesInfo);
1871 EXPECT_EQ(0.0f, test.convertToFloat());
1872 EXPECT_TRUE(losesInfo);
1873
1874 test = APFloat(APFloat::IEEEdouble(), "-0x0.0000010000001p-1022");
1875 test.convert(APFloat::IEEEsingle(), APFloat::rmNearestTiesToEven, &losesInfo);
1876 EXPECT_EQ(0.0f, test.convertToFloat());
1877 EXPECT_TRUE(losesInfo);
1878
1879 test = APFloat(APFloat::IEEEdouble(), "0x0.0000020000000p-1022");
1880 test.convert(APFloat::IEEEsingle(), APFloat::rmNearestTiesToEven, &losesInfo);
1881 EXPECT_EQ(0.0f, test.convertToFloat());
1882 EXPECT_TRUE(losesInfo);
1883
1884 test = APFloat(APFloat::IEEEdouble(), "0x0.0000020000001p-1022");
1885 test.convert(APFloat::IEEEsingle(), APFloat::rmNearestTiesToEven, &losesInfo);
1886 EXPECT_EQ(0.0f, test.convertToFloat());
1887 EXPECT_TRUE(losesInfo);
1888
1889 // Test subnormal conversion to bfloat
1890 test = APFloat(APFloat::IEEEsingle(), "0x0.01p-126");
1891 test.convert(APFloat::BFloat(), APFloat::rmNearestTiesToEven, &losesInfo);
1892 EXPECT_EQ(0.0f, test.convertToFloat());
1893 EXPECT_TRUE(losesInfo);
1894
1895 test = APFloat(APFloat::IEEEsingle(), "0x0.02p-126");
1896 test.convert(APFloat::BFloat(), APFloat::rmNearestTiesToEven, &losesInfo);
1897 EXPECT_EQ(0x01, test.bitcastToAPInt());
1898 EXPECT_FALSE(losesInfo);
1899
1900 test = APFloat(APFloat::IEEEsingle(), "0x0.01p-126");
1901 test.convert(APFloat::BFloat(), APFloat::rmNearestTiesToAway, &losesInfo);
1902 EXPECT_EQ(0x01, test.bitcastToAPInt());
1903 EXPECT_TRUE(losesInfo);
1904 }
1905
1906 TEST(APFloatTest, PPCDoubleDouble) {
1907 APFloat test(APFloat::PPCDoubleDouble(), "1.0");
1908 EXPECT_EQ(0x3ff0000000000000ull, test.bitcastToAPInt().getRawData()[0]);
1909 EXPECT_EQ(0x0000000000000000ull, test.bitcastToAPInt().getRawData()[1]);
1910
1911 // LDBL_MAX
1912 test = APFloat(APFloat::PPCDoubleDouble(), "1.79769313486231580793728971405301e+308");
1913 EXPECT_EQ(0x7fefffffffffffffull, test.bitcastToAPInt().getRawData()[0]);
1914 EXPECT_EQ(0x7c8ffffffffffffeull, test.bitcastToAPInt().getRawData()[1]);
1915
1916 // LDBL_MIN
1917 test = APFloat(APFloat::PPCDoubleDouble(), "2.00416836000897277799610805135016e-292");
1918 EXPECT_EQ(0x0360000000000000ull, test.bitcastToAPInt().getRawData()[0]);
1919 EXPECT_EQ(0x0000000000000000ull, test.bitcastToAPInt().getRawData()[1]);
1920
1921 // PR30869
1922 {
1923 auto Result = APFloat(APFloat::PPCDoubleDouble(), "1.0") +
1924 APFloat(APFloat::PPCDoubleDouble(), "1.0");
1925 EXPECT_EQ(&APFloat::PPCDoubleDouble(), &Result.getSemantics());
1926
1927 Result = APFloat(APFloat::PPCDoubleDouble(), "1.0") -
1928 APFloat(APFloat::PPCDoubleDouble(), "1.0");
1929 EXPECT_EQ(&APFloat::PPCDoubleDouble(), &Result.getSemantics());
1930
1931 Result = APFloat(APFloat::PPCDoubleDouble(), "1.0") *
1932 APFloat(APFloat::PPCDoubleDouble(), "1.0");
1933 EXPECT_EQ(&APFloat::PPCDoubleDouble(), &Result.getSemantics());
1934
1935 Result = APFloat(APFloat::PPCDoubleDouble(), "1.0") /
1936 APFloat(APFloat::PPCDoubleDouble(), "1.0");
1937 EXPECT_EQ(&APFloat::PPCDoubleDouble(), &Result.getSemantics());
1938
1939 int Exp;
1940 Result = frexp(APFloat(APFloat::PPCDoubleDouble(), "1.0"), Exp,
1941 APFloat::rmNearestTiesToEven);
1942 EXPECT_EQ(&APFloat::PPCDoubleDouble(), &Result.getSemantics());
1943
1944 Result = scalbn(APFloat(APFloat::PPCDoubleDouble(), "1.0"), 1,
1945 APFloat::rmNearestTiesToEven);
1946 EXPECT_EQ(&APFloat::PPCDoubleDouble(), &Result.getSemantics());
1947 }
1948 }
1949
1950 TEST(APFloatTest, isNegative) {
1951 APFloat t(APFloat::IEEEsingle(), "0x1p+0");
1952 EXPECT_FALSE(t.isNegative());
1953 t = APFloat(APFloat::IEEEsingle(), "-0x1p+0");
1954 EXPECT_TRUE(t.isNegative());
1955
1956 EXPECT_FALSE(APFloat::getInf(APFloat::IEEEsingle(), false).isNegative());
1957 EXPECT_TRUE(APFloat::getInf(APFloat::IEEEsingle(), true).isNegative());
1958
1959 EXPECT_FALSE(APFloat::getZero(APFloat::IEEEsingle(), false).isNegative());
1960 EXPECT_TRUE(APFloat::getZero(APFloat::IEEEsingle(), true).isNegative());
1961
1962 EXPECT_FALSE(APFloat::getNaN(APFloat::IEEEsingle(), false).isNegative());
1963 EXPECT_TRUE(APFloat::getNaN(APFloat::IEEEsingle(), true).isNegative());
1964
1965 EXPECT_FALSE(APFloat::getSNaN(APFloat::IEEEsingle(), false).isNegative());
1966 EXPECT_TRUE(APFloat::getSNaN(APFloat::IEEEsingle(), true).isNegative());
1967 }
1968
1969 TEST(APFloatTest, isNormal) {
1970 APFloat t(APFloat::IEEEsingle(), "0x1p+0");
1971 EXPECT_TRUE(t.isNormal());
1972
1973 EXPECT_FALSE(APFloat::getInf(APFloat::IEEEsingle(), false).isNormal());
1974 EXPECT_FALSE(APFloat::getZero(APFloat::IEEEsingle(), false).isNormal());
1975 EXPECT_FALSE(APFloat::getNaN(APFloat::IEEEsingle(), false).isNormal());
1976 EXPECT_FALSE(APFloat::getSNaN(APFloat::IEEEsingle(), false).isNormal());
1977 EXPECT_FALSE(APFloat(APFloat::IEEEsingle(), "0x1p-149").isNormal());
1978 }
1979
1980 TEST(APFloatTest, isFinite) {
1981 APFloat t(APFloat::IEEEsingle(), "0x1p+0");
1982 EXPECT_TRUE(t.isFinite());
1983 EXPECT_FALSE(APFloat::getInf(APFloat::IEEEsingle(), false).isFinite());
1984 EXPECT_TRUE(APFloat::getZero(APFloat::IEEEsingle(), false).isFinite());
1985 EXPECT_FALSE(APFloat::getNaN(APFloat::IEEEsingle(), false).isFinite());
1986 EXPECT_FALSE(APFloat::getSNaN(APFloat::IEEEsingle(), false).isFinite());
1987 EXPECT_TRUE(APFloat(APFloat::IEEEsingle(), "0x1p-149").isFinite());
1988 }
1989
1990 TEST(APFloatTest, isInfinity) {
1991 APFloat t(APFloat::IEEEsingle(), "0x1p+0");
1992 EXPECT_FALSE(t.isInfinity());
1993 EXPECT_TRUE(APFloat::getInf(APFloat::IEEEsingle(), false).isInfinity());
1994 EXPECT_FALSE(APFloat::getZero(APFloat::IEEEsingle(), false).isInfinity());
1995 EXPECT_FALSE(APFloat::getNaN(APFloat::IEEEsingle(), false).isInfinity());
1996 EXPECT_FALSE(APFloat::getSNaN(APFloat::IEEEsingle(), false).isInfinity());
1997 EXPECT_FALSE(APFloat(APFloat::IEEEsingle(), "0x1p-149").isInfinity());
1998 }
1999
2000 TEST(APFloatTest, isNaN) {
2001 APFloat t(APFloat::IEEEsingle(), "0x1p+0");
2002 EXPECT_FALSE(t.isNaN());
2003 EXPECT_FALSE(APFloat::getInf(APFloat::IEEEsingle(), false).isNaN());
2004 EXPECT_FALSE(APFloat::getZero(APFloat::IEEEsingle(), false).isNaN());
2005 EXPECT_TRUE(APFloat::getNaN(APFloat::IEEEsingle(), false).isNaN());
2006 EXPECT_TRUE(APFloat::getSNaN(APFloat::IEEEsingle(), false).isNaN());
2007 EXPECT_FALSE(APFloat(APFloat::IEEEsingle(), "0x1p-149").isNaN());
2008 }
2009
2010 TEST(APFloatTest, isFiniteNonZero) {
2011 // Test positive/negative normal value.
2012 EXPECT_TRUE(APFloat(APFloat::IEEEsingle(), "0x1p+0").isFiniteNonZero());
2013 EXPECT_TRUE(APFloat(APFloat::IEEEsingle(), "-0x1p+0").isFiniteNonZero());
2014
2015 // Test positive/negative denormal value.
2016 EXPECT_TRUE(APFloat(APFloat::IEEEsingle(), "0x1p-149").isFiniteNonZero());
2017 EXPECT_TRUE(APFloat(APFloat::IEEEsingle(), "-0x1p-149").isFiniteNonZero());
2018
2019 // Test +/- Infinity.
2020 EXPECT_FALSE(APFloat::getInf(APFloat::IEEEsingle(), false).isFiniteNonZero());
2021 EXPECT_FALSE(APFloat::getInf(APFloat::IEEEsingle(), true).isFiniteNonZero());
2022
2023 // Test +/- Zero.
2024 EXPECT_FALSE(APFloat::getZero(APFloat::IEEEsingle(), false).isFiniteNonZero());
2025 EXPECT_FALSE(APFloat::getZero(APFloat::IEEEsingle(), true).isFiniteNonZero());
2026
2027 // Test +/- qNaN. +/- dont mean anything with qNaN but paranoia can't hurt in
2028 // this instance.
2029 EXPECT_FALSE(APFloat::getNaN(APFloat::IEEEsingle(), false).isFiniteNonZero());
2030 EXPECT_FALSE(APFloat::getNaN(APFloat::IEEEsingle(), true).isFiniteNonZero());
2031
2032 // Test +/- sNaN. +/- dont mean anything with sNaN but paranoia can't hurt in
2033 // this instance.
2034 EXPECT_FALSE(APFloat::getSNaN(APFloat::IEEEsingle(), false).isFiniteNonZero());
2035 EXPECT_FALSE(APFloat::getSNaN(APFloat::IEEEsingle(), true).isFiniteNonZero());
2036 }
2037
2038 TEST(APFloatTest, add) {
2039 // Test Special Cases against each other and normal values.
2040
2041 APFloat PInf = APFloat::getInf(APFloat::IEEEsingle(), false);
2042 APFloat MInf = APFloat::getInf(APFloat::IEEEsingle(), true);
2043 APFloat PZero = APFloat::getZero(APFloat::IEEEsingle(), false);
2044 APFloat MZero = APFloat::getZero(APFloat::IEEEsingle(), true);
2045 APFloat QNaN = APFloat::getNaN(APFloat::IEEEsingle(), false);
2046 APFloat SNaN = APFloat(APFloat::IEEEsingle(), "snan123");
2047 APFloat PNormalValue = APFloat(APFloat::IEEEsingle(), "0x1p+0");
2048 APFloat MNormalValue = APFloat(APFloat::IEEEsingle(), "-0x1p+0");
2049 APFloat PLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), false);
2050 APFloat MLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), true);
2051 APFloat PSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), false);
2052 APFloat MSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), true);
2053 APFloat PSmallestNormalized =
2054 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), false);
2055 APFloat MSmallestNormalized =
2056 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), true);
2057
2058 const int OverflowStatus = APFloat::opOverflow | APFloat::opInexact;
2059
2060 struct {
2061 APFloat x;
2062 APFloat y;
2063 const char *result;
2064 int status;
2065 int category;
2066 } SpecialCaseTests[] = {
2067 { PInf, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2068 { PInf, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2069 { PInf, PZero, "inf", APFloat::opOK, APFloat::fcInfinity },
2070 { PInf, MZero, "inf", APFloat::opOK, APFloat::fcInfinity },
2071 { PInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2072 { PInf, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2073 { PInf, PNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2074 { PInf, MNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2075 { PInf, PLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2076 { PInf, MLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2077 { PInf, PSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2078 { PInf, MSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2079 { PInf, PSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity },
2080 { PInf, MSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity },
2081 { MInf, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2082 { MInf, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2083 { MInf, PZero, "-inf", APFloat::opOK, APFloat::fcInfinity },
2084 { MInf, MZero, "-inf", APFloat::opOK, APFloat::fcInfinity },
2085 { MInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2086 { MInf, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2087 { MInf, PNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2088 { MInf, MNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2089 { MInf, PLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2090 { MInf, MLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2091 { MInf, PSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2092 { MInf, MSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2093 { MInf, PSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity },
2094 { MInf, MSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity },
2095 { PZero, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2096 { PZero, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2097 { PZero, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2098 { PZero, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2099 { PZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2100 { PZero, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2101 { PZero, PNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2102 { PZero, MNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2103 { PZero, PLargestValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2104 { PZero, MLargestValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2105 { PZero, PSmallestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2106 { PZero, MSmallestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2107 { PZero, PSmallestNormalized, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2108 { PZero, MSmallestNormalized, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2109 { MZero, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2110 { MZero, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2111 { MZero, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2112 { MZero, MZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2113 { MZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2114 { MZero, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2115 { MZero, PNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2116 { MZero, MNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2117 { MZero, PLargestValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2118 { MZero, MLargestValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2119 { MZero, PSmallestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2120 { MZero, MSmallestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2121 { MZero, PSmallestNormalized, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2122 { MZero, MSmallestNormalized, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2123 { QNaN, PInf, "nan", APFloat::opOK, APFloat::fcNaN },
2124 { QNaN, MInf, "nan", APFloat::opOK, APFloat::fcNaN },
2125 { QNaN, PZero, "nan", APFloat::opOK, APFloat::fcNaN },
2126 { QNaN, MZero, "nan", APFloat::opOK, APFloat::fcNaN },
2127 { QNaN, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2128 { QNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2129 { QNaN, PNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
2130 { QNaN, MNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
2131 { QNaN, PLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2132 { QNaN, MLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2133 { QNaN, PSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2134 { QNaN, MSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2135 { QNaN, PSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
2136 { QNaN, MSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
2137 { SNaN, PInf, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2138 { SNaN, MInf, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2139 { SNaN, PZero, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2140 { SNaN, MZero, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2141 { SNaN, QNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2142 { SNaN, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2143 { SNaN, PNormalValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2144 { SNaN, MNormalValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2145 { SNaN, PLargestValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2146 { SNaN, MLargestValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2147 { SNaN, PSmallestValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2148 { SNaN, MSmallestValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2149 { SNaN, PSmallestNormalized, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2150 { SNaN, MSmallestNormalized, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2151 { PNormalValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2152 { PNormalValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2153 { PNormalValue, PZero, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2154 { PNormalValue, MZero, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2155 { PNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2156 { PNormalValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2157 { PNormalValue, PNormalValue, "0x1p+1", APFloat::opOK, APFloat::fcNormal },
2158 { PNormalValue, MNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2159 { PNormalValue, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2160 { PNormalValue, MLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2161 { PNormalValue, PSmallestValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2162 { PNormalValue, MSmallestValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2163 { PNormalValue, PSmallestNormalized, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2164 { PNormalValue, MSmallestNormalized, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2165 { MNormalValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2166 { MNormalValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2167 { MNormalValue, PZero, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2168 { MNormalValue, MZero, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2169 { MNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2170 { MNormalValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2171 { MNormalValue, PNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2172 { MNormalValue, MNormalValue, "-0x1p+1", APFloat::opOK, APFloat::fcNormal },
2173 { MNormalValue, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2174 { MNormalValue, MLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2175 { MNormalValue, PSmallestValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2176 { MNormalValue, MSmallestValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2177 { MNormalValue, PSmallestNormalized, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2178 { MNormalValue, MSmallestNormalized, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2179 { PLargestValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2180 { PLargestValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2181 { PLargestValue, PZero, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2182 { PLargestValue, MZero, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2183 { PLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2184 { PLargestValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2185 { PLargestValue, PNormalValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2186 { PLargestValue, MNormalValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2187 { PLargestValue, PLargestValue, "inf", OverflowStatus, APFloat::fcInfinity },
2188 { PLargestValue, MLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2189 { PLargestValue, PSmallestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2190 { PLargestValue, MSmallestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2191 { PLargestValue, PSmallestNormalized, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2192 { PLargestValue, MSmallestNormalized, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2193 { MLargestValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2194 { MLargestValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2195 { MLargestValue, PZero, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2196 { MLargestValue, MZero, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2197 { MLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2198 { MLargestValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2199 { MLargestValue, PNormalValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2200 { MLargestValue, MNormalValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2201 { MLargestValue, PLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2202 { MLargestValue, MLargestValue, "-inf", OverflowStatus, APFloat::fcInfinity },
2203 { MLargestValue, PSmallestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2204 { MLargestValue, MSmallestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2205 { MLargestValue, PSmallestNormalized, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2206 { MLargestValue, MSmallestNormalized, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2207 { PSmallestValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2208 { PSmallestValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2209 { PSmallestValue, PZero, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2210 { PSmallestValue, MZero, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2211 { PSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2212 { PSmallestValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2213 { PSmallestValue, PNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2214 { PSmallestValue, MNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2215 { PSmallestValue, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2216 { PSmallestValue, MLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2217 { PSmallestValue, PSmallestValue, "0x1p-148", APFloat::opOK, APFloat::fcNormal },
2218 { PSmallestValue, MSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2219 { PSmallestValue, PSmallestNormalized, "0x1.000002p-126", APFloat::opOK, APFloat::fcNormal },
2220 { PSmallestValue, MSmallestNormalized, "-0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal },
2221 { MSmallestValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2222 { MSmallestValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2223 { MSmallestValue, PZero, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2224 { MSmallestValue, MZero, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2225 { MSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2226 { MSmallestValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2227 { MSmallestValue, PNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2228 { MSmallestValue, MNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2229 { MSmallestValue, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2230 { MSmallestValue, MLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2231 { MSmallestValue, PSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2232 { MSmallestValue, MSmallestValue, "-0x1p-148", APFloat::opOK, APFloat::fcNormal },
2233 { MSmallestValue, PSmallestNormalized, "0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal },
2234 { MSmallestValue, MSmallestNormalized, "-0x1.000002p-126", APFloat::opOK, APFloat::fcNormal },
2235 { PSmallestNormalized, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2236 { PSmallestNormalized, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2237 { PSmallestNormalized, PZero, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2238 { PSmallestNormalized, MZero, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2239 { PSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2240 { PSmallestNormalized, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2241 { PSmallestNormalized, PNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2242 { PSmallestNormalized, MNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2243 { PSmallestNormalized, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2244 { PSmallestNormalized, MLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2245 { PSmallestNormalized, PSmallestValue, "0x1.000002p-126", APFloat::opOK, APFloat::fcNormal },
2246 { PSmallestNormalized, MSmallestValue, "0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal },
2247 { PSmallestNormalized, PSmallestNormalized, "0x1p-125", APFloat::opOK, APFloat::fcNormal },
2248 { PSmallestNormalized, MSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2249 { MSmallestNormalized, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2250 { MSmallestNormalized, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2251 { MSmallestNormalized, PZero, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2252 { MSmallestNormalized, MZero, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2253 { MSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2254 { MSmallestNormalized, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2255 { MSmallestNormalized, PNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2256 { MSmallestNormalized, MNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2257 { MSmallestNormalized, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2258 { MSmallestNormalized, MLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2259 { MSmallestNormalized, PSmallestValue, "-0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal },
2260 { MSmallestNormalized, MSmallestValue, "-0x1.000002p-126", APFloat::opOK, APFloat::fcNormal },
2261 { MSmallestNormalized, PSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2262 { MSmallestNormalized, MSmallestNormalized, "-0x1p-125", APFloat::opOK, APFloat::fcNormal }
2263 };
2264
2265 for (size_t i = 0; i < std::size(SpecialCaseTests); ++i) {
2266 APFloat x(SpecialCaseTests[i].x);
2267 APFloat y(SpecialCaseTests[i].y);
2268 APFloat::opStatus status = x.add(y, APFloat::rmNearestTiesToEven);
2269
2270 APFloat result(APFloat::IEEEsingle(), SpecialCaseTests[i].result);
2271
2272 EXPECT_TRUE(result.bitwiseIsEqual(x));
2273 EXPECT_EQ(SpecialCaseTests[i].status, (int)status);
2274 EXPECT_EQ(SpecialCaseTests[i].category, (int)x.getCategory());
2275 }
2276 }
2277
2278 TEST(APFloatTest, subtract) {
2279 // Test Special Cases against each other and normal values.
2280
2281 APFloat PInf = APFloat::getInf(APFloat::IEEEsingle(), false);
2282 APFloat MInf = APFloat::getInf(APFloat::IEEEsingle(), true);
2283 APFloat PZero = APFloat::getZero(APFloat::IEEEsingle(), false);
2284 APFloat MZero = APFloat::getZero(APFloat::IEEEsingle(), true);
2285 APFloat QNaN = APFloat::getNaN(APFloat::IEEEsingle(), false);
2286 APFloat SNaN = APFloat(APFloat::IEEEsingle(), "snan123");
2287 APFloat PNormalValue = APFloat(APFloat::IEEEsingle(), "0x1p+0");
2288 APFloat MNormalValue = APFloat(APFloat::IEEEsingle(), "-0x1p+0");
2289 APFloat PLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), false);
2290 APFloat MLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), true);
2291 APFloat PSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), false);
2292 APFloat MSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), true);
2293 APFloat PSmallestNormalized =
2294 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), false);
2295 APFloat MSmallestNormalized =
2296 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), true);
2297
2298 const int OverflowStatus = APFloat::opOverflow | APFloat::opInexact;
2299
2300 struct {
2301 APFloat x;
2302 APFloat y;
2303 const char *result;
2304 int status;
2305 int category;
2306 } SpecialCaseTests[] = {
2307 { PInf, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2308 { PInf, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2309 { PInf, PZero, "inf", APFloat::opOK, APFloat::fcInfinity },
2310 { PInf, MZero, "inf", APFloat::opOK, APFloat::fcInfinity },
2311 { PInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2312 { PInf, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2313 { PInf, PNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2314 { PInf, MNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2315 { PInf, PLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2316 { PInf, MLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2317 { PInf, PSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2318 { PInf, MSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2319 { PInf, PSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity },
2320 { PInf, MSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity },
2321 { MInf, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2322 { MInf, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2323 { MInf, PZero, "-inf", APFloat::opOK, APFloat::fcInfinity },
2324 { MInf, MZero, "-inf", APFloat::opOK, APFloat::fcInfinity },
2325 { MInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2326 { MInf, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2327 { MInf, PNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2328 { MInf, MNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2329 { MInf, PLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2330 { MInf, MLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2331 { MInf, PSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2332 { MInf, MSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2333 { MInf, PSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity },
2334 { MInf, MSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity },
2335 { PZero, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2336 { PZero, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2337 { PZero, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2338 { PZero, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2339 { PZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2340 { PZero, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2341 { PZero, PNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2342 { PZero, MNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2343 { PZero, PLargestValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2344 { PZero, MLargestValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2345 { PZero, PSmallestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2346 { PZero, MSmallestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2347 { PZero, PSmallestNormalized, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2348 { PZero, MSmallestNormalized, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2349 { MZero, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2350 { MZero, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2351 { MZero, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2352 { MZero, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2353 { MZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2354 { MZero, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2355 { MZero, PNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2356 { MZero, MNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2357 { MZero, PLargestValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2358 { MZero, MLargestValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2359 { MZero, PSmallestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2360 { MZero, MSmallestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2361 { MZero, PSmallestNormalized, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2362 { MZero, MSmallestNormalized, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2363 { QNaN, PInf, "nan", APFloat::opOK, APFloat::fcNaN },
2364 { QNaN, MInf, "nan", APFloat::opOK, APFloat::fcNaN },
2365 { QNaN, PZero, "nan", APFloat::opOK, APFloat::fcNaN },
2366 { QNaN, MZero, "nan", APFloat::opOK, APFloat::fcNaN },
2367 { QNaN, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2368 { QNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2369 { QNaN, PNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
2370 { QNaN, MNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
2371 { QNaN, PLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2372 { QNaN, MLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2373 { QNaN, PSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2374 { QNaN, MSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2375 { QNaN, PSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
2376 { QNaN, MSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
2377 { SNaN, PInf, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2378 { SNaN, MInf, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2379 { SNaN, PZero, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2380 { SNaN, MZero, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2381 { SNaN, QNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2382 { SNaN, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2383 { SNaN, PNormalValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2384 { SNaN, MNormalValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2385 { SNaN, PLargestValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2386 { SNaN, MLargestValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2387 { SNaN, PSmallestValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2388 { SNaN, MSmallestValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2389 { SNaN, PSmallestNormalized, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2390 { SNaN, MSmallestNormalized, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2391 { PNormalValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2392 { PNormalValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2393 { PNormalValue, PZero, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2394 { PNormalValue, MZero, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2395 { PNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2396 { PNormalValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2397 { PNormalValue, PNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2398 { PNormalValue, MNormalValue, "0x1p+1", APFloat::opOK, APFloat::fcNormal },
2399 { PNormalValue, PLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2400 { PNormalValue, MLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2401 { PNormalValue, PSmallestValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2402 { PNormalValue, MSmallestValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2403 { PNormalValue, PSmallestNormalized, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2404 { PNormalValue, MSmallestNormalized, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2405 { MNormalValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2406 { MNormalValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2407 { MNormalValue, PZero, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2408 { MNormalValue, MZero, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2409 { MNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2410 { MNormalValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2411 { MNormalValue, PNormalValue, "-0x1p+1", APFloat::opOK, APFloat::fcNormal },
2412 { MNormalValue, MNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2413 { MNormalValue, PLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2414 { MNormalValue, MLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2415 { MNormalValue, PSmallestValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2416 { MNormalValue, MSmallestValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2417 { MNormalValue, PSmallestNormalized, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2418 { MNormalValue, MSmallestNormalized, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2419 { PLargestValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2420 { PLargestValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2421 { PLargestValue, PZero, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2422 { PLargestValue, MZero, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2423 { PLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2424 { PLargestValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2425 { PLargestValue, PNormalValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2426 { PLargestValue, MNormalValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2427 { PLargestValue, PLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2428 { PLargestValue, MLargestValue, "inf", OverflowStatus, APFloat::fcInfinity },
2429 { PLargestValue, PSmallestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2430 { PLargestValue, MSmallestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2431 { PLargestValue, PSmallestNormalized, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2432 { PLargestValue, MSmallestNormalized, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2433 { MLargestValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2434 { MLargestValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2435 { MLargestValue, PZero, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2436 { MLargestValue, MZero, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2437 { MLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2438 { MLargestValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2439 { MLargestValue, PNormalValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2440 { MLargestValue, MNormalValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2441 { MLargestValue, PLargestValue, "-inf", OverflowStatus, APFloat::fcInfinity },
2442 { MLargestValue, MLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2443 { MLargestValue, PSmallestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2444 { MLargestValue, MSmallestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2445 { MLargestValue, PSmallestNormalized, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2446 { MLargestValue, MSmallestNormalized, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2447 { PSmallestValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2448 { PSmallestValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2449 { PSmallestValue, PZero, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2450 { PSmallestValue, MZero, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2451 { PSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2452 { PSmallestValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2453 { PSmallestValue, PNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2454 { PSmallestValue, MNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2455 { PSmallestValue, PLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2456 { PSmallestValue, MLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2457 { PSmallestValue, PSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2458 { PSmallestValue, MSmallestValue, "0x1p-148", APFloat::opOK, APFloat::fcNormal },
2459 { PSmallestValue, PSmallestNormalized, "-0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal },
2460 { PSmallestValue, MSmallestNormalized, "0x1.000002p-126", APFloat::opOK, APFloat::fcNormal },
2461 { MSmallestValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2462 { MSmallestValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2463 { MSmallestValue, PZero, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2464 { MSmallestValue, MZero, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2465 { MSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2466 { MSmallestValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2467 { MSmallestValue, PNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2468 { MSmallestValue, MNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2469 { MSmallestValue, PLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2470 { MSmallestValue, MLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2471 { MSmallestValue, PSmallestValue, "-0x1p-148", APFloat::opOK, APFloat::fcNormal },
2472 { MSmallestValue, MSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2473 { MSmallestValue, PSmallestNormalized, "-0x1.000002p-126", APFloat::opOK, APFloat::fcNormal },
2474 { MSmallestValue, MSmallestNormalized, "0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal },
2475 { PSmallestNormalized, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2476 { PSmallestNormalized, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2477 { PSmallestNormalized, PZero, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2478 { PSmallestNormalized, MZero, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2479 { PSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2480 { PSmallestNormalized, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2481 { PSmallestNormalized, PNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2482 { PSmallestNormalized, MNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2483 { PSmallestNormalized, PLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2484 { PSmallestNormalized, MLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2485 { PSmallestNormalized, PSmallestValue, "0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal },
2486 { PSmallestNormalized, MSmallestValue, "0x1.000002p-126", APFloat::opOK, APFloat::fcNormal },
2487 { PSmallestNormalized, PSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2488 { PSmallestNormalized, MSmallestNormalized, "0x1p-125", APFloat::opOK, APFloat::fcNormal },
2489 { MSmallestNormalized, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2490 { MSmallestNormalized, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2491 { MSmallestNormalized, PZero, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2492 { MSmallestNormalized, MZero, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2493 { MSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2494 { MSmallestNormalized, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2495 { MSmallestNormalized, PNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2496 { MSmallestNormalized, MNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2497 { MSmallestNormalized, PLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2498 { MSmallestNormalized, MLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2499 { MSmallestNormalized, PSmallestValue, "-0x1.000002p-126", APFloat::opOK, APFloat::fcNormal },
2500 { MSmallestNormalized, MSmallestValue, "-0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal },
2501 { MSmallestNormalized, PSmallestNormalized, "-0x1p-125", APFloat::opOK, APFloat::fcNormal },
2502 { MSmallestNormalized, MSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero }
2503 };
2504
2505 for (size_t i = 0; i < std::size(SpecialCaseTests); ++i) {
2506 APFloat x(SpecialCaseTests[i].x);
2507 APFloat y(SpecialCaseTests[i].y);
2508 APFloat::opStatus status = x.subtract(y, APFloat::rmNearestTiesToEven);
2509
2510 APFloat result(APFloat::IEEEsingle(), SpecialCaseTests[i].result);
2511
2512 EXPECT_TRUE(result.bitwiseIsEqual(x));
2513 EXPECT_EQ(SpecialCaseTests[i].status, (int)status);
2514 EXPECT_EQ(SpecialCaseTests[i].category, (int)x.getCategory());
2515 }
2516 }
2517
2518 TEST(APFloatTest, multiply) {
2519 // Test Special Cases against each other and normal values.
2520
2521 APFloat PInf = APFloat::getInf(APFloat::IEEEsingle(), false);
2522 APFloat MInf = APFloat::getInf(APFloat::IEEEsingle(), true);
2523 APFloat PZero = APFloat::getZero(APFloat::IEEEsingle(), false);
2524 APFloat MZero = APFloat::getZero(APFloat::IEEEsingle(), true);
2525 APFloat QNaN = APFloat::getNaN(APFloat::IEEEsingle(), false);
2526 APFloat SNaN = APFloat(APFloat::IEEEsingle(), "snan123");
2527 APFloat PNormalValue = APFloat(APFloat::IEEEsingle(), "0x1p+0");
2528 APFloat MNormalValue = APFloat(APFloat::IEEEsingle(), "-0x1p+0");
2529 APFloat PLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), false);
2530 APFloat MLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), true);
2531 APFloat PSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), false);
2532 APFloat MSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), true);
2533 APFloat PSmallestNormalized =
2534 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), false);
2535 APFloat MSmallestNormalized =
2536 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), true);
2537
2538 APFloat MaxQuad(APFloat::IEEEquad(),
2539 "0x1.ffffffffffffffffffffffffffffp+16383");
2540 APFloat MinQuad(APFloat::IEEEquad(),
2541 "0x0.0000000000000000000000000001p-16382");
2542 APFloat NMinQuad(APFloat::IEEEquad(),
2543 "-0x0.0000000000000000000000000001p-16382");
2544
2545 const int OverflowStatus = APFloat::opOverflow | APFloat::opInexact;
2546 const int UnderflowStatus = APFloat::opUnderflow | APFloat::opInexact;
2547
2548 struct {
2549 APFloat x;
2550 APFloat y;
2551 const char *result;
2552 int status;
2553 int category;
2554 APFloat::roundingMode roundingMode = APFloat::rmNearestTiesToEven;
2555 } SpecialCaseTests[] = {
2556 { PInf, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2557 { PInf, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2558 { PInf, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2559 { PInf, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2560 { PInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2561 { PInf, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2562 { PInf, PNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2563 { PInf, MNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2564 { PInf, PLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2565 { PInf, MLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2566 { PInf, PSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2567 { PInf, MSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2568 { PInf, PSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity },
2569 { PInf, MSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity },
2570 { MInf, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2571 { MInf, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2572 { MInf, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2573 { MInf, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2574 { MInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2575 { MInf, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2576 { MInf, PNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2577 { MInf, MNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2578 { MInf, PLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2579 { MInf, MLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2580 { MInf, PSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2581 { MInf, MSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2582 { MInf, PSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity },
2583 { MInf, MSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity },
2584 { PZero, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2585 { PZero, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2586 { PZero, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2587 { PZero, MZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2588 { PZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2589 { PZero, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2590 { PZero, PNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2591 { PZero, MNormalValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2592 { PZero, PLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2593 { PZero, MLargestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2594 { PZero, PSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2595 { PZero, MSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2596 { PZero, PSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2597 { PZero, MSmallestNormalized, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2598 { MZero, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2599 { MZero, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2600 { MZero, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2601 { MZero, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2602 { MZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2603 { MZero, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2604 { MZero, PNormalValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2605 { MZero, MNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2606 { MZero, PLargestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2607 { MZero, MLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2608 { MZero, PSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2609 { MZero, MSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2610 { MZero, PSmallestNormalized, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2611 { MZero, MSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2612 { QNaN, PInf, "nan", APFloat::opOK, APFloat::fcNaN },
2613 { QNaN, MInf, "nan", APFloat::opOK, APFloat::fcNaN },
2614 { QNaN, PZero, "nan", APFloat::opOK, APFloat::fcNaN },
2615 { QNaN, MZero, "nan", APFloat::opOK, APFloat::fcNaN },
2616 { QNaN, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2617 { QNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2618 { QNaN, PNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
2619 { QNaN, MNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
2620 { QNaN, PLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2621 { QNaN, MLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2622 { QNaN, PSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2623 { QNaN, MSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2624 { QNaN, PSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
2625 { QNaN, MSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
2626 { SNaN, PInf, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2627 { SNaN, MInf, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2628 { SNaN, PZero, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2629 { SNaN, MZero, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2630 { SNaN, QNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2631 { SNaN, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2632 { SNaN, PNormalValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2633 { SNaN, MNormalValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2634 { SNaN, PLargestValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2635 { SNaN, MLargestValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2636 { SNaN, PSmallestValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2637 { SNaN, MSmallestValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2638 { SNaN, PSmallestNormalized, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2639 { SNaN, MSmallestNormalized, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2640 { PNormalValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2641 { PNormalValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2642 { PNormalValue, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2643 { PNormalValue, MZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2644 { PNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2645 { PNormalValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2646 { PNormalValue, PNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2647 { PNormalValue, MNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2648 { PNormalValue, PLargestValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2649 { PNormalValue, MLargestValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2650 { PNormalValue, PSmallestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2651 { PNormalValue, MSmallestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2652 { PNormalValue, PSmallestNormalized, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2653 { PNormalValue, MSmallestNormalized, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2654 { MNormalValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2655 { MNormalValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2656 { MNormalValue, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2657 { MNormalValue, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2658 { MNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2659 { MNormalValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2660 { MNormalValue, PNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2661 { MNormalValue, MNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2662 { MNormalValue, PLargestValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2663 { MNormalValue, MLargestValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2664 { MNormalValue, PSmallestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2665 { MNormalValue, MSmallestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2666 { MNormalValue, PSmallestNormalized, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2667 { MNormalValue, MSmallestNormalized, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2668 { PLargestValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2669 { PLargestValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2670 { PLargestValue, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2671 { PLargestValue, MZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2672 { PLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2673 { PLargestValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2674 { PLargestValue, PNormalValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2675 { PLargestValue, MNormalValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2676 { PLargestValue, PLargestValue, "inf", OverflowStatus, APFloat::fcInfinity },
2677 { PLargestValue, MLargestValue, "-inf", OverflowStatus, APFloat::fcInfinity },
2678 { PLargestValue, PSmallestValue, "0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal },
2679 { PLargestValue, MSmallestValue, "-0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal },
2680 { PLargestValue, PSmallestNormalized, "0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal },
2681 { PLargestValue, MSmallestNormalized, "-0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal },
2682 { MLargestValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2683 { MLargestValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2684 { MLargestValue, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2685 { MLargestValue, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2686 { MLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2687 { MLargestValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2688 { MLargestValue, PNormalValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2689 { MLargestValue, MNormalValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2690 { MLargestValue, PLargestValue, "-inf", OverflowStatus, APFloat::fcInfinity },
2691 { MLargestValue, MLargestValue, "inf", OverflowStatus, APFloat::fcInfinity },
2692 { MLargestValue, PSmallestValue, "-0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal },
2693 { MLargestValue, MSmallestValue, "0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal },
2694 { MLargestValue, PSmallestNormalized, "-0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal },
2695 { MLargestValue, MSmallestNormalized, "0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal },
2696 { PSmallestValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2697 { PSmallestValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2698 { PSmallestValue, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2699 { PSmallestValue, MZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2700 { PSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2701 { PSmallestValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2702 { PSmallestValue, PNormalValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2703 { PSmallestValue, MNormalValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2704 { PSmallestValue, PLargestValue, "0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal },
2705 { PSmallestValue, MLargestValue, "-0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal },
2706 { PSmallestValue, PSmallestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero },
2707 { PSmallestValue, MSmallestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2708 { PSmallestValue, PSmallestNormalized, "0x0p+0", UnderflowStatus, APFloat::fcZero },
2709 { PSmallestValue, MSmallestNormalized, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2710 { MSmallestValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2711 { MSmallestValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2712 { MSmallestValue, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2713 { MSmallestValue, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2714 { MSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2715 { MSmallestValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2716 { MSmallestValue, PNormalValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2717 { MSmallestValue, MNormalValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2718 { MSmallestValue, PLargestValue, "-0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal },
2719 { MSmallestValue, MLargestValue, "0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal },
2720 { MSmallestValue, PSmallestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2721 { MSmallestValue, MSmallestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero },
2722 { MSmallestValue, PSmallestNormalized, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2723 { MSmallestValue, MSmallestNormalized, "0x0p+0", UnderflowStatus, APFloat::fcZero },
2724 { PSmallestNormalized, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2725 { PSmallestNormalized, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2726 { PSmallestNormalized, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2727 { PSmallestNormalized, MZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2728 { PSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2729 { PSmallestNormalized, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2730 { PSmallestNormalized, PNormalValue, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2731 { PSmallestNormalized, MNormalValue, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2732 { PSmallestNormalized, PLargestValue, "0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal },
2733 { PSmallestNormalized, MLargestValue, "-0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal },
2734 { PSmallestNormalized, PSmallestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero },
2735 { PSmallestNormalized, MSmallestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2736 { PSmallestNormalized, PSmallestNormalized, "0x0p+0", UnderflowStatus, APFloat::fcZero },
2737 { PSmallestNormalized, MSmallestNormalized, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2738 { MSmallestNormalized, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2739 { MSmallestNormalized, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2740 { MSmallestNormalized, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2741 { MSmallestNormalized, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2742 { MSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2743 { MSmallestNormalized, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2744 { MSmallestNormalized, PNormalValue, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2745 { MSmallestNormalized, MNormalValue, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2746 { MSmallestNormalized, PLargestValue, "-0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal },
2747 { MSmallestNormalized, MLargestValue, "0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal },
2748 { MSmallestNormalized, PSmallestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2749 { MSmallestNormalized, MSmallestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero },
2750 { MSmallestNormalized, PSmallestNormalized, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2751 { MSmallestNormalized, MSmallestNormalized, "0x0p+0", UnderflowStatus, APFloat::fcZero },
2752
2753 {MaxQuad, MinQuad, "0x1.ffffffffffffffffffffffffffffp-111", APFloat::opOK,
2754 APFloat::fcNormal, APFloat::rmNearestTiesToEven},
2755 {MaxQuad, MinQuad, "0x1.ffffffffffffffffffffffffffffp-111", APFloat::opOK,
2756 APFloat::fcNormal, APFloat::rmTowardPositive},
2757 {MaxQuad, MinQuad, "0x1.ffffffffffffffffffffffffffffp-111", APFloat::opOK,
2758 APFloat::fcNormal, APFloat::rmTowardNegative},
2759 {MaxQuad, MinQuad, "0x1.ffffffffffffffffffffffffffffp-111", APFloat::opOK,
2760 APFloat::fcNormal, APFloat::rmTowardZero},
2761 {MaxQuad, MinQuad, "0x1.ffffffffffffffffffffffffffffp-111", APFloat::opOK,
2762 APFloat::fcNormal, APFloat::rmNearestTiesToAway},
2763
2764 {MaxQuad, NMinQuad, "-0x1.ffffffffffffffffffffffffffffp-111", APFloat::opOK,
2765 APFloat::fcNormal, APFloat::rmNearestTiesToEven},
2766 {MaxQuad, NMinQuad, "-0x1.ffffffffffffffffffffffffffffp-111", APFloat::opOK,
2767 APFloat::fcNormal, APFloat::rmTowardPositive},
2768 {MaxQuad, NMinQuad, "-0x1.ffffffffffffffffffffffffffffp-111", APFloat::opOK,
2769 APFloat::fcNormal, APFloat::rmTowardNegative},
2770 {MaxQuad, NMinQuad, "-0x1.ffffffffffffffffffffffffffffp-111", APFloat::opOK,
2771 APFloat::fcNormal, APFloat::rmTowardZero},
2772 {MaxQuad, NMinQuad, "-0x1.ffffffffffffffffffffffffffffp-111", APFloat::opOK,
2773 APFloat::fcNormal, APFloat::rmNearestTiesToAway},
2774
2775 {MaxQuad, MaxQuad, "inf", OverflowStatus, APFloat::fcInfinity,
2776 APFloat::rmNearestTiesToEven},
2777 {MaxQuad, MaxQuad, "inf", OverflowStatus, APFloat::fcInfinity,
2778 APFloat::rmTowardPositive},
2779 {MaxQuad, MaxQuad, "0x1.ffffffffffffffffffffffffffffp+16383",
2780 APFloat::opInexact, APFloat::fcNormal, APFloat::rmTowardNegative},
2781 {MaxQuad, MaxQuad, "0x1.ffffffffffffffffffffffffffffp+16383",
2782 APFloat::opInexact, APFloat::fcNormal, APFloat::rmTowardZero},
2783 {MaxQuad, MaxQuad, "inf", OverflowStatus, APFloat::fcInfinity,
2784 APFloat::rmNearestTiesToAway},
2785
2786 {MinQuad, MinQuad, "0", UnderflowStatus, APFloat::fcZero,
2787 APFloat::rmNearestTiesToEven},
2788 {MinQuad, MinQuad, "0x0.0000000000000000000000000001p-16382",
2789 UnderflowStatus, APFloat::fcNormal, APFloat::rmTowardPositive},
2790 {MinQuad, MinQuad, "0", UnderflowStatus, APFloat::fcZero,
2791 APFloat::rmTowardNegative},
2792 {MinQuad, MinQuad, "0", UnderflowStatus, APFloat::fcZero,
2793 APFloat::rmTowardZero},
2794 {MinQuad, MinQuad, "0", UnderflowStatus, APFloat::fcZero,
2795 APFloat::rmNearestTiesToAway},
2796
2797 {MinQuad, NMinQuad, "-0", UnderflowStatus, APFloat::fcZero,
2798 APFloat::rmNearestTiesToEven},
2799 {MinQuad, NMinQuad, "-0", UnderflowStatus, APFloat::fcZero,
2800 APFloat::rmTowardPositive},
2801 {MinQuad, NMinQuad, "-0x0.0000000000000000000000000001p-16382",
2802 UnderflowStatus, APFloat::fcNormal, APFloat::rmTowardNegative},
2803 {MinQuad, NMinQuad, "-0", UnderflowStatus, APFloat::fcZero,
2804 APFloat::rmTowardZero},
2805 {MinQuad, NMinQuad, "-0", UnderflowStatus, APFloat::fcZero,
2806 APFloat::rmNearestTiesToAway},
2807 };
2808
2809 for (size_t i = 0; i < std::size(SpecialCaseTests); ++i) {
2810 APFloat x(SpecialCaseTests[i].x);
2811 APFloat y(SpecialCaseTests[i].y);
2812 APFloat::opStatus status = x.multiply(y, SpecialCaseTests[i].roundingMode);
2813
2814 APFloat result(x.getSemantics(), SpecialCaseTests[i].result);
2815
2816 EXPECT_TRUE(result.bitwiseIsEqual(x));
2817 EXPECT_EQ(SpecialCaseTests[i].status, (int)status);
2818 EXPECT_EQ(SpecialCaseTests[i].category, (int)x.getCategory());
2819 }
2820 }
2821
2822 TEST(APFloatTest, divide) {
2823 // Test Special Cases against each other and normal values.
2824
2825 APFloat PInf = APFloat::getInf(APFloat::IEEEsingle(), false);
2826 APFloat MInf = APFloat::getInf(APFloat::IEEEsingle(), true);
2827 APFloat PZero = APFloat::getZero(APFloat::IEEEsingle(), false);
2828 APFloat MZero = APFloat::getZero(APFloat::IEEEsingle(), true);
2829 APFloat QNaN = APFloat::getNaN(APFloat::IEEEsingle(), false);
2830 APFloat SNaN = APFloat(APFloat::IEEEsingle(), "snan123");
2831 APFloat PNormalValue = APFloat(APFloat::IEEEsingle(), "0x1p+0");
2832 APFloat MNormalValue = APFloat(APFloat::IEEEsingle(), "-0x1p+0");
2833 APFloat PLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), false);
2834 APFloat MLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), true);
2835 APFloat PSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), false);
2836 APFloat MSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), true);
2837 APFloat PSmallestNormalized =
2838 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), false);
2839 APFloat MSmallestNormalized =
2840 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), true);
2841
2842 APFloat MaxQuad(APFloat::IEEEquad(),
2843 "0x1.ffffffffffffffffffffffffffffp+16383");
2844 APFloat MinQuad(APFloat::IEEEquad(),
2845 "0x0.0000000000000000000000000001p-16382");
2846 APFloat NMinQuad(APFloat::IEEEquad(),
2847 "-0x0.0000000000000000000000000001p-16382");
2848
2849 const int OverflowStatus = APFloat::opOverflow | APFloat::opInexact;
2850 const int UnderflowStatus = APFloat::opUnderflow | APFloat::opInexact;
2851
2852 struct {
2853 APFloat x;
2854 APFloat y;
2855 const char *result;
2856 int status;
2857 int category;
2858 APFloat::roundingMode roundingMode = APFloat::rmNearestTiesToEven;
2859 } SpecialCaseTests[] = {
2860 { PInf, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2861 { PInf, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2862 { PInf, PZero, "inf", APFloat::opOK, APFloat::fcInfinity },
2863 { PInf, MZero, "-inf", APFloat::opOK, APFloat::fcInfinity },
2864 { PInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2865 { PInf, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2866 { PInf, PNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2867 { PInf, MNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2868 { PInf, PLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2869 { PInf, MLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2870 { PInf, PSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2871 { PInf, MSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2872 { PInf, PSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity },
2873 { PInf, MSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity },
2874 { MInf, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2875 { MInf, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2876 { MInf, PZero, "-inf", APFloat::opOK, APFloat::fcInfinity },
2877 { MInf, MZero, "inf", APFloat::opOK, APFloat::fcInfinity },
2878 { MInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2879 { MInf, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2880 { MInf, PNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2881 { MInf, MNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2882 { MInf, PLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2883 { MInf, MLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2884 { MInf, PSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2885 { MInf, MSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2886 { MInf, PSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity },
2887 { MInf, MSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity },
2888 { PZero, PInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2889 { PZero, MInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2890 { PZero, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2891 { PZero, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2892 { PZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2893 { PZero, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2894 { PZero, PNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2895 { PZero, MNormalValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2896 { PZero, PLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2897 { PZero, MLargestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2898 { PZero, PSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2899 { PZero, MSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2900 { PZero, PSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2901 { PZero, MSmallestNormalized, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2902 { MZero, PInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2903 { MZero, MInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2904 { MZero, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2905 { MZero, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2906 { MZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2907 { MZero, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2908 { MZero, PNormalValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2909 { MZero, MNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2910 { MZero, PLargestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2911 { MZero, MLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2912 { MZero, PSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2913 { MZero, MSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2914 { MZero, PSmallestNormalized, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2915 { MZero, MSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2916 { QNaN, PInf, "nan", APFloat::opOK, APFloat::fcNaN },
2917 { QNaN, MInf, "nan", APFloat::opOK, APFloat::fcNaN },
2918 { QNaN, PZero, "nan", APFloat::opOK, APFloat::fcNaN },
2919 { QNaN, MZero, "nan", APFloat::opOK, APFloat::fcNaN },
2920 { QNaN, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2921 { QNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2922 { QNaN, PNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
2923 { QNaN, MNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
2924 { QNaN, PLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2925 { QNaN, MLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2926 { QNaN, PSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2927 { QNaN, MSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2928 { QNaN, PSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
2929 { QNaN, MSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
2930 { SNaN, PInf, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2931 { SNaN, MInf, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2932 { SNaN, PZero, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2933 { SNaN, MZero, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2934 { SNaN, QNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2935 { SNaN, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2936 { SNaN, PNormalValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2937 { SNaN, MNormalValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2938 { SNaN, PLargestValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2939 { SNaN, MLargestValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2940 { SNaN, PSmallestValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2941 { SNaN, MSmallestValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2942 { SNaN, PSmallestNormalized, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2943 { SNaN, MSmallestNormalized, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2944 { PNormalValue, PInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2945 { PNormalValue, MInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2946 { PNormalValue, PZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
2947 { PNormalValue, MZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
2948 { PNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2949 { PNormalValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2950 { PNormalValue, PNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2951 { PNormalValue, MNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2952 { PNormalValue, PLargestValue, "0x1p-128", UnderflowStatus, APFloat::fcNormal },
2953 { PNormalValue, MLargestValue, "-0x1p-128", UnderflowStatus, APFloat::fcNormal },
2954 { PNormalValue, PSmallestValue, "inf", OverflowStatus, APFloat::fcInfinity },
2955 { PNormalValue, MSmallestValue, "-inf", OverflowStatus, APFloat::fcInfinity },
2956 { PNormalValue, PSmallestNormalized, "0x1p+126", APFloat::opOK, APFloat::fcNormal },
2957 { PNormalValue, MSmallestNormalized, "-0x1p+126", APFloat::opOK, APFloat::fcNormal },
2958 { MNormalValue, PInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2959 { MNormalValue, MInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2960 { MNormalValue, PZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
2961 { MNormalValue, MZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
2962 { MNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2963 { MNormalValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2964 { MNormalValue, PNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2965 { MNormalValue, MNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2966 { MNormalValue, PLargestValue, "-0x1p-128", UnderflowStatus, APFloat::fcNormal },
2967 { MNormalValue, MLargestValue, "0x1p-128", UnderflowStatus, APFloat::fcNormal },
2968 { MNormalValue, PSmallestValue, "-inf", OverflowStatus, APFloat::fcInfinity },
2969 { MNormalValue, MSmallestValue, "inf", OverflowStatus, APFloat::fcInfinity },
2970 { MNormalValue, PSmallestNormalized, "-0x1p+126", APFloat::opOK, APFloat::fcNormal },
2971 { MNormalValue, MSmallestNormalized, "0x1p+126", APFloat::opOK, APFloat::fcNormal },
2972 { PLargestValue, PInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2973 { PLargestValue, MInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2974 { PLargestValue, PZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
2975 { PLargestValue, MZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
2976 { PLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2977 { PLargestValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2978 { PLargestValue, PNormalValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2979 { PLargestValue, MNormalValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2980 { PLargestValue, PLargestValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2981 { PLargestValue, MLargestValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2982 { PLargestValue, PSmallestValue, "inf", OverflowStatus, APFloat::fcInfinity },
2983 { PLargestValue, MSmallestValue, "-inf", OverflowStatus, APFloat::fcInfinity },
2984 { PLargestValue, PSmallestNormalized, "inf", OverflowStatus, APFloat::fcInfinity },
2985 { PLargestValue, MSmallestNormalized, "-inf", OverflowStatus, APFloat::fcInfinity },
2986 { MLargestValue, PInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2987 { MLargestValue, MInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2988 { MLargestValue, PZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
2989 { MLargestValue, MZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
2990 { MLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2991 { MLargestValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
2992 { MLargestValue, PNormalValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2993 { MLargestValue, MNormalValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2994 { MLargestValue, PLargestValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2995 { MLargestValue, MLargestValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2996 { MLargestValue, PSmallestValue, "-inf", OverflowStatus, APFloat::fcInfinity },
2997 { MLargestValue, MSmallestValue, "inf", OverflowStatus, APFloat::fcInfinity },
2998 { MLargestValue, PSmallestNormalized, "-inf", OverflowStatus, APFloat::fcInfinity },
2999 { MLargestValue, MSmallestNormalized, "inf", OverflowStatus, APFloat::fcInfinity },
3000 { PSmallestValue, PInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3001 { PSmallestValue, MInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3002 { PSmallestValue, PZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
3003 { PSmallestValue, MZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
3004 { PSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
3005 { PSmallestValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3006 { PSmallestValue, PNormalValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
3007 { PSmallestValue, MNormalValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
3008 { PSmallestValue, PLargestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero },
3009 { PSmallestValue, MLargestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
3010 { PSmallestValue, PSmallestValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
3011 { PSmallestValue, MSmallestValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
3012 { PSmallestValue, PSmallestNormalized, "0x1p-23", APFloat::opOK, APFloat::fcNormal },
3013 { PSmallestValue, MSmallestNormalized, "-0x1p-23", APFloat::opOK, APFloat::fcNormal },
3014 { MSmallestValue, PInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3015 { MSmallestValue, MInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3016 { MSmallestValue, PZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
3017 { MSmallestValue, MZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
3018 { MSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
3019 { MSmallestValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3020 { MSmallestValue, PNormalValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
3021 { MSmallestValue, MNormalValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
3022 { MSmallestValue, PLargestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
3023 { MSmallestValue, MLargestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero },
3024 { MSmallestValue, PSmallestValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
3025 { MSmallestValue, MSmallestValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
3026 { MSmallestValue, PSmallestNormalized, "-0x1p-23", APFloat::opOK, APFloat::fcNormal },
3027 { MSmallestValue, MSmallestNormalized, "0x1p-23", APFloat::opOK, APFloat::fcNormal },
3028 { PSmallestNormalized, PInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3029 { PSmallestNormalized, MInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3030 { PSmallestNormalized, PZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
3031 { PSmallestNormalized, MZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
3032 { PSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
3033 { PSmallestNormalized, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3034 { PSmallestNormalized, PNormalValue, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
3035 { PSmallestNormalized, MNormalValue, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
3036 { PSmallestNormalized, PLargestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero },
3037 { PSmallestNormalized, MLargestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
3038 { PSmallestNormalized, PSmallestValue, "0x1p+23", APFloat::opOK, APFloat::fcNormal },
3039 { PSmallestNormalized, MSmallestValue, "-0x1p+23", APFloat::opOK, APFloat::fcNormal },
3040 { PSmallestNormalized, PSmallestNormalized, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
3041 { PSmallestNormalized, MSmallestNormalized, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
3042 { MSmallestNormalized, PInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3043 { MSmallestNormalized, MInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3044 { MSmallestNormalized, PZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
3045 { MSmallestNormalized, MZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
3046 { MSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
3047 { MSmallestNormalized, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3048 { MSmallestNormalized, PNormalValue, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
3049 { MSmallestNormalized, MNormalValue, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
3050 { MSmallestNormalized, PLargestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
3051 { MSmallestNormalized, MLargestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero },
3052 { MSmallestNormalized, PSmallestValue, "-0x1p+23", APFloat::opOK, APFloat::fcNormal },
3053 { MSmallestNormalized, MSmallestValue, "0x1p+23", APFloat::opOK, APFloat::fcNormal },
3054 { MSmallestNormalized, PSmallestNormalized, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
3055 { MSmallestNormalized, MSmallestNormalized, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
3056
3057 {MaxQuad, NMinQuad, "-inf", OverflowStatus, APFloat::fcInfinity,
3058 APFloat::rmNearestTiesToEven},
3059 {MaxQuad, NMinQuad, "-0x1.ffffffffffffffffffffffffffffp+16383",
3060 APFloat::opInexact, APFloat::fcNormal, APFloat::rmTowardPositive},
3061 {MaxQuad, NMinQuad, "-inf", OverflowStatus, APFloat::fcInfinity,
3062 APFloat::rmTowardNegative},
3063 {MaxQuad, NMinQuad, "-0x1.ffffffffffffffffffffffffffffp+16383",
3064 APFloat::opInexact, APFloat::fcNormal, APFloat::rmTowardZero},
3065 {MaxQuad, NMinQuad, "-inf", OverflowStatus, APFloat::fcInfinity,
3066 APFloat::rmNearestTiesToAway},
3067
3068 {MinQuad, MaxQuad, "0", UnderflowStatus, APFloat::fcZero,
3069 APFloat::rmNearestTiesToEven},
3070 {MinQuad, MaxQuad, "0x0.0000000000000000000000000001p-16382",
3071 UnderflowStatus, APFloat::fcNormal, APFloat::rmTowardPositive},
3072 {MinQuad, MaxQuad, "0", UnderflowStatus, APFloat::fcZero,
3073 APFloat::rmTowardNegative},
3074 {MinQuad, MaxQuad, "0", UnderflowStatus, APFloat::fcZero,
3075 APFloat::rmTowardZero},
3076 {MinQuad, MaxQuad, "0", UnderflowStatus, APFloat::fcZero,
3077 APFloat::rmNearestTiesToAway},
3078
3079 {NMinQuad, MaxQuad, "-0", UnderflowStatus, APFloat::fcZero,
3080 APFloat::rmNearestTiesToEven},
3081 {NMinQuad, MaxQuad, "-0", UnderflowStatus, APFloat::fcZero,
3082 APFloat::rmTowardPositive},
3083 {NMinQuad, MaxQuad, "-0x0.0000000000000000000000000001p-16382",
3084 UnderflowStatus, APFloat::fcNormal, APFloat::rmTowardNegative},
3085 {NMinQuad, MaxQuad, "-0", UnderflowStatus, APFloat::fcZero,
3086 APFloat::rmTowardZero},
3087 {NMinQuad, MaxQuad, "-0", UnderflowStatus, APFloat::fcZero,
3088 APFloat::rmNearestTiesToAway},
3089 };
3090
3091 for (size_t i = 0; i < std::size(SpecialCaseTests); ++i) {
3092 APFloat x(SpecialCaseTests[i].x);
3093 APFloat y(SpecialCaseTests[i].y);
3094 APFloat::opStatus status = x.divide(y, SpecialCaseTests[i].roundingMode);
3095
3096 APFloat result(x.getSemantics(), SpecialCaseTests[i].result);
3097
3098 EXPECT_TRUE(result.bitwiseIsEqual(x));
3099 EXPECT_EQ(SpecialCaseTests[i].status, (int)status);
3100 EXPECT_EQ(SpecialCaseTests[i].category, (int)x.getCategory());
3101 }
3102 }
3103
3104 TEST(APFloatTest, operatorOverloads) {
3105 // This is mostly testing that these operator overloads compile.
3106 APFloat One = APFloat(APFloat::IEEEsingle(), "0x1p+0");
3107 APFloat Two = APFloat(APFloat::IEEEsingle(), "0x2p+0");
3108 EXPECT_TRUE(Two.bitwiseIsEqual(One + One));
3109 EXPECT_TRUE(One.bitwiseIsEqual(Two - One));
3110 EXPECT_TRUE(Two.bitwiseIsEqual(One * Two));
3111 EXPECT_TRUE(One.bitwiseIsEqual(Two / Two));
3112 }
3113
3114 TEST(APFloatTest, Comparisons) {
3115 enum {MNan, MInf, MBig, MOne, MZer, PZer, POne, PBig, PInf, PNan, NumVals};
3116 APFloat Vals[NumVals] = {
3117 APFloat::getNaN(APFloat::IEEEsingle(), true),
3118 APFloat::getInf(APFloat::IEEEsingle(), true),
3119 APFloat::getLargest(APFloat::IEEEsingle(), true),
3120 APFloat(APFloat::IEEEsingle(), "-0x1p+0"),
3121 APFloat::getZero(APFloat::IEEEsingle(), true),
3122 APFloat::getZero(APFloat::IEEEsingle(), false),
3123 APFloat(APFloat::IEEEsingle(), "0x1p+0"),
3124 APFloat::getLargest(APFloat::IEEEsingle(), false),
3125 APFloat::getInf(APFloat::IEEEsingle(), false),
3126 APFloat::getNaN(APFloat::IEEEsingle(), false),
3127 };
3128 using Relation = void (*)(const APFloat &, const APFloat &);
3129 Relation LT = [](const APFloat &LHS, const APFloat &RHS) {
3130 EXPECT_FALSE(LHS == RHS);
3131 EXPECT_TRUE(LHS != RHS);
3132 EXPECT_TRUE(LHS < RHS);
3133 EXPECT_FALSE(LHS > RHS);
3134 EXPECT_TRUE(LHS <= RHS);
3135 EXPECT_FALSE(LHS >= RHS);
3136 };
3137 Relation EQ = [](const APFloat &LHS, const APFloat &RHS) {
3138 EXPECT_TRUE(LHS == RHS);
3139 EXPECT_FALSE(LHS != RHS);
3140 EXPECT_FALSE(LHS < RHS);
3141 EXPECT_FALSE(LHS > RHS);
3142 EXPECT_TRUE(LHS <= RHS);
3143 EXPECT_TRUE(LHS >= RHS);
3144 };
3145 Relation GT = [](const APFloat &LHS, const APFloat &RHS) {
3146 EXPECT_FALSE(LHS == RHS);
3147 EXPECT_TRUE(LHS != RHS);
3148 EXPECT_FALSE(LHS < RHS);
3149 EXPECT_TRUE(LHS > RHS);
3150 EXPECT_FALSE(LHS <= RHS);
3151 EXPECT_TRUE(LHS >= RHS);
3152 };
3153 Relation UN = [](const APFloat &LHS, const APFloat &RHS) {
3154 EXPECT_FALSE(LHS == RHS);
3155 EXPECT_TRUE(LHS != RHS);
3156 EXPECT_FALSE(LHS < RHS);
3157 EXPECT_FALSE(LHS > RHS);
3158 EXPECT_FALSE(LHS <= RHS);
3159 EXPECT_FALSE(LHS >= RHS);
3160 };
3161 Relation Relations[NumVals][NumVals] = {
3162 // -N -I -B -1 -0 +0 +1 +B +I +N
3163 /* MNan */ {UN, UN, UN, UN, UN, UN, UN, UN, UN, UN},
3164 /* MInf */ {UN, EQ, LT, LT, LT, LT, LT, LT, LT, UN},
3165 /* MBig */ {UN, GT, EQ, LT, LT, LT, LT, LT, LT, UN},
3166 /* MOne */ {UN, GT, GT, EQ, LT, LT, LT, LT, LT, UN},
3167 /* MZer */ {UN, GT, GT, GT, EQ, EQ, LT, LT, LT, UN},
3168 /* PZer */ {UN, GT, GT, GT, EQ, EQ, LT, LT, LT, UN},
3169 /* POne */ {UN, GT, GT, GT, GT, GT, EQ, LT, LT, UN},
3170 /* PBig */ {UN, GT, GT, GT, GT, GT, GT, EQ, LT, UN},
3171 /* PInf */ {UN, GT, GT, GT, GT, GT, GT, GT, EQ, UN},
3172 /* PNan */ {UN, UN, UN, UN, UN, UN, UN, UN, UN, UN},
3173 };
3174 for (unsigned I = 0; I < NumVals; ++I)
3175 for (unsigned J = 0; J < NumVals; ++J)
3176 Relations[I][J](Vals[I], Vals[J]);
3177 }
3178
3179 TEST(APFloatTest, abs) {
3180 APFloat PInf = APFloat::getInf(APFloat::IEEEsingle(), false);
3181 APFloat MInf = APFloat::getInf(APFloat::IEEEsingle(), true);
3182 APFloat PZero = APFloat::getZero(APFloat::IEEEsingle(), false);
3183 APFloat MZero = APFloat::getZero(APFloat::IEEEsingle(), true);
3184 APFloat PQNaN = APFloat::getNaN(APFloat::IEEEsingle(), false);
3185 APFloat MQNaN = APFloat::getNaN(APFloat::IEEEsingle(), true);
3186 APFloat PSNaN = APFloat::getSNaN(APFloat::IEEEsingle(), false);
3187 APFloat MSNaN = APFloat::getSNaN(APFloat::IEEEsingle(), true);
3188 APFloat PNormalValue = APFloat(APFloat::IEEEsingle(), "0x1p+0");
3189 APFloat MNormalValue = APFloat(APFloat::IEEEsingle(), "-0x1p+0");
3190 APFloat PLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), false);
3191 APFloat MLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), true);
3192 APFloat PSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), false);
3193 APFloat MSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), true);
3194 APFloat PSmallestNormalized =
3195 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), false);
3196 APFloat MSmallestNormalized =
3197 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), true);
3198
3199 EXPECT_TRUE(PInf.bitwiseIsEqual(abs(PInf)));
3200 EXPECT_TRUE(PInf.bitwiseIsEqual(abs(MInf)));
3201 EXPECT_TRUE(PZero.bitwiseIsEqual(abs(PZero)));
3202 EXPECT_TRUE(PZero.bitwiseIsEqual(abs(MZero)));
3203 EXPECT_TRUE(PQNaN.bitwiseIsEqual(abs(PQNaN)));
3204 EXPECT_TRUE(PQNaN.bitwiseIsEqual(abs(MQNaN)));
3205 EXPECT_TRUE(PSNaN.bitwiseIsEqual(abs(PSNaN)));
3206 EXPECT_TRUE(PSNaN.bitwiseIsEqual(abs(MSNaN)));
3207 EXPECT_TRUE(PNormalValue.bitwiseIsEqual(abs(PNormalValue)));
3208 EXPECT_TRUE(PNormalValue.bitwiseIsEqual(abs(MNormalValue)));
3209 EXPECT_TRUE(PLargestValue.bitwiseIsEqual(abs(PLargestValue)));
3210 EXPECT_TRUE(PLargestValue.bitwiseIsEqual(abs(MLargestValue)));
3211 EXPECT_TRUE(PSmallestValue.bitwiseIsEqual(abs(PSmallestValue)));
3212 EXPECT_TRUE(PSmallestValue.bitwiseIsEqual(abs(MSmallestValue)));
3213 EXPECT_TRUE(PSmallestNormalized.bitwiseIsEqual(abs(PSmallestNormalized)));
3214 EXPECT_TRUE(PSmallestNormalized.bitwiseIsEqual(abs(MSmallestNormalized)));
3215 }
3216
3217 TEST(APFloatTest, neg) {
3218 APFloat One = APFloat(APFloat::IEEEsingle(), "1.0");
3219 APFloat NegOne = APFloat(APFloat::IEEEsingle(), "-1.0");
3220 APFloat Zero = APFloat::getZero(APFloat::IEEEsingle(), false);
3221 APFloat NegZero = APFloat::getZero(APFloat::IEEEsingle(), true);
3222 APFloat Inf = APFloat::getInf(APFloat::IEEEsingle(), false);
3223 APFloat NegInf = APFloat::getInf(APFloat::IEEEsingle(), true);
3224 APFloat QNaN = APFloat::getNaN(APFloat::IEEEsingle(), false);
3225 APFloat NegQNaN = APFloat::getNaN(APFloat::IEEEsingle(), true);
3226
3227 EXPECT_TRUE(NegOne.bitwiseIsEqual(neg(One)));
3228 EXPECT_TRUE(One.bitwiseIsEqual(neg(NegOne)));
3229 EXPECT_TRUE(NegZero.bitwiseIsEqual(neg(Zero)));
3230 EXPECT_TRUE(Zero.bitwiseIsEqual(neg(NegZero)));
3231 EXPECT_TRUE(NegInf.bitwiseIsEqual(neg(Inf)));
3232 EXPECT_TRUE(Inf.bitwiseIsEqual(neg(NegInf)));
3233 EXPECT_TRUE(NegInf.bitwiseIsEqual(neg(Inf)));
3234 EXPECT_TRUE(Inf.bitwiseIsEqual(neg(NegInf)));
3235 EXPECT_TRUE(NegQNaN.bitwiseIsEqual(neg(QNaN)));
3236 EXPECT_TRUE(QNaN.bitwiseIsEqual(neg(NegQNaN)));
3237
3238 EXPECT_TRUE(NegOne.bitwiseIsEqual(-One));
3239 EXPECT_TRUE(One.bitwiseIsEqual(-NegOne));
3240 EXPECT_TRUE(NegZero.bitwiseIsEqual(-Zero));
3241 EXPECT_TRUE(Zero.bitwiseIsEqual(-NegZero));
3242 EXPECT_TRUE(NegInf.bitwiseIsEqual(-Inf));
3243 EXPECT_TRUE(Inf.bitwiseIsEqual(-NegInf));
3244 EXPECT_TRUE(NegInf.bitwiseIsEqual(-Inf));
3245 EXPECT_TRUE(Inf.bitwiseIsEqual(-NegInf));
3246 EXPECT_TRUE(NegQNaN.bitwiseIsEqual(-QNaN));
3247 EXPECT_TRUE(QNaN.bitwiseIsEqual(-NegQNaN));
3248 }
3249
3250 TEST(APFloatTest, ilogb) {
3251 EXPECT_EQ(-1074, ilogb(APFloat::getSmallest(APFloat::IEEEdouble(), false)));
3252 EXPECT_EQ(-1074, ilogb(APFloat::getSmallest(APFloat::IEEEdouble(), true)));
3253 EXPECT_EQ(-1023, ilogb(APFloat(APFloat::IEEEdouble(), "0x1.ffffffffffffep-1024")));
3254 EXPECT_EQ(-1023, ilogb(APFloat(APFloat::IEEEdouble(), "0x1.ffffffffffffep-1023")));
3255 EXPECT_EQ(-1023, ilogb(APFloat(APFloat::IEEEdouble(), "-0x1.ffffffffffffep-1023")));
3256 EXPECT_EQ(-51, ilogb(APFloat(APFloat::IEEEdouble(), "0x1p-51")));
3257 EXPECT_EQ(-1023, ilogb(APFloat(APFloat::IEEEdouble(), "0x1.c60f120d9f87cp-1023")));
3258 EXPECT_EQ(-2, ilogb(APFloat(APFloat::IEEEdouble(), "0x0.ffffp-1")));
3259 EXPECT_EQ(-1023, ilogb(APFloat(APFloat::IEEEdouble(), "0x1.fffep-1023")));
3260 EXPECT_EQ(1023, ilogb(APFloat::getLargest(APFloat::IEEEdouble(), false)));
3261 EXPECT_EQ(1023, ilogb(APFloat::getLargest(APFloat::IEEEdouble(), true)));
3262
3263
3264 EXPECT_EQ(0, ilogb(APFloat(APFloat::IEEEsingle(), "0x1p+0")));
3265 EXPECT_EQ(0, ilogb(APFloat(APFloat::IEEEsingle(), "-0x1p+0")));
3266 EXPECT_EQ(42, ilogb(APFloat(APFloat::IEEEsingle(), "0x1p+42")));
3267 EXPECT_EQ(-42, ilogb(APFloat(APFloat::IEEEsingle(), "0x1p-42")));
3268
3269 EXPECT_EQ(APFloat::IEK_Inf,
3270 ilogb(APFloat::getInf(APFloat::IEEEsingle(), false)));
3271 EXPECT_EQ(APFloat::IEK_Inf,
3272 ilogb(APFloat::getInf(APFloat::IEEEsingle(), true)));
3273 EXPECT_EQ(APFloat::IEK_Zero,
3274 ilogb(APFloat::getZero(APFloat::IEEEsingle(), false)));
3275 EXPECT_EQ(APFloat::IEK_Zero,
3276 ilogb(APFloat::getZero(APFloat::IEEEsingle(), true)));
3277 EXPECT_EQ(APFloat::IEK_NaN,
3278 ilogb(APFloat::getNaN(APFloat::IEEEsingle(), false)));
3279 EXPECT_EQ(APFloat::IEK_NaN,
3280 ilogb(APFloat::getSNaN(APFloat::IEEEsingle(), false)));
3281
3282 EXPECT_EQ(127, ilogb(APFloat::getLargest(APFloat::IEEEsingle(), false)));
3283 EXPECT_EQ(127, ilogb(APFloat::getLargest(APFloat::IEEEsingle(), true)));
3284
3285 EXPECT_EQ(-149, ilogb(APFloat::getSmallest(APFloat::IEEEsingle(), false)));
3286 EXPECT_EQ(-149, ilogb(APFloat::getSmallest(APFloat::IEEEsingle(), true)));
3287 EXPECT_EQ(-126,
3288 ilogb(APFloat::getSmallestNormalized(APFloat::IEEEsingle(), false)));
3289 EXPECT_EQ(-126,
3290 ilogb(APFloat::getSmallestNormalized(APFloat::IEEEsingle(), true)));
3291 }
3292
3293 TEST(APFloatTest, scalbn) {
3294
3295 const APFloat::roundingMode RM = APFloat::rmNearestTiesToEven;
3296 EXPECT_TRUE(
3297 APFloat(APFloat::IEEEsingle(), "0x1p+0")
3298 .bitwiseIsEqual(scalbn(APFloat(APFloat::IEEEsingle(), "0x1p+0"), 0, RM)));
3299 EXPECT_TRUE(
3300 APFloat(APFloat::IEEEsingle(), "0x1p+42")
3301 .bitwiseIsEqual(scalbn(APFloat(APFloat::IEEEsingle(), "0x1p+0"), 42, RM)));
3302 EXPECT_TRUE(
3303 APFloat(APFloat::IEEEsingle(), "0x1p-42")
3304 .bitwiseIsEqual(scalbn(APFloat(APFloat::IEEEsingle(), "0x1p+0"), -42, RM)));
3305
3306 APFloat PInf = APFloat::getInf(APFloat::IEEEsingle(), false);
3307 APFloat MInf = APFloat::getInf(APFloat::IEEEsingle(), true);
3308 APFloat PZero = APFloat::getZero(APFloat::IEEEsingle(), false);
3309 APFloat MZero = APFloat::getZero(APFloat::IEEEsingle(), true);
3310 APFloat QPNaN = APFloat::getNaN(APFloat::IEEEsingle(), false);
3311 APFloat QMNaN = APFloat::getNaN(APFloat::IEEEsingle(), true);
3312 APFloat SNaN = APFloat::getSNaN(APFloat::IEEEsingle(), false);
3313
3314 EXPECT_TRUE(PInf.bitwiseIsEqual(scalbn(PInf, 0, RM)));
3315 EXPECT_TRUE(MInf.bitwiseIsEqual(scalbn(MInf, 0, RM)));
3316 EXPECT_TRUE(PZero.bitwiseIsEqual(scalbn(PZero, 0, RM)));
3317 EXPECT_TRUE(MZero.bitwiseIsEqual(scalbn(MZero, 0, RM)));
3318 EXPECT_TRUE(QPNaN.bitwiseIsEqual(scalbn(QPNaN, 0, RM)));
3319 EXPECT_TRUE(QMNaN.bitwiseIsEqual(scalbn(QMNaN, 0, RM)));
3320 EXPECT_FALSE(scalbn(SNaN, 0, RM).isSignaling());
3321
3322 APFloat ScalbnSNaN = scalbn(SNaN, 1, RM);
3323 EXPECT_TRUE(ScalbnSNaN.isNaN() && !ScalbnSNaN.isSignaling());
3324
3325 // Make sure highest bit of payload is preserved.
3326 const APInt Payload(64, (UINT64_C(1) << 50) |
3327 (UINT64_C(1) << 49) |
3328 (UINT64_C(1234) << 32) |
3329 1);
3330
3331 APFloat SNaNWithPayload = APFloat::getSNaN(APFloat::IEEEdouble(), false,
3332 &Payload);
3333 APFloat QuietPayload = scalbn(SNaNWithPayload, 1, RM);
3334 EXPECT_TRUE(QuietPayload.isNaN() && !QuietPayload.isSignaling());
3335 EXPECT_EQ(Payload, QuietPayload.bitcastToAPInt().getLoBits(51));
3336
3337 EXPECT_TRUE(PInf.bitwiseIsEqual(
3338 scalbn(APFloat(APFloat::IEEEsingle(), "0x1p+0"), 128, RM)));
3339 EXPECT_TRUE(MInf.bitwiseIsEqual(
3340 scalbn(APFloat(APFloat::IEEEsingle(), "-0x1p+0"), 128, RM)));
3341 EXPECT_TRUE(PInf.bitwiseIsEqual(
3342 scalbn(APFloat(APFloat::IEEEsingle(), "0x1p+127"), 1, RM)));
3343 EXPECT_TRUE(PZero.bitwiseIsEqual(
3344 scalbn(APFloat(APFloat::IEEEsingle(), "0x1p-127"), -127, RM)));
3345 EXPECT_TRUE(MZero.bitwiseIsEqual(
3346 scalbn(APFloat(APFloat::IEEEsingle(), "-0x1p-127"), -127, RM)));
3347 EXPECT_TRUE(APFloat(APFloat::IEEEsingle(), "-0x1p-149").bitwiseIsEqual(
3348 scalbn(APFloat(APFloat::IEEEsingle(), "-0x1p-127"), -22, RM)));
3349 EXPECT_TRUE(PZero.bitwiseIsEqual(
3350 scalbn(APFloat(APFloat::IEEEsingle(), "0x1p-126"), -24, RM)));
3351
3352
3353 APFloat SmallestF64 = APFloat::getSmallest(APFloat::IEEEdouble(), false);
3354 APFloat NegSmallestF64 = APFloat::getSmallest(APFloat::IEEEdouble(), true);
3355
3356 APFloat LargestF64 = APFloat::getLargest(APFloat::IEEEdouble(), false);
3357 APFloat NegLargestF64 = APFloat::getLargest(APFloat::IEEEdouble(), true);
3358
3359 APFloat SmallestNormalizedF64
3360 = APFloat::getSmallestNormalized(APFloat::IEEEdouble(), false);
3361 APFloat NegSmallestNormalizedF64
3362 = APFloat::getSmallestNormalized(APFloat::IEEEdouble(), true);
3363
3364 APFloat LargestDenormalF64(APFloat::IEEEdouble(), "0x1.ffffffffffffep-1023");
3365 APFloat NegLargestDenormalF64(APFloat::IEEEdouble(), "-0x1.ffffffffffffep-1023");
3366
3367
3368 EXPECT_TRUE(SmallestF64.bitwiseIsEqual(
3369 scalbn(APFloat(APFloat::IEEEdouble(), "0x1p-1074"), 0, RM)));
3370 EXPECT_TRUE(NegSmallestF64.bitwiseIsEqual(
3371 scalbn(APFloat(APFloat::IEEEdouble(), "-0x1p-1074"), 0, RM)));
3372
3373 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1p+1023")
3374 .bitwiseIsEqual(scalbn(SmallestF64, 2097, RM)));
3375
3376 EXPECT_TRUE(scalbn(SmallestF64, -2097, RM).isPosZero());
3377 EXPECT_TRUE(scalbn(SmallestF64, -2098, RM).isPosZero());
3378 EXPECT_TRUE(scalbn(SmallestF64, -2099, RM).isPosZero());
3379 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1p+1022")
3380 .bitwiseIsEqual(scalbn(SmallestF64, 2096, RM)));
3381 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1p+1023")
3382 .bitwiseIsEqual(scalbn(SmallestF64, 2097, RM)));
3383 EXPECT_TRUE(scalbn(SmallestF64, 2098, RM).isInfinity());
3384 EXPECT_TRUE(scalbn(SmallestF64, 2099, RM).isInfinity());
3385
3386 // Test for integer overflows when adding to exponent.
3387 EXPECT_TRUE(scalbn(SmallestF64, -INT_MAX, RM).isPosZero());
3388 EXPECT_TRUE(scalbn(LargestF64, INT_MAX, RM).isInfinity());
3389
3390 EXPECT_TRUE(LargestDenormalF64
3391 .bitwiseIsEqual(scalbn(LargestDenormalF64, 0, RM)));
3392 EXPECT_TRUE(NegLargestDenormalF64
3393 .bitwiseIsEqual(scalbn(NegLargestDenormalF64, 0, RM)));
3394
3395 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.ffffffffffffep-1022")
3396 .bitwiseIsEqual(scalbn(LargestDenormalF64, 1, RM)));
3397 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "-0x1.ffffffffffffep-1021")
3398 .bitwiseIsEqual(scalbn(NegLargestDenormalF64, 2, RM)));
3399
3400 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.ffffffffffffep+1")
3401 .bitwiseIsEqual(scalbn(LargestDenormalF64, 1024, RM)));
3402 EXPECT_TRUE(scalbn(LargestDenormalF64, -1023, RM).isPosZero());
3403 EXPECT_TRUE(scalbn(LargestDenormalF64, -1024, RM).isPosZero());
3404 EXPECT_TRUE(scalbn(LargestDenormalF64, -2048, RM).isPosZero());
3405 EXPECT_TRUE(scalbn(LargestDenormalF64, 2047, RM).isInfinity());
3406 EXPECT_TRUE(scalbn(LargestDenormalF64, 2098, RM).isInfinity());
3407 EXPECT_TRUE(scalbn(LargestDenormalF64, 2099, RM).isInfinity());
3408
3409 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.ffffffffffffep-2")
3410 .bitwiseIsEqual(scalbn(LargestDenormalF64, 1021, RM)));
3411 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.ffffffffffffep-1")
3412 .bitwiseIsEqual(scalbn(LargestDenormalF64, 1022, RM)));
3413 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.ffffffffffffep+0")
3414 .bitwiseIsEqual(scalbn(LargestDenormalF64, 1023, RM)));
3415 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.ffffffffffffep+1023")
3416 .bitwiseIsEqual(scalbn(LargestDenormalF64, 2046, RM)));
3417 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1p+974")
3418 .bitwiseIsEqual(scalbn(SmallestF64, 2048, RM)));
3419
3420 APFloat RandomDenormalF64(APFloat::IEEEdouble(), "0x1.c60f120d9f87cp+51");
3421 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.c60f120d9f87cp-972")
3422 .bitwiseIsEqual(scalbn(RandomDenormalF64, -1023, RM)));
3423 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.c60f120d9f87cp-1")
3424 .bitwiseIsEqual(scalbn(RandomDenormalF64, -52, RM)));
3425 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.c60f120d9f87cp-2")
3426 .bitwiseIsEqual(scalbn(RandomDenormalF64, -53, RM)));
3427 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.c60f120d9f87cp+0")
3428 .bitwiseIsEqual(scalbn(RandomDenormalF64, -51, RM)));
3429
3430 EXPECT_TRUE(scalbn(RandomDenormalF64, -2097, RM).isPosZero());
3431 EXPECT_TRUE(scalbn(RandomDenormalF64, -2090, RM).isPosZero());
3432
3433
3434 EXPECT_TRUE(
3435 APFloat(APFloat::IEEEdouble(), "-0x1p-1073")
3436 .bitwiseIsEqual(scalbn(NegLargestF64, -2097, RM)));
3437
3438 EXPECT_TRUE(
3439 APFloat(APFloat::IEEEdouble(), "-0x1p-1024")
3440 .bitwiseIsEqual(scalbn(NegLargestF64, -2048, RM)));
3441
3442 EXPECT_TRUE(
3443 APFloat(APFloat::IEEEdouble(), "0x1p-1073")
3444 .bitwiseIsEqual(scalbn(LargestF64, -2097, RM)));
3445
3446 EXPECT_TRUE(
3447 APFloat(APFloat::IEEEdouble(), "0x1p-1074")
3448 .bitwiseIsEqual(scalbn(LargestF64, -2098, RM)));
3449 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "-0x1p-1074")
3450 .bitwiseIsEqual(scalbn(NegLargestF64, -2098, RM)));
3451 EXPECT_TRUE(scalbn(NegLargestF64, -2099, RM).isNegZero());
3452 EXPECT_TRUE(scalbn(LargestF64, 1, RM).isInfinity());
3453
3454
3455 EXPECT_TRUE(
3456 APFloat(APFloat::IEEEdouble(), "0x1p+0")
3457 .bitwiseIsEqual(scalbn(APFloat(APFloat::IEEEdouble(), "0x1p+52"), -52, RM)));
3458
3459 EXPECT_TRUE(
3460 APFloat(APFloat::IEEEdouble(), "0x1p-103")
3461 .bitwiseIsEqual(scalbn(APFloat(APFloat::IEEEdouble(), "0x1p-51"), -52, RM)));
3462 }
3463
3464 TEST(APFloatTest, frexp) {
3465 const APFloat::roundingMode RM = APFloat::rmNearestTiesToEven;
3466
3467 APFloat PZero = APFloat::getZero(APFloat::IEEEdouble(), false);
3468 APFloat MZero = APFloat::getZero(APFloat::IEEEdouble(), true);
3469 APFloat One(1.0);
3470 APFloat MOne(-1.0);
3471 APFloat Two(2.0);
3472 APFloat MTwo(-2.0);
3473
3474 APFloat LargestDenormal(APFloat::IEEEdouble(), "0x1.ffffffffffffep-1023");
3475 APFloat NegLargestDenormal(APFloat::IEEEdouble(), "-0x1.ffffffffffffep-1023");
3476
3477 APFloat Smallest = APFloat::getSmallest(APFloat::IEEEdouble(), false);
3478 APFloat NegSmallest = APFloat::getSmallest(APFloat::IEEEdouble(), true);
3479
3480 APFloat Largest = APFloat::getLargest(APFloat::IEEEdouble(), false);
3481 APFloat NegLargest = APFloat::getLargest(APFloat::IEEEdouble(), true);
3482
3483 APFloat PInf = APFloat::getInf(APFloat::IEEEdouble(), false);
3484 APFloat MInf = APFloat::getInf(APFloat::IEEEdouble(), true);
3485
3486 APFloat QPNaN = APFloat::getNaN(APFloat::IEEEdouble(), false);
3487 APFloat QMNaN = APFloat::getNaN(APFloat::IEEEdouble(), true);
3488 APFloat SNaN = APFloat::getSNaN(APFloat::IEEEdouble(), false);
3489
3490 // Make sure highest bit of payload is preserved.
3491 const APInt Payload(64, (UINT64_C(1) << 50) |
3492 (UINT64_C(1) << 49) |
3493 (UINT64_C(1234) << 32) |
3494 1);
3495
3496 APFloat SNaNWithPayload = APFloat::getSNaN(APFloat::IEEEdouble(), false,
3497 &Payload);
3498
3499 APFloat SmallestNormalized
3500 = APFloat::getSmallestNormalized(APFloat::IEEEdouble(), false);
3501 APFloat NegSmallestNormalized
3502 = APFloat::getSmallestNormalized(APFloat::IEEEdouble(), true);
3503
3504 int Exp;
3505 APFloat Frac(APFloat::IEEEdouble());
3506
3507
3508 Frac = frexp(PZero, Exp, RM);
3509 EXPECT_EQ(0, Exp);
3510 EXPECT_TRUE(Frac.isPosZero());
3511
3512 Frac = frexp(MZero, Exp, RM);
3513 EXPECT_EQ(0, Exp);
3514 EXPECT_TRUE(Frac.isNegZero());
3515
3516
3517 Frac = frexp(One, Exp, RM);
3518 EXPECT_EQ(1, Exp);
3519 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1p-1").bitwiseIsEqual(Frac));
3520
3521 Frac = frexp(MOne, Exp, RM);
3522 EXPECT_EQ(1, Exp);
3523 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "-0x1p-1").bitwiseIsEqual(Frac));
3524
3525 Frac = frexp(LargestDenormal, Exp, RM);
3526 EXPECT_EQ(-1022, Exp);
3527 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.ffffffffffffep-1").bitwiseIsEqual(Frac));
3528
3529 Frac = frexp(NegLargestDenormal, Exp, RM);
3530 EXPECT_EQ(-1022, Exp);
3531 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "-0x1.ffffffffffffep-1").bitwiseIsEqual(Frac));
3532
3533
3534 Frac = frexp(Smallest, Exp, RM);
3535 EXPECT_EQ(-1073, Exp);
3536 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1p-1").bitwiseIsEqual(Frac));
3537
3538 Frac = frexp(NegSmallest, Exp, RM);
3539 EXPECT_EQ(-1073, Exp);
3540 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "-0x1p-1").bitwiseIsEqual(Frac));
3541
3542
3543 Frac = frexp(Largest, Exp, RM);
3544 EXPECT_EQ(1024, Exp);
3545 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.fffffffffffffp-1").bitwiseIsEqual(Frac));
3546
3547 Frac = frexp(NegLargest, Exp, RM);
3548 EXPECT_EQ(1024, Exp);
3549 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "-0x1.fffffffffffffp-1").bitwiseIsEqual(Frac));
3550
3551
3552 Frac = frexp(PInf, Exp, RM);
3553 EXPECT_EQ(INT_MAX, Exp);
3554 EXPECT_TRUE(Frac.isInfinity() && !Frac.isNegative());
3555
3556 Frac = frexp(MInf, Exp, RM);
3557 EXPECT_EQ(INT_MAX, Exp);
3558 EXPECT_TRUE(Frac.isInfinity() && Frac.isNegative());
3559
3560 Frac = frexp(QPNaN, Exp, RM);
3561 EXPECT_EQ(INT_MIN, Exp);
3562 EXPECT_TRUE(Frac.isNaN());
3563
3564 Frac = frexp(QMNaN, Exp, RM);
3565 EXPECT_EQ(INT_MIN, Exp);
3566 EXPECT_TRUE(Frac.isNaN());
3567
3568 Frac = frexp(SNaN, Exp, RM);
3569 EXPECT_EQ(INT_MIN, Exp);
3570 EXPECT_TRUE(Frac.isNaN() && !Frac.isSignaling());
3571
3572 Frac = frexp(SNaNWithPayload, Exp, RM);
3573 EXPECT_EQ(INT_MIN, Exp);
3574 EXPECT_TRUE(Frac.isNaN() && !Frac.isSignaling());
3575 EXPECT_EQ(Payload, Frac.bitcastToAPInt().getLoBits(51));
3576
3577 Frac = frexp(APFloat(APFloat::IEEEdouble(), "0x0.ffffp-1"), Exp, RM);
3578 EXPECT_EQ(-1, Exp);
3579 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.fffep-1").bitwiseIsEqual(Frac));
3580
3581 Frac = frexp(APFloat(APFloat::IEEEdouble(), "0x1p-51"), Exp, RM);
3582 EXPECT_EQ(-50, Exp);
3583 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1p-1").bitwiseIsEqual(Frac));
3584
3585 Frac = frexp(APFloat(APFloat::IEEEdouble(), "0x1.c60f120d9f87cp+51"), Exp, RM);
3586 EXPECT_EQ(52, Exp);
3587 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.c60f120d9f87cp-1").bitwiseIsEqual(Frac));
3588 }
3589
3590 TEST(APFloatTest, mod) {
3591 {
3592 APFloat f1(APFloat::IEEEdouble(), "1.5");
3593 APFloat f2(APFloat::IEEEdouble(), "1.0");
3594 APFloat expected(APFloat::IEEEdouble(), "0.5");
3595 EXPECT_EQ(f1.mod(f2), APFloat::opOK);
3596 EXPECT_TRUE(f1.bitwiseIsEqual(expected));
3597 }
3598 {
3599 APFloat f1(APFloat::IEEEdouble(), "0.5");
3600 APFloat f2(APFloat::IEEEdouble(), "1.0");
3601 APFloat expected(APFloat::IEEEdouble(), "0.5");
3602 EXPECT_EQ(f1.mod(f2), APFloat::opOK);
3603 EXPECT_TRUE(f1.bitwiseIsEqual(expected));
3604 }
3605 {
3606 APFloat f1(APFloat::IEEEdouble(), "0x1.3333333333333p-2"); // 0.3
3607 APFloat f2(APFloat::IEEEdouble(), "0x1.47ae147ae147bp-7"); // 0.01
3608 APFloat expected(APFloat::IEEEdouble(),
3609 "0x1.47ae147ae1471p-7"); // 0.009999999999999983
3610 EXPECT_EQ(f1.mod(f2), APFloat::opOK);
3611 EXPECT_TRUE(f1.bitwiseIsEqual(expected));
3612 }
3613 {
3614 APFloat f1(APFloat::IEEEdouble(), "0x1p64"); // 1.8446744073709552e19
3615 APFloat f2(APFloat::IEEEdouble(), "1.5");
3616 APFloat expected(APFloat::IEEEdouble(), "1.0");
3617 EXPECT_EQ(f1.mod(f2), APFloat::opOK);
3618 EXPECT_TRUE(f1.bitwiseIsEqual(expected));
3619 }
3620 {
3621 APFloat f1(APFloat::IEEEdouble(), "0x1p1000");
3622 APFloat f2(APFloat::IEEEdouble(), "0x1p-1000");
3623 APFloat expected(APFloat::IEEEdouble(), "0.0");
3624 EXPECT_EQ(f1.mod(f2), APFloat::opOK);
3625 EXPECT_TRUE(f1.bitwiseIsEqual(expected));
3626 }
3627 {
3628 APFloat f1(APFloat::IEEEdouble(), "0.0");
3629 APFloat f2(APFloat::IEEEdouble(), "1.0");
3630 APFloat expected(APFloat::IEEEdouble(), "0.0");
3631 EXPECT_EQ(f1.mod(f2), APFloat::opOK);
3632 EXPECT_TRUE(f1.bitwiseIsEqual(expected));
3633 }
3634 {
3635 APFloat f1(APFloat::IEEEdouble(), "1.0");
3636 APFloat f2(APFloat::IEEEdouble(), "0.0");
3637 EXPECT_EQ(f1.mod(f2), APFloat::opInvalidOp);
3638 EXPECT_TRUE(f1.isNaN());
3639 }
3640 {
3641 APFloat f1(APFloat::IEEEdouble(), "0.0");
3642 APFloat f2(APFloat::IEEEdouble(), "0.0");
3643 EXPECT_EQ(f1.mod(f2), APFloat::opInvalidOp);
3644 EXPECT_TRUE(f1.isNaN());
3645 }
3646 {
3647 APFloat f1 = APFloat::getInf(APFloat::IEEEdouble(), false);
3648 APFloat f2(APFloat::IEEEdouble(), "1.0");
3649 EXPECT_EQ(f1.mod(f2), APFloat::opInvalidOp);
3650 EXPECT_TRUE(f1.isNaN());
3651 }
3652 {
3653 APFloat f1(APFloat::IEEEdouble(), "-4.0");
3654 APFloat f2(APFloat::IEEEdouble(), "-2.0");
3655 APFloat expected(APFloat::IEEEdouble(), "-0.0");
3656 EXPECT_EQ(f1.mod(f2), APFloat::opOK);
3657 EXPECT_TRUE(f1.bitwiseIsEqual(expected));
3658 }
3659 {
3660 APFloat f1(APFloat::IEEEdouble(), "-4.0");
3661 APFloat f2(APFloat::IEEEdouble(), "2.0");
3662 APFloat expected(APFloat::IEEEdouble(), "-0.0");
3663 EXPECT_EQ(f1.mod(f2), APFloat::opOK);
3664 EXPECT_TRUE(f1.bitwiseIsEqual(expected));
3665 }
3666 }
3667
3668 TEST(APFloatTest, remainder) {
3669 // Test Special Cases against each other and normal values.
3670
3671 APFloat PInf = APFloat::getInf(APFloat::IEEEsingle(), false);
3672 APFloat MInf = APFloat::getInf(APFloat::IEEEsingle(), true);
3673 APFloat PZero = APFloat::getZero(APFloat::IEEEsingle(), false);
3674 APFloat MZero = APFloat::getZero(APFloat::IEEEsingle(), true);
3675 APFloat QNaN = APFloat::getNaN(APFloat::IEEEsingle(), false);
3676 APFloat SNaN = APFloat(APFloat::IEEEsingle(), "snan123");
3677 APFloat PNormalValue = APFloat(APFloat::IEEEsingle(), "0x1p+0");
3678 APFloat MNormalValue = APFloat(APFloat::IEEEsingle(), "-0x1p+0");
3679 APFloat PLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), false);
3680 APFloat MLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), true);
3681 APFloat PSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), false);
3682 APFloat MSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), true);
3683 APFloat PSmallestNormalized =
3684 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), false);
3685 APFloat MSmallestNormalized =
3686 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), true);
3687
3688 APFloat PVal1(APFloat::IEEEsingle(), "0x1.fffffep+126");
3689 APFloat MVal1(APFloat::IEEEsingle(), "-0x1.fffffep+126");
3690 APFloat PVal2(APFloat::IEEEsingle(), "0x1.fffffep-126");
3691 APFloat MVal2(APFloat::IEEEsingle(), "-0x1.fffffep-126");
3692 APFloat PVal3(APFloat::IEEEsingle(), "0x1p-125");
3693 APFloat MVal3(APFloat::IEEEsingle(), "-0x1p-125");
3694 APFloat PVal4(APFloat::IEEEsingle(), "0x1p+127");
3695 APFloat MVal4(APFloat::IEEEsingle(), "-0x1p+127");
3696 APFloat PVal5(APFloat::IEEEsingle(), "1.5");
3697 APFloat MVal5(APFloat::IEEEsingle(), "-1.5");
3698 APFloat PVal6(APFloat::IEEEsingle(), "1");
3699 APFloat MVal6(APFloat::IEEEsingle(), "-1");
3700
3701 struct {
3702 APFloat x;
3703 APFloat y;
3704 const char *result;
3705 int status;
3706 int category;
3707 } SpecialCaseTests[] = {
3708 { PInf, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
3709 { PInf, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
3710 { PInf, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
3711 { PInf, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
3712 { PInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
3713 { PInf, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3714 { PInf, PNormalValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
3715 { PInf, MNormalValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
3716 { PInf, PLargestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
3717 { PInf, MLargestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
3718 { PInf, PSmallestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
3719 { PInf, MSmallestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
3720 { PInf, PSmallestNormalized, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
3721 { PInf, MSmallestNormalized, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
3722 { MInf, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
3723 { MInf, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
3724 { MInf, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
3725 { MInf, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
3726 { MInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
3727 { MInf, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3728 { MInf, PNormalValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
3729 { MInf, MNormalValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
3730 { MInf, PLargestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
3731 { MInf, MLargestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
3732 { MInf, PSmallestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
3733 { MInf, MSmallestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
3734 { MInf, PSmallestNormalized, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
3735 { MInf, MSmallestNormalized, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
3736 { PZero, PInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3737 { PZero, MInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3738 { PZero, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
3739 { PZero, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
3740 { PZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
3741 { PZero, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3742 { PZero, PNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3743 { PZero, MNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3744 { PZero, PLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3745 { PZero, MLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3746 { PZero, PSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3747 { PZero, MSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3748 { PZero, PSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3749 { PZero, MSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3750 { MZero, PInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3751 { MZero, MInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3752 { MZero, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
3753 { MZero, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
3754 { MZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
3755 { MZero, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3756 { MZero, PNormalValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3757 { MZero, MNormalValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3758 { MZero, PLargestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3759 { MZero, MLargestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3760 { MZero, PSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3761 { MZero, MSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3762 { MZero, PSmallestNormalized, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3763 { MZero, MSmallestNormalized, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3764 { QNaN, PInf, "nan", APFloat::opOK, APFloat::fcNaN },
3765 { QNaN, MInf, "nan", APFloat::opOK, APFloat::fcNaN },
3766 { QNaN, PZero, "nan", APFloat::opOK, APFloat::fcNaN },
3767 { QNaN, MZero, "nan", APFloat::opOK, APFloat::fcNaN },
3768 { QNaN, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
3769 { QNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
3770 { QNaN, PNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
3771 { QNaN, MNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
3772 { QNaN, PLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
3773 { QNaN, MLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
3774 { QNaN, PSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
3775 { QNaN, MSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
3776 { QNaN, PSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
3777 { QNaN, MSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
3778 { SNaN, PInf, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3779 { SNaN, MInf, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3780 { SNaN, PZero, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3781 { SNaN, MZero, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3782 { SNaN, QNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3783 { SNaN, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3784 { SNaN, PNormalValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3785 { SNaN, MNormalValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3786 { SNaN, PLargestValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3787 { SNaN, MLargestValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3788 { SNaN, PSmallestValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3789 { SNaN, MSmallestValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3790 { SNaN, PSmallestNormalized, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3791 { SNaN, MSmallestNormalized, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3792 { PNormalValue, PInf, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
3793 { PNormalValue, MInf, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
3794 { PNormalValue, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
3795 { PNormalValue, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
3796 { PNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
3797 { PNormalValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3798 { PNormalValue, PNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3799 { PNormalValue, MNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3800 { PNormalValue, PLargestValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
3801 { PNormalValue, MLargestValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
3802 { PNormalValue, PSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3803 { PNormalValue, MSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3804 { PNormalValue, PSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3805 { PNormalValue, MSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3806 { MNormalValue, PInf, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
3807 { MNormalValue, MInf, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
3808 { MNormalValue, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
3809 { MNormalValue, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
3810 { MNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
3811 { MNormalValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3812 { MNormalValue, PNormalValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3813 { MNormalValue, MNormalValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3814 { MNormalValue, PLargestValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
3815 { MNormalValue, MLargestValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
3816 { MNormalValue, PSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3817 { MNormalValue, MSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3818 { MNormalValue, PSmallestNormalized, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3819 { MNormalValue, MSmallestNormalized, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3820 { PLargestValue, PInf, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
3821 { PLargestValue, MInf, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
3822 { PLargestValue, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
3823 { PLargestValue, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
3824 { PLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
3825 { PLargestValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3826 { PLargestValue, PNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3827 { PLargestValue, MNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3828 { PLargestValue, PLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3829 { PLargestValue, MLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3830 { PLargestValue, PSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3831 { PLargestValue, MSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3832 { PLargestValue, PSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3833 { PLargestValue, MSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3834 { MLargestValue, PInf, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
3835 { MLargestValue, MInf, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
3836 { MLargestValue, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
3837 { MLargestValue, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
3838 { MLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
3839 { MLargestValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3840 { MLargestValue, PNormalValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3841 { MLargestValue, MNormalValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3842 { MLargestValue, PLargestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3843 { MLargestValue, MLargestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3844 { MLargestValue, PSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3845 { MLargestValue, MSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3846 { MLargestValue, PSmallestNormalized, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3847 { MLargestValue, MSmallestNormalized, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3848 { PSmallestValue, PInf, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
3849 { PSmallestValue, MInf, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
3850 { PSmallestValue, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
3851 { PSmallestValue, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
3852 { PSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
3853 { PSmallestValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3854 { PSmallestValue, PNormalValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
3855 { PSmallestValue, MNormalValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
3856 { PSmallestValue, PLargestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
3857 { PSmallestValue, MLargestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
3858 { PSmallestValue, PSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3859 { PSmallestValue, MSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3860 { PSmallestValue, PSmallestNormalized, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
3861 { PSmallestValue, MSmallestNormalized, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
3862 { MSmallestValue, PInf, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
3863 { MSmallestValue, MInf, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
3864 { MSmallestValue, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
3865 { MSmallestValue, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
3866 { MSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
3867 { MSmallestValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3868 { MSmallestValue, PNormalValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
3869 { MSmallestValue, MNormalValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
3870 { MSmallestValue, PLargestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
3871 { MSmallestValue, MLargestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
3872 { MSmallestValue, PSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3873 { MSmallestValue, MSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3874 { MSmallestValue, PSmallestNormalized, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
3875 { MSmallestValue, MSmallestNormalized, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
3876 { PSmallestNormalized, PInf, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
3877 { PSmallestNormalized, MInf, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
3878 { PSmallestNormalized, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
3879 { PSmallestNormalized, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
3880 { PSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
3881 { PSmallestNormalized, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3882 { PSmallestNormalized, PNormalValue, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
3883 { PSmallestNormalized, MNormalValue, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
3884 { PSmallestNormalized, PLargestValue, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
3885 { PSmallestNormalized, MLargestValue, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
3886 { PSmallestNormalized, PSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3887 { PSmallestNormalized, MSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3888 { PSmallestNormalized, PSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3889 { PSmallestNormalized, MSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3890 { MSmallestNormalized, PInf, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
3891 { MSmallestNormalized, MInf, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
3892 { MSmallestNormalized, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
3893 { MSmallestNormalized, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
3894 { MSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
3895 { MSmallestNormalized, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN },
3896 { MSmallestNormalized, PNormalValue, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
3897 { MSmallestNormalized, MNormalValue, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
3898 { MSmallestNormalized, PLargestValue, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
3899 { MSmallestNormalized, MLargestValue, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
3900 { MSmallestNormalized, PSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3901 { MSmallestNormalized, MSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3902 { MSmallestNormalized, PSmallestNormalized, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3903 { MSmallestNormalized, MSmallestNormalized, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3904
3905 { PVal1, PVal1, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3906 { PVal1, MVal1, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3907 { PVal1, PVal2, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3908 { PVal1, MVal2, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3909 { PVal1, PVal3, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3910 { PVal1, MVal3, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3911 { PVal1, PVal4, "-0x1p+103", APFloat::opOK, APFloat::fcNormal },
3912 { PVal1, MVal4, "-0x1p+103", APFloat::opOK, APFloat::fcNormal },
3913 { PVal1, PVal5, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3914 { PVal1, MVal5, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3915 { PVal1, PVal6, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3916 { PVal1, MVal6, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3917 { MVal1, PVal1, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3918 { MVal1, MVal1, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3919 { MVal1, PVal2, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3920 { MVal1, MVal2, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3921 { MVal1, PVal3, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3922 { MVal1, MVal3, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3923 { MVal1, PVal4, "0x1p+103", APFloat::opOK, APFloat::fcNormal },
3924 { MVal1, MVal4, "0x1p+103", APFloat::opOK, APFloat::fcNormal },
3925 { MVal1, PVal5, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3926 { MVal1, MVal5, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3927 { MVal1, PVal6, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3928 { MVal1, MVal6, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3929 { PVal2, PVal1, "0x1.fffffep-126", APFloat::opOK, APFloat::fcNormal },
3930 { PVal2, MVal1, "0x1.fffffep-126", APFloat::opOK, APFloat::fcNormal },
3931 { PVal2, PVal2, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3932 { PVal2, MVal2, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3933 { PVal2, PVal3, "-0x0.000002p-126", APFloat::opOK, APFloat::fcNormal },
3934 { PVal2, MVal3, "-0x0.000002p-126", APFloat::opOK, APFloat::fcNormal },
3935 { PVal2, PVal4, "0x1.fffffep-126", APFloat::opOK, APFloat::fcNormal },
3936 { PVal2, MVal4, "0x1.fffffep-126", APFloat::opOK, APFloat::fcNormal },
3937 { PVal2, PVal5, "0x1.fffffep-126", APFloat::opOK, APFloat::fcNormal },
3938 { PVal2, MVal5, "0x1.fffffep-126", APFloat::opOK, APFloat::fcNormal },
3939 { PVal2, PVal6, "0x1.fffffep-126", APFloat::opOK, APFloat::fcNormal },
3940 { PVal2, MVal6, "0x1.fffffep-126", APFloat::opOK, APFloat::fcNormal },
3941 { MVal2, PVal1, "-0x1.fffffep-126", APFloat::opOK, APFloat::fcNormal },
3942 { MVal2, MVal1, "-0x1.fffffep-126", APFloat::opOK, APFloat::fcNormal },
3943 { MVal2, PVal2, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3944 { MVal2, MVal2, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3945 { MVal2, PVal3, "0x0.000002p-126", APFloat::opOK, APFloat::fcNormal },
3946 { MVal2, MVal3, "0x0.000002p-126", APFloat::opOK, APFloat::fcNormal },
3947 { MVal2, PVal4, "-0x1.fffffep-126", APFloat::opOK, APFloat::fcNormal },
3948 { MVal2, MVal4, "-0x1.fffffep-126", APFloat::opOK, APFloat::fcNormal },
3949 { MVal2, PVal5, "-0x1.fffffep-126", APFloat::opOK, APFloat::fcNormal },
3950 { MVal2, MVal5, "-0x1.fffffep-126", APFloat::opOK, APFloat::fcNormal },
3951 { MVal2, PVal6, "-0x1.fffffep-126", APFloat::opOK, APFloat::fcNormal },
3952 { MVal2, MVal6, "-0x1.fffffep-126", APFloat::opOK, APFloat::fcNormal },
3953 { PVal3, PVal1, "0x1p-125", APFloat::opOK, APFloat::fcNormal },
3954 { PVal3, MVal1, "0x1p-125", APFloat::opOK, APFloat::fcNormal },
3955 { PVal3, PVal2, "0x0.000002p-126", APFloat::opOK, APFloat::fcNormal },
3956 { PVal3, MVal2, "0x0.000002p-126", APFloat::opOK, APFloat::fcNormal },
3957 { PVal3, PVal3, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3958 { PVal3, MVal3, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3959 { PVal3, PVal4, "0x1p-125", APFloat::opOK, APFloat::fcNormal },
3960 { PVal3, MVal4, "0x1p-125", APFloat::opOK, APFloat::fcNormal },
3961 { PVal3, PVal5, "0x1p-125", APFloat::opOK, APFloat::fcNormal },
3962 { PVal3, MVal5, "0x1p-125", APFloat::opOK, APFloat::fcNormal },
3963 { PVal3, PVal6, "0x1p-125", APFloat::opOK, APFloat::fcNormal },
3964 { PVal3, MVal6, "0x1p-125", APFloat::opOK, APFloat::fcNormal },
3965 { MVal3, PVal1, "-0x1p-125", APFloat::opOK, APFloat::fcNormal },
3966 { MVal3, MVal1, "-0x1p-125", APFloat::opOK, APFloat::fcNormal },
3967 { MVal3, PVal2, "-0x0.000002p-126", APFloat::opOK, APFloat::fcNormal },
3968 { MVal3, MVal2, "-0x0.000002p-126", APFloat::opOK, APFloat::fcNormal },
3969 { MVal3, PVal3, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3970 { MVal3, MVal3, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3971 { MVal3, PVal4, "-0x1p-125", APFloat::opOK, APFloat::fcNormal },
3972 { MVal3, MVal4, "-0x1p-125", APFloat::opOK, APFloat::fcNormal },
3973 { MVal3, PVal5, "-0x1p-125", APFloat::opOK, APFloat::fcNormal },
3974 { MVal3, MVal5, "-0x1p-125", APFloat::opOK, APFloat::fcNormal },
3975 { MVal3, PVal6, "-0x1p-125", APFloat::opOK, APFloat::fcNormal },
3976 { MVal3, MVal6, "-0x1p-125", APFloat::opOK, APFloat::fcNormal },
3977 { PVal4, PVal1, "0x1p+103", APFloat::opOK, APFloat::fcNormal },
3978 { PVal4, MVal1, "0x1p+103", APFloat::opOK, APFloat::fcNormal },
3979 { PVal4, PVal2, "0x0.002p-126", APFloat::opOK, APFloat::fcNormal },
3980 { PVal4, MVal2, "0x0.002p-126", APFloat::opOK, APFloat::fcNormal },
3981 { PVal4, PVal3, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3982 { PVal4, MVal3, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3983 { PVal4, PVal4, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3984 { PVal4, MVal4, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3985 { PVal4, PVal5, "0.5", APFloat::opOK, APFloat::fcNormal },
3986 { PVal4, MVal5, "0.5", APFloat::opOK, APFloat::fcNormal },
3987 { PVal4, PVal6, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3988 { PVal4, MVal6, "0x0p+0", APFloat::opOK, APFloat::fcZero },
3989 { MVal4, PVal1, "-0x1p+103", APFloat::opOK, APFloat::fcNormal },
3990 { MVal4, MVal1, "-0x1p+103", APFloat::opOK, APFloat::fcNormal },
3991 { MVal4, PVal2, "-0x0.002p-126", APFloat::opOK, APFloat::fcNormal },
3992 { MVal4, MVal2, "-0x0.002p-126", APFloat::opOK, APFloat::fcNormal },
3993 { MVal4, PVal3, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3994 { MVal4, MVal3, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3995 { MVal4, PVal4, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3996 { MVal4, MVal4, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
3997 { MVal4, PVal5, "-0.5", APFloat::opOK, APFloat::fcNormal },
3998 { MVal4, MVal5, "-0.5", APFloat::opOK, APFloat::fcNormal },
3999 { MVal4, PVal6, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
4000 { MVal4, MVal6, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
4001 { PVal5, PVal1, "1.5", APFloat::opOK, APFloat::fcNormal },
4002 { PVal5, MVal1, "1.5", APFloat::opOK, APFloat::fcNormal },
4003 { PVal5, PVal2, "0x0.00006p-126", APFloat::opOK, APFloat::fcNormal },
4004 { PVal5, MVal2, "0x0.00006p-126", APFloat::opOK, APFloat::fcNormal },
4005 { PVal5, PVal3, "0x0p+0", APFloat::opOK, APFloat::fcZero },
4006 { PVal5, MVal3, "0x0p+0", APFloat::opOK, APFloat::fcZero },
4007 { PVal5, PVal4, "1.5", APFloat::opOK, APFloat::fcNormal },
4008 { PVal5, MVal4, "1.5", APFloat::opOK, APFloat::fcNormal },
4009 { PVal5, PVal5, "0x0p+0", APFloat::opOK, APFloat::fcZero },
4010 { PVal5, MVal5, "0x0p+0", APFloat::opOK, APFloat::fcZero },
4011 { PVal5, PVal6, "-0.5", APFloat::opOK, APFloat::fcNormal },
4012 { PVal5, MVal6, "-0.5", APFloat::opOK, APFloat::fcNormal },
4013 { MVal5, PVal1, "-1.5", APFloat::opOK, APFloat::fcNormal },
4014 { MVal5, MVal1, "-1.5", APFloat::opOK, APFloat::fcNormal },
4015 { MVal5, PVal2, "-0x0.00006p-126", APFloat::opOK, APFloat::fcNormal },
4016 { MVal5, MVal2, "-0x0.00006p-126", APFloat::opOK, APFloat::fcNormal },
4017 { MVal5, PVal3, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
4018 { MVal5, MVal3, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
4019 { MVal5, PVal4, "-1.5", APFloat::opOK, APFloat::fcNormal },
4020 { MVal5, MVal4, "-1.5", APFloat::opOK, APFloat::fcNormal },
4021 { MVal5, PVal5, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
4022 { MVal5, MVal5, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
4023 { MVal5, PVal6, "0.5", APFloat::opOK, APFloat::fcNormal },
4024 { MVal5, MVal6, "0.5", APFloat::opOK, APFloat::fcNormal },
4025 { PVal6, PVal1, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
4026 { PVal6, MVal1, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
4027 { PVal6, PVal2, "0x0.00004p-126", APFloat::opOK, APFloat::fcNormal },
4028 { PVal6, MVal2, "0x0.00004p-126", APFloat::opOK, APFloat::fcNormal },
4029 { PVal6, PVal3, "0x0p+0", APFloat::opOK, APFloat::fcZero },
4030 { PVal6, MVal3, "0x0p+0", APFloat::opOK, APFloat::fcZero },
4031 { PVal6, PVal4, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
4032 { PVal6, MVal4, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
4033 { PVal6, PVal5, "-0.5", APFloat::opOK, APFloat::fcNormal },
4034 { PVal6, MVal5, "-0.5", APFloat::opOK, APFloat::fcNormal },
4035 { PVal6, PVal6, "0x0p+0", APFloat::opOK, APFloat::fcZero },
4036 { PVal6, MVal6, "0x0p+0", APFloat::opOK, APFloat::fcZero },
4037 { MVal6, PVal1, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
4038 { MVal6, MVal1, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
4039 { MVal6, PVal2, "-0x0.00004p-126", APFloat::opOK, APFloat::fcNormal },
4040 { MVal6, MVal2, "-0x0.00004p-126", APFloat::opOK, APFloat::fcNormal },
4041 { MVal6, PVal3, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
4042 { MVal6, MVal3, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
4043 { MVal6, PVal4, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
4044 { MVal6, MVal4, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
4045 { MVal6, PVal5, "0.5", APFloat::opOK, APFloat::fcNormal },
4046 { MVal6, MVal5, "0.5", APFloat::opOK, APFloat::fcNormal },
4047 { MVal6, PVal6, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
4048 { MVal6, MVal6, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
4049 };
4050
4051 for (size_t i = 0; i < std::size(SpecialCaseTests); ++i) {
4052 APFloat x(SpecialCaseTests[i].x);
4053 APFloat y(SpecialCaseTests[i].y);
4054 APFloat::opStatus status = x.remainder(y);
4055
4056 APFloat result(x.getSemantics(), SpecialCaseTests[i].result);
4057
4058 EXPECT_TRUE(result.bitwiseIsEqual(x));
4059 EXPECT_EQ(SpecialCaseTests[i].status, (int)status);
4060 EXPECT_EQ(SpecialCaseTests[i].category, (int)x.getCategory());
4061 }
4062
4063 {
4064 APFloat f1(APFloat::IEEEdouble(), "0x1.3333333333333p-2"); // 0.3
4065 APFloat f2(APFloat::IEEEdouble(), "0x1.47ae147ae147bp-7"); // 0.01
4066 APFloat expected(APFloat::IEEEdouble(), "-0x1.4p-56");
4067 EXPECT_EQ(APFloat::opOK, f1.remainder(f2));
4068 EXPECT_TRUE(f1.bitwiseIsEqual(expected));
4069 }
4070 {
4071 APFloat f1(APFloat::IEEEdouble(), "0x1p64"); // 1.8446744073709552e19
4072 APFloat f2(APFloat::IEEEdouble(), "1.5");
4073 APFloat expected(APFloat::IEEEdouble(), "-0.5");
4074 EXPECT_EQ(APFloat::opOK, f1.remainder(f2));
4075 EXPECT_TRUE(f1.bitwiseIsEqual(expected));
4076 }
4077 {
4078 APFloat f1(APFloat::IEEEdouble(), "0x1p1000");
4079 APFloat f2(APFloat::IEEEdouble(), "0x1p-1000");
4080 APFloat expected(APFloat::IEEEdouble(), "0.0");
4081 EXPECT_EQ(APFloat::opOK, f1.remainder(f2));
4082 EXPECT_TRUE(f1.bitwiseIsEqual(expected));
4083 }
4084 {
4085 APFloat f1 = APFloat::getInf(APFloat::IEEEdouble(), false);
4086 APFloat f2(APFloat::IEEEdouble(), "1.0");
4087 EXPECT_EQ(f1.remainder(f2), APFloat::opInvalidOp);
4088 EXPECT_TRUE(f1.isNaN());
4089 }
4090 {
4091 APFloat f1(APFloat::IEEEdouble(), "-4.0");
4092 APFloat f2(APFloat::IEEEdouble(), "-2.0");
4093 APFloat expected(APFloat::IEEEdouble(), "-0.0");
4094 EXPECT_EQ(APFloat::opOK, f1.remainder(f2));
4095 EXPECT_TRUE(f1.bitwiseIsEqual(expected));
4096 }
4097 {
4098 APFloat f1(APFloat::IEEEdouble(), "-4.0");
4099 APFloat f2(APFloat::IEEEdouble(), "2.0");
4100 APFloat expected(APFloat::IEEEdouble(), "-0.0");
4101 EXPECT_EQ(APFloat::opOK, f1.remainder(f2));
4102 EXPECT_TRUE(f1.bitwiseIsEqual(expected));
4103 }
4104 }
4105
4106 TEST(APFloatTest, PPCDoubleDoubleAddSpecial) {
4107 using DataType = std::tuple<uint64_t, uint64_t, uint64_t, uint64_t,
4108 APFloat::fltCategory, APFloat::roundingMode>;
4109 DataType Data[] = {
4110 // (1 + 0) + (-1 + 0) = fcZero
4111 std::make_tuple(0x3ff0000000000000ull, 0, 0xbff0000000000000ull, 0,
4112 APFloat::fcZero, APFloat::rmNearestTiesToEven),
4113 // LDBL_MAX + (1.1 >> (1023 - 106) + 0)) = fcInfinity
4114 std::make_tuple(0x7fefffffffffffffull, 0x7c8ffffffffffffeull,
4115 0x7948000000000000ull, 0ull, APFloat::fcInfinity,
4116 APFloat::rmNearestTiesToEven),
4117 // TODO: change the 4th 0x75effffffffffffe to 0x75efffffffffffff when
4118 // semPPCDoubleDoubleLegacy is gone.
4119 // LDBL_MAX + (1.011111... >> (1023 - 106) + (1.1111111...0 >> (1023 -
4120 // 160))) = fcNormal
4121 std::make_tuple(0x7fefffffffffffffull, 0x7c8ffffffffffffeull,
4122 0x7947ffffffffffffull, 0x75effffffffffffeull,
4123 APFloat::fcNormal, APFloat::rmNearestTiesToEven),
4124 // LDBL_MAX + (1.1 >> (1023 - 106) + 0)) = fcInfinity
4125 std::make_tuple(0x7fefffffffffffffull, 0x7c8ffffffffffffeull,
4126 0x7fefffffffffffffull, 0x7c8ffffffffffffeull,
4127 APFloat::fcInfinity, APFloat::rmNearestTiesToEven),
4128 // NaN + (1 + 0) = fcNaN
4129 std::make_tuple(0x7ff8000000000000ull, 0, 0x3ff0000000000000ull, 0,
4130 APFloat::fcNaN, APFloat::rmNearestTiesToEven),
4131 };
4132
4133 for (auto Tp : Data) {
4134 uint64_t Op1[2], Op2[2];
4135 APFloat::fltCategory Expected;
4136 APFloat::roundingMode RM;
4137 std::tie(Op1[0], Op1[1], Op2[0], Op2[1], Expected, RM) = Tp;
4138
4139 {
4140 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
4141 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
4142 A1.add(A2, RM);
4143
4144 EXPECT_EQ(Expected, A1.getCategory())
4145 << formatv("({0:x} + {1:x}) + ({2:x} + {3:x})", Op1[0], Op1[1],
4146 Op2[0], Op2[1])
4147 .str();
4148 }
4149 {
4150 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
4151 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
4152 A2.add(A1, RM);
4153
4154 EXPECT_EQ(Expected, A2.getCategory())
4155 << formatv("({0:x} + {1:x}) + ({2:x} + {3:x})", Op2[0], Op2[1],
4156 Op1[0], Op1[1])
4157 .str();
4158 }
4159 }
4160 }
4161
4162 TEST(APFloatTest, PPCDoubleDoubleAdd) {
4163 using DataType = std::tuple<uint64_t, uint64_t, uint64_t, uint64_t, uint64_t,
4164 uint64_t, APFloat::roundingMode>;
4165 DataType Data[] = {
4166 // (1 + 0) + (1e-105 + 0) = (1 + 1e-105)
4167 std::make_tuple(0x3ff0000000000000ull, 0, 0x3960000000000000ull, 0,
4168 0x3ff0000000000000ull, 0x3960000000000000ull,
4169 APFloat::rmNearestTiesToEven),
4170 // (1 + 0) + (1e-106 + 0) = (1 + 1e-106)
4171 std::make_tuple(0x3ff0000000000000ull, 0, 0x3950000000000000ull, 0,
4172 0x3ff0000000000000ull, 0x3950000000000000ull,
4173 APFloat::rmNearestTiesToEven),
4174 // (1 + 1e-106) + (1e-106 + 0) = (1 + 1e-105)
4175 std::make_tuple(0x3ff0000000000000ull, 0x3950000000000000ull,
4176 0x3950000000000000ull, 0, 0x3ff0000000000000ull,
4177 0x3960000000000000ull, APFloat::rmNearestTiesToEven),
4178 // (1 + 0) + (epsilon + 0) = (1 + epsilon)
4179 std::make_tuple(0x3ff0000000000000ull, 0, 0x0000000000000001ull, 0,
4180 0x3ff0000000000000ull, 0x0000000000000001ull,
4181 APFloat::rmNearestTiesToEven),
4182 // TODO: change 0xf950000000000000 to 0xf940000000000000, when
4183 // semPPCDoubleDoubleLegacy is gone.
4184 // (DBL_MAX - 1 << (1023 - 105)) + (1 << (1023 - 53) + 0) = DBL_MAX +
4185 // 1.11111... << (1023 - 52)
4186 std::make_tuple(0x7fefffffffffffffull, 0xf950000000000000ull,
4187 0x7c90000000000000ull, 0, 0x7fefffffffffffffull,
4188 0x7c8ffffffffffffeull, APFloat::rmNearestTiesToEven),
4189 // TODO: change 0xf950000000000000 to 0xf940000000000000, when
4190 // semPPCDoubleDoubleLegacy is gone.
4191 // (1 << (1023 - 53) + 0) + (DBL_MAX - 1 << (1023 - 105)) = DBL_MAX +
4192 // 1.11111... << (1023 - 52)
4193 std::make_tuple(0x7c90000000000000ull, 0, 0x7fefffffffffffffull,
4194 0xf950000000000000ull, 0x7fefffffffffffffull,
4195 0x7c8ffffffffffffeull, APFloat::rmNearestTiesToEven),
4196 };
4197
4198 for (auto Tp : Data) {
4199 uint64_t Op1[2], Op2[2], Expected[2];
4200 APFloat::roundingMode RM;
4201 std::tie(Op1[0], Op1[1], Op2[0], Op2[1], Expected[0], Expected[1], RM) = Tp;
4202
4203 {
4204 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
4205 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
4206 A1.add(A2, RM);
4207
4208 EXPECT_EQ(Expected[0], A1.bitcastToAPInt().getRawData()[0])
4209 << formatv("({0:x} + {1:x}) + ({2:x} + {3:x})", Op1[0], Op1[1],
4210 Op2[0], Op2[1])
4211 .str();
4212 EXPECT_EQ(Expected[1], A1.bitcastToAPInt().getRawData()[1])
4213 << formatv("({0:x} + {1:x}) + ({2:x} + {3:x})", Op1[0], Op1[1],
4214 Op2[0], Op2[1])
4215 .str();
4216 }
4217 {
4218 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
4219 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
4220 A2.add(A1, RM);
4221
4222 EXPECT_EQ(Expected[0], A2.bitcastToAPInt().getRawData()[0])
4223 << formatv("({0:x} + {1:x}) + ({2:x} + {3:x})", Op2[0], Op2[1],
4224 Op1[0], Op1[1])
4225 .str();
4226 EXPECT_EQ(Expected[1], A2.bitcastToAPInt().getRawData()[1])
4227 << formatv("({0:x} + {1:x}) + ({2:x} + {3:x})", Op2[0], Op2[1],
4228 Op1[0], Op1[1])
4229 .str();
4230 }
4231 }
4232 }
4233
4234 TEST(APFloatTest, PPCDoubleDoubleSubtract) {
4235 using DataType = std::tuple<uint64_t, uint64_t, uint64_t, uint64_t, uint64_t,
4236 uint64_t, APFloat::roundingMode>;
4237 DataType Data[] = {
4238 // (1 + 0) - (-1e-105 + 0) = (1 + 1e-105)
4239 std::make_tuple(0x3ff0000000000000ull, 0, 0xb960000000000000ull, 0,
4240 0x3ff0000000000000ull, 0x3960000000000000ull,
4241 APFloat::rmNearestTiesToEven),
4242 // (1 + 0) - (-1e-106 + 0) = (1 + 1e-106)
4243 std::make_tuple(0x3ff0000000000000ull, 0, 0xb950000000000000ull, 0,
4244 0x3ff0000000000000ull, 0x3950000000000000ull,
4245 APFloat::rmNearestTiesToEven),
4246 };
4247
4248 for (auto Tp : Data) {
4249 uint64_t Op1[2], Op2[2], Expected[2];
4250 APFloat::roundingMode RM;
4251 std::tie(Op1[0], Op1[1], Op2[0], Op2[1], Expected[0], Expected[1], RM) = Tp;
4252
4253 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
4254 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
4255 A1.subtract(A2, RM);
4256
4257 EXPECT_EQ(Expected[0], A1.bitcastToAPInt().getRawData()[0])
4258 << formatv("({0:x} + {1:x}) - ({2:x} + {3:x})", Op1[0], Op1[1], Op2[0],
4259 Op2[1])
4260 .str();
4261 EXPECT_EQ(Expected[1], A1.bitcastToAPInt().getRawData()[1])
4262 << formatv("({0:x} + {1:x}) - ({2:x} + {3:x})", Op1[0], Op1[1], Op2[0],
4263 Op2[1])
4264 .str();
4265 }
4266 }
4267
4268 TEST(APFloatTest, PPCDoubleDoubleMultiplySpecial) {
4269 using DataType = std::tuple<uint64_t, uint64_t, uint64_t, uint64_t,
4270 APFloat::fltCategory, APFloat::roundingMode>;
4271 DataType Data[] = {
4272 // fcNaN * fcNaN = fcNaN
4273 std::make_tuple(0x7ff8000000000000ull, 0, 0x7ff8000000000000ull, 0,
4274 APFloat::fcNaN, APFloat::rmNearestTiesToEven),
4275 // fcNaN * fcZero = fcNaN
4276 std::make_tuple(0x7ff8000000000000ull, 0, 0, 0, APFloat::fcNaN,
4277 APFloat::rmNearestTiesToEven),
4278 // fcNaN * fcInfinity = fcNaN
4279 std::make_tuple(0x7ff8000000000000ull, 0, 0x7ff0000000000000ull, 0,
4280 APFloat::fcNaN, APFloat::rmNearestTiesToEven),
4281 // fcNaN * fcNormal = fcNaN
4282 std::make_tuple(0x7ff8000000000000ull, 0, 0x3ff0000000000000ull, 0,
4283 APFloat::fcNaN, APFloat::rmNearestTiesToEven),
4284 // fcInfinity * fcInfinity = fcInfinity
4285 std::make_tuple(0x7ff0000000000000ull, 0, 0x7ff0000000000000ull, 0,
4286 APFloat::fcInfinity, APFloat::rmNearestTiesToEven),
4287 // fcInfinity * fcZero = fcNaN
4288 std::make_tuple(0x7ff0000000000000ull, 0, 0, 0, APFloat::fcNaN,
4289 APFloat::rmNearestTiesToEven),
4290 // fcInfinity * fcNormal = fcInfinity
4291 std::make_tuple(0x7ff0000000000000ull, 0, 0x3ff0000000000000ull, 0,
4292 APFloat::fcInfinity, APFloat::rmNearestTiesToEven),
4293 // fcZero * fcZero = fcZero
4294 std::make_tuple(0, 0, 0, 0, APFloat::fcZero,
4295 APFloat::rmNearestTiesToEven),
4296 // fcZero * fcNormal = fcZero
4297 std::make_tuple(0, 0, 0x3ff0000000000000ull, 0, APFloat::fcZero,
4298 APFloat::rmNearestTiesToEven),
4299 };
4300
4301 for (auto Tp : Data) {
4302 uint64_t Op1[2], Op2[2];
4303 APFloat::fltCategory Expected;
4304 APFloat::roundingMode RM;
4305 std::tie(Op1[0], Op1[1], Op2[0], Op2[1], Expected, RM) = Tp;
4306
4307 {
4308 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
4309 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
4310 A1.multiply(A2, RM);
4311
4312 EXPECT_EQ(Expected, A1.getCategory())
4313 << formatv("({0:x} + {1:x}) * ({2:x} + {3:x})", Op1[0], Op1[1],
4314 Op2[0], Op2[1])
4315 .str();
4316 }
4317 {
4318 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
4319 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
4320 A2.multiply(A1, RM);
4321
4322 EXPECT_EQ(Expected, A2.getCategory())
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, PPCDoubleDoubleMultiply) {
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/3 * 3 = 1.0
4335 std::make_tuple(0x3fd5555555555555ull, 0x3c75555555555556ull,
4336 0x4008000000000000ull, 0, 0x3ff0000000000000ull, 0,
4337 APFloat::rmNearestTiesToEven),
4338 // (1 + epsilon) * (1 + 0) = fcZero
4339 std::make_tuple(0x3ff0000000000000ull, 0x0000000000000001ull,
4340 0x3ff0000000000000ull, 0, 0x3ff0000000000000ull,
4341 0x0000000000000001ull, APFloat::rmNearestTiesToEven),
4342 // (1 + epsilon) * (1 + epsilon) = 1 + 2 * epsilon
4343 std::make_tuple(0x3ff0000000000000ull, 0x0000000000000001ull,
4344 0x3ff0000000000000ull, 0x0000000000000001ull,
4345 0x3ff0000000000000ull, 0x0000000000000002ull,
4346 APFloat::rmNearestTiesToEven),
4347 // -(1 + epsilon) * (1 + epsilon) = -1
4348 std::make_tuple(0xbff0000000000000ull, 0x0000000000000001ull,
4349 0x3ff0000000000000ull, 0x0000000000000001ull,
4350 0xbff0000000000000ull, 0, APFloat::rmNearestTiesToEven),
4351 // (0.5 + 0) * (1 + 2 * epsilon) = 0.5 + epsilon
4352 std::make_tuple(0x3fe0000000000000ull, 0, 0x3ff0000000000000ull,
4353 0x0000000000000002ull, 0x3fe0000000000000ull,
4354 0x0000000000000001ull, APFloat::rmNearestTiesToEven),
4355 // (0.5 + 0) * (1 + epsilon) = 0.5
4356 std::make_tuple(0x3fe0000000000000ull, 0, 0x3ff0000000000000ull,
4357 0x0000000000000001ull, 0x3fe0000000000000ull, 0,
4358 APFloat::rmNearestTiesToEven),
4359 // __LDBL_MAX__ * (1 + 1 << 106) = inf
4360 std::make_tuple(0x7fefffffffffffffull, 0x7c8ffffffffffffeull,
4361 0x3ff0000000000000ull, 0x3950000000000000ull,
4362 0x7ff0000000000000ull, 0, APFloat::rmNearestTiesToEven),
4363 // __LDBL_MAX__ * (1 + 1 << 107) > __LDBL_MAX__, but not inf, yes =_=|||
4364 std::make_tuple(0x7fefffffffffffffull, 0x7c8ffffffffffffeull,
4365 0x3ff0000000000000ull, 0x3940000000000000ull,
4366 0x7fefffffffffffffull, 0x7c8fffffffffffffull,
4367 APFloat::rmNearestTiesToEven),
4368 // __LDBL_MAX__ * (1 + 1 << 108) = __LDBL_MAX__
4369 std::make_tuple(0x7fefffffffffffffull, 0x7c8ffffffffffffeull,
4370 0x3ff0000000000000ull, 0x3930000000000000ull,
4371 0x7fefffffffffffffull, 0x7c8ffffffffffffeull,
4372 APFloat::rmNearestTiesToEven),
4373 };
4374
4375 for (auto Tp : Data) {
4376 uint64_t Op1[2], Op2[2], Expected[2];
4377 APFloat::roundingMode RM;
4378 std::tie(Op1[0], Op1[1], Op2[0], Op2[1], Expected[0], Expected[1], RM) = Tp;
4379
4380 {
4381 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
4382 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
4383 A1.multiply(A2, RM);
4384
4385 EXPECT_EQ(Expected[0], A1.bitcastToAPInt().getRawData()[0])
4386 << formatv("({0:x} + {1:x}) * ({2:x} + {3:x})", Op1[0], Op1[1],
4387 Op2[0], Op2[1])
4388 .str();
4389 EXPECT_EQ(Expected[1], A1.bitcastToAPInt().getRawData()[1])
4390 << formatv("({0:x} + {1:x}) * ({2:x} + {3:x})", Op1[0], Op1[1],
4391 Op2[0], Op2[1])
4392 .str();
4393 }
4394 {
4395 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
4396 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
4397 A2.multiply(A1, RM);
4398
4399 EXPECT_EQ(Expected[0], A2.bitcastToAPInt().getRawData()[0])
4400 << formatv("({0:x} + {1:x}) * ({2:x} + {3:x})", Op2[0], Op2[1],
4401 Op1[0], Op1[1])
4402 .str();
4403 EXPECT_EQ(Expected[1], A2.bitcastToAPInt().getRawData()[1])
4404 << formatv("({0:x} + {1:x}) * ({2:x} + {3:x})", Op2[0], Op2[1],
4405 Op1[0], Op1[1])
4406 .str();
4407 }
4408 }
4409 }
4410
4411 TEST(APFloatTest, PPCDoubleDoubleDivide) {
4412 using DataType = std::tuple<uint64_t, uint64_t, uint64_t, uint64_t, uint64_t,
4413 uint64_t, APFloat::roundingMode>;
4414 // TODO: Only a sanity check for now. Add more edge cases when the
4415 // double-double algorithm is implemented.
4416 DataType Data[] = {
4417 // 1 / 3 = 1/3
4418 std::make_tuple(0x3ff0000000000000ull, 0, 0x4008000000000000ull, 0,
4419 0x3fd5555555555555ull, 0x3c75555555555556ull,
4420 APFloat::rmNearestTiesToEven),
4421 };
4422
4423 for (auto Tp : Data) {
4424 uint64_t Op1[2], Op2[2], Expected[2];
4425 APFloat::roundingMode RM;
4426 std::tie(Op1[0], Op1[1], Op2[0], Op2[1], Expected[0], Expected[1], RM) = Tp;
4427
4428 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
4429 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
4430 A1.divide(A2, RM);
4431
4432 EXPECT_EQ(Expected[0], A1.bitcastToAPInt().getRawData()[0])
4433 << formatv("({0:x} + {1:x}) / ({2:x} + {3:x})", Op1[0], Op1[1], Op2[0],
4434 Op2[1])
4435 .str();
4436 EXPECT_EQ(Expected[1], A1.bitcastToAPInt().getRawData()[1])
4437 << formatv("({0:x} + {1:x}) / ({2:x} + {3:x})", Op1[0], Op1[1], Op2[0],
4438 Op2[1])
4439 .str();
4440 }
4441 }
4442
4443 TEST(APFloatTest, PPCDoubleDoubleRemainder) {
4444 using DataType =
4445 std::tuple<uint64_t, uint64_t, uint64_t, uint64_t, uint64_t, uint64_t>;
4446 DataType Data[] = {
4447 // remainder(3.0 + 3.0 << 53, 1.25 + 1.25 << 53) = (0.5 + 0.5 << 53)
4448 std::make_tuple(0x4008000000000000ull, 0x3cb8000000000000ull,
4449 0x3ff4000000000000ull, 0x3ca4000000000000ull,
4450 0x3fe0000000000000ull, 0x3c90000000000000ull),
4451 // remainder(3.0 + 3.0 << 53, 1.75 + 1.75 << 53) = (-0.5 - 0.5 << 53)
4452 std::make_tuple(0x4008000000000000ull, 0x3cb8000000000000ull,
4453 0x3ffc000000000000ull, 0x3cac000000000000ull,
4454 0xbfe0000000000000ull, 0xbc90000000000000ull),
4455 };
4456
4457 for (auto Tp : Data) {
4458 uint64_t Op1[2], Op2[2], Expected[2];
4459 std::tie(Op1[0], Op1[1], Op2[0], Op2[1], Expected[0], Expected[1]) = Tp;
4460
4461 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
4462 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
4463 A1.remainder(A2);
4464
4465 EXPECT_EQ(Expected[0], A1.bitcastToAPInt().getRawData()[0])
4466 << formatv("remainder({0:x} + {1:x}), ({2:x} + {3:x}))", Op1[0], Op1[1],
4467 Op2[0], Op2[1])
4468 .str();
4469 EXPECT_EQ(Expected[1], A1.bitcastToAPInt().getRawData()[1])
4470 << formatv("remainder(({0:x} + {1:x}), ({2:x} + {3:x}))", Op1[0],
4471 Op1[1], Op2[0], Op2[1])
4472 .str();
4473 }
4474 }
4475
4476 TEST(APFloatTest, PPCDoubleDoubleMod) {
4477 using DataType =
4478 std::tuple<uint64_t, uint64_t, uint64_t, uint64_t, uint64_t, uint64_t>;
4479 DataType Data[] = {
4480 // mod(3.0 + 3.0 << 53, 1.25 + 1.25 << 53) = (0.5 + 0.5 << 53)
4481 std::make_tuple(0x4008000000000000ull, 0x3cb8000000000000ull,
4482 0x3ff4000000000000ull, 0x3ca4000000000000ull,
4483 0x3fe0000000000000ull, 0x3c90000000000000ull),
4484 // mod(3.0 + 3.0 << 53, 1.75 + 1.75 << 53) = (1.25 + 1.25 << 53)
4485 // 0xbc98000000000000 doesn't seem right, but it's what we currently have.
4486 // TODO: investigate
4487 std::make_tuple(0x4008000000000000ull, 0x3cb8000000000000ull,
4488 0x3ffc000000000000ull, 0x3cac000000000000ull,
4489 0x3ff4000000000001ull, 0xbc98000000000000ull),
4490 };
4491
4492 for (auto Tp : Data) {
4493 uint64_t Op1[2], Op2[2], Expected[2];
4494 std::tie(Op1[0], Op1[1], Op2[0], Op2[1], Expected[0], Expected[1]) = Tp;
4495
4496 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
4497 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
4498 A1.mod(A2);
4499
4500 EXPECT_EQ(Expected[0], A1.bitcastToAPInt().getRawData()[0])
4501 << formatv("fmod(({0:x} + {1:x}), ({2:x} + {3:x}))", Op1[0], Op1[1],
4502 Op2[0], Op2[1])
4503 .str();
4504 EXPECT_EQ(Expected[1], A1.bitcastToAPInt().getRawData()[1])
4505 << formatv("fmod(({0:x} + {1:x}), ({2:x} + {3:x}))", Op1[0], Op1[1],
4506 Op2[0], Op2[1])
4507 .str();
4508 }
4509 }
4510
4511 TEST(APFloatTest, PPCDoubleDoubleFMA) {
4512 // Sanity check for now.
4513 APFloat A(APFloat::PPCDoubleDouble(), "2");
4514 A.fusedMultiplyAdd(APFloat(APFloat::PPCDoubleDouble(), "3"),
4515 APFloat(APFloat::PPCDoubleDouble(), "4"),
4516 APFloat::rmNearestTiesToEven);
4517 EXPECT_EQ(APFloat::cmpEqual,
4518 APFloat(APFloat::PPCDoubleDouble(), "10").compare(A));
4519 }
4520
4521 TEST(APFloatTest, PPCDoubleDoubleRoundToIntegral) {
4522 {
4523 APFloat A(APFloat::PPCDoubleDouble(), "1.5");
4524 A.roundToIntegral(APFloat::rmNearestTiesToEven);
4525 EXPECT_EQ(APFloat::cmpEqual,
4526 APFloat(APFloat::PPCDoubleDouble(), "2").compare(A));
4527 }
4528 {
4529 APFloat A(APFloat::PPCDoubleDouble(), "2.5");
4530 A.roundToIntegral(APFloat::rmNearestTiesToEven);
4531 EXPECT_EQ(APFloat::cmpEqual,
4532 APFloat(APFloat::PPCDoubleDouble(), "2").compare(A));
4533 }
4534 }
4535
4536 TEST(APFloatTest, PPCDoubleDoubleCompare) {
4537 using DataType =
4538 std::tuple<uint64_t, uint64_t, uint64_t, uint64_t, APFloat::cmpResult>;
4539
4540 DataType Data[] = {
4541 // (1 + 0) = (1 + 0)
4542 std::make_tuple(0x3ff0000000000000ull, 0, 0x3ff0000000000000ull, 0,
4543 APFloat::cmpEqual),
4544 // (1 + 0) < (1.00...1 + 0)
4545 std::make_tuple(0x3ff0000000000000ull, 0, 0x3ff0000000000001ull, 0,
4546 APFloat::cmpLessThan),
4547 // (1.00...1 + 0) > (1 + 0)
4548 std::make_tuple(0x3ff0000000000001ull, 0, 0x3ff0000000000000ull, 0,
4549 APFloat::cmpGreaterThan),
4550 // (1 + 0) < (1 + epsilon)
4551 std::make_tuple(0x3ff0000000000000ull, 0, 0x3ff0000000000001ull,
4552 0x0000000000000001ull, APFloat::cmpLessThan),
4553 // NaN != NaN
4554 std::make_tuple(0x7ff8000000000000ull, 0, 0x7ff8000000000000ull, 0,
4555 APFloat::cmpUnordered),
4556 // (1 + 0) != NaN
4557 std::make_tuple(0x3ff0000000000000ull, 0, 0x7ff8000000000000ull, 0,
4558 APFloat::cmpUnordered),
4559 // Inf = Inf
4560 std::make_tuple(0x7ff0000000000000ull, 0, 0x7ff0000000000000ull, 0,
4561 APFloat::cmpEqual),
4562 };
4563
4564 for (auto Tp : Data) {
4565 uint64_t Op1[2], Op2[2];
4566 APFloat::cmpResult Expected;
4567 std::tie(Op1[0], Op1[1], Op2[0], Op2[1], Expected) = Tp;
4568
4569 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
4570 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
4571 EXPECT_EQ(Expected, A1.compare(A2))
4572 << formatv("compare(({0:x} + {1:x}), ({2:x} + {3:x}))", Op1[0], Op1[1],
4573 Op2[0], Op2[1])
4574 .str();
4575 }
4576 }
4577
4578 TEST(APFloatTest, PPCDoubleDoubleBitwiseIsEqual) {
4579 using DataType = std::tuple<uint64_t, uint64_t, uint64_t, uint64_t, bool>;
4580
4581 DataType Data[] = {
4582 // (1 + 0) = (1 + 0)
4583 std::make_tuple(0x3ff0000000000000ull, 0, 0x3ff0000000000000ull, 0, true),
4584 // (1 + 0) != (1.00...1 + 0)
4585 std::make_tuple(0x3ff0000000000000ull, 0, 0x3ff0000000000001ull, 0,
4586 false),
4587 // NaN = NaN
4588 std::make_tuple(0x7ff8000000000000ull, 0, 0x7ff8000000000000ull, 0, true),
4589 // NaN != NaN with a different bit pattern
4590 std::make_tuple(0x7ff8000000000000ull, 0, 0x7ff8000000000000ull,
4591 0x3ff0000000000000ull, false),
4592 // Inf = Inf
4593 std::make_tuple(0x7ff0000000000000ull, 0, 0x7ff0000000000000ull, 0, true),
4594 };
4595
4596 for (auto Tp : Data) {
4597 uint64_t Op1[2], Op2[2];
4598 bool Expected;
4599 std::tie(Op1[0], Op1[1], Op2[0], Op2[1], Expected) = Tp;
4600
4601 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
4602 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
4603 EXPECT_EQ(Expected, A1.bitwiseIsEqual(A2))
4604 << formatv("({0:x} + {1:x}) = ({2:x} + {3:x})", Op1[0], Op1[1], Op2[0],
4605 Op2[1])
4606 .str();
4607 }
4608 }
4609
4610 TEST(APFloatTest, PPCDoubleDoubleHashValue) {
4611 uint64_t Data1[] = {0x3ff0000000000001ull, 0x0000000000000001ull};
4612 uint64_t Data2[] = {0x3ff0000000000001ull, 0};
4613 // The hash values are *hopefully* different.
4614 EXPECT_NE(
4615 hash_value(APFloat(APFloat::PPCDoubleDouble(), APInt(128, 2, Data1))),
4616 hash_value(APFloat(APFloat::PPCDoubleDouble(), APInt(128, 2, Data2))));
4617 }
4618
4619 TEST(APFloatTest, PPCDoubleDoubleChangeSign) {
4620 uint64_t Data[] = {
4621 0x400f000000000000ull, 0xbcb0000000000000ull,
4622 };
4623 APFloat Float(APFloat::PPCDoubleDouble(), APInt(128, 2, Data));
4624 {
4625 APFloat Actual =
4626 APFloat::copySign(Float, APFloat(APFloat::IEEEdouble(), "1"));
4627 EXPECT_EQ(0x400f000000000000ull, Actual.bitcastToAPInt().getRawData()[0]);
4628 EXPECT_EQ(0xbcb0000000000000ull, Actual.bitcastToAPInt().getRawData()[1]);
4629 }
4630 {
4631 APFloat Actual =
4632 APFloat::copySign(Float, APFloat(APFloat::IEEEdouble(), "-1"));
4633 EXPECT_EQ(0xc00f000000000000ull, Actual.bitcastToAPInt().getRawData()[0]);
4634 EXPECT_EQ(0x3cb0000000000000ull, Actual.bitcastToAPInt().getRawData()[1]);
4635 }
4636 }
4637
4638 TEST(APFloatTest, PPCDoubleDoubleFactories) {
4639 {
4640 uint64_t Data[] = {
4641 0, 0,
4642 };
4643 EXPECT_EQ(APInt(128, 2, Data),
4644 APFloat::getZero(APFloat::PPCDoubleDouble()).bitcastToAPInt());
4645 }
4646 {
4647 uint64_t Data[] = {
4648 0x7fefffffffffffffull, 0x7c8ffffffffffffeull,
4649 };
4650 EXPECT_EQ(APInt(128, 2, Data),
4651 APFloat::getLargest(APFloat::PPCDoubleDouble()).bitcastToAPInt());
4652 }
4653 {
4654 uint64_t Data[] = {
4655 0x0000000000000001ull, 0,
4656 };
4657 EXPECT_EQ(
4658 APInt(128, 2, Data),
4659 APFloat::getSmallest(APFloat::PPCDoubleDouble()).bitcastToAPInt());
4660 }
4661 {
4662 uint64_t Data[] = {0x0360000000000000ull, 0};
4663 EXPECT_EQ(APInt(128, 2, Data),
4664 APFloat::getSmallestNormalized(APFloat::PPCDoubleDouble())
4665 .bitcastToAPInt());
4666 }
4667 {
4668 uint64_t Data[] = {
4669 0x8000000000000000ull, 0x0000000000000000ull,
4670 };
4671 EXPECT_EQ(
4672 APInt(128, 2, Data),
4673 APFloat::getZero(APFloat::PPCDoubleDouble(), true).bitcastToAPInt());
4674 }
4675 {
4676 uint64_t Data[] = {
4677 0xffefffffffffffffull, 0xfc8ffffffffffffeull,
4678 };
4679 EXPECT_EQ(
4680 APInt(128, 2, Data),
4681 APFloat::getLargest(APFloat::PPCDoubleDouble(), true).bitcastToAPInt());
4682 }
4683 {
4684 uint64_t Data[] = {
4685 0x8000000000000001ull, 0x0000000000000000ull,
4686 };
4687 EXPECT_EQ(APInt(128, 2, Data),
4688 APFloat::getSmallest(APFloat::PPCDoubleDouble(), true)
4689 .bitcastToAPInt());
4690 }
4691 {
4692 uint64_t Data[] = {
4693 0x8360000000000000ull, 0x0000000000000000ull,
4694 };
4695 EXPECT_EQ(APInt(128, 2, Data),
4696 APFloat::getSmallestNormalized(APFloat::PPCDoubleDouble(), true)
4697 .bitcastToAPInt());
4698 }
4699 EXPECT_TRUE(APFloat::getSmallest(APFloat::PPCDoubleDouble()).isSmallest());
4700 EXPECT_TRUE(APFloat::getLargest(APFloat::PPCDoubleDouble()).isLargest());
4701 }
4702
4703 TEST(APFloatTest, PPCDoubleDoubleIsDenormal) {
4704 EXPECT_TRUE(APFloat::getSmallest(APFloat::PPCDoubleDouble()).isDenormal());
4705 EXPECT_FALSE(APFloat::getLargest(APFloat::PPCDoubleDouble()).isDenormal());
4706 EXPECT_FALSE(
4707 APFloat::getSmallestNormalized(APFloat::PPCDoubleDouble()).isDenormal());
4708 {
4709 // (4 + 3) is not normalized
4710 uint64_t Data[] = {
4711 0x4010000000000000ull, 0x4008000000000000ull,
4712 };
4713 EXPECT_TRUE(
4714 APFloat(APFloat::PPCDoubleDouble(), APInt(128, 2, Data)).isDenormal());
4715 }
4716 }
4717
4718 TEST(APFloatTest, PPCDoubleDoubleScalbn) {
4719 // 3.0 + 3.0 << 53
4720 uint64_t Input[] = {
4721 0x4008000000000000ull, 0x3cb8000000000000ull,
4722 };
4723 APFloat Result =
4724 scalbn(APFloat(APFloat::PPCDoubleDouble(), APInt(128, 2, Input)), 1,
4725 APFloat::rmNearestTiesToEven);
4726 // 6.0 + 6.0 << 53
4727 EXPECT_EQ(0x4018000000000000ull, Result.bitcastToAPInt().getRawData()[0]);
4728 EXPECT_EQ(0x3cc8000000000000ull, Result.bitcastToAPInt().getRawData()[1]);
4729 }
4730
4731 TEST(APFloatTest, PPCDoubleDoubleFrexp) {
4732 // 3.0 + 3.0 << 53
4733 uint64_t Input[] = {
4734 0x4008000000000000ull, 0x3cb8000000000000ull,
4735 };
4736 int Exp;
4737 // 0.75 + 0.75 << 53
4738 APFloat Result =
4739 frexp(APFloat(APFloat::PPCDoubleDouble(), APInt(128, 2, Input)), Exp,
4740 APFloat::rmNearestTiesToEven);
4741 EXPECT_EQ(2, Exp);
4742 EXPECT_EQ(0x3fe8000000000000ull, Result.bitcastToAPInt().getRawData()[0]);
4743 EXPECT_EQ(0x3c98000000000000ull, Result.bitcastToAPInt().getRawData()[1]);
4744 }
4745
4746 TEST(APFloatTest, x87Largest) {
4747 APFloat MaxX87Val = APFloat::getLargest(APFloat::x87DoubleExtended());
4748 EXPECT_TRUE(MaxX87Val.isLargest());
4749 }
4750
4751 TEST(APFloatTest, x87Next) {
4752 APFloat F(APFloat::x87DoubleExtended(), "-1.0");
4753 F.next(false);
4754 EXPECT_TRUE(ilogb(F) == -1);
4755 }
4756
4757 TEST(APFloatTest, ToDouble) {
4758 APFloat DPosZero(0.0);
4759 APFloat DPosZeroToDouble(DPosZero.convertToDouble());
4760 EXPECT_TRUE(DPosZeroToDouble.isPosZero());
4761 APFloat DNegZero(-0.0);
4762 APFloat DNegZeroToDouble(DNegZero.convertToDouble());
4763 EXPECT_TRUE(DNegZeroToDouble.isNegZero());
4764
4765 APFloat DOne(1.0);
4766 EXPECT_EQ(1.0, DOne.convertToDouble());
4767 APFloat DPosLargest = APFloat::getLargest(APFloat::IEEEdouble(), false);
4768 EXPECT_EQ(std::numeric_limits<double>::max(), DPosLargest.convertToDouble());
4769 APFloat DNegLargest = APFloat::getLargest(APFloat::IEEEdouble(), true);
4770 EXPECT_EQ(-std::numeric_limits<double>::max(), DNegLargest.convertToDouble());
4771 APFloat DPosSmallest =
4772 APFloat::getSmallestNormalized(APFloat::IEEEdouble(), false);
4773 EXPECT_EQ(std::numeric_limits<double>::min(), DPosSmallest.convertToDouble());
4774 APFloat DNegSmallest =
4775 APFloat::getSmallestNormalized(APFloat::IEEEdouble(), true);
4776 EXPECT_EQ(-std::numeric_limits<double>::min(),
4777 DNegSmallest.convertToDouble());
4778
4779 APFloat DSmallestDenorm = APFloat::getSmallest(APFloat::IEEEdouble(), false);
4780 EXPECT_EQ(std::numeric_limits<double>::denorm_min(),
4781 DSmallestDenorm.convertToDouble());
4782 APFloat DLargestDenorm(APFloat::IEEEdouble(), "0x0.FFFFFFFFFFFFFp-1022");
4783 EXPECT_EQ(/*0x0.FFFFFFFFFFFFFp-1022*/ 2.225073858507201e-308,
4784 DLargestDenorm.convertToDouble());
4785
4786 APFloat DPosInf = APFloat::getInf(APFloat::IEEEdouble());
4787 EXPECT_EQ(std::numeric_limits<double>::infinity(), DPosInf.convertToDouble());
4788 APFloat DNegInf = APFloat::getInf(APFloat::IEEEdouble(), true);
4789 EXPECT_EQ(-std::numeric_limits<double>::infinity(),
4790 DNegInf.convertToDouble());
4791 APFloat DQNaN = APFloat::getQNaN(APFloat::IEEEdouble());
4792 EXPECT_TRUE(std::isnan(DQNaN.convertToDouble()));
4793
4794 APFloat FPosZero(0.0F);
4795 APFloat FPosZeroToDouble(FPosZero.convertToDouble());
4796 EXPECT_TRUE(FPosZeroToDouble.isPosZero());
4797 APFloat FNegZero(-0.0F);
4798 APFloat FNegZeroToDouble(FNegZero.convertToDouble());
4799 EXPECT_TRUE(FNegZeroToDouble.isNegZero());
4800
4801 APFloat FOne(1.0F);
4802 EXPECT_EQ(1.0, FOne.convertToDouble());
4803 APFloat FPosLargest = APFloat::getLargest(APFloat::IEEEsingle(), false);
4804 EXPECT_EQ(std::numeric_limits<float>::max(), FPosLargest.convertToDouble());
4805 APFloat FNegLargest = APFloat::getLargest(APFloat::IEEEsingle(), true);
4806 EXPECT_EQ(-std::numeric_limits<float>::max(), FNegLargest.convertToDouble());
4807 APFloat FPosSmallest =
4808 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), false);
4809 EXPECT_EQ(std::numeric_limits<float>::min(), FPosSmallest.convertToDouble());
4810 APFloat FNegSmallest =
4811 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), true);
4812 EXPECT_EQ(-std::numeric_limits<float>::min(), FNegSmallest.convertToDouble());
4813
4814 APFloat FSmallestDenorm = APFloat::getSmallest(APFloat::IEEEsingle(), false);
4815 EXPECT_EQ(std::numeric_limits<float>::denorm_min(),
4816 FSmallestDenorm.convertToDouble());
4817 APFloat FLargestDenorm(APFloat::IEEEdouble(), "0x0.FFFFFEp-126");
4818 EXPECT_EQ(/*0x0.FFFFFEp-126*/ 1.1754942106924411e-38,
4819 FLargestDenorm.convertToDouble());
4820
4821 APFloat FPosInf = APFloat::getInf(APFloat::IEEEsingle());
4822 EXPECT_EQ(std::numeric_limits<double>::infinity(), FPosInf.convertToDouble());
4823 APFloat FNegInf = APFloat::getInf(APFloat::IEEEsingle(), true);
4824 EXPECT_EQ(-std::numeric_limits<double>::infinity(),
4825 FNegInf.convertToDouble());
4826 APFloat FQNaN = APFloat::getQNaN(APFloat::IEEEsingle());
4827 EXPECT_TRUE(std::isnan(FQNaN.convertToDouble()));
4828
4829 APFloat HPosZero = APFloat::getZero(APFloat::IEEEhalf());
4830 APFloat HPosZeroToDouble(HPosZero.convertToDouble());
4831 EXPECT_TRUE(HPosZeroToDouble.isPosZero());
4832 APFloat HNegZero = APFloat::getZero(APFloat::IEEEhalf(), true);
4833 APFloat HNegZeroToDouble(HNegZero.convertToDouble());
4834 EXPECT_TRUE(HNegZeroToDouble.isNegZero());
4835
4836 APFloat HOne(APFloat::IEEEhalf(), "1.0");
4837 EXPECT_EQ(1.0, HOne.convertToDouble());
4838 APFloat HPosLargest = APFloat::getLargest(APFloat::IEEEhalf(), false);
4839 EXPECT_EQ(65504.0, HPosLargest.convertToDouble());
4840 APFloat HNegLargest = APFloat::getLargest(APFloat::IEEEhalf(), true);
4841 EXPECT_EQ(-65504.0, HNegLargest.convertToDouble());
4842 APFloat HPosSmallest =
4843 APFloat::getSmallestNormalized(APFloat::IEEEhalf(), false);
4844 EXPECT_EQ(/*0x1.p-14*/ 6.103515625e-05, HPosSmallest.convertToDouble());
4845 APFloat HNegSmallest =
4846 APFloat::getSmallestNormalized(APFloat::IEEEhalf(), true);
4847 EXPECT_EQ(/*-0x1.p-14*/ -6.103515625e-05, HNegSmallest.convertToDouble());
4848
4849 APFloat HSmallestDenorm = APFloat::getSmallest(APFloat::IEEEhalf(), false);
4850 EXPECT_EQ(/*0x1.p-24*/ 5.960464477539063e-08,
4851 HSmallestDenorm.convertToDouble());
4852 APFloat HLargestDenorm(APFloat::IEEEhalf(), "0x1.FFCp-14");
4853 EXPECT_EQ(/*0x1.FFCp-14*/ 0.00012201070785522461,
4854 HLargestDenorm.convertToDouble());
4855
4856 APFloat HPosInf = APFloat::getInf(APFloat::IEEEhalf());
4857 EXPECT_EQ(std::numeric_limits<double>::infinity(), HPosInf.convertToDouble());
4858 APFloat HNegInf = APFloat::getInf(APFloat::IEEEhalf(), true);
4859 EXPECT_EQ(-std::numeric_limits<double>::infinity(),
4860 HNegInf.convertToDouble());
4861 APFloat HQNaN = APFloat::getQNaN(APFloat::IEEEhalf());
4862 EXPECT_TRUE(std::isnan(HQNaN.convertToDouble()));
4863
4864 APFloat BPosZero = APFloat::getZero(APFloat::IEEEhalf());
4865 APFloat BPosZeroToDouble(BPosZero.convertToDouble());
4866 EXPECT_TRUE(BPosZeroToDouble.isPosZero());
4867 APFloat BNegZero = APFloat::getZero(APFloat::IEEEhalf(), true);
4868 APFloat BNegZeroToDouble(BNegZero.convertToDouble());
4869 EXPECT_TRUE(BNegZeroToDouble.isNegZero());
4870
4871 APFloat BOne(APFloat::BFloat(), "1.0");
4872 EXPECT_EQ(1.0, BOne.convertToDouble());
4873 APFloat BPosLargest = APFloat::getLargest(APFloat::BFloat(), false);
4874 EXPECT_EQ(/*0x1.FEp127*/ 3.3895313892515355e+38,
4875 BPosLargest.convertToDouble());
4876 APFloat BNegLargest = APFloat::getLargest(APFloat::BFloat(), true);
4877 EXPECT_EQ(/*-0x1.FEp127*/ -3.3895313892515355e+38,
4878 BNegLargest.convertToDouble());
4879 APFloat BPosSmallest =
4880 APFloat::getSmallestNormalized(APFloat::BFloat(), false);
4881 EXPECT_EQ(/*0x1.p-126*/ 1.1754943508222875e-38,
4882 BPosSmallest.convertToDouble());
4883 APFloat BNegSmallest =
4884 APFloat::getSmallestNormalized(APFloat::BFloat(), true);
4885 EXPECT_EQ(/*-0x1.p-126*/ -1.1754943508222875e-38,
4886 BNegSmallest.convertToDouble());
4887
4888 APFloat BSmallestDenorm = APFloat::getSmallest(APFloat::BFloat(), false);
4889 EXPECT_EQ(/*0x1.p-133*/ 9.183549615799121e-41,
4890 BSmallestDenorm.convertToDouble());
4891 APFloat BLargestDenorm(APFloat::BFloat(), "0x1.FCp-127");
4892 EXPECT_EQ(/*0x1.FCp-127*/ 1.1663108012064884e-38,
4893 BLargestDenorm.convertToDouble());
4894
4895 APFloat BPosInf = APFloat::getInf(APFloat::BFloat());
4896 EXPECT_EQ(std::numeric_limits<double>::infinity(), BPosInf.convertToDouble());
4897 APFloat BNegInf = APFloat::getInf(APFloat::BFloat(), true);
4898 EXPECT_EQ(-std::numeric_limits<double>::infinity(),
4899 BNegInf.convertToDouble());
4900 APFloat BQNaN = APFloat::getQNaN(APFloat::BFloat());
4901 EXPECT_TRUE(std::isnan(BQNaN.convertToDouble()));
4902 }
4903
4904 TEST(APFloatTest, ToFloat) {
4905 APFloat FPosZero(0.0F);
4906 APFloat FPosZeroToFloat(FPosZero.convertToFloat());
4907 EXPECT_TRUE(FPosZeroToFloat.isPosZero());
4908 APFloat FNegZero(-0.0F);
4909 APFloat FNegZeroToFloat(FNegZero.convertToFloat());
4910 EXPECT_TRUE(FNegZeroToFloat.isNegZero());
4911
4912 APFloat FOne(1.0F);
4913 EXPECT_EQ(1.0F, FOne.convertToFloat());
4914 APFloat FPosLargest = APFloat::getLargest(APFloat::IEEEsingle(), false);
4915 EXPECT_EQ(std::numeric_limits<float>::max(), FPosLargest.convertToFloat());
4916 APFloat FNegLargest = APFloat::getLargest(APFloat::IEEEsingle(), true);
4917 EXPECT_EQ(-std::numeric_limits<float>::max(), FNegLargest.convertToFloat());
4918 APFloat FPosSmallest =
4919 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), false);
4920 EXPECT_EQ(std::numeric_limits<float>::min(), FPosSmallest.convertToFloat());
4921 APFloat FNegSmallest =
4922 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), true);
4923 EXPECT_EQ(-std::numeric_limits<float>::min(), FNegSmallest.convertToFloat());
4924
4925 APFloat FSmallestDenorm = APFloat::getSmallest(APFloat::IEEEsingle(), false);
4926 EXPECT_EQ(std::numeric_limits<float>::denorm_min(),
4927 FSmallestDenorm.convertToFloat());
4928 APFloat FLargestDenorm(APFloat::IEEEsingle(), "0x1.FFFFFEp-126");
4929 EXPECT_EQ(/*0x1.FFFFFEp-126*/ 2.3509885615147286e-38F,
4930 FLargestDenorm.convertToFloat());
4931
4932 APFloat FPosInf = APFloat::getInf(APFloat::IEEEsingle());
4933 EXPECT_EQ(std::numeric_limits<float>::infinity(), FPosInf.convertToFloat());
4934 APFloat FNegInf = APFloat::getInf(APFloat::IEEEsingle(), true);
4935 EXPECT_EQ(-std::numeric_limits<float>::infinity(), FNegInf.convertToFloat());
4936 APFloat FQNaN = APFloat::getQNaN(APFloat::IEEEsingle());
4937 EXPECT_TRUE(std::isnan(FQNaN.convertToFloat()));
4938
4939 APFloat HPosZero = APFloat::getZero(APFloat::IEEEhalf());
4940 APFloat HPosZeroToFloat(HPosZero.convertToFloat());
4941 EXPECT_TRUE(HPosZeroToFloat.isPosZero());
4942 APFloat HNegZero = APFloat::getZero(APFloat::IEEEhalf(), true);
4943 APFloat HNegZeroToFloat(HNegZero.convertToFloat());
4944 EXPECT_TRUE(HNegZeroToFloat.isNegZero());
4945
4946 APFloat HOne(APFloat::IEEEhalf(), "1.0");
4947 EXPECT_EQ(1.0F, HOne.convertToFloat());
4948 APFloat HPosLargest = APFloat::getLargest(APFloat::IEEEhalf(), false);
4949 EXPECT_EQ(/*0x1.FFCp15*/ 65504.0F, HPosLargest.convertToFloat());
4950 APFloat HNegLargest = APFloat::getLargest(APFloat::IEEEhalf(), true);
4951 EXPECT_EQ(/*-0x1.FFCp15*/ -65504.0F, HNegLargest.convertToFloat());
4952 APFloat HPosSmallest =
4953 APFloat::getSmallestNormalized(APFloat::IEEEhalf(), false);
4954 EXPECT_EQ(/*0x1.p-14*/ 6.103515625e-05F, HPosSmallest.convertToFloat());
4955 APFloat HNegSmallest =
4956 APFloat::getSmallestNormalized(APFloat::IEEEhalf(), true);
4957 EXPECT_EQ(/*-0x1.p-14*/ -6.103515625e-05F, HNegSmallest.convertToFloat());
4958
4959 APFloat HSmallestDenorm = APFloat::getSmallest(APFloat::IEEEhalf(), false);
4960 EXPECT_EQ(/*0x1.p-24*/ 5.960464477539063e-08F,
4961 HSmallestDenorm.convertToFloat());
4962 APFloat HLargestDenorm(APFloat::IEEEhalf(), "0x1.FFCp-14");
4963 EXPECT_EQ(/*0x1.FFCp-14*/ 0.00012201070785522461F,
4964 HLargestDenorm.convertToFloat());
4965
4966 APFloat HPosInf = APFloat::getInf(APFloat::IEEEhalf());
4967 EXPECT_EQ(std::numeric_limits<float>::infinity(), HPosInf.convertToFloat());
4968 APFloat HNegInf = APFloat::getInf(APFloat::IEEEhalf(), true);
4969 EXPECT_EQ(-std::numeric_limits<float>::infinity(), HNegInf.convertToFloat());
4970 APFloat HQNaN = APFloat::getQNaN(APFloat::IEEEhalf());
4971 EXPECT_TRUE(std::isnan(HQNaN.convertToFloat()));
4972
4973 APFloat BPosZero = APFloat::getZero(APFloat::BFloat());
4974 APFloat BPosZeroToDouble(BPosZero.convertToFloat());
4975 EXPECT_TRUE(BPosZeroToDouble.isPosZero());
4976 APFloat BNegZero = APFloat::getZero(APFloat::BFloat(), true);
4977 APFloat BNegZeroToDouble(BNegZero.convertToFloat());
4978 EXPECT_TRUE(BNegZeroToDouble.isNegZero());
4979
4980 APFloat BOne(APFloat::BFloat(), "1.0");
4981 EXPECT_EQ(1.0F, BOne.convertToFloat());
4982 APFloat BPosLargest = APFloat::getLargest(APFloat::BFloat(), false);
4983 EXPECT_EQ(/*0x1.FEp127*/ 3.3895313892515355e+38F,
4984 BPosLargest.convertToFloat());
4985 APFloat BNegLargest = APFloat::getLargest(APFloat::BFloat(), true);
4986 EXPECT_EQ(/*-0x1.FEp127*/ -3.3895313892515355e+38F,
4987 BNegLargest.convertToFloat());
4988 APFloat BPosSmallest =
4989 APFloat::getSmallestNormalized(APFloat::BFloat(), false);
4990 EXPECT_EQ(/*0x1.p-126*/ 1.1754943508222875e-38F,
4991 BPosSmallest.convertToFloat());
4992 APFloat BNegSmallest =
4993 APFloat::getSmallestNormalized(APFloat::BFloat(), true);
4994 EXPECT_EQ(/*-0x1.p-126*/ -1.1754943508222875e-38F,
4995 BNegSmallest.convertToFloat());
4996
4997 APFloat BSmallestDenorm = APFloat::getSmallest(APFloat::BFloat(), false);
4998 EXPECT_EQ(/*0x1.p-133*/ 9.183549615799121e-41F,
4999 BSmallestDenorm.convertToFloat());
5000 APFloat BLargestDenorm(APFloat::BFloat(), "0x1.FCp-127");
5001 EXPECT_EQ(/*0x1.FCp-127*/ 1.1663108012064884e-38F,
5002 BLargestDenorm.convertToFloat());
5003
5004 APFloat BPosInf = APFloat::getInf(APFloat::BFloat());
5005 EXPECT_EQ(std::numeric_limits<float>::infinity(), BPosInf.convertToFloat());
5006 APFloat BNegInf = APFloat::getInf(APFloat::BFloat(), true);
5007 EXPECT_EQ(-std::numeric_limits<float>::infinity(), BNegInf.convertToFloat());
5008 APFloat BQNaN = APFloat::getQNaN(APFloat::BFloat());
5009 EXPECT_TRUE(std::isnan(BQNaN.convertToFloat()));
5010 }
5011 }
LLVM monorepo