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
convertToErrorFromString(StringRef Str)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
convertToDoubleFromString(StringRef Str)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
convertToString(double d,unsigned Prec,unsigned Pad,bool Tr=true)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
TEST(APFloatTest,isSignaling)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
TEST(APFloatTest,next)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
TEST(APFloatTest,FMA)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
TEST(APFloatTest,MinNum)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
TEST(APFloatTest,MaxNum)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
TEST(APFloatTest,Minimum)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
TEST(APFloatTest,Maximum)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
TEST(APFloatTest,Denormal)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
TEST(APFloatTest,Zero)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
TEST(APFloatTest,DecimalStringsWithoutNullTerminators)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
TEST(APFloatTest,fromZeroDecimalString)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
TEST(APFloatTest,fromZeroDecimalSingleExponentString)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
TEST(APFloatTest,fromZeroDecimalLargeExponentString)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
TEST(APFloatTest,fromZeroHexadecimalString)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
TEST(APFloatTest,fromDecimalString)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
TEST(APFloatTest,fromToStringSpecials)922 TEST(APFloatTest, fromToStringSpecials) {
923 auto expects = [] (const char *first, const char *second) {
924 std::string roundtrip = convertToString(convertToDoubleFromString(second), 0, 3);
925 EXPECT_STREQ(first, roundtrip.c_str());
926 };
927 expects("+Inf", "+Inf");
928 expects("+Inf", "INFINITY");
929 expects("+Inf", "inf");
930 expects("-Inf", "-Inf");
931 expects("-Inf", "-INFINITY");
932 expects("-Inf", "-inf");
933 expects("NaN", "NaN");
934 expects("NaN", "nan");
935 expects("NaN", "-NaN");
936 expects("NaN", "-nan");
937 }
938
TEST(APFloatTest,fromHexadecimalString)939 TEST(APFloatTest, fromHexadecimalString) {
940 EXPECT_EQ( 1.0, APFloat(APFloat::IEEEdouble(), "0x1p0").convertToDouble());
941 EXPECT_EQ(+1.0, APFloat(APFloat::IEEEdouble(), "+0x1p0").convertToDouble());
942 EXPECT_EQ(-1.0, APFloat(APFloat::IEEEdouble(), "-0x1p0").convertToDouble());
943
944 EXPECT_EQ( 1.0, APFloat(APFloat::IEEEdouble(), "0x1p+0").convertToDouble());
945 EXPECT_EQ(+1.0, APFloat(APFloat::IEEEdouble(), "+0x1p+0").convertToDouble());
946 EXPECT_EQ(-1.0, APFloat(APFloat::IEEEdouble(), "-0x1p+0").convertToDouble());
947
948 EXPECT_EQ( 1.0, APFloat(APFloat::IEEEdouble(), "0x1p-0").convertToDouble());
949 EXPECT_EQ(+1.0, APFloat(APFloat::IEEEdouble(), "+0x1p-0").convertToDouble());
950 EXPECT_EQ(-1.0, APFloat(APFloat::IEEEdouble(), "-0x1p-0").convertToDouble());
951
952
953 EXPECT_EQ( 2.0, APFloat(APFloat::IEEEdouble(), "0x1p1").convertToDouble());
954 EXPECT_EQ(+2.0, APFloat(APFloat::IEEEdouble(), "+0x1p1").convertToDouble());
955 EXPECT_EQ(-2.0, APFloat(APFloat::IEEEdouble(), "-0x1p1").convertToDouble());
956
957 EXPECT_EQ( 2.0, APFloat(APFloat::IEEEdouble(), "0x1p+1").convertToDouble());
958 EXPECT_EQ(+2.0, APFloat(APFloat::IEEEdouble(), "+0x1p+1").convertToDouble());
959 EXPECT_EQ(-2.0, APFloat(APFloat::IEEEdouble(), "-0x1p+1").convertToDouble());
960
961 EXPECT_EQ( 0.5, APFloat(APFloat::IEEEdouble(), "0x1p-1").convertToDouble());
962 EXPECT_EQ(+0.5, APFloat(APFloat::IEEEdouble(), "+0x1p-1").convertToDouble());
963 EXPECT_EQ(-0.5, APFloat(APFloat::IEEEdouble(), "-0x1p-1").convertToDouble());
964
965
966 EXPECT_EQ( 3.0, APFloat(APFloat::IEEEdouble(), "0x1.8p1").convertToDouble());
967 EXPECT_EQ(+3.0, APFloat(APFloat::IEEEdouble(), "+0x1.8p1").convertToDouble());
968 EXPECT_EQ(-3.0, APFloat(APFloat::IEEEdouble(), "-0x1.8p1").convertToDouble());
969
970 EXPECT_EQ( 3.0, APFloat(APFloat::IEEEdouble(), "0x1.8p+1").convertToDouble());
971 EXPECT_EQ(+3.0, APFloat(APFloat::IEEEdouble(), "+0x1.8p+1").convertToDouble());
972 EXPECT_EQ(-3.0, APFloat(APFloat::IEEEdouble(), "-0x1.8p+1").convertToDouble());
973
974 EXPECT_EQ( 0.75, APFloat(APFloat::IEEEdouble(), "0x1.8p-1").convertToDouble());
975 EXPECT_EQ(+0.75, APFloat(APFloat::IEEEdouble(), "+0x1.8p-1").convertToDouble());
976 EXPECT_EQ(-0.75, APFloat(APFloat::IEEEdouble(), "-0x1.8p-1").convertToDouble());
977
978
979 EXPECT_EQ( 8192.0, APFloat(APFloat::IEEEdouble(), "0x1000.000p1").convertToDouble());
980 EXPECT_EQ(+8192.0, APFloat(APFloat::IEEEdouble(), "+0x1000.000p1").convertToDouble());
981 EXPECT_EQ(-8192.0, APFloat(APFloat::IEEEdouble(), "-0x1000.000p1").convertToDouble());
982
983 EXPECT_EQ( 8192.0, APFloat(APFloat::IEEEdouble(), "0x1000.000p+1").convertToDouble());
984 EXPECT_EQ(+8192.0, APFloat(APFloat::IEEEdouble(), "+0x1000.000p+1").convertToDouble());
985 EXPECT_EQ(-8192.0, APFloat(APFloat::IEEEdouble(), "-0x1000.000p+1").convertToDouble());
986
987 EXPECT_EQ( 2048.0, APFloat(APFloat::IEEEdouble(), "0x1000.000p-1").convertToDouble());
988 EXPECT_EQ(+2048.0, APFloat(APFloat::IEEEdouble(), "+0x1000.000p-1").convertToDouble());
989 EXPECT_EQ(-2048.0, APFloat(APFloat::IEEEdouble(), "-0x1000.000p-1").convertToDouble());
990
991
992 EXPECT_EQ( 8192.0, APFloat(APFloat::IEEEdouble(), "0x1000p1").convertToDouble());
993 EXPECT_EQ(+8192.0, APFloat(APFloat::IEEEdouble(), "+0x1000p1").convertToDouble());
994 EXPECT_EQ(-8192.0, APFloat(APFloat::IEEEdouble(), "-0x1000p1").convertToDouble());
995
996 EXPECT_EQ( 8192.0, APFloat(APFloat::IEEEdouble(), "0x1000p+1").convertToDouble());
997 EXPECT_EQ(+8192.0, APFloat(APFloat::IEEEdouble(), "+0x1000p+1").convertToDouble());
998 EXPECT_EQ(-8192.0, APFloat(APFloat::IEEEdouble(), "-0x1000p+1").convertToDouble());
999
1000 EXPECT_EQ( 2048.0, APFloat(APFloat::IEEEdouble(), "0x1000p-1").convertToDouble());
1001 EXPECT_EQ(+2048.0, APFloat(APFloat::IEEEdouble(), "+0x1000p-1").convertToDouble());
1002 EXPECT_EQ(-2048.0, APFloat(APFloat::IEEEdouble(), "-0x1000p-1").convertToDouble());
1003
1004
1005 EXPECT_EQ( 16384.0, APFloat(APFloat::IEEEdouble(), "0x10p10").convertToDouble());
1006 EXPECT_EQ(+16384.0, APFloat(APFloat::IEEEdouble(), "+0x10p10").convertToDouble());
1007 EXPECT_EQ(-16384.0, APFloat(APFloat::IEEEdouble(), "-0x10p10").convertToDouble());
1008
1009 EXPECT_EQ( 16384.0, APFloat(APFloat::IEEEdouble(), "0x10p+10").convertToDouble());
1010 EXPECT_EQ(+16384.0, APFloat(APFloat::IEEEdouble(), "+0x10p+10").convertToDouble());
1011 EXPECT_EQ(-16384.0, APFloat(APFloat::IEEEdouble(), "-0x10p+10").convertToDouble());
1012
1013 EXPECT_EQ( 0.015625, APFloat(APFloat::IEEEdouble(), "0x10p-10").convertToDouble());
1014 EXPECT_EQ(+0.015625, APFloat(APFloat::IEEEdouble(), "+0x10p-10").convertToDouble());
1015 EXPECT_EQ(-0.015625, APFloat(APFloat::IEEEdouble(), "-0x10p-10").convertToDouble());
1016
1017 EXPECT_EQ(1.0625, APFloat(APFloat::IEEEdouble(), "0x1.1p0").convertToDouble());
1018 EXPECT_EQ(1.0, APFloat(APFloat::IEEEdouble(), "0x1p0").convertToDouble());
1019
1020 EXPECT_EQ(convertToDoubleFromString("0x1p-150"),
1021 convertToDoubleFromString("+0x800000000000000001.p-221"));
1022 EXPECT_EQ(2251799813685248.5,
1023 convertToDoubleFromString("0x80000000000004000000.010p-28"));
1024 }
1025
TEST(APFloatTest,toString)1026 TEST(APFloatTest, toString) {
1027 ASSERT_EQ("10", convertToString(10.0, 6, 3));
1028 ASSERT_EQ("1.0E+1", convertToString(10.0, 6, 0));
1029 ASSERT_EQ("10100", convertToString(1.01E+4, 5, 2));
1030 ASSERT_EQ("1.01E+4", convertToString(1.01E+4, 4, 2));
1031 ASSERT_EQ("1.01E+4", convertToString(1.01E+4, 5, 1));
1032 ASSERT_EQ("0.0101", convertToString(1.01E-2, 5, 2));
1033 ASSERT_EQ("0.0101", convertToString(1.01E-2, 4, 2));
1034 ASSERT_EQ("1.01E-2", convertToString(1.01E-2, 5, 1));
1035 ASSERT_EQ("0.78539816339744828", convertToString(0.78539816339744830961, 0, 3));
1036 ASSERT_EQ("4.9406564584124654E-324", convertToString(4.9406564584124654e-324, 0, 3));
1037 ASSERT_EQ("873.18340000000001", convertToString(873.1834, 0, 1));
1038 ASSERT_EQ("8.7318340000000001E+2", convertToString(873.1834, 0, 0));
1039 ASSERT_EQ("1.7976931348623157E+308", convertToString(1.7976931348623157E+308, 0, 0));
1040 ASSERT_EQ("10", convertToString(10.0, 6, 3, false));
1041 ASSERT_EQ("1.000000e+01", convertToString(10.0, 6, 0, false));
1042 ASSERT_EQ("10100", convertToString(1.01E+4, 5, 2, false));
1043 ASSERT_EQ("1.0100e+04", convertToString(1.01E+4, 4, 2, false));
1044 ASSERT_EQ("1.01000e+04", convertToString(1.01E+4, 5, 1, false));
1045 ASSERT_EQ("0.0101", convertToString(1.01E-2, 5, 2, false));
1046 ASSERT_EQ("0.0101", convertToString(1.01E-2, 4, 2, false));
1047 ASSERT_EQ("1.01000e-02", convertToString(1.01E-2, 5, 1, false));
1048 ASSERT_EQ("0.78539816339744828",
1049 convertToString(0.78539816339744830961, 0, 3, false));
1050 ASSERT_EQ("4.94065645841246540e-324",
1051 convertToString(4.9406564584124654e-324, 0, 3, false));
1052 ASSERT_EQ("873.18340000000001", convertToString(873.1834, 0, 1, false));
1053 ASSERT_EQ("8.73183400000000010e+02", convertToString(873.1834, 0, 0, false));
1054 ASSERT_EQ("1.79769313486231570e+308",
1055 convertToString(1.7976931348623157E+308, 0, 0, false));
1056
1057 {
1058 SmallString<64> Str;
1059 APFloat UnnormalZero(APFloat::x87DoubleExtended(), APInt(80, {0, 1}));
1060 UnnormalZero.toString(Str);
1061 ASSERT_EQ("NaN", Str);
1062 }
1063 }
1064
TEST(APFloatTest,toInteger)1065 TEST(APFloatTest, toInteger) {
1066 bool isExact = false;
1067 APSInt result(5, /*isUnsigned=*/true);
1068
1069 EXPECT_EQ(APFloat::opOK,
1070 APFloat(APFloat::IEEEdouble(), "10")
1071 .convertToInteger(result, APFloat::rmTowardZero, &isExact));
1072 EXPECT_TRUE(isExact);
1073 EXPECT_EQ(APSInt(APInt(5, 10), true), result);
1074
1075 EXPECT_EQ(APFloat::opInvalidOp,
1076 APFloat(APFloat::IEEEdouble(), "-10")
1077 .convertToInteger(result, APFloat::rmTowardZero, &isExact));
1078 EXPECT_FALSE(isExact);
1079 EXPECT_EQ(APSInt::getMinValue(5, true), result);
1080
1081 EXPECT_EQ(APFloat::opInvalidOp,
1082 APFloat(APFloat::IEEEdouble(), "32")
1083 .convertToInteger(result, APFloat::rmTowardZero, &isExact));
1084 EXPECT_FALSE(isExact);
1085 EXPECT_EQ(APSInt::getMaxValue(5, true), result);
1086
1087 EXPECT_EQ(APFloat::opInexact,
1088 APFloat(APFloat::IEEEdouble(), "7.9")
1089 .convertToInteger(result, APFloat::rmTowardZero, &isExact));
1090 EXPECT_FALSE(isExact);
1091 EXPECT_EQ(APSInt(APInt(5, 7), true), result);
1092
1093 result.setIsUnsigned(false);
1094 EXPECT_EQ(APFloat::opOK,
1095 APFloat(APFloat::IEEEdouble(), "-10")
1096 .convertToInteger(result, APFloat::rmTowardZero, &isExact));
1097 EXPECT_TRUE(isExact);
1098 EXPECT_EQ(APSInt(APInt(5, -10, true), false), result);
1099
1100 EXPECT_EQ(APFloat::opInvalidOp,
1101 APFloat(APFloat::IEEEdouble(), "-17")
1102 .convertToInteger(result, APFloat::rmTowardZero, &isExact));
1103 EXPECT_FALSE(isExact);
1104 EXPECT_EQ(APSInt::getMinValue(5, false), result);
1105
1106 EXPECT_EQ(APFloat::opInvalidOp,
1107 APFloat(APFloat::IEEEdouble(), "16")
1108 .convertToInteger(result, APFloat::rmTowardZero, &isExact));
1109 EXPECT_FALSE(isExact);
1110 EXPECT_EQ(APSInt::getMaxValue(5, false), result);
1111 }
1112
nanbitsFromAPInt(const fltSemantics & Sem,bool SNaN,bool Negative,uint64_t payload)1113 static APInt nanbitsFromAPInt(const fltSemantics &Sem, bool SNaN, bool Negative,
1114 uint64_t payload) {
1115 APInt appayload(64, payload);
1116 if (SNaN)
1117 return APFloat::getSNaN(Sem, Negative, &appayload).bitcastToAPInt();
1118 else
1119 return APFloat::getQNaN(Sem, Negative, &appayload).bitcastToAPInt();
1120 }
1121
TEST(APFloatTest,makeNaN)1122 TEST(APFloatTest, makeNaN) {
1123 const struct {
1124 uint64_t expected;
1125 const fltSemantics &semantics;
1126 bool SNaN;
1127 bool Negative;
1128 uint64_t payload;
1129 } tests[] = {
1130 /* expected semantics SNaN Neg payload */
1131 { 0x7fc00000ULL, APFloat::IEEEsingle(), false, false, 0x00000000ULL },
1132 { 0xffc00000ULL, APFloat::IEEEsingle(), false, true, 0x00000000ULL },
1133 { 0x7fc0ae72ULL, APFloat::IEEEsingle(), false, false, 0x0000ae72ULL },
1134 { 0x7fffae72ULL, APFloat::IEEEsingle(), false, false, 0xffffae72ULL },
1135 { 0x7fdaae72ULL, APFloat::IEEEsingle(), false, false, 0x00daae72ULL },
1136 { 0x7fa00000ULL, APFloat::IEEEsingle(), true, false, 0x00000000ULL },
1137 { 0xffa00000ULL, APFloat::IEEEsingle(), true, true, 0x00000000ULL },
1138 { 0x7f80ae72ULL, APFloat::IEEEsingle(), true, false, 0x0000ae72ULL },
1139 { 0x7fbfae72ULL, APFloat::IEEEsingle(), true, false, 0xffffae72ULL },
1140 { 0x7f9aae72ULL, APFloat::IEEEsingle(), true, false, 0x001aae72ULL },
1141 { 0x7ff8000000000000ULL, APFloat::IEEEdouble(), false, false, 0x0000000000000000ULL },
1142 { 0xfff8000000000000ULL, APFloat::IEEEdouble(), false, true, 0x0000000000000000ULL },
1143 { 0x7ff800000000ae72ULL, APFloat::IEEEdouble(), false, false, 0x000000000000ae72ULL },
1144 { 0x7fffffffffffae72ULL, APFloat::IEEEdouble(), false, false, 0xffffffffffffae72ULL },
1145 { 0x7ffdaaaaaaaaae72ULL, APFloat::IEEEdouble(), false, false, 0x000daaaaaaaaae72ULL },
1146 { 0x7ff4000000000000ULL, APFloat::IEEEdouble(), true, false, 0x0000000000000000ULL },
1147 { 0xfff4000000000000ULL, APFloat::IEEEdouble(), true, true, 0x0000000000000000ULL },
1148 { 0x7ff000000000ae72ULL, APFloat::IEEEdouble(), true, false, 0x000000000000ae72ULL },
1149 { 0x7ff7ffffffffae72ULL, APFloat::IEEEdouble(), true, false, 0xffffffffffffae72ULL },
1150 { 0x7ff1aaaaaaaaae72ULL, APFloat::IEEEdouble(), true, false, 0x0001aaaaaaaaae72ULL },
1151 };
1152
1153 for (const auto &t : tests) {
1154 ASSERT_EQ(t.expected, nanbitsFromAPInt(t.semantics, t.SNaN, t.Negative, t.payload));
1155 }
1156 }
1157
1158 #ifdef GTEST_HAS_DEATH_TEST
1159 #ifndef NDEBUG
TEST(APFloatTest,SemanticsDeath)1160 TEST(APFloatTest, SemanticsDeath) {
1161 EXPECT_DEATH(APFloat(APFloat::IEEEsingle(), 0).convertToDouble(), "Float semantics are not IEEEdouble");
1162 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), 0).convertToFloat(), "Float semantics are not IEEEsingle");
1163 }
1164 #endif
1165 #endif
1166
TEST(APFloatTest,StringDecimalError)1167 TEST(APFloatTest, StringDecimalError) {
1168 EXPECT_EQ("Invalid string length", convertToErrorFromString(""));
1169 EXPECT_EQ("String has no digits", convertToErrorFromString("+"));
1170 EXPECT_EQ("String has no digits", convertToErrorFromString("-"));
1171
1172 EXPECT_EQ("Invalid character in significand", convertToErrorFromString(StringRef("\0", 1)));
1173 EXPECT_EQ("Invalid character in significand", convertToErrorFromString(StringRef("1\0", 2)));
1174 EXPECT_EQ("Invalid character in significand", convertToErrorFromString(StringRef("1" "\0" "2", 3)));
1175 EXPECT_EQ("Invalid character in significand", convertToErrorFromString(StringRef("1" "\0" "2e1", 5)));
1176 EXPECT_EQ("Invalid character in exponent", convertToErrorFromString(StringRef("1e\0", 3)));
1177 EXPECT_EQ("Invalid character in exponent", convertToErrorFromString(StringRef("1e1\0", 4)));
1178 EXPECT_EQ("Invalid character in exponent", convertToErrorFromString(StringRef("1e1" "\0" "2", 5)));
1179
1180 EXPECT_EQ("Invalid character in significand", convertToErrorFromString("1.0f"));
1181
1182 EXPECT_EQ("String contains multiple dots", convertToErrorFromString(".."));
1183 EXPECT_EQ("String contains multiple dots", convertToErrorFromString("..0"));
1184 EXPECT_EQ("String contains multiple dots", convertToErrorFromString("1.0.0"));
1185 }
1186
TEST(APFloatTest,StringDecimalSignificandError)1187 TEST(APFloatTest, StringDecimalSignificandError) {
1188 EXPECT_EQ("Significand has no digits", convertToErrorFromString( "."));
1189 EXPECT_EQ("Significand has no digits", convertToErrorFromString("+."));
1190 EXPECT_EQ("Significand has no digits", convertToErrorFromString("-."));
1191
1192
1193 EXPECT_EQ("Significand has no digits", convertToErrorFromString( "e"));
1194 EXPECT_EQ("Significand has no digits", convertToErrorFromString("+e"));
1195 EXPECT_EQ("Significand has no digits", convertToErrorFromString("-e"));
1196
1197 EXPECT_EQ("Significand has no digits", convertToErrorFromString( "e1"));
1198 EXPECT_EQ("Significand has no digits", convertToErrorFromString("+e1"));
1199 EXPECT_EQ("Significand has no digits", convertToErrorFromString("-e1"));
1200
1201 EXPECT_EQ("Significand has no digits", convertToErrorFromString( ".e1"));
1202 EXPECT_EQ("Significand has no digits", convertToErrorFromString("+.e1"));
1203 EXPECT_EQ("Significand has no digits", convertToErrorFromString("-.e1"));
1204
1205
1206 EXPECT_EQ("Significand has no digits", convertToErrorFromString( ".e"));
1207 EXPECT_EQ("Significand has no digits", convertToErrorFromString("+.e"));
1208 EXPECT_EQ("Significand has no digits", convertToErrorFromString("-.e"));
1209 }
1210
TEST(APFloatTest,StringHexadecimalError)1211 TEST(APFloatTest, StringHexadecimalError) {
1212 EXPECT_EQ("Invalid string", convertToErrorFromString( "0x"));
1213 EXPECT_EQ("Invalid string", convertToErrorFromString("+0x"));
1214 EXPECT_EQ("Invalid string", convertToErrorFromString("-0x"));
1215
1216 EXPECT_EQ("Hex strings require an exponent", convertToErrorFromString( "0x0"));
1217 EXPECT_EQ("Hex strings require an exponent", convertToErrorFromString("+0x0"));
1218 EXPECT_EQ("Hex strings require an exponent", convertToErrorFromString("-0x0"));
1219
1220 EXPECT_EQ("Hex strings require an exponent", convertToErrorFromString( "0x0."));
1221 EXPECT_EQ("Hex strings require an exponent", convertToErrorFromString("+0x0."));
1222 EXPECT_EQ("Hex strings require an exponent", convertToErrorFromString("-0x0."));
1223
1224 EXPECT_EQ("Hex strings require an exponent", convertToErrorFromString( "0x.0"));
1225 EXPECT_EQ("Hex strings require an exponent", convertToErrorFromString("+0x.0"));
1226 EXPECT_EQ("Hex strings require an exponent", convertToErrorFromString("-0x.0"));
1227
1228 EXPECT_EQ("Hex strings require an exponent", convertToErrorFromString( "0x0.0"));
1229 EXPECT_EQ("Hex strings require an exponent", convertToErrorFromString("+0x0.0"));
1230 EXPECT_EQ("Hex strings require an exponent", convertToErrorFromString("-0x0.0"));
1231
1232 EXPECT_EQ("Invalid character in significand", convertToErrorFromString(StringRef("0x\0", 3)));
1233 EXPECT_EQ("Invalid character in significand", convertToErrorFromString(StringRef("0x1\0", 4)));
1234 EXPECT_EQ("Invalid character in significand", convertToErrorFromString(StringRef("0x1" "\0" "2", 5)));
1235 EXPECT_EQ("Invalid character in significand", convertToErrorFromString(StringRef("0x1" "\0" "2p1", 7)));
1236 EXPECT_EQ("Invalid character in exponent", convertToErrorFromString(StringRef("0x1p\0", 5)));
1237 EXPECT_EQ("Invalid character in exponent", convertToErrorFromString(StringRef("0x1p1\0", 6)));
1238 EXPECT_EQ("Invalid character in exponent", convertToErrorFromString(StringRef("0x1p1" "\0" "2", 7)));
1239
1240 EXPECT_EQ("Invalid character in exponent", convertToErrorFromString("0x1p0f"));
1241
1242 EXPECT_EQ("String contains multiple dots", convertToErrorFromString("0x..p1"));
1243 EXPECT_EQ("String contains multiple dots", convertToErrorFromString("0x..0p1"));
1244 EXPECT_EQ("String contains multiple dots", convertToErrorFromString("0x1.0.0p1"));
1245 }
1246
TEST(APFloatTest,StringHexadecimalSignificandError)1247 TEST(APFloatTest, StringHexadecimalSignificandError) {
1248 EXPECT_EQ("Significand has no digits", convertToErrorFromString( "0x."));
1249 EXPECT_EQ("Significand has no digits", convertToErrorFromString("+0x."));
1250 EXPECT_EQ("Significand has no digits", convertToErrorFromString("-0x."));
1251
1252 EXPECT_EQ("Significand has no digits", convertToErrorFromString( "0xp"));
1253 EXPECT_EQ("Significand has no digits", convertToErrorFromString("+0xp"));
1254 EXPECT_EQ("Significand has no digits", convertToErrorFromString("-0xp"));
1255
1256 EXPECT_EQ("Significand has no digits", convertToErrorFromString( "0xp+"));
1257 EXPECT_EQ("Significand has no digits", convertToErrorFromString("+0xp+"));
1258 EXPECT_EQ("Significand has no digits", convertToErrorFromString("-0xp+"));
1259
1260 EXPECT_EQ("Significand has no digits", convertToErrorFromString( "0xp-"));
1261 EXPECT_EQ("Significand has no digits", convertToErrorFromString("+0xp-"));
1262 EXPECT_EQ("Significand has no digits", convertToErrorFromString("-0xp-"));
1263
1264
1265 EXPECT_EQ("Significand has no digits", convertToErrorFromString( "0x.p"));
1266 EXPECT_EQ("Significand has no digits", convertToErrorFromString("+0x.p"));
1267 EXPECT_EQ("Significand has no digits", convertToErrorFromString("-0x.p"));
1268
1269 EXPECT_EQ("Significand has no digits", convertToErrorFromString( "0x.p+"));
1270 EXPECT_EQ("Significand has no digits", convertToErrorFromString("+0x.p+"));
1271 EXPECT_EQ("Significand has no digits", convertToErrorFromString("-0x.p+"));
1272
1273 EXPECT_EQ("Significand has no digits", convertToErrorFromString( "0x.p-"));
1274 EXPECT_EQ("Significand has no digits", convertToErrorFromString("+0x.p-"));
1275 EXPECT_EQ("Significand has no digits", convertToErrorFromString("-0x.p-"));
1276 }
1277
TEST(APFloatTest,StringHexadecimalExponentError)1278 TEST(APFloatTest, StringHexadecimalExponentError) {
1279 EXPECT_EQ("Exponent has no digits", convertToErrorFromString( "0x1p"));
1280 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("+0x1p"));
1281 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("-0x1p"));
1282
1283 EXPECT_EQ("Exponent has no digits", convertToErrorFromString( "0x1p+"));
1284 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("+0x1p+"));
1285 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("-0x1p+"));
1286
1287 EXPECT_EQ("Exponent has no digits", convertToErrorFromString( "0x1p-"));
1288 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("+0x1p-"));
1289 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("-0x1p-"));
1290
1291
1292 EXPECT_EQ("Exponent has no digits", convertToErrorFromString( "0x1.p"));
1293 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("+0x1.p"));
1294 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("-0x1.p"));
1295
1296 EXPECT_EQ("Exponent has no digits", convertToErrorFromString( "0x1.p+"));
1297 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("+0x1.p+"));
1298 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("-0x1.p+"));
1299
1300 EXPECT_EQ("Exponent has no digits", convertToErrorFromString( "0x1.p-"));
1301 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("+0x1.p-"));
1302 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("-0x1.p-"));
1303
1304
1305 EXPECT_EQ("Exponent has no digits", convertToErrorFromString( "0x.1p"));
1306 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("+0x.1p"));
1307 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("-0x.1p"));
1308
1309 EXPECT_EQ("Exponent has no digits", convertToErrorFromString( "0x.1p+"));
1310 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("+0x.1p+"));
1311 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("-0x.1p+"));
1312
1313 EXPECT_EQ("Exponent has no digits", convertToErrorFromString( "0x.1p-"));
1314 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("+0x.1p-"));
1315 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("-0x.1p-"));
1316
1317
1318 EXPECT_EQ("Exponent has no digits", convertToErrorFromString( "0x1.1p"));
1319 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("+0x1.1p"));
1320 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("-0x1.1p"));
1321
1322 EXPECT_EQ("Exponent has no digits", convertToErrorFromString( "0x1.1p+"));
1323 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("+0x1.1p+"));
1324 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("-0x1.1p+"));
1325
1326 EXPECT_EQ("Exponent has no digits", convertToErrorFromString( "0x1.1p-"));
1327 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("+0x1.1p-"));
1328 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("-0x1.1p-"));
1329 }
1330
TEST(APFloatTest,exactInverse)1331 TEST(APFloatTest, exactInverse) {
1332 APFloat inv(0.0f);
1333
1334 // Trivial operation.
1335 EXPECT_TRUE(APFloat(2.0).getExactInverse(&inv));
1336 EXPECT_TRUE(inv.bitwiseIsEqual(APFloat(0.5)));
1337 EXPECT_TRUE(APFloat(2.0f).getExactInverse(&inv));
1338 EXPECT_TRUE(inv.bitwiseIsEqual(APFloat(0.5f)));
1339 EXPECT_TRUE(APFloat(APFloat::IEEEquad(), "2.0").getExactInverse(&inv));
1340 EXPECT_TRUE(inv.bitwiseIsEqual(APFloat(APFloat::IEEEquad(), "0.5")));
1341 EXPECT_TRUE(APFloat(APFloat::PPCDoubleDouble(), "2.0").getExactInverse(&inv));
1342 EXPECT_TRUE(inv.bitwiseIsEqual(APFloat(APFloat::PPCDoubleDouble(), "0.5")));
1343 EXPECT_TRUE(APFloat(APFloat::x87DoubleExtended(), "2.0").getExactInverse(&inv));
1344 EXPECT_TRUE(inv.bitwiseIsEqual(APFloat(APFloat::x87DoubleExtended(), "0.5")));
1345
1346 // FLT_MIN
1347 EXPECT_TRUE(APFloat(1.17549435e-38f).getExactInverse(&inv));
1348 EXPECT_TRUE(inv.bitwiseIsEqual(APFloat(8.5070592e+37f)));
1349
1350 // Large float, inverse is a denormal.
1351 EXPECT_FALSE(APFloat(1.7014118e38f).getExactInverse(nullptr));
1352 // Zero
1353 EXPECT_FALSE(APFloat(0.0).getExactInverse(nullptr));
1354 // Denormalized float
1355 EXPECT_FALSE(APFloat(1.40129846e-45f).getExactInverse(nullptr));
1356 }
1357
TEST(APFloatTest,roundToIntegral)1358 TEST(APFloatTest, roundToIntegral) {
1359 APFloat T(-0.5), S(3.14), R(APFloat::getLargest(APFloat::IEEEdouble())), P(0.0);
1360
1361 P = T;
1362 P.roundToIntegral(APFloat::rmTowardZero);
1363 EXPECT_EQ(-0.0, P.convertToDouble());
1364 P = T;
1365 P.roundToIntegral(APFloat::rmTowardNegative);
1366 EXPECT_EQ(-1.0, P.convertToDouble());
1367 P = T;
1368 P.roundToIntegral(APFloat::rmTowardPositive);
1369 EXPECT_EQ(-0.0, P.convertToDouble());
1370 P = T;
1371 P.roundToIntegral(APFloat::rmNearestTiesToEven);
1372 EXPECT_EQ(-0.0, P.convertToDouble());
1373
1374 P = S;
1375 P.roundToIntegral(APFloat::rmTowardZero);
1376 EXPECT_EQ(3.0, P.convertToDouble());
1377 P = S;
1378 P.roundToIntegral(APFloat::rmTowardNegative);
1379 EXPECT_EQ(3.0, P.convertToDouble());
1380 P = S;
1381 P.roundToIntegral(APFloat::rmTowardPositive);
1382 EXPECT_EQ(4.0, P.convertToDouble());
1383 P = S;
1384 P.roundToIntegral(APFloat::rmNearestTiesToEven);
1385 EXPECT_EQ(3.0, P.convertToDouble());
1386
1387 P = R;
1388 P.roundToIntegral(APFloat::rmTowardZero);
1389 EXPECT_EQ(R.convertToDouble(), P.convertToDouble());
1390 P = R;
1391 P.roundToIntegral(APFloat::rmTowardNegative);
1392 EXPECT_EQ(R.convertToDouble(), P.convertToDouble());
1393 P = R;
1394 P.roundToIntegral(APFloat::rmTowardPositive);
1395 EXPECT_EQ(R.convertToDouble(), P.convertToDouble());
1396 P = R;
1397 P.roundToIntegral(APFloat::rmNearestTiesToEven);
1398 EXPECT_EQ(R.convertToDouble(), P.convertToDouble());
1399
1400 P = APFloat::getZero(APFloat::IEEEdouble());
1401 P.roundToIntegral(APFloat::rmTowardZero);
1402 EXPECT_EQ(0.0, P.convertToDouble());
1403 P = APFloat::getZero(APFloat::IEEEdouble(), true);
1404 P.roundToIntegral(APFloat::rmTowardZero);
1405 EXPECT_EQ(-0.0, P.convertToDouble());
1406 P = APFloat::getNaN(APFloat::IEEEdouble());
1407 P.roundToIntegral(APFloat::rmTowardZero);
1408 EXPECT_TRUE(std::isnan(P.convertToDouble()));
1409 P = APFloat::getInf(APFloat::IEEEdouble());
1410 P.roundToIntegral(APFloat::rmTowardZero);
1411 EXPECT_TRUE(std::isinf(P.convertToDouble()) && P.convertToDouble() > 0.0);
1412 P = APFloat::getInf(APFloat::IEEEdouble(), true);
1413 P.roundToIntegral(APFloat::rmTowardZero);
1414 EXPECT_TRUE(std::isinf(P.convertToDouble()) && P.convertToDouble() < 0.0);
1415 }
1416
TEST(APFloatTest,isInteger)1417 TEST(APFloatTest, isInteger) {
1418 APFloat T(-0.0);
1419 EXPECT_TRUE(T.isInteger());
1420 T = APFloat(3.14159);
1421 EXPECT_FALSE(T.isInteger());
1422 T = APFloat::getNaN(APFloat::IEEEdouble());
1423 EXPECT_FALSE(T.isInteger());
1424 T = APFloat::getInf(APFloat::IEEEdouble());
1425 EXPECT_FALSE(T.isInteger());
1426 T = APFloat::getInf(APFloat::IEEEdouble(), true);
1427 EXPECT_FALSE(T.isInteger());
1428 T = APFloat::getLargest(APFloat::IEEEdouble());
1429 EXPECT_TRUE(T.isInteger());
1430 }
1431
TEST(DoubleAPFloatTest,isInteger)1432 TEST(DoubleAPFloatTest, isInteger) {
1433 APFloat F1(-0.0);
1434 APFloat F2(-0.0);
1435 llvm::detail::DoubleAPFloat T(APFloat::PPCDoubleDouble(), std::move(F1),
1436 std::move(F2));
1437 EXPECT_TRUE(T.isInteger());
1438 APFloat F3(3.14159);
1439 APFloat F4(-0.0);
1440 llvm::detail::DoubleAPFloat T2(APFloat::PPCDoubleDouble(), std::move(F3),
1441 std::move(F4));
1442 EXPECT_FALSE(T2.isInteger());
1443 APFloat F5(-0.0);
1444 APFloat F6(3.14159);
1445 llvm::detail::DoubleAPFloat T3(APFloat::PPCDoubleDouble(), std::move(F5),
1446 std::move(F6));
1447 EXPECT_FALSE(T3.isInteger());
1448 }
1449
TEST(APFloatTest,getLargest)1450 TEST(APFloatTest, getLargest) {
1451 EXPECT_EQ(3.402823466e+38f, APFloat::getLargest(APFloat::IEEEsingle()).convertToFloat());
1452 EXPECT_EQ(1.7976931348623158e+308, APFloat::getLargest(APFloat::IEEEdouble()).convertToDouble());
1453 }
1454
TEST(APFloatTest,getSmallest)1455 TEST(APFloatTest, getSmallest) {
1456 APFloat test = APFloat::getSmallest(APFloat::IEEEsingle(), false);
1457 APFloat expected = APFloat(APFloat::IEEEsingle(), "0x0.000002p-126");
1458 EXPECT_FALSE(test.isNegative());
1459 EXPECT_TRUE(test.isFiniteNonZero());
1460 EXPECT_TRUE(test.isDenormal());
1461 EXPECT_TRUE(test.bitwiseIsEqual(expected));
1462
1463 test = APFloat::getSmallest(APFloat::IEEEsingle(), true);
1464 expected = APFloat(APFloat::IEEEsingle(), "-0x0.000002p-126");
1465 EXPECT_TRUE(test.isNegative());
1466 EXPECT_TRUE(test.isFiniteNonZero());
1467 EXPECT_TRUE(test.isDenormal());
1468 EXPECT_TRUE(test.bitwiseIsEqual(expected));
1469
1470 test = APFloat::getSmallest(APFloat::IEEEquad(), false);
1471 expected = APFloat(APFloat::IEEEquad(), "0x0.0000000000000000000000000001p-16382");
1472 EXPECT_FALSE(test.isNegative());
1473 EXPECT_TRUE(test.isFiniteNonZero());
1474 EXPECT_TRUE(test.isDenormal());
1475 EXPECT_TRUE(test.bitwiseIsEqual(expected));
1476
1477 test = APFloat::getSmallest(APFloat::IEEEquad(), true);
1478 expected = APFloat(APFloat::IEEEquad(), "-0x0.0000000000000000000000000001p-16382");
1479 EXPECT_TRUE(test.isNegative());
1480 EXPECT_TRUE(test.isFiniteNonZero());
1481 EXPECT_TRUE(test.isDenormal());
1482 EXPECT_TRUE(test.bitwiseIsEqual(expected));
1483 }
1484
TEST(APFloatTest,getSmallestNormalized)1485 TEST(APFloatTest, getSmallestNormalized) {
1486 APFloat test = APFloat::getSmallestNormalized(APFloat::IEEEsingle(), false);
1487 APFloat expected = APFloat(APFloat::IEEEsingle(), "0x1p-126");
1488 EXPECT_FALSE(test.isNegative());
1489 EXPECT_TRUE(test.isFiniteNonZero());
1490 EXPECT_FALSE(test.isDenormal());
1491 EXPECT_TRUE(test.bitwiseIsEqual(expected));
1492
1493 test = APFloat::getSmallestNormalized(APFloat::IEEEsingle(), true);
1494 expected = APFloat(APFloat::IEEEsingle(), "-0x1p-126");
1495 EXPECT_TRUE(test.isNegative());
1496 EXPECT_TRUE(test.isFiniteNonZero());
1497 EXPECT_FALSE(test.isDenormal());
1498 EXPECT_TRUE(test.bitwiseIsEqual(expected));
1499
1500 test = APFloat::getSmallestNormalized(APFloat::IEEEquad(), false);
1501 expected = APFloat(APFloat::IEEEquad(), "0x1p-16382");
1502 EXPECT_FALSE(test.isNegative());
1503 EXPECT_TRUE(test.isFiniteNonZero());
1504 EXPECT_FALSE(test.isDenormal());
1505 EXPECT_TRUE(test.bitwiseIsEqual(expected));
1506
1507 test = APFloat::getSmallestNormalized(APFloat::IEEEquad(), true);
1508 expected = APFloat(APFloat::IEEEquad(), "-0x1p-16382");
1509 EXPECT_TRUE(test.isNegative());
1510 EXPECT_TRUE(test.isFiniteNonZero());
1511 EXPECT_FALSE(test.isDenormal());
1512 EXPECT_TRUE(test.bitwiseIsEqual(expected));
1513 }
1514
TEST(APFloatTest,getZero)1515 TEST(APFloatTest, getZero) {
1516 struct {
1517 const fltSemantics *semantics;
1518 const bool sign;
1519 const unsigned long long bitPattern[2];
1520 const unsigned bitPatternLength;
1521 } const GetZeroTest[] = {
1522 { &APFloat::IEEEhalf(), false, {0, 0}, 1},
1523 { &APFloat::IEEEhalf(), true, {0x8000ULL, 0}, 1},
1524 { &APFloat::IEEEsingle(), false, {0, 0}, 1},
1525 { &APFloat::IEEEsingle(), true, {0x80000000ULL, 0}, 1},
1526 { &APFloat::IEEEdouble(), false, {0, 0}, 1},
1527 { &APFloat::IEEEdouble(), true, {0x8000000000000000ULL, 0}, 1},
1528 { &APFloat::IEEEquad(), false, {0, 0}, 2},
1529 { &APFloat::IEEEquad(), true, {0, 0x8000000000000000ULL}, 2},
1530 { &APFloat::PPCDoubleDouble(), false, {0, 0}, 2},
1531 { &APFloat::PPCDoubleDouble(), true, {0x8000000000000000ULL, 0}, 2},
1532 { &APFloat::x87DoubleExtended(), false, {0, 0}, 2},
1533 { &APFloat::x87DoubleExtended(), true, {0, 0x8000ULL}, 2},
1534 };
1535 const unsigned NumGetZeroTests = 12;
1536 for (unsigned i = 0; i < NumGetZeroTests; ++i) {
1537 APFloat test = APFloat::getZero(*GetZeroTest[i].semantics,
1538 GetZeroTest[i].sign);
1539 const char *pattern = GetZeroTest[i].sign? "-0x0p+0" : "0x0p+0";
1540 APFloat expected = APFloat(*GetZeroTest[i].semantics,
1541 pattern);
1542 EXPECT_TRUE(test.isZero());
1543 EXPECT_TRUE(GetZeroTest[i].sign? test.isNegative() : !test.isNegative());
1544 EXPECT_TRUE(test.bitwiseIsEqual(expected));
1545 for (unsigned j = 0, je = GetZeroTest[i].bitPatternLength; j < je; ++j) {
1546 EXPECT_EQ(GetZeroTest[i].bitPattern[j],
1547 test.bitcastToAPInt().getRawData()[j]);
1548 }
1549 }
1550 }
1551
TEST(APFloatTest,copySign)1552 TEST(APFloatTest, copySign) {
1553 EXPECT_TRUE(APFloat(-42.0).bitwiseIsEqual(
1554 APFloat::copySign(APFloat(42.0), APFloat(-1.0))));
1555 EXPECT_TRUE(APFloat(42.0).bitwiseIsEqual(
1556 APFloat::copySign(APFloat(-42.0), APFloat(1.0))));
1557 EXPECT_TRUE(APFloat(-42.0).bitwiseIsEqual(
1558 APFloat::copySign(APFloat(-42.0), APFloat(-1.0))));
1559 EXPECT_TRUE(APFloat(42.0).bitwiseIsEqual(
1560 APFloat::copySign(APFloat(42.0), APFloat(1.0))));
1561 }
1562
TEST(APFloatTest,convert)1563 TEST(APFloatTest, convert) {
1564 bool losesInfo;
1565 APFloat test(APFloat::IEEEdouble(), "1.0");
1566 test.convert(APFloat::IEEEsingle(), APFloat::rmNearestTiesToEven, &losesInfo);
1567 EXPECT_EQ(1.0f, test.convertToFloat());
1568 EXPECT_FALSE(losesInfo);
1569
1570 test = APFloat(APFloat::x87DoubleExtended(), "0x1p-53");
1571 test.add(APFloat(APFloat::x87DoubleExtended(), "1.0"), APFloat::rmNearestTiesToEven);
1572 test.convert(APFloat::IEEEdouble(), APFloat::rmNearestTiesToEven, &losesInfo);
1573 EXPECT_EQ(1.0, test.convertToDouble());
1574 EXPECT_TRUE(losesInfo);
1575
1576 test = APFloat(APFloat::IEEEquad(), "0x1p-53");
1577 test.add(APFloat(APFloat::IEEEquad(), "1.0"), APFloat::rmNearestTiesToEven);
1578 test.convert(APFloat::IEEEdouble(), APFloat::rmNearestTiesToEven, &losesInfo);
1579 EXPECT_EQ(1.0, test.convertToDouble());
1580 EXPECT_TRUE(losesInfo);
1581
1582 test = APFloat(APFloat::x87DoubleExtended(), "0xf.fffffffp+28");
1583 test.convert(APFloat::IEEEdouble(), APFloat::rmNearestTiesToEven, &losesInfo);
1584 EXPECT_EQ(4294967295.0, test.convertToDouble());
1585 EXPECT_FALSE(losesInfo);
1586
1587 test = APFloat::getSNaN(APFloat::IEEEsingle());
1588 APFloat X87SNaN = APFloat::getSNaN(APFloat::x87DoubleExtended());
1589 test.convert(APFloat::x87DoubleExtended(), APFloat::rmNearestTiesToEven,
1590 &losesInfo);
1591 EXPECT_TRUE(test.bitwiseIsEqual(X87SNaN));
1592 EXPECT_FALSE(losesInfo);
1593
1594 test = APFloat::getQNaN(APFloat::IEEEsingle());
1595 APFloat X87QNaN = APFloat::getQNaN(APFloat::x87DoubleExtended());
1596 test.convert(APFloat::x87DoubleExtended(), APFloat::rmNearestTiesToEven,
1597 &losesInfo);
1598 EXPECT_TRUE(test.bitwiseIsEqual(X87QNaN));
1599 EXPECT_FALSE(losesInfo);
1600
1601 test = APFloat::getSNaN(APFloat::x87DoubleExtended());
1602 test.convert(APFloat::x87DoubleExtended(), APFloat::rmNearestTiesToEven,
1603 &losesInfo);
1604 EXPECT_TRUE(test.bitwiseIsEqual(X87SNaN));
1605 EXPECT_FALSE(losesInfo);
1606
1607 test = APFloat::getQNaN(APFloat::x87DoubleExtended());
1608 test.convert(APFloat::x87DoubleExtended(), APFloat::rmNearestTiesToEven,
1609 &losesInfo);
1610 EXPECT_TRUE(test.bitwiseIsEqual(X87QNaN));
1611 EXPECT_FALSE(losesInfo);
1612 }
1613
TEST(APFloatTest,PPCDoubleDouble)1614 TEST(APFloatTest, PPCDoubleDouble) {
1615 APFloat test(APFloat::PPCDoubleDouble(), "1.0");
1616 EXPECT_EQ(0x3ff0000000000000ull, test.bitcastToAPInt().getRawData()[0]);
1617 EXPECT_EQ(0x0000000000000000ull, test.bitcastToAPInt().getRawData()[1]);
1618
1619 // LDBL_MAX
1620 test = APFloat(APFloat::PPCDoubleDouble(), "1.79769313486231580793728971405301e+308");
1621 EXPECT_EQ(0x7fefffffffffffffull, test.bitcastToAPInt().getRawData()[0]);
1622 EXPECT_EQ(0x7c8ffffffffffffeull, test.bitcastToAPInt().getRawData()[1]);
1623
1624 // LDBL_MIN
1625 test = APFloat(APFloat::PPCDoubleDouble(), "2.00416836000897277799610805135016e-292");
1626 EXPECT_EQ(0x0360000000000000ull, test.bitcastToAPInt().getRawData()[0]);
1627 EXPECT_EQ(0x0000000000000000ull, test.bitcastToAPInt().getRawData()[1]);
1628
1629 // PR30869
1630 {
1631 auto Result = APFloat(APFloat::PPCDoubleDouble(), "1.0") +
1632 APFloat(APFloat::PPCDoubleDouble(), "1.0");
1633 EXPECT_EQ(&APFloat::PPCDoubleDouble(), &Result.getSemantics());
1634
1635 Result = APFloat(APFloat::PPCDoubleDouble(), "1.0") -
1636 APFloat(APFloat::PPCDoubleDouble(), "1.0");
1637 EXPECT_EQ(&APFloat::PPCDoubleDouble(), &Result.getSemantics());
1638
1639 Result = APFloat(APFloat::PPCDoubleDouble(), "1.0") *
1640 APFloat(APFloat::PPCDoubleDouble(), "1.0");
1641 EXPECT_EQ(&APFloat::PPCDoubleDouble(), &Result.getSemantics());
1642
1643 Result = APFloat(APFloat::PPCDoubleDouble(), "1.0") /
1644 APFloat(APFloat::PPCDoubleDouble(), "1.0");
1645 EXPECT_EQ(&APFloat::PPCDoubleDouble(), &Result.getSemantics());
1646
1647 int Exp;
1648 Result = frexp(APFloat(APFloat::PPCDoubleDouble(), "1.0"), Exp,
1649 APFloat::rmNearestTiesToEven);
1650 EXPECT_EQ(&APFloat::PPCDoubleDouble(), &Result.getSemantics());
1651
1652 Result = scalbn(APFloat(APFloat::PPCDoubleDouble(), "1.0"), 1,
1653 APFloat::rmNearestTiesToEven);
1654 EXPECT_EQ(&APFloat::PPCDoubleDouble(), &Result.getSemantics());
1655 }
1656 }
1657
TEST(APFloatTest,isNegative)1658 TEST(APFloatTest, isNegative) {
1659 APFloat t(APFloat::IEEEsingle(), "0x1p+0");
1660 EXPECT_FALSE(t.isNegative());
1661 t = APFloat(APFloat::IEEEsingle(), "-0x1p+0");
1662 EXPECT_TRUE(t.isNegative());
1663
1664 EXPECT_FALSE(APFloat::getInf(APFloat::IEEEsingle(), false).isNegative());
1665 EXPECT_TRUE(APFloat::getInf(APFloat::IEEEsingle(), true).isNegative());
1666
1667 EXPECT_FALSE(APFloat::getZero(APFloat::IEEEsingle(), false).isNegative());
1668 EXPECT_TRUE(APFloat::getZero(APFloat::IEEEsingle(), true).isNegative());
1669
1670 EXPECT_FALSE(APFloat::getNaN(APFloat::IEEEsingle(), false).isNegative());
1671 EXPECT_TRUE(APFloat::getNaN(APFloat::IEEEsingle(), true).isNegative());
1672
1673 EXPECT_FALSE(APFloat::getSNaN(APFloat::IEEEsingle(), false).isNegative());
1674 EXPECT_TRUE(APFloat::getSNaN(APFloat::IEEEsingle(), true).isNegative());
1675 }
1676
TEST(APFloatTest,isNormal)1677 TEST(APFloatTest, isNormal) {
1678 APFloat t(APFloat::IEEEsingle(), "0x1p+0");
1679 EXPECT_TRUE(t.isNormal());
1680
1681 EXPECT_FALSE(APFloat::getInf(APFloat::IEEEsingle(), false).isNormal());
1682 EXPECT_FALSE(APFloat::getZero(APFloat::IEEEsingle(), false).isNormal());
1683 EXPECT_FALSE(APFloat::getNaN(APFloat::IEEEsingle(), false).isNormal());
1684 EXPECT_FALSE(APFloat::getSNaN(APFloat::IEEEsingle(), false).isNormal());
1685 EXPECT_FALSE(APFloat(APFloat::IEEEsingle(), "0x1p-149").isNormal());
1686 }
1687
TEST(APFloatTest,isFinite)1688 TEST(APFloatTest, isFinite) {
1689 APFloat t(APFloat::IEEEsingle(), "0x1p+0");
1690 EXPECT_TRUE(t.isFinite());
1691 EXPECT_FALSE(APFloat::getInf(APFloat::IEEEsingle(), false).isFinite());
1692 EXPECT_TRUE(APFloat::getZero(APFloat::IEEEsingle(), false).isFinite());
1693 EXPECT_FALSE(APFloat::getNaN(APFloat::IEEEsingle(), false).isFinite());
1694 EXPECT_FALSE(APFloat::getSNaN(APFloat::IEEEsingle(), false).isFinite());
1695 EXPECT_TRUE(APFloat(APFloat::IEEEsingle(), "0x1p-149").isFinite());
1696 }
1697
TEST(APFloatTest,isInfinity)1698 TEST(APFloatTest, isInfinity) {
1699 APFloat t(APFloat::IEEEsingle(), "0x1p+0");
1700 EXPECT_FALSE(t.isInfinity());
1701 EXPECT_TRUE(APFloat::getInf(APFloat::IEEEsingle(), false).isInfinity());
1702 EXPECT_FALSE(APFloat::getZero(APFloat::IEEEsingle(), false).isInfinity());
1703 EXPECT_FALSE(APFloat::getNaN(APFloat::IEEEsingle(), false).isInfinity());
1704 EXPECT_FALSE(APFloat::getSNaN(APFloat::IEEEsingle(), false).isInfinity());
1705 EXPECT_FALSE(APFloat(APFloat::IEEEsingle(), "0x1p-149").isInfinity());
1706 }
1707
TEST(APFloatTest,isNaN)1708 TEST(APFloatTest, isNaN) {
1709 APFloat t(APFloat::IEEEsingle(), "0x1p+0");
1710 EXPECT_FALSE(t.isNaN());
1711 EXPECT_FALSE(APFloat::getInf(APFloat::IEEEsingle(), false).isNaN());
1712 EXPECT_FALSE(APFloat::getZero(APFloat::IEEEsingle(), false).isNaN());
1713 EXPECT_TRUE(APFloat::getNaN(APFloat::IEEEsingle(), false).isNaN());
1714 EXPECT_TRUE(APFloat::getSNaN(APFloat::IEEEsingle(), false).isNaN());
1715 EXPECT_FALSE(APFloat(APFloat::IEEEsingle(), "0x1p-149").isNaN());
1716 }
1717
TEST(APFloatTest,isFiniteNonZero)1718 TEST(APFloatTest, isFiniteNonZero) {
1719 // Test positive/negative normal value.
1720 EXPECT_TRUE(APFloat(APFloat::IEEEsingle(), "0x1p+0").isFiniteNonZero());
1721 EXPECT_TRUE(APFloat(APFloat::IEEEsingle(), "-0x1p+0").isFiniteNonZero());
1722
1723 // Test positive/negative denormal value.
1724 EXPECT_TRUE(APFloat(APFloat::IEEEsingle(), "0x1p-149").isFiniteNonZero());
1725 EXPECT_TRUE(APFloat(APFloat::IEEEsingle(), "-0x1p-149").isFiniteNonZero());
1726
1727 // Test +/- Infinity.
1728 EXPECT_FALSE(APFloat::getInf(APFloat::IEEEsingle(), false).isFiniteNonZero());
1729 EXPECT_FALSE(APFloat::getInf(APFloat::IEEEsingle(), true).isFiniteNonZero());
1730
1731 // Test +/- Zero.
1732 EXPECT_FALSE(APFloat::getZero(APFloat::IEEEsingle(), false).isFiniteNonZero());
1733 EXPECT_FALSE(APFloat::getZero(APFloat::IEEEsingle(), true).isFiniteNonZero());
1734
1735 // Test +/- qNaN. +/- dont mean anything with qNaN but paranoia can't hurt in
1736 // this instance.
1737 EXPECT_FALSE(APFloat::getNaN(APFloat::IEEEsingle(), false).isFiniteNonZero());
1738 EXPECT_FALSE(APFloat::getNaN(APFloat::IEEEsingle(), true).isFiniteNonZero());
1739
1740 // Test +/- sNaN. +/- dont mean anything with sNaN but paranoia can't hurt in
1741 // this instance.
1742 EXPECT_FALSE(APFloat::getSNaN(APFloat::IEEEsingle(), false).isFiniteNonZero());
1743 EXPECT_FALSE(APFloat::getSNaN(APFloat::IEEEsingle(), true).isFiniteNonZero());
1744 }
1745
TEST(APFloatTest,add)1746 TEST(APFloatTest, add) {
1747 // Test Special Cases against each other and normal values.
1748
1749 // TODOS/NOTES:
1750 // 1. Since we perform only default exception handling all operations with
1751 // signaling NaNs should have a result that is a quiet NaN. Currently they
1752 // return sNaN.
1753
1754 APFloat PInf = APFloat::getInf(APFloat::IEEEsingle(), false);
1755 APFloat MInf = APFloat::getInf(APFloat::IEEEsingle(), true);
1756 APFloat PZero = APFloat::getZero(APFloat::IEEEsingle(), false);
1757 APFloat MZero = APFloat::getZero(APFloat::IEEEsingle(), true);
1758 APFloat QNaN = APFloat::getNaN(APFloat::IEEEsingle(), false);
1759 APFloat SNaN = APFloat::getSNaN(APFloat::IEEEsingle(), false);
1760 APFloat PNormalValue = APFloat(APFloat::IEEEsingle(), "0x1p+0");
1761 APFloat MNormalValue = APFloat(APFloat::IEEEsingle(), "-0x1p+0");
1762 APFloat PLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), false);
1763 APFloat MLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), true);
1764 APFloat PSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), false);
1765 APFloat MSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), true);
1766 APFloat PSmallestNormalized =
1767 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), false);
1768 APFloat MSmallestNormalized =
1769 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), true);
1770
1771 const int OverflowStatus = APFloat::opOverflow | APFloat::opInexact;
1772
1773 const unsigned NumTests = 169;
1774 struct {
1775 APFloat x;
1776 APFloat y;
1777 const char *result;
1778 int status;
1779 int category;
1780 } SpecialCaseTests[NumTests] = {
1781 { PInf, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1782 { PInf, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1783 { PInf, PZero, "inf", APFloat::opOK, APFloat::fcInfinity },
1784 { PInf, MZero, "inf", APFloat::opOK, APFloat::fcInfinity },
1785 { PInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1786 #if 0
1787 // See Note 1.
1788 { PInf, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1789 #endif
1790 { PInf, PNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
1791 { PInf, MNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
1792 { PInf, PLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
1793 { PInf, MLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
1794 { PInf, PSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
1795 { PInf, MSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
1796 { PInf, PSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity },
1797 { PInf, MSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity },
1798 { MInf, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1799 { MInf, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1800 { MInf, PZero, "-inf", APFloat::opOK, APFloat::fcInfinity },
1801 { MInf, MZero, "-inf", APFloat::opOK, APFloat::fcInfinity },
1802 { MInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1803 #if 0
1804 // See Note 1.
1805 { MInf, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1806 #endif
1807 { MInf, PNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
1808 { MInf, MNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
1809 { MInf, PLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
1810 { MInf, MLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
1811 { MInf, PSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
1812 { MInf, MSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
1813 { MInf, PSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity },
1814 { MInf, MSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity },
1815 { PZero, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1816 { PZero, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1817 { PZero, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1818 { PZero, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1819 { PZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1820 #if 0
1821 // See Note 1.
1822 { PZero, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1823 #endif
1824 { PZero, PNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
1825 { PZero, MNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
1826 { PZero, PLargestValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
1827 { PZero, MLargestValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
1828 { PZero, PSmallestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
1829 { PZero, MSmallestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
1830 { PZero, PSmallestNormalized, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
1831 { PZero, MSmallestNormalized, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
1832 { MZero, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1833 { MZero, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1834 { MZero, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1835 { MZero, MZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
1836 { MZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1837 #if 0
1838 // See Note 1.
1839 { MZero, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1840 #endif
1841 { MZero, PNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
1842 { MZero, MNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
1843 { MZero, PLargestValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
1844 { MZero, MLargestValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
1845 { MZero, PSmallestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
1846 { MZero, MSmallestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
1847 { MZero, PSmallestNormalized, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
1848 { MZero, MSmallestNormalized, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
1849 { QNaN, PInf, "nan", APFloat::opOK, APFloat::fcNaN },
1850 { QNaN, MInf, "nan", APFloat::opOK, APFloat::fcNaN },
1851 { QNaN, PZero, "nan", APFloat::opOK, APFloat::fcNaN },
1852 { QNaN, MZero, "nan", APFloat::opOK, APFloat::fcNaN },
1853 { QNaN, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1854 #if 0
1855 // See Note 1.
1856 { QNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1857 #endif
1858 { QNaN, PNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
1859 { QNaN, MNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
1860 { QNaN, PLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
1861 { QNaN, MLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
1862 { QNaN, PSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
1863 { QNaN, MSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
1864 { QNaN, PSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
1865 { QNaN, MSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
1866 #if 0
1867 // See Note 1.
1868 { SNaN, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1869 { SNaN, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1870 { SNaN, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1871 { SNaN, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1872 { SNaN, QNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1873 { SNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1874 { SNaN, PNormalValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1875 { SNaN, MNormalValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1876 { SNaN, PLargestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1877 { SNaN, MLargestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1878 { SNaN, PSmallestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1879 { SNaN, MSmallestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1880 { SNaN, PSmallestNormalized, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1881 { SNaN, MSmallestNormalized, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1882 #endif
1883 { PNormalValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1884 { PNormalValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1885 { PNormalValue, PZero, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
1886 { PNormalValue, MZero, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
1887 { PNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1888 #if 0
1889 // See Note 1.
1890 { PNormalValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1891 #endif
1892 { PNormalValue, PNormalValue, "0x1p+1", APFloat::opOK, APFloat::fcNormal },
1893 { PNormalValue, MNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1894 { PNormalValue, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1895 { PNormalValue, MLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1896 { PNormalValue, PSmallestValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1897 { PNormalValue, MSmallestValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1898 { PNormalValue, PSmallestNormalized, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1899 { PNormalValue, MSmallestNormalized, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1900 { MNormalValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1901 { MNormalValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1902 { MNormalValue, PZero, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
1903 { MNormalValue, MZero, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
1904 { MNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1905 #if 0
1906 // See Note 1.
1907 { MNormalValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1908 #endif
1909 { MNormalValue, PNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1910 { MNormalValue, MNormalValue, "-0x1p+1", APFloat::opOK, APFloat::fcNormal },
1911 { MNormalValue, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1912 { MNormalValue, MLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1913 { MNormalValue, PSmallestValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1914 { MNormalValue, MSmallestValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1915 { MNormalValue, PSmallestNormalized, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1916 { MNormalValue, MSmallestNormalized, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1917 { PLargestValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1918 { PLargestValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1919 { PLargestValue, PZero, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
1920 { PLargestValue, MZero, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
1921 { PLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1922 #if 0
1923 // See Note 1.
1924 { PLargestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1925 #endif
1926 { PLargestValue, PNormalValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1927 { PLargestValue, MNormalValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1928 { PLargestValue, PLargestValue, "inf", OverflowStatus, APFloat::fcInfinity },
1929 { PLargestValue, MLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1930 { PLargestValue, PSmallestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1931 { PLargestValue, MSmallestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1932 { PLargestValue, PSmallestNormalized, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1933 { PLargestValue, MSmallestNormalized, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1934 { MLargestValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1935 { MLargestValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1936 { MLargestValue, PZero, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
1937 { MLargestValue, MZero, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
1938 { MLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1939 #if 0
1940 // See Note 1.
1941 { MLargestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1942 #endif
1943 { MLargestValue, PNormalValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1944 { MLargestValue, MNormalValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1945 { MLargestValue, PLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1946 { MLargestValue, MLargestValue, "-inf", OverflowStatus, APFloat::fcInfinity },
1947 { MLargestValue, PSmallestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1948 { MLargestValue, MSmallestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1949 { MLargestValue, PSmallestNormalized, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1950 { MLargestValue, MSmallestNormalized, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1951 { PSmallestValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1952 { PSmallestValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1953 { PSmallestValue, PZero, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
1954 { PSmallestValue, MZero, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
1955 { PSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1956 #if 0
1957 // See Note 1.
1958 { PSmallestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1959 #endif
1960 { PSmallestValue, PNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1961 { PSmallestValue, MNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1962 { PSmallestValue, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1963 { PSmallestValue, MLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1964 { PSmallestValue, PSmallestValue, "0x1p-148", APFloat::opOK, APFloat::fcNormal },
1965 { PSmallestValue, MSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1966 { PSmallestValue, PSmallestNormalized, "0x1.000002p-126", APFloat::opOK, APFloat::fcNormal },
1967 { PSmallestValue, MSmallestNormalized, "-0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal },
1968 { MSmallestValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1969 { MSmallestValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1970 { MSmallestValue, PZero, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
1971 { MSmallestValue, MZero, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
1972 { MSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1973 #if 0
1974 // See Note 1.
1975 { MSmallestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1976 #endif
1977 { MSmallestValue, PNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1978 { MSmallestValue, MNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1979 { MSmallestValue, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1980 { MSmallestValue, MLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1981 { MSmallestValue, PSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1982 { MSmallestValue, MSmallestValue, "-0x1p-148", APFloat::opOK, APFloat::fcNormal },
1983 { MSmallestValue, PSmallestNormalized, "0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal },
1984 { MSmallestValue, MSmallestNormalized, "-0x1.000002p-126", APFloat::opOK, APFloat::fcNormal },
1985 { PSmallestNormalized, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1986 { PSmallestNormalized, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1987 { PSmallestNormalized, PZero, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
1988 { PSmallestNormalized, MZero, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
1989 { PSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1990 #if 0
1991 // See Note 1.
1992 { PSmallestNormalized, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1993 #endif
1994 { PSmallestNormalized, PNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1995 { PSmallestNormalized, MNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1996 { PSmallestNormalized, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1997 { PSmallestNormalized, MLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1998 { PSmallestNormalized, PSmallestValue, "0x1.000002p-126", APFloat::opOK, APFloat::fcNormal },
1999 { PSmallestNormalized, MSmallestValue, "0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal },
2000 { PSmallestNormalized, PSmallestNormalized, "0x1p-125", APFloat::opOK, APFloat::fcNormal },
2001 { PSmallestNormalized, MSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2002 { MSmallestNormalized, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2003 { MSmallestNormalized, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2004 { MSmallestNormalized, PZero, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2005 { MSmallestNormalized, MZero, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2006 { MSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2007 #if 0
2008 // See Note 1.
2009 { MSmallestNormalized, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2010 #endif
2011 { MSmallestNormalized, PNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2012 { MSmallestNormalized, MNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2013 { MSmallestNormalized, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2014 { MSmallestNormalized, MLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2015 { MSmallestNormalized, PSmallestValue, "-0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal },
2016 { MSmallestNormalized, MSmallestValue, "-0x1.000002p-126", APFloat::opOK, APFloat::fcNormal },
2017 { MSmallestNormalized, PSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2018 { MSmallestNormalized, MSmallestNormalized, "-0x1p-125", APFloat::opOK, APFloat::fcNormal }
2019 };
2020
2021 for (size_t i = 0; i < NumTests; ++i) {
2022 APFloat x(SpecialCaseTests[i].x);
2023 APFloat y(SpecialCaseTests[i].y);
2024 APFloat::opStatus status = x.add(y, APFloat::rmNearestTiesToEven);
2025
2026 APFloat result(APFloat::IEEEsingle(), SpecialCaseTests[i].result);
2027
2028 EXPECT_TRUE(result.bitwiseIsEqual(x));
2029 EXPECT_TRUE((int)status == SpecialCaseTests[i].status);
2030 EXPECT_TRUE((int)x.getCategory() == SpecialCaseTests[i].category);
2031 }
2032 }
2033
TEST(APFloatTest,subtract)2034 TEST(APFloatTest, subtract) {
2035 // Test Special Cases against each other and normal values.
2036
2037 // TODOS/NOTES:
2038 // 1. Since we perform only default exception handling all operations with
2039 // signaling NaNs should have a result that is a quiet NaN. Currently they
2040 // return sNaN.
2041
2042 APFloat PInf = APFloat::getInf(APFloat::IEEEsingle(), false);
2043 APFloat MInf = APFloat::getInf(APFloat::IEEEsingle(), true);
2044 APFloat PZero = APFloat::getZero(APFloat::IEEEsingle(), false);
2045 APFloat MZero = APFloat::getZero(APFloat::IEEEsingle(), true);
2046 APFloat QNaN = APFloat::getNaN(APFloat::IEEEsingle(), false);
2047 APFloat SNaN = APFloat::getSNaN(APFloat::IEEEsingle(), false);
2048 APFloat PNormalValue = APFloat(APFloat::IEEEsingle(), "0x1p+0");
2049 APFloat MNormalValue = APFloat(APFloat::IEEEsingle(), "-0x1p+0");
2050 APFloat PLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), false);
2051 APFloat MLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), true);
2052 APFloat PSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), false);
2053 APFloat MSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), true);
2054 APFloat PSmallestNormalized =
2055 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), false);
2056 APFloat MSmallestNormalized =
2057 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), true);
2058
2059 const int OverflowStatus = APFloat::opOverflow | APFloat::opInexact;
2060
2061 const unsigned NumTests = 169;
2062 struct {
2063 APFloat x;
2064 APFloat y;
2065 const char *result;
2066 int status;
2067 int category;
2068 } SpecialCaseTests[NumTests] = {
2069 { PInf, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2070 { PInf, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2071 { PInf, PZero, "inf", APFloat::opOK, APFloat::fcInfinity },
2072 { PInf, MZero, "inf", APFloat::opOK, APFloat::fcInfinity },
2073 { PInf, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
2074 #if 0
2075 // See Note 1.
2076 { PInf, SNaN, "-nan", APFloat::opInvalidOp, APFloat::fcNaN },
2077 #endif
2078 { PInf, PNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2079 { PInf, MNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2080 { PInf, PLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2081 { PInf, MLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2082 { PInf, PSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2083 { PInf, MSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2084 { PInf, PSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity },
2085 { PInf, MSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity },
2086 { MInf, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2087 { MInf, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2088 { MInf, PZero, "-inf", APFloat::opOK, APFloat::fcInfinity },
2089 { MInf, MZero, "-inf", APFloat::opOK, APFloat::fcInfinity },
2090 { MInf, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
2091 #if 0
2092 // See Note 1.
2093 { MInf, SNaN, "-nan", APFloat::opInvalidOp, APFloat::fcNaN },
2094 #endif
2095 { MInf, PNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2096 { MInf, MNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2097 { MInf, PLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2098 { MInf, MLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2099 { MInf, PSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2100 { MInf, MSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2101 { MInf, PSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity },
2102 { MInf, MSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity },
2103 { PZero, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2104 { PZero, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2105 { PZero, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2106 { PZero, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2107 { PZero, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
2108 #if 0
2109 // See Note 1.
2110 { PZero, SNaN, "-nan", APFloat::opInvalidOp, APFloat::fcNaN },
2111 #endif
2112 { PZero, PNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2113 { PZero, MNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2114 { PZero, PLargestValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2115 { PZero, MLargestValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2116 { PZero, PSmallestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2117 { PZero, MSmallestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2118 { PZero, PSmallestNormalized, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2119 { PZero, MSmallestNormalized, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2120 { MZero, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2121 { MZero, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2122 { MZero, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2123 { MZero, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2124 { MZero, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
2125 #if 0
2126 // See Note 1.
2127 { MZero, SNaN, "-nan", APFloat::opInvalidOp, APFloat::fcNaN },
2128 #endif
2129 { MZero, PNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2130 { MZero, MNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2131 { MZero, PLargestValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2132 { MZero, MLargestValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2133 { MZero, PSmallestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2134 { MZero, MSmallestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2135 { MZero, PSmallestNormalized, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2136 { MZero, MSmallestNormalized, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2137 { QNaN, PInf, "nan", APFloat::opOK, APFloat::fcNaN },
2138 { QNaN, MInf, "nan", APFloat::opOK, APFloat::fcNaN },
2139 { QNaN, PZero, "nan", APFloat::opOK, APFloat::fcNaN },
2140 { QNaN, MZero, "nan", APFloat::opOK, APFloat::fcNaN },
2141 { QNaN, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2142 #if 0
2143 // See Note 1.
2144 { QNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2145 #endif
2146 { QNaN, PNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
2147 { QNaN, MNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
2148 { QNaN, PLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2149 { QNaN, MLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2150 { QNaN, PSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2151 { QNaN, MSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2152 { QNaN, PSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
2153 { QNaN, MSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
2154 #if 0
2155 // See Note 1.
2156 { SNaN, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2157 { SNaN, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2158 { SNaN, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2159 { SNaN, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2160 { SNaN, QNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2161 { SNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2162 { SNaN, PNormalValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2163 { SNaN, MNormalValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2164 { SNaN, PLargestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2165 { SNaN, MLargestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2166 { SNaN, PSmallestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2167 { SNaN, MSmallestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2168 { SNaN, PSmallestNormalized, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2169 { SNaN, MSmallestNormalized, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2170 #endif
2171 { PNormalValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2172 { PNormalValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2173 { PNormalValue, PZero, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2174 { PNormalValue, MZero, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2175 { PNormalValue, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
2176 #if 0
2177 // See Note 1.
2178 { PNormalValue, SNaN, "-nan", APFloat::opInvalidOp, APFloat::fcNaN },
2179 #endif
2180 { PNormalValue, PNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2181 { PNormalValue, MNormalValue, "0x1p+1", APFloat::opOK, APFloat::fcNormal },
2182 { PNormalValue, PLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2183 { PNormalValue, MLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2184 { PNormalValue, PSmallestValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2185 { PNormalValue, MSmallestValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2186 { PNormalValue, PSmallestNormalized, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2187 { PNormalValue, MSmallestNormalized, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2188 { MNormalValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2189 { MNormalValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2190 { MNormalValue, PZero, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2191 { MNormalValue, MZero, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2192 { MNormalValue, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
2193 #if 0
2194 // See Note 1.
2195 { MNormalValue, SNaN, "-nan", APFloat::opInvalidOp, APFloat::fcNaN },
2196 #endif
2197 { MNormalValue, PNormalValue, "-0x1p+1", APFloat::opOK, APFloat::fcNormal },
2198 { MNormalValue, MNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2199 { MNormalValue, PLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2200 { MNormalValue, MLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2201 { MNormalValue, PSmallestValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2202 { MNormalValue, MSmallestValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2203 { MNormalValue, PSmallestNormalized, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2204 { MNormalValue, MSmallestNormalized, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2205 { PLargestValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2206 { PLargestValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2207 { PLargestValue, PZero, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2208 { PLargestValue, MZero, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2209 { PLargestValue, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
2210 #if 0
2211 // See Note 1.
2212 { PLargestValue, SNaN, "-nan", APFloat::opInvalidOp, APFloat::fcNaN },
2213 #endif
2214 { PLargestValue, PNormalValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2215 { PLargestValue, MNormalValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2216 { PLargestValue, PLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2217 { PLargestValue, MLargestValue, "inf", OverflowStatus, APFloat::fcInfinity },
2218 { PLargestValue, PSmallestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2219 { PLargestValue, MSmallestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2220 { PLargestValue, PSmallestNormalized, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2221 { PLargestValue, MSmallestNormalized, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2222 { MLargestValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2223 { MLargestValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2224 { MLargestValue, PZero, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2225 { MLargestValue, MZero, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2226 { MLargestValue, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
2227 #if 0
2228 // See Note 1.
2229 { MLargestValue, SNaN, "-nan", APFloat::opInvalidOp, APFloat::fcNaN },
2230 #endif
2231 { MLargestValue, PNormalValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2232 { MLargestValue, MNormalValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2233 { MLargestValue, PLargestValue, "-inf", OverflowStatus, APFloat::fcInfinity },
2234 { MLargestValue, MLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2235 { MLargestValue, PSmallestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2236 { MLargestValue, MSmallestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2237 { MLargestValue, PSmallestNormalized, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2238 { MLargestValue, MSmallestNormalized, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2239 { PSmallestValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2240 { PSmallestValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2241 { PSmallestValue, PZero, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2242 { PSmallestValue, MZero, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2243 { PSmallestValue, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
2244 #if 0
2245 // See Note 1.
2246 { PSmallestValue, SNaN, "-nan", APFloat::opInvalidOp, APFloat::fcNaN },
2247 #endif
2248 { PSmallestValue, PNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2249 { PSmallestValue, MNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2250 { PSmallestValue, PLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2251 { PSmallestValue, MLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2252 { PSmallestValue, PSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2253 { PSmallestValue, MSmallestValue, "0x1p-148", APFloat::opOK, APFloat::fcNormal },
2254 { PSmallestValue, PSmallestNormalized, "-0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal },
2255 { PSmallestValue, MSmallestNormalized, "0x1.000002p-126", APFloat::opOK, APFloat::fcNormal },
2256 { MSmallestValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2257 { MSmallestValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2258 { MSmallestValue, PZero, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2259 { MSmallestValue, MZero, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2260 { MSmallestValue, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
2261 #if 0
2262 // See Note 1.
2263 { MSmallestValue, SNaN, "-nan", APFloat::opInvalidOp, APFloat::fcNaN },
2264 #endif
2265 { MSmallestValue, PNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2266 { MSmallestValue, MNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2267 { MSmallestValue, PLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2268 { MSmallestValue, MLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2269 { MSmallestValue, PSmallestValue, "-0x1p-148", APFloat::opOK, APFloat::fcNormal },
2270 { MSmallestValue, MSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2271 { MSmallestValue, PSmallestNormalized, "-0x1.000002p-126", APFloat::opOK, APFloat::fcNormal },
2272 { MSmallestValue, MSmallestNormalized, "0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal },
2273 { PSmallestNormalized, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2274 { PSmallestNormalized, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2275 { PSmallestNormalized, PZero, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2276 { PSmallestNormalized, MZero, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2277 { PSmallestNormalized, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
2278 #if 0
2279 // See Note 1.
2280 { PSmallestNormalized, SNaN, "-nan", APFloat::opInvalidOp, APFloat::fcNaN },
2281 #endif
2282 { PSmallestNormalized, PNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2283 { PSmallestNormalized, MNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2284 { PSmallestNormalized, PLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2285 { PSmallestNormalized, MLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2286 { PSmallestNormalized, PSmallestValue, "0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal },
2287 { PSmallestNormalized, MSmallestValue, "0x1.000002p-126", APFloat::opOK, APFloat::fcNormal },
2288 { PSmallestNormalized, PSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2289 { PSmallestNormalized, MSmallestNormalized, "0x1p-125", APFloat::opOK, APFloat::fcNormal },
2290 { MSmallestNormalized, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2291 { MSmallestNormalized, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2292 { MSmallestNormalized, PZero, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2293 { MSmallestNormalized, MZero, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2294 { MSmallestNormalized, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
2295 #if 0
2296 // See Note 1.
2297 { MSmallestNormalized, SNaN, "-nan", APFloat::opInvalidOp, APFloat::fcNaN },
2298 #endif
2299 { MSmallestNormalized, PNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2300 { MSmallestNormalized, MNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2301 { MSmallestNormalized, PLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2302 { MSmallestNormalized, MLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2303 { MSmallestNormalized, PSmallestValue, "-0x1.000002p-126", APFloat::opOK, APFloat::fcNormal },
2304 { MSmallestNormalized, MSmallestValue, "-0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal },
2305 { MSmallestNormalized, PSmallestNormalized, "-0x1p-125", APFloat::opOK, APFloat::fcNormal },
2306 { MSmallestNormalized, MSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero }
2307 };
2308
2309 for (size_t i = 0; i < NumTests; ++i) {
2310 APFloat x(SpecialCaseTests[i].x);
2311 APFloat y(SpecialCaseTests[i].y);
2312 APFloat::opStatus status = x.subtract(y, APFloat::rmNearestTiesToEven);
2313
2314 APFloat result(APFloat::IEEEsingle(), SpecialCaseTests[i].result);
2315
2316 EXPECT_TRUE(result.bitwiseIsEqual(x));
2317 EXPECT_TRUE((int)status == SpecialCaseTests[i].status);
2318 EXPECT_TRUE((int)x.getCategory() == SpecialCaseTests[i].category);
2319 }
2320 }
2321
TEST(APFloatTest,multiply)2322 TEST(APFloatTest, multiply) {
2323 // Test Special Cases against each other and normal values.
2324
2325 // TODOS/NOTES:
2326 // 1. Since we perform only default exception handling all operations with
2327 // signaling NaNs should have a result that is a quiet NaN. Currently they
2328 // return sNaN.
2329
2330 APFloat PInf = APFloat::getInf(APFloat::IEEEsingle(), false);
2331 APFloat MInf = APFloat::getInf(APFloat::IEEEsingle(), true);
2332 APFloat PZero = APFloat::getZero(APFloat::IEEEsingle(), false);
2333 APFloat MZero = APFloat::getZero(APFloat::IEEEsingle(), true);
2334 APFloat QNaN = APFloat::getNaN(APFloat::IEEEsingle(), false);
2335 APFloat SNaN = APFloat::getSNaN(APFloat::IEEEsingle(), false);
2336 APFloat PNormalValue = APFloat(APFloat::IEEEsingle(), "0x1p+0");
2337 APFloat MNormalValue = APFloat(APFloat::IEEEsingle(), "-0x1p+0");
2338 APFloat PLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), false);
2339 APFloat MLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), true);
2340 APFloat PSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), false);
2341 APFloat MSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), true);
2342 APFloat PSmallestNormalized =
2343 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), false);
2344 APFloat MSmallestNormalized =
2345 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), true);
2346
2347 APFloat MaxQuad(APFloat::IEEEquad(),
2348 "0x1.ffffffffffffffffffffffffffffp+16383");
2349 APFloat MinQuad(APFloat::IEEEquad(),
2350 "0x0.0000000000000000000000000001p-16382");
2351 APFloat NMinQuad(APFloat::IEEEquad(),
2352 "-0x0.0000000000000000000000000001p-16382");
2353
2354 const int OverflowStatus = APFloat::opOverflow | APFloat::opInexact;
2355 const int UnderflowStatus = APFloat::opUnderflow | APFloat::opInexact;
2356
2357 struct {
2358 APFloat x;
2359 APFloat y;
2360 const char *result;
2361 int status;
2362 int category;
2363 APFloat::roundingMode roundingMode = APFloat::rmNearestTiesToEven;
2364 } SpecialCaseTests[] = {
2365 { PInf, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2366 { PInf, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2367 { PInf, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2368 { PInf, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2369 { PInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2370 #if 0
2371 // See Note 1.
2372 { PInf, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2373 #endif
2374 { PInf, PNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2375 { PInf, MNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2376 { PInf, PLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2377 { PInf, MLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2378 { PInf, PSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2379 { PInf, MSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2380 { PInf, PSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity },
2381 { PInf, MSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity },
2382 { MInf, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2383 { MInf, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2384 { MInf, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2385 { MInf, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2386 { MInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2387 #if 0
2388 // See Note 1.
2389 { MInf, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2390 #endif
2391 { MInf, PNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2392 { MInf, MNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2393 { MInf, PLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2394 { MInf, MLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2395 { MInf, PSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2396 { MInf, MSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2397 { MInf, PSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity },
2398 { MInf, MSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity },
2399 { PZero, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2400 { PZero, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2401 { PZero, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2402 { PZero, MZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2403 { PZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2404 #if 0
2405 // See Note 1.
2406 { PZero, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2407 #endif
2408 { PZero, PNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2409 { PZero, MNormalValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2410 { PZero, PLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2411 { PZero, MLargestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2412 { PZero, PSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2413 { PZero, MSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2414 { PZero, PSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2415 { PZero, MSmallestNormalized, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2416 { MZero, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2417 { MZero, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2418 { MZero, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2419 { MZero, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2420 { MZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2421 #if 0
2422 // See Note 1.
2423 { MZero, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2424 #endif
2425 { MZero, PNormalValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2426 { MZero, MNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2427 { MZero, PLargestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2428 { MZero, MLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2429 { MZero, PSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2430 { MZero, MSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2431 { MZero, PSmallestNormalized, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2432 { MZero, MSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2433 { QNaN, PInf, "nan", APFloat::opOK, APFloat::fcNaN },
2434 { QNaN, MInf, "nan", APFloat::opOK, APFloat::fcNaN },
2435 { QNaN, PZero, "nan", APFloat::opOK, APFloat::fcNaN },
2436 { QNaN, MZero, "nan", APFloat::opOK, APFloat::fcNaN },
2437 { QNaN, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2438 #if 0
2439 // See Note 1.
2440 { QNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2441 #endif
2442 { QNaN, PNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
2443 { QNaN, MNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
2444 { QNaN, PLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2445 { QNaN, MLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2446 { QNaN, PSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2447 { QNaN, MSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2448 { QNaN, PSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
2449 { QNaN, MSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
2450 #if 0
2451 // See Note 1.
2452 { SNaN, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2453 { SNaN, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2454 { SNaN, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2455 { SNaN, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2456 { SNaN, QNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2457 { SNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2458 { SNaN, PNormalValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2459 { SNaN, MNormalValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2460 { SNaN, PLargestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2461 { SNaN, MLargestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2462 { SNaN, PSmallestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2463 { SNaN, MSmallestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2464 { SNaN, PSmallestNormalized, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2465 { SNaN, MSmallestNormalized, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2466 #endif
2467 { PNormalValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2468 { PNormalValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2469 { PNormalValue, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2470 { PNormalValue, MZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2471 { PNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2472 #if 0
2473 // See Note 1.
2474 { PNormalValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2475 #endif
2476 { PNormalValue, PNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2477 { PNormalValue, MNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2478 { PNormalValue, PLargestValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2479 { PNormalValue, MLargestValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2480 { PNormalValue, PSmallestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2481 { PNormalValue, MSmallestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2482 { PNormalValue, PSmallestNormalized, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2483 { PNormalValue, MSmallestNormalized, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2484 { MNormalValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2485 { MNormalValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2486 { MNormalValue, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2487 { MNormalValue, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2488 { MNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2489 #if 0
2490 // See Note 1.
2491 { MNormalValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2492 #endif
2493 { MNormalValue, PNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2494 { MNormalValue, MNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2495 { MNormalValue, PLargestValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2496 { MNormalValue, MLargestValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2497 { MNormalValue, PSmallestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2498 { MNormalValue, MSmallestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2499 { MNormalValue, PSmallestNormalized, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2500 { MNormalValue, MSmallestNormalized, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2501 { PLargestValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2502 { PLargestValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2503 { PLargestValue, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2504 { PLargestValue, MZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2505 { PLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2506 #if 0
2507 // See Note 1.
2508 { PLargestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2509 #endif
2510 { PLargestValue, PNormalValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2511 { PLargestValue, MNormalValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2512 { PLargestValue, PLargestValue, "inf", OverflowStatus, APFloat::fcInfinity },
2513 { PLargestValue, MLargestValue, "-inf", OverflowStatus, APFloat::fcInfinity },
2514 { PLargestValue, PSmallestValue, "0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal },
2515 { PLargestValue, MSmallestValue, "-0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal },
2516 { PLargestValue, PSmallestNormalized, "0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal },
2517 { PLargestValue, MSmallestNormalized, "-0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal },
2518 { MLargestValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2519 { MLargestValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2520 { MLargestValue, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2521 { MLargestValue, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2522 { MLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2523 #if 0
2524 // See Note 1.
2525 { MLargestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2526 #endif
2527 { MLargestValue, PNormalValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2528 { MLargestValue, MNormalValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2529 { MLargestValue, PLargestValue, "-inf", OverflowStatus, APFloat::fcInfinity },
2530 { MLargestValue, MLargestValue, "inf", OverflowStatus, APFloat::fcInfinity },
2531 { MLargestValue, PSmallestValue, "-0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal },
2532 { MLargestValue, MSmallestValue, "0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal },
2533 { MLargestValue, PSmallestNormalized, "-0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal },
2534 { MLargestValue, MSmallestNormalized, "0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal },
2535 { PSmallestValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2536 { PSmallestValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2537 { PSmallestValue, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2538 { PSmallestValue, MZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2539 { PSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2540 #if 0
2541 // See Note 1.
2542 { PSmallestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2543 #endif
2544 { PSmallestValue, PNormalValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2545 { PSmallestValue, MNormalValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2546 { PSmallestValue, PLargestValue, "0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal },
2547 { PSmallestValue, MLargestValue, "-0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal },
2548 { PSmallestValue, PSmallestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero },
2549 { PSmallestValue, MSmallestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2550 { PSmallestValue, PSmallestNormalized, "0x0p+0", UnderflowStatus, APFloat::fcZero },
2551 { PSmallestValue, MSmallestNormalized, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2552 { MSmallestValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2553 { MSmallestValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2554 { MSmallestValue, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2555 { MSmallestValue, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2556 { MSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2557 #if 0
2558 // See Note 1.
2559 { MSmallestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2560 #endif
2561 { MSmallestValue, PNormalValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2562 { MSmallestValue, MNormalValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2563 { MSmallestValue, PLargestValue, "-0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal },
2564 { MSmallestValue, MLargestValue, "0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal },
2565 { MSmallestValue, PSmallestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2566 { MSmallestValue, MSmallestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero },
2567 { MSmallestValue, PSmallestNormalized, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2568 { MSmallestValue, MSmallestNormalized, "0x0p+0", UnderflowStatus, APFloat::fcZero },
2569 { PSmallestNormalized, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2570 { PSmallestNormalized, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2571 { PSmallestNormalized, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2572 { PSmallestNormalized, MZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2573 { PSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2574 #if 0
2575 // See Note 1.
2576 { PSmallestNormalized, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2577 #endif
2578 { PSmallestNormalized, PNormalValue, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2579 { PSmallestNormalized, MNormalValue, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2580 { PSmallestNormalized, PLargestValue, "0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal },
2581 { PSmallestNormalized, MLargestValue, "-0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal },
2582 { PSmallestNormalized, PSmallestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero },
2583 { PSmallestNormalized, MSmallestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2584 { PSmallestNormalized, PSmallestNormalized, "0x0p+0", UnderflowStatus, APFloat::fcZero },
2585 { PSmallestNormalized, MSmallestNormalized, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2586 { MSmallestNormalized, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2587 { MSmallestNormalized, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2588 { MSmallestNormalized, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2589 { MSmallestNormalized, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2590 { MSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2591 #if 0
2592 // See Note 1.
2593 { MSmallestNormalized, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2594 #endif
2595 { MSmallestNormalized, PNormalValue, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2596 { MSmallestNormalized, MNormalValue, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2597 { MSmallestNormalized, PLargestValue, "-0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal },
2598 { MSmallestNormalized, MLargestValue, "0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal },
2599 { MSmallestNormalized, PSmallestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2600 { MSmallestNormalized, MSmallestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero },
2601 { MSmallestNormalized, PSmallestNormalized, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2602 { MSmallestNormalized, MSmallestNormalized, "0x0p+0", UnderflowStatus, APFloat::fcZero },
2603
2604 {MaxQuad, MinQuad, "0x1.ffffffffffffffffffffffffffffp-111", APFloat::opOK,
2605 APFloat::fcNormal, APFloat::rmNearestTiesToEven},
2606 {MaxQuad, MinQuad, "0x1.ffffffffffffffffffffffffffffp-111", APFloat::opOK,
2607 APFloat::fcNormal, APFloat::rmTowardPositive},
2608 {MaxQuad, MinQuad, "0x1.ffffffffffffffffffffffffffffp-111", APFloat::opOK,
2609 APFloat::fcNormal, APFloat::rmTowardNegative},
2610 {MaxQuad, MinQuad, "0x1.ffffffffffffffffffffffffffffp-111", APFloat::opOK,
2611 APFloat::fcNormal, APFloat::rmTowardZero},
2612 {MaxQuad, MinQuad, "0x1.ffffffffffffffffffffffffffffp-111", APFloat::opOK,
2613 APFloat::fcNormal, APFloat::rmNearestTiesToAway},
2614
2615 {MaxQuad, NMinQuad, "-0x1.ffffffffffffffffffffffffffffp-111", APFloat::opOK,
2616 APFloat::fcNormal, APFloat::rmNearestTiesToEven},
2617 {MaxQuad, NMinQuad, "-0x1.ffffffffffffffffffffffffffffp-111", APFloat::opOK,
2618 APFloat::fcNormal, APFloat::rmTowardPositive},
2619 {MaxQuad, NMinQuad, "-0x1.ffffffffffffffffffffffffffffp-111", APFloat::opOK,
2620 APFloat::fcNormal, APFloat::rmTowardNegative},
2621 {MaxQuad, NMinQuad, "-0x1.ffffffffffffffffffffffffffffp-111", APFloat::opOK,
2622 APFloat::fcNormal, APFloat::rmTowardZero},
2623 {MaxQuad, NMinQuad, "-0x1.ffffffffffffffffffffffffffffp-111", APFloat::opOK,
2624 APFloat::fcNormal, APFloat::rmNearestTiesToAway},
2625
2626 {MaxQuad, MaxQuad, "inf", OverflowStatus, APFloat::fcInfinity,
2627 APFloat::rmNearestTiesToEven},
2628 {MaxQuad, MaxQuad, "inf", OverflowStatus, APFloat::fcInfinity,
2629 APFloat::rmTowardPositive},
2630 {MaxQuad, MaxQuad, "0x1.ffffffffffffffffffffffffffffp+16383",
2631 APFloat::opInexact, APFloat::fcNormal, APFloat::rmTowardNegative},
2632 {MaxQuad, MaxQuad, "0x1.ffffffffffffffffffffffffffffp+16383",
2633 APFloat::opInexact, APFloat::fcNormal, APFloat::rmTowardZero},
2634 {MaxQuad, MaxQuad, "inf", OverflowStatus, APFloat::fcInfinity,
2635 APFloat::rmNearestTiesToAway},
2636
2637 {MinQuad, MinQuad, "0", UnderflowStatus, APFloat::fcZero,
2638 APFloat::rmNearestTiesToEven},
2639 {MinQuad, MinQuad, "0x0.0000000000000000000000000001p-16382",
2640 UnderflowStatus, APFloat::fcNormal, APFloat::rmTowardPositive},
2641 {MinQuad, MinQuad, "0", UnderflowStatus, APFloat::fcZero,
2642 APFloat::rmTowardNegative},
2643 {MinQuad, MinQuad, "0", UnderflowStatus, APFloat::fcZero,
2644 APFloat::rmTowardZero},
2645 {MinQuad, MinQuad, "0", UnderflowStatus, APFloat::fcZero,
2646 APFloat::rmNearestTiesToAway},
2647
2648 {MinQuad, NMinQuad, "-0", UnderflowStatus, APFloat::fcZero,
2649 APFloat::rmNearestTiesToEven},
2650 {MinQuad, NMinQuad, "-0", UnderflowStatus, APFloat::fcZero,
2651 APFloat::rmTowardPositive},
2652 {MinQuad, NMinQuad, "-0x0.0000000000000000000000000001p-16382",
2653 UnderflowStatus, APFloat::fcNormal, APFloat::rmTowardNegative},
2654 {MinQuad, NMinQuad, "-0", UnderflowStatus, APFloat::fcZero,
2655 APFloat::rmTowardZero},
2656 {MinQuad, NMinQuad, "-0", UnderflowStatus, APFloat::fcZero,
2657 APFloat::rmNearestTiesToAway},
2658 };
2659
2660 for (size_t i = 0; i < array_lengthof(SpecialCaseTests); ++i) {
2661 APFloat x(SpecialCaseTests[i].x);
2662 APFloat y(SpecialCaseTests[i].y);
2663 APFloat::opStatus status = x.multiply(y, SpecialCaseTests[i].roundingMode);
2664
2665 APFloat result(x.getSemantics(), SpecialCaseTests[i].result);
2666
2667 EXPECT_TRUE(result.bitwiseIsEqual(x));
2668 EXPECT_TRUE((int)status == SpecialCaseTests[i].status);
2669 EXPECT_TRUE((int)x.getCategory() == SpecialCaseTests[i].category);
2670 }
2671 }
2672
TEST(APFloatTest,divide)2673 TEST(APFloatTest, divide) {
2674 // Test Special Cases against each other and normal values.
2675
2676 // TODOS/NOTES:
2677 // 1. Since we perform only default exception handling all operations with
2678 // signaling NaNs should have a result that is a quiet NaN. Currently they
2679 // return sNaN.
2680
2681 APFloat PInf = APFloat::getInf(APFloat::IEEEsingle(), false);
2682 APFloat MInf = APFloat::getInf(APFloat::IEEEsingle(), true);
2683 APFloat PZero = APFloat::getZero(APFloat::IEEEsingle(), false);
2684 APFloat MZero = APFloat::getZero(APFloat::IEEEsingle(), true);
2685 APFloat QNaN = APFloat::getNaN(APFloat::IEEEsingle(), false);
2686 APFloat SNaN = APFloat::getSNaN(APFloat::IEEEsingle(), false);
2687 APFloat PNormalValue = APFloat(APFloat::IEEEsingle(), "0x1p+0");
2688 APFloat MNormalValue = APFloat(APFloat::IEEEsingle(), "-0x1p+0");
2689 APFloat PLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), false);
2690 APFloat MLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), true);
2691 APFloat PSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), false);
2692 APFloat MSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), true);
2693 APFloat PSmallestNormalized =
2694 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), false);
2695 APFloat MSmallestNormalized =
2696 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), true);
2697
2698 APFloat MaxQuad(APFloat::IEEEquad(),
2699 "0x1.ffffffffffffffffffffffffffffp+16383");
2700 APFloat MinQuad(APFloat::IEEEquad(),
2701 "0x0.0000000000000000000000000001p-16382");
2702 APFloat NMinQuad(APFloat::IEEEquad(),
2703 "-0x0.0000000000000000000000000001p-16382");
2704
2705 const int OverflowStatus = APFloat::opOverflow | APFloat::opInexact;
2706 const int UnderflowStatus = APFloat::opUnderflow | APFloat::opInexact;
2707
2708 struct {
2709 APFloat x;
2710 APFloat y;
2711 const char *result;
2712 int status;
2713 int category;
2714 APFloat::roundingMode roundingMode = APFloat::rmNearestTiesToEven;
2715 } SpecialCaseTests[] = {
2716 { PInf, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2717 { PInf, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2718 { PInf, PZero, "inf", APFloat::opOK, APFloat::fcInfinity },
2719 { PInf, MZero, "-inf", APFloat::opOK, APFloat::fcInfinity },
2720 { PInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2721 #if 0
2722 // See Note 1.
2723 { PInf, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2724 #endif
2725 { PInf, PNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2726 { PInf, MNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2727 { PInf, PLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2728 { PInf, MLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2729 { PInf, PSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2730 { PInf, MSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2731 { PInf, PSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity },
2732 { PInf, MSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity },
2733 { MInf, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2734 { MInf, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2735 { MInf, PZero, "-inf", APFloat::opOK, APFloat::fcInfinity },
2736 { MInf, MZero, "inf", APFloat::opOK, APFloat::fcInfinity },
2737 { MInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2738 #if 0
2739 // See Note 1.
2740 { MInf, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2741 #endif
2742 { MInf, PNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2743 { MInf, MNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2744 { MInf, PLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2745 { MInf, MLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2746 { MInf, PSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2747 { MInf, MSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2748 { MInf, PSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity },
2749 { MInf, MSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity },
2750 { PZero, PInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2751 { PZero, MInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2752 { PZero, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2753 { PZero, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2754 { PZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2755 #if 0
2756 // See Note 1.
2757 { PZero, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2758 #endif
2759 { PZero, PNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2760 { PZero, MNormalValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2761 { PZero, PLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2762 { PZero, MLargestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2763 { PZero, PSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2764 { PZero, MSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2765 { PZero, PSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2766 { PZero, MSmallestNormalized, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2767 { MZero, PInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2768 { MZero, MInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2769 { MZero, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2770 { MZero, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2771 { MZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2772 #if 0
2773 // See Note 1.
2774 { MZero, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2775 #endif
2776 { MZero, PNormalValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2777 { MZero, MNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2778 { MZero, PLargestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2779 { MZero, MLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2780 { MZero, PSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2781 { MZero, MSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2782 { MZero, PSmallestNormalized, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2783 { MZero, MSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2784 { QNaN, PInf, "nan", APFloat::opOK, APFloat::fcNaN },
2785 { QNaN, MInf, "nan", APFloat::opOK, APFloat::fcNaN },
2786 { QNaN, PZero, "nan", APFloat::opOK, APFloat::fcNaN },
2787 { QNaN, MZero, "nan", APFloat::opOK, APFloat::fcNaN },
2788 { QNaN, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2789 #if 0
2790 // See Note 1.
2791 { QNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2792 #endif
2793 { QNaN, PNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
2794 { QNaN, MNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
2795 { QNaN, PLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2796 { QNaN, MLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2797 { QNaN, PSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2798 { QNaN, MSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2799 { QNaN, PSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
2800 { QNaN, MSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
2801 #if 0
2802 // See Note 1.
2803 { SNaN, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2804 { SNaN, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2805 { SNaN, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2806 { SNaN, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2807 { SNaN, QNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2808 { SNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2809 { SNaN, PNormalValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2810 { SNaN, MNormalValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2811 { SNaN, PLargestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2812 { SNaN, MLargestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2813 { SNaN, PSmallestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2814 { SNaN, MSmallestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2815 { SNaN, PSmallestNormalized, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2816 { SNaN, MSmallestNormalized, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2817 #endif
2818 { PNormalValue, PInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2819 { PNormalValue, MInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2820 { PNormalValue, PZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
2821 { PNormalValue, MZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
2822 { PNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2823 #if 0
2824 // See Note 1.
2825 { PNormalValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2826 #endif
2827 { PNormalValue, PNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2828 { PNormalValue, MNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2829 { PNormalValue, PLargestValue, "0x1p-128", UnderflowStatus, APFloat::fcNormal },
2830 { PNormalValue, MLargestValue, "-0x1p-128", UnderflowStatus, APFloat::fcNormal },
2831 { PNormalValue, PSmallestValue, "inf", OverflowStatus, APFloat::fcInfinity },
2832 { PNormalValue, MSmallestValue, "-inf", OverflowStatus, APFloat::fcInfinity },
2833 { PNormalValue, PSmallestNormalized, "0x1p+126", APFloat::opOK, APFloat::fcNormal },
2834 { PNormalValue, MSmallestNormalized, "-0x1p+126", APFloat::opOK, APFloat::fcNormal },
2835 { MNormalValue, PInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2836 { MNormalValue, MInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2837 { MNormalValue, PZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
2838 { MNormalValue, MZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
2839 { MNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2840 #if 0
2841 // See Note 1.
2842 { MNormalValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2843 #endif
2844 { MNormalValue, PNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2845 { MNormalValue, MNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2846 { MNormalValue, PLargestValue, "-0x1p-128", UnderflowStatus, APFloat::fcNormal },
2847 { MNormalValue, MLargestValue, "0x1p-128", UnderflowStatus, APFloat::fcNormal },
2848 { MNormalValue, PSmallestValue, "-inf", OverflowStatus, APFloat::fcInfinity },
2849 { MNormalValue, MSmallestValue, "inf", OverflowStatus, APFloat::fcInfinity },
2850 { MNormalValue, PSmallestNormalized, "-0x1p+126", APFloat::opOK, APFloat::fcNormal },
2851 { MNormalValue, MSmallestNormalized, "0x1p+126", APFloat::opOK, APFloat::fcNormal },
2852 { PLargestValue, PInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2853 { PLargestValue, MInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2854 { PLargestValue, PZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
2855 { PLargestValue, MZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
2856 { PLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2857 #if 0
2858 // See Note 1.
2859 { PLargestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2860 #endif
2861 { PLargestValue, PNormalValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2862 { PLargestValue, MNormalValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2863 { PLargestValue, PLargestValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2864 { PLargestValue, MLargestValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2865 { PLargestValue, PSmallestValue, "inf", OverflowStatus, APFloat::fcInfinity },
2866 { PLargestValue, MSmallestValue, "-inf", OverflowStatus, APFloat::fcInfinity },
2867 { PLargestValue, PSmallestNormalized, "inf", OverflowStatus, APFloat::fcInfinity },
2868 { PLargestValue, MSmallestNormalized, "-inf", OverflowStatus, APFloat::fcInfinity },
2869 { MLargestValue, PInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2870 { MLargestValue, MInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2871 { MLargestValue, PZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
2872 { MLargestValue, MZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
2873 { MLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2874 #if 0
2875 // See Note 1.
2876 { MLargestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2877 #endif
2878 { MLargestValue, PNormalValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2879 { MLargestValue, MNormalValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2880 { MLargestValue, PLargestValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2881 { MLargestValue, MLargestValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2882 { MLargestValue, PSmallestValue, "-inf", OverflowStatus, APFloat::fcInfinity },
2883 { MLargestValue, MSmallestValue, "inf", OverflowStatus, APFloat::fcInfinity },
2884 { MLargestValue, PSmallestNormalized, "-inf", OverflowStatus, APFloat::fcInfinity },
2885 { MLargestValue, MSmallestNormalized, "inf", OverflowStatus, APFloat::fcInfinity },
2886 { PSmallestValue, PInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2887 { PSmallestValue, MInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2888 { PSmallestValue, PZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
2889 { PSmallestValue, MZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
2890 { PSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2891 #if 0
2892 // See Note 1.
2893 { PSmallestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2894 #endif
2895 { PSmallestValue, PNormalValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2896 { PSmallestValue, MNormalValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2897 { PSmallestValue, PLargestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero },
2898 { PSmallestValue, MLargestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2899 { PSmallestValue, PSmallestValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2900 { PSmallestValue, MSmallestValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2901 { PSmallestValue, PSmallestNormalized, "0x1p-23", APFloat::opOK, APFloat::fcNormal },
2902 { PSmallestValue, MSmallestNormalized, "-0x1p-23", APFloat::opOK, APFloat::fcNormal },
2903 { MSmallestValue, PInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2904 { MSmallestValue, MInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2905 { MSmallestValue, PZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
2906 { MSmallestValue, MZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
2907 { MSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2908 #if 0
2909 // See Note 1.
2910 { MSmallestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2911 #endif
2912 { MSmallestValue, PNormalValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2913 { MSmallestValue, MNormalValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2914 { MSmallestValue, PLargestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2915 { MSmallestValue, MLargestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero },
2916 { MSmallestValue, PSmallestValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2917 { MSmallestValue, MSmallestValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2918 { MSmallestValue, PSmallestNormalized, "-0x1p-23", APFloat::opOK, APFloat::fcNormal },
2919 { MSmallestValue, MSmallestNormalized, "0x1p-23", APFloat::opOK, APFloat::fcNormal },
2920 { PSmallestNormalized, PInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2921 { PSmallestNormalized, MInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2922 { PSmallestNormalized, PZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
2923 { PSmallestNormalized, MZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
2924 { PSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2925 #if 0
2926 // See Note 1.
2927 { PSmallestNormalized, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2928 #endif
2929 { PSmallestNormalized, PNormalValue, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2930 { PSmallestNormalized, MNormalValue, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2931 { PSmallestNormalized, PLargestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero },
2932 { PSmallestNormalized, MLargestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2933 { PSmallestNormalized, PSmallestValue, "0x1p+23", APFloat::opOK, APFloat::fcNormal },
2934 { PSmallestNormalized, MSmallestValue, "-0x1p+23", APFloat::opOK, APFloat::fcNormal },
2935 { PSmallestNormalized, PSmallestNormalized, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2936 { PSmallestNormalized, MSmallestNormalized, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2937 { MSmallestNormalized, PInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2938 { MSmallestNormalized, MInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2939 { MSmallestNormalized, PZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
2940 { MSmallestNormalized, MZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
2941 { MSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2942 #if 0
2943 // See Note 1.
2944 { MSmallestNormalized, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2945 #endif
2946 { MSmallestNormalized, PNormalValue, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2947 { MSmallestNormalized, MNormalValue, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2948 { MSmallestNormalized, PLargestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2949 { MSmallestNormalized, MLargestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero },
2950 { MSmallestNormalized, PSmallestValue, "-0x1p+23", APFloat::opOK, APFloat::fcNormal },
2951 { MSmallestNormalized, MSmallestValue, "0x1p+23", APFloat::opOK, APFloat::fcNormal },
2952 { MSmallestNormalized, PSmallestNormalized, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2953 { MSmallestNormalized, MSmallestNormalized, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2954
2955 {MaxQuad, NMinQuad, "-inf", OverflowStatus, APFloat::fcInfinity,
2956 APFloat::rmNearestTiesToEven},
2957 {MaxQuad, NMinQuad, "-0x1.ffffffffffffffffffffffffffffp+16383",
2958 APFloat::opInexact, APFloat::fcNormal, APFloat::rmTowardPositive},
2959 {MaxQuad, NMinQuad, "-inf", OverflowStatus, APFloat::fcInfinity,
2960 APFloat::rmTowardNegative},
2961 {MaxQuad, NMinQuad, "-0x1.ffffffffffffffffffffffffffffp+16383",
2962 APFloat::opInexact, APFloat::fcNormal, APFloat::rmTowardZero},
2963 {MaxQuad, NMinQuad, "-inf", OverflowStatus, APFloat::fcInfinity,
2964 APFloat::rmNearestTiesToAway},
2965
2966 {MinQuad, MaxQuad, "0", UnderflowStatus, APFloat::fcZero,
2967 APFloat::rmNearestTiesToEven},
2968 {MinQuad, MaxQuad, "0x0.0000000000000000000000000001p-16382",
2969 UnderflowStatus, APFloat::fcNormal, APFloat::rmTowardPositive},
2970 {MinQuad, MaxQuad, "0", UnderflowStatus, APFloat::fcZero,
2971 APFloat::rmTowardNegative},
2972 {MinQuad, MaxQuad, "0", UnderflowStatus, APFloat::fcZero,
2973 APFloat::rmTowardZero},
2974 {MinQuad, MaxQuad, "0", UnderflowStatus, APFloat::fcZero,
2975 APFloat::rmNearestTiesToAway},
2976
2977 {NMinQuad, MaxQuad, "-0", UnderflowStatus, APFloat::fcZero,
2978 APFloat::rmNearestTiesToEven},
2979 {NMinQuad, MaxQuad, "-0", UnderflowStatus, APFloat::fcZero,
2980 APFloat::rmTowardPositive},
2981 {NMinQuad, MaxQuad, "-0x0.0000000000000000000000000001p-16382",
2982 UnderflowStatus, APFloat::fcNormal, APFloat::rmTowardNegative},
2983 {NMinQuad, MaxQuad, "-0", UnderflowStatus, APFloat::fcZero,
2984 APFloat::rmTowardZero},
2985 {NMinQuad, MaxQuad, "-0", UnderflowStatus, APFloat::fcZero,
2986 APFloat::rmNearestTiesToAway},
2987 };
2988
2989 for (size_t i = 0; i < array_lengthof(SpecialCaseTests); ++i) {
2990 APFloat x(SpecialCaseTests[i].x);
2991 APFloat y(SpecialCaseTests[i].y);
2992 APFloat::opStatus status = x.divide(y, SpecialCaseTests[i].roundingMode);
2993
2994 APFloat result(x.getSemantics(), SpecialCaseTests[i].result);
2995
2996 EXPECT_TRUE(result.bitwiseIsEqual(x));
2997 EXPECT_TRUE((int)status == SpecialCaseTests[i].status);
2998 EXPECT_TRUE((int)x.getCategory() == SpecialCaseTests[i].category);
2999 }
3000 }
3001
TEST(APFloatTest,operatorOverloads)3002 TEST(APFloatTest, operatorOverloads) {
3003 // This is mostly testing that these operator overloads compile.
3004 APFloat One = APFloat(APFloat::IEEEsingle(), "0x1p+0");
3005 APFloat Two = APFloat(APFloat::IEEEsingle(), "0x2p+0");
3006 EXPECT_TRUE(Two.bitwiseIsEqual(One + One));
3007 EXPECT_TRUE(One.bitwiseIsEqual(Two - One));
3008 EXPECT_TRUE(Two.bitwiseIsEqual(One * Two));
3009 EXPECT_TRUE(One.bitwiseIsEqual(Two / Two));
3010 }
3011
TEST(APFloatTest,abs)3012 TEST(APFloatTest, abs) {
3013 APFloat PInf = APFloat::getInf(APFloat::IEEEsingle(), false);
3014 APFloat MInf = APFloat::getInf(APFloat::IEEEsingle(), true);
3015 APFloat PZero = APFloat::getZero(APFloat::IEEEsingle(), false);
3016 APFloat MZero = APFloat::getZero(APFloat::IEEEsingle(), true);
3017 APFloat PQNaN = APFloat::getNaN(APFloat::IEEEsingle(), false);
3018 APFloat MQNaN = APFloat::getNaN(APFloat::IEEEsingle(), true);
3019 APFloat PSNaN = APFloat::getSNaN(APFloat::IEEEsingle(), false);
3020 APFloat MSNaN = APFloat::getSNaN(APFloat::IEEEsingle(), true);
3021 APFloat PNormalValue = APFloat(APFloat::IEEEsingle(), "0x1p+0");
3022 APFloat MNormalValue = APFloat(APFloat::IEEEsingle(), "-0x1p+0");
3023 APFloat PLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), false);
3024 APFloat MLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), true);
3025 APFloat PSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), false);
3026 APFloat MSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), true);
3027 APFloat PSmallestNormalized =
3028 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), false);
3029 APFloat MSmallestNormalized =
3030 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), true);
3031
3032 EXPECT_TRUE(PInf.bitwiseIsEqual(abs(PInf)));
3033 EXPECT_TRUE(PInf.bitwiseIsEqual(abs(MInf)));
3034 EXPECT_TRUE(PZero.bitwiseIsEqual(abs(PZero)));
3035 EXPECT_TRUE(PZero.bitwiseIsEqual(abs(MZero)));
3036 EXPECT_TRUE(PQNaN.bitwiseIsEqual(abs(PQNaN)));
3037 EXPECT_TRUE(PQNaN.bitwiseIsEqual(abs(MQNaN)));
3038 EXPECT_TRUE(PSNaN.bitwiseIsEqual(abs(PSNaN)));
3039 EXPECT_TRUE(PSNaN.bitwiseIsEqual(abs(MSNaN)));
3040 EXPECT_TRUE(PNormalValue.bitwiseIsEqual(abs(PNormalValue)));
3041 EXPECT_TRUE(PNormalValue.bitwiseIsEqual(abs(MNormalValue)));
3042 EXPECT_TRUE(PLargestValue.bitwiseIsEqual(abs(PLargestValue)));
3043 EXPECT_TRUE(PLargestValue.bitwiseIsEqual(abs(MLargestValue)));
3044 EXPECT_TRUE(PSmallestValue.bitwiseIsEqual(abs(PSmallestValue)));
3045 EXPECT_TRUE(PSmallestValue.bitwiseIsEqual(abs(MSmallestValue)));
3046 EXPECT_TRUE(PSmallestNormalized.bitwiseIsEqual(abs(PSmallestNormalized)));
3047 EXPECT_TRUE(PSmallestNormalized.bitwiseIsEqual(abs(MSmallestNormalized)));
3048 }
3049
TEST(APFloatTest,neg)3050 TEST(APFloatTest, neg) {
3051 APFloat One = APFloat(APFloat::IEEEsingle(), "1.0");
3052 APFloat NegOne = APFloat(APFloat::IEEEsingle(), "-1.0");
3053 APFloat Zero = APFloat::getZero(APFloat::IEEEsingle(), false);
3054 APFloat NegZero = APFloat::getZero(APFloat::IEEEsingle(), true);
3055 APFloat Inf = APFloat::getInf(APFloat::IEEEsingle(), false);
3056 APFloat NegInf = APFloat::getInf(APFloat::IEEEsingle(), true);
3057 APFloat QNaN = APFloat::getNaN(APFloat::IEEEsingle(), false);
3058 APFloat NegQNaN = APFloat::getNaN(APFloat::IEEEsingle(), true);
3059
3060 EXPECT_TRUE(NegOne.bitwiseIsEqual(neg(One)));
3061 EXPECT_TRUE(One.bitwiseIsEqual(neg(NegOne)));
3062 EXPECT_TRUE(NegZero.bitwiseIsEqual(neg(Zero)));
3063 EXPECT_TRUE(Zero.bitwiseIsEqual(neg(NegZero)));
3064 EXPECT_TRUE(NegInf.bitwiseIsEqual(neg(Inf)));
3065 EXPECT_TRUE(Inf.bitwiseIsEqual(neg(NegInf)));
3066 EXPECT_TRUE(NegInf.bitwiseIsEqual(neg(Inf)));
3067 EXPECT_TRUE(Inf.bitwiseIsEqual(neg(NegInf)));
3068 EXPECT_TRUE(NegQNaN.bitwiseIsEqual(neg(QNaN)));
3069 EXPECT_TRUE(QNaN.bitwiseIsEqual(neg(NegQNaN)));
3070 }
3071
TEST(APFloatTest,ilogb)3072 TEST(APFloatTest, ilogb) {
3073 EXPECT_EQ(-1074, ilogb(APFloat::getSmallest(APFloat::IEEEdouble(), false)));
3074 EXPECT_EQ(-1074, ilogb(APFloat::getSmallest(APFloat::IEEEdouble(), true)));
3075 EXPECT_EQ(-1023, ilogb(APFloat(APFloat::IEEEdouble(), "0x1.ffffffffffffep-1024")));
3076 EXPECT_EQ(-1023, ilogb(APFloat(APFloat::IEEEdouble(), "0x1.ffffffffffffep-1023")));
3077 EXPECT_EQ(-1023, ilogb(APFloat(APFloat::IEEEdouble(), "-0x1.ffffffffffffep-1023")));
3078 EXPECT_EQ(-51, ilogb(APFloat(APFloat::IEEEdouble(), "0x1p-51")));
3079 EXPECT_EQ(-1023, ilogb(APFloat(APFloat::IEEEdouble(), "0x1.c60f120d9f87cp-1023")));
3080 EXPECT_EQ(-2, ilogb(APFloat(APFloat::IEEEdouble(), "0x0.ffffp-1")));
3081 EXPECT_EQ(-1023, ilogb(APFloat(APFloat::IEEEdouble(), "0x1.fffep-1023")));
3082 EXPECT_EQ(1023, ilogb(APFloat::getLargest(APFloat::IEEEdouble(), false)));
3083 EXPECT_EQ(1023, ilogb(APFloat::getLargest(APFloat::IEEEdouble(), true)));
3084
3085
3086 EXPECT_EQ(0, ilogb(APFloat(APFloat::IEEEsingle(), "0x1p+0")));
3087 EXPECT_EQ(0, ilogb(APFloat(APFloat::IEEEsingle(), "-0x1p+0")));
3088 EXPECT_EQ(42, ilogb(APFloat(APFloat::IEEEsingle(), "0x1p+42")));
3089 EXPECT_EQ(-42, ilogb(APFloat(APFloat::IEEEsingle(), "0x1p-42")));
3090
3091 EXPECT_EQ(APFloat::IEK_Inf,
3092 ilogb(APFloat::getInf(APFloat::IEEEsingle(), false)));
3093 EXPECT_EQ(APFloat::IEK_Inf,
3094 ilogb(APFloat::getInf(APFloat::IEEEsingle(), true)));
3095 EXPECT_EQ(APFloat::IEK_Zero,
3096 ilogb(APFloat::getZero(APFloat::IEEEsingle(), false)));
3097 EXPECT_EQ(APFloat::IEK_Zero,
3098 ilogb(APFloat::getZero(APFloat::IEEEsingle(), true)));
3099 EXPECT_EQ(APFloat::IEK_NaN,
3100 ilogb(APFloat::getNaN(APFloat::IEEEsingle(), false)));
3101 EXPECT_EQ(APFloat::IEK_NaN,
3102 ilogb(APFloat::getSNaN(APFloat::IEEEsingle(), false)));
3103
3104 EXPECT_EQ(127, ilogb(APFloat::getLargest(APFloat::IEEEsingle(), false)));
3105 EXPECT_EQ(127, ilogb(APFloat::getLargest(APFloat::IEEEsingle(), true)));
3106
3107 EXPECT_EQ(-149, ilogb(APFloat::getSmallest(APFloat::IEEEsingle(), false)));
3108 EXPECT_EQ(-149, ilogb(APFloat::getSmallest(APFloat::IEEEsingle(), true)));
3109 EXPECT_EQ(-126,
3110 ilogb(APFloat::getSmallestNormalized(APFloat::IEEEsingle(), false)));
3111 EXPECT_EQ(-126,
3112 ilogb(APFloat::getSmallestNormalized(APFloat::IEEEsingle(), true)));
3113 }
3114
TEST(APFloatTest,scalbn)3115 TEST(APFloatTest, scalbn) {
3116
3117 const APFloat::roundingMode RM = APFloat::rmNearestTiesToEven;
3118 EXPECT_TRUE(
3119 APFloat(APFloat::IEEEsingle(), "0x1p+0")
3120 .bitwiseIsEqual(scalbn(APFloat(APFloat::IEEEsingle(), "0x1p+0"), 0, RM)));
3121 EXPECT_TRUE(
3122 APFloat(APFloat::IEEEsingle(), "0x1p+42")
3123 .bitwiseIsEqual(scalbn(APFloat(APFloat::IEEEsingle(), "0x1p+0"), 42, RM)));
3124 EXPECT_TRUE(
3125 APFloat(APFloat::IEEEsingle(), "0x1p-42")
3126 .bitwiseIsEqual(scalbn(APFloat(APFloat::IEEEsingle(), "0x1p+0"), -42, RM)));
3127
3128 APFloat PInf = APFloat::getInf(APFloat::IEEEsingle(), false);
3129 APFloat MInf = APFloat::getInf(APFloat::IEEEsingle(), true);
3130 APFloat PZero = APFloat::getZero(APFloat::IEEEsingle(), false);
3131 APFloat MZero = APFloat::getZero(APFloat::IEEEsingle(), true);
3132 APFloat QPNaN = APFloat::getNaN(APFloat::IEEEsingle(), false);
3133 APFloat QMNaN = APFloat::getNaN(APFloat::IEEEsingle(), true);
3134 APFloat SNaN = APFloat::getSNaN(APFloat::IEEEsingle(), false);
3135
3136 EXPECT_TRUE(PInf.bitwiseIsEqual(scalbn(PInf, 0, RM)));
3137 EXPECT_TRUE(MInf.bitwiseIsEqual(scalbn(MInf, 0, RM)));
3138 EXPECT_TRUE(PZero.bitwiseIsEqual(scalbn(PZero, 0, RM)));
3139 EXPECT_TRUE(MZero.bitwiseIsEqual(scalbn(MZero, 0, RM)));
3140 EXPECT_TRUE(QPNaN.bitwiseIsEqual(scalbn(QPNaN, 0, RM)));
3141 EXPECT_TRUE(QMNaN.bitwiseIsEqual(scalbn(QMNaN, 0, RM)));
3142 EXPECT_FALSE(scalbn(SNaN, 0, RM).isSignaling());
3143
3144 APFloat ScalbnSNaN = scalbn(SNaN, 1, RM);
3145 EXPECT_TRUE(ScalbnSNaN.isNaN() && !ScalbnSNaN.isSignaling());
3146
3147 // Make sure highest bit of payload is preserved.
3148 const APInt Payload(64, (UINT64_C(1) << 50) |
3149 (UINT64_C(1) << 49) |
3150 (UINT64_C(1234) << 32) |
3151 1);
3152
3153 APFloat SNaNWithPayload = APFloat::getSNaN(APFloat::IEEEdouble(), false,
3154 &Payload);
3155 APFloat QuietPayload = scalbn(SNaNWithPayload, 1, RM);
3156 EXPECT_TRUE(QuietPayload.isNaN() && !QuietPayload.isSignaling());
3157 EXPECT_EQ(Payload, QuietPayload.bitcastToAPInt().getLoBits(51));
3158
3159 EXPECT_TRUE(PInf.bitwiseIsEqual(
3160 scalbn(APFloat(APFloat::IEEEsingle(), "0x1p+0"), 128, RM)));
3161 EXPECT_TRUE(MInf.bitwiseIsEqual(
3162 scalbn(APFloat(APFloat::IEEEsingle(), "-0x1p+0"), 128, RM)));
3163 EXPECT_TRUE(PInf.bitwiseIsEqual(
3164 scalbn(APFloat(APFloat::IEEEsingle(), "0x1p+127"), 1, RM)));
3165 EXPECT_TRUE(PZero.bitwiseIsEqual(
3166 scalbn(APFloat(APFloat::IEEEsingle(), "0x1p-127"), -127, RM)));
3167 EXPECT_TRUE(MZero.bitwiseIsEqual(
3168 scalbn(APFloat(APFloat::IEEEsingle(), "-0x1p-127"), -127, RM)));
3169 EXPECT_TRUE(APFloat(APFloat::IEEEsingle(), "-0x1p-149").bitwiseIsEqual(
3170 scalbn(APFloat(APFloat::IEEEsingle(), "-0x1p-127"), -22, RM)));
3171 EXPECT_TRUE(PZero.bitwiseIsEqual(
3172 scalbn(APFloat(APFloat::IEEEsingle(), "0x1p-126"), -24, RM)));
3173
3174
3175 APFloat SmallestF64 = APFloat::getSmallest(APFloat::IEEEdouble(), false);
3176 APFloat NegSmallestF64 = APFloat::getSmallest(APFloat::IEEEdouble(), true);
3177
3178 APFloat LargestF64 = APFloat::getLargest(APFloat::IEEEdouble(), false);
3179 APFloat NegLargestF64 = APFloat::getLargest(APFloat::IEEEdouble(), true);
3180
3181 APFloat SmallestNormalizedF64
3182 = APFloat::getSmallestNormalized(APFloat::IEEEdouble(), false);
3183 APFloat NegSmallestNormalizedF64
3184 = APFloat::getSmallestNormalized(APFloat::IEEEdouble(), true);
3185
3186 APFloat LargestDenormalF64(APFloat::IEEEdouble(), "0x1.ffffffffffffep-1023");
3187 APFloat NegLargestDenormalF64(APFloat::IEEEdouble(), "-0x1.ffffffffffffep-1023");
3188
3189
3190 EXPECT_TRUE(SmallestF64.bitwiseIsEqual(
3191 scalbn(APFloat(APFloat::IEEEdouble(), "0x1p-1074"), 0, RM)));
3192 EXPECT_TRUE(NegSmallestF64.bitwiseIsEqual(
3193 scalbn(APFloat(APFloat::IEEEdouble(), "-0x1p-1074"), 0, RM)));
3194
3195 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1p+1023")
3196 .bitwiseIsEqual(scalbn(SmallestF64, 2097, RM)));
3197
3198 EXPECT_TRUE(scalbn(SmallestF64, -2097, RM).isPosZero());
3199 EXPECT_TRUE(scalbn(SmallestF64, -2098, RM).isPosZero());
3200 EXPECT_TRUE(scalbn(SmallestF64, -2099, RM).isPosZero());
3201 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1p+1022")
3202 .bitwiseIsEqual(scalbn(SmallestF64, 2096, RM)));
3203 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1p+1023")
3204 .bitwiseIsEqual(scalbn(SmallestF64, 2097, RM)));
3205 EXPECT_TRUE(scalbn(SmallestF64, 2098, RM).isInfinity());
3206 EXPECT_TRUE(scalbn(SmallestF64, 2099, RM).isInfinity());
3207
3208 // Test for integer overflows when adding to exponent.
3209 EXPECT_TRUE(scalbn(SmallestF64, -INT_MAX, RM).isPosZero());
3210 EXPECT_TRUE(scalbn(LargestF64, INT_MAX, RM).isInfinity());
3211
3212 EXPECT_TRUE(LargestDenormalF64
3213 .bitwiseIsEqual(scalbn(LargestDenormalF64, 0, RM)));
3214 EXPECT_TRUE(NegLargestDenormalF64
3215 .bitwiseIsEqual(scalbn(NegLargestDenormalF64, 0, RM)));
3216
3217 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.ffffffffffffep-1022")
3218 .bitwiseIsEqual(scalbn(LargestDenormalF64, 1, RM)));
3219 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "-0x1.ffffffffffffep-1021")
3220 .bitwiseIsEqual(scalbn(NegLargestDenormalF64, 2, RM)));
3221
3222 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.ffffffffffffep+1")
3223 .bitwiseIsEqual(scalbn(LargestDenormalF64, 1024, RM)));
3224 EXPECT_TRUE(scalbn(LargestDenormalF64, -1023, RM).isPosZero());
3225 EXPECT_TRUE(scalbn(LargestDenormalF64, -1024, RM).isPosZero());
3226 EXPECT_TRUE(scalbn(LargestDenormalF64, -2048, RM).isPosZero());
3227 EXPECT_TRUE(scalbn(LargestDenormalF64, 2047, RM).isInfinity());
3228 EXPECT_TRUE(scalbn(LargestDenormalF64, 2098, RM).isInfinity());
3229 EXPECT_TRUE(scalbn(LargestDenormalF64, 2099, RM).isInfinity());
3230
3231 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.ffffffffffffep-2")
3232 .bitwiseIsEqual(scalbn(LargestDenormalF64, 1021, RM)));
3233 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.ffffffffffffep-1")
3234 .bitwiseIsEqual(scalbn(LargestDenormalF64, 1022, RM)));
3235 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.ffffffffffffep+0")
3236 .bitwiseIsEqual(scalbn(LargestDenormalF64, 1023, RM)));
3237 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.ffffffffffffep+1023")
3238 .bitwiseIsEqual(scalbn(LargestDenormalF64, 2046, RM)));
3239 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1p+974")
3240 .bitwiseIsEqual(scalbn(SmallestF64, 2048, RM)));
3241
3242 APFloat RandomDenormalF64(APFloat::IEEEdouble(), "0x1.c60f120d9f87cp+51");
3243 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.c60f120d9f87cp-972")
3244 .bitwiseIsEqual(scalbn(RandomDenormalF64, -1023, RM)));
3245 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.c60f120d9f87cp-1")
3246 .bitwiseIsEqual(scalbn(RandomDenormalF64, -52, RM)));
3247 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.c60f120d9f87cp-2")
3248 .bitwiseIsEqual(scalbn(RandomDenormalF64, -53, RM)));
3249 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.c60f120d9f87cp+0")
3250 .bitwiseIsEqual(scalbn(RandomDenormalF64, -51, RM)));
3251
3252 EXPECT_TRUE(scalbn(RandomDenormalF64, -2097, RM).isPosZero());
3253 EXPECT_TRUE(scalbn(RandomDenormalF64, -2090, RM).isPosZero());
3254
3255
3256 EXPECT_TRUE(
3257 APFloat(APFloat::IEEEdouble(), "-0x1p-1073")
3258 .bitwiseIsEqual(scalbn(NegLargestF64, -2097, RM)));
3259
3260 EXPECT_TRUE(
3261 APFloat(APFloat::IEEEdouble(), "-0x1p-1024")
3262 .bitwiseIsEqual(scalbn(NegLargestF64, -2048, RM)));
3263
3264 EXPECT_TRUE(
3265 APFloat(APFloat::IEEEdouble(), "0x1p-1073")
3266 .bitwiseIsEqual(scalbn(LargestF64, -2097, RM)));
3267
3268 EXPECT_TRUE(
3269 APFloat(APFloat::IEEEdouble(), "0x1p-1074")
3270 .bitwiseIsEqual(scalbn(LargestF64, -2098, RM)));
3271 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "-0x1p-1074")
3272 .bitwiseIsEqual(scalbn(NegLargestF64, -2098, RM)));
3273 EXPECT_TRUE(scalbn(NegLargestF64, -2099, RM).isNegZero());
3274 EXPECT_TRUE(scalbn(LargestF64, 1, RM).isInfinity());
3275
3276
3277 EXPECT_TRUE(
3278 APFloat(APFloat::IEEEdouble(), "0x1p+0")
3279 .bitwiseIsEqual(scalbn(APFloat(APFloat::IEEEdouble(), "0x1p+52"), -52, RM)));
3280
3281 EXPECT_TRUE(
3282 APFloat(APFloat::IEEEdouble(), "0x1p-103")
3283 .bitwiseIsEqual(scalbn(APFloat(APFloat::IEEEdouble(), "0x1p-51"), -52, RM)));
3284 }
3285
TEST(APFloatTest,frexp)3286 TEST(APFloatTest, frexp) {
3287 const APFloat::roundingMode RM = APFloat::rmNearestTiesToEven;
3288
3289 APFloat PZero = APFloat::getZero(APFloat::IEEEdouble(), false);
3290 APFloat MZero = APFloat::getZero(APFloat::IEEEdouble(), true);
3291 APFloat One(1.0);
3292 APFloat MOne(-1.0);
3293 APFloat Two(2.0);
3294 APFloat MTwo(-2.0);
3295
3296 APFloat LargestDenormal(APFloat::IEEEdouble(), "0x1.ffffffffffffep-1023");
3297 APFloat NegLargestDenormal(APFloat::IEEEdouble(), "-0x1.ffffffffffffep-1023");
3298
3299 APFloat Smallest = APFloat::getSmallest(APFloat::IEEEdouble(), false);
3300 APFloat NegSmallest = APFloat::getSmallest(APFloat::IEEEdouble(), true);
3301
3302 APFloat Largest = APFloat::getLargest(APFloat::IEEEdouble(), false);
3303 APFloat NegLargest = APFloat::getLargest(APFloat::IEEEdouble(), true);
3304
3305 APFloat PInf = APFloat::getInf(APFloat::IEEEdouble(), false);
3306 APFloat MInf = APFloat::getInf(APFloat::IEEEdouble(), true);
3307
3308 APFloat QPNaN = APFloat::getNaN(APFloat::IEEEdouble(), false);
3309 APFloat QMNaN = APFloat::getNaN(APFloat::IEEEdouble(), true);
3310 APFloat SNaN = APFloat::getSNaN(APFloat::IEEEdouble(), false);
3311
3312 // Make sure highest bit of payload is preserved.
3313 const APInt Payload(64, (UINT64_C(1) << 50) |
3314 (UINT64_C(1) << 49) |
3315 (UINT64_C(1234) << 32) |
3316 1);
3317
3318 APFloat SNaNWithPayload = APFloat::getSNaN(APFloat::IEEEdouble(), false,
3319 &Payload);
3320
3321 APFloat SmallestNormalized
3322 = APFloat::getSmallestNormalized(APFloat::IEEEdouble(), false);
3323 APFloat NegSmallestNormalized
3324 = APFloat::getSmallestNormalized(APFloat::IEEEdouble(), true);
3325
3326 int Exp;
3327 APFloat Frac(APFloat::IEEEdouble());
3328
3329
3330 Frac = frexp(PZero, Exp, RM);
3331 EXPECT_EQ(0, Exp);
3332 EXPECT_TRUE(Frac.isPosZero());
3333
3334 Frac = frexp(MZero, Exp, RM);
3335 EXPECT_EQ(0, Exp);
3336 EXPECT_TRUE(Frac.isNegZero());
3337
3338
3339 Frac = frexp(One, Exp, RM);
3340 EXPECT_EQ(1, Exp);
3341 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1p-1").bitwiseIsEqual(Frac));
3342
3343 Frac = frexp(MOne, Exp, RM);
3344 EXPECT_EQ(1, Exp);
3345 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "-0x1p-1").bitwiseIsEqual(Frac));
3346
3347 Frac = frexp(LargestDenormal, Exp, RM);
3348 EXPECT_EQ(-1022, Exp);
3349 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.ffffffffffffep-1").bitwiseIsEqual(Frac));
3350
3351 Frac = frexp(NegLargestDenormal, Exp, RM);
3352 EXPECT_EQ(-1022, Exp);
3353 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "-0x1.ffffffffffffep-1").bitwiseIsEqual(Frac));
3354
3355
3356 Frac = frexp(Smallest, Exp, RM);
3357 EXPECT_EQ(-1073, Exp);
3358 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1p-1").bitwiseIsEqual(Frac));
3359
3360 Frac = frexp(NegSmallest, Exp, RM);
3361 EXPECT_EQ(-1073, Exp);
3362 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "-0x1p-1").bitwiseIsEqual(Frac));
3363
3364
3365 Frac = frexp(Largest, Exp, RM);
3366 EXPECT_EQ(1024, Exp);
3367 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.fffffffffffffp-1").bitwiseIsEqual(Frac));
3368
3369 Frac = frexp(NegLargest, Exp, RM);
3370 EXPECT_EQ(1024, Exp);
3371 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "-0x1.fffffffffffffp-1").bitwiseIsEqual(Frac));
3372
3373
3374 Frac = frexp(PInf, Exp, RM);
3375 EXPECT_EQ(INT_MAX, Exp);
3376 EXPECT_TRUE(Frac.isInfinity() && !Frac.isNegative());
3377
3378 Frac = frexp(MInf, Exp, RM);
3379 EXPECT_EQ(INT_MAX, Exp);
3380 EXPECT_TRUE(Frac.isInfinity() && Frac.isNegative());
3381
3382 Frac = frexp(QPNaN, Exp, RM);
3383 EXPECT_EQ(INT_MIN, Exp);
3384 EXPECT_TRUE(Frac.isNaN());
3385
3386 Frac = frexp(QMNaN, Exp, RM);
3387 EXPECT_EQ(INT_MIN, Exp);
3388 EXPECT_TRUE(Frac.isNaN());
3389
3390 Frac = frexp(SNaN, Exp, RM);
3391 EXPECT_EQ(INT_MIN, Exp);
3392 EXPECT_TRUE(Frac.isNaN() && !Frac.isSignaling());
3393
3394 Frac = frexp(SNaNWithPayload, Exp, RM);
3395 EXPECT_EQ(INT_MIN, Exp);
3396 EXPECT_TRUE(Frac.isNaN() && !Frac.isSignaling());
3397 EXPECT_EQ(Payload, Frac.bitcastToAPInt().getLoBits(51));
3398
3399 Frac = frexp(APFloat(APFloat::IEEEdouble(), "0x0.ffffp-1"), Exp, RM);
3400 EXPECT_EQ(-1, Exp);
3401 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.fffep-1").bitwiseIsEqual(Frac));
3402
3403 Frac = frexp(APFloat(APFloat::IEEEdouble(), "0x1p-51"), Exp, RM);
3404 EXPECT_EQ(-50, Exp);
3405 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1p-1").bitwiseIsEqual(Frac));
3406
3407 Frac = frexp(APFloat(APFloat::IEEEdouble(), "0x1.c60f120d9f87cp+51"), Exp, RM);
3408 EXPECT_EQ(52, Exp);
3409 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.c60f120d9f87cp-1").bitwiseIsEqual(Frac));
3410 }
3411
TEST(APFloatTest,mod)3412 TEST(APFloatTest, mod) {
3413 {
3414 APFloat f1(APFloat::IEEEdouble(), "1.5");
3415 APFloat f2(APFloat::IEEEdouble(), "1.0");
3416 APFloat expected(APFloat::IEEEdouble(), "0.5");
3417 EXPECT_EQ(f1.mod(f2), APFloat::opOK);
3418 EXPECT_TRUE(f1.bitwiseIsEqual(expected));
3419 }
3420 {
3421 APFloat f1(APFloat::IEEEdouble(), "0.5");
3422 APFloat f2(APFloat::IEEEdouble(), "1.0");
3423 APFloat expected(APFloat::IEEEdouble(), "0.5");
3424 EXPECT_EQ(f1.mod(f2), APFloat::opOK);
3425 EXPECT_TRUE(f1.bitwiseIsEqual(expected));
3426 }
3427 {
3428 APFloat f1(APFloat::IEEEdouble(), "0x1.3333333333333p-2"); // 0.3
3429 APFloat f2(APFloat::IEEEdouble(), "0x1.47ae147ae147bp-7"); // 0.01
3430 APFloat expected(APFloat::IEEEdouble(),
3431 "0x1.47ae147ae1471p-7"); // 0.009999999999999983
3432 EXPECT_EQ(f1.mod(f2), APFloat::opOK);
3433 EXPECT_TRUE(f1.bitwiseIsEqual(expected));
3434 }
3435 {
3436 APFloat f1(APFloat::IEEEdouble(), "0x1p64"); // 1.8446744073709552e19
3437 APFloat f2(APFloat::IEEEdouble(), "1.5");
3438 APFloat expected(APFloat::IEEEdouble(), "1.0");
3439 EXPECT_EQ(f1.mod(f2), APFloat::opOK);
3440 EXPECT_TRUE(f1.bitwiseIsEqual(expected));
3441 }
3442 {
3443 APFloat f1(APFloat::IEEEdouble(), "0x1p1000");
3444 APFloat f2(APFloat::IEEEdouble(), "0x1p-1000");
3445 APFloat expected(APFloat::IEEEdouble(), "0.0");
3446 EXPECT_EQ(f1.mod(f2), APFloat::opOK);
3447 EXPECT_TRUE(f1.bitwiseIsEqual(expected));
3448 }
3449 {
3450 APFloat f1(APFloat::IEEEdouble(), "0.0");
3451 APFloat f2(APFloat::IEEEdouble(), "1.0");
3452 APFloat expected(APFloat::IEEEdouble(), "0.0");
3453 EXPECT_EQ(f1.mod(f2), APFloat::opOK);
3454 EXPECT_TRUE(f1.bitwiseIsEqual(expected));
3455 }
3456 {
3457 APFloat f1(APFloat::IEEEdouble(), "1.0");
3458 APFloat f2(APFloat::IEEEdouble(), "0.0");
3459 EXPECT_EQ(f1.mod(f2), APFloat::opInvalidOp);
3460 EXPECT_TRUE(f1.isNaN());
3461 }
3462 {
3463 APFloat f1(APFloat::IEEEdouble(), "0.0");
3464 APFloat f2(APFloat::IEEEdouble(), "0.0");
3465 EXPECT_EQ(f1.mod(f2), APFloat::opInvalidOp);
3466 EXPECT_TRUE(f1.isNaN());
3467 }
3468 {
3469 APFloat f1 = APFloat::getInf(APFloat::IEEEdouble(), false);
3470 APFloat f2(APFloat::IEEEdouble(), "1.0");
3471 EXPECT_EQ(f1.mod(f2), APFloat::opInvalidOp);
3472 EXPECT_TRUE(f1.isNaN());
3473 }
3474 {
3475 APFloat f1(APFloat::IEEEdouble(), "-4.0");
3476 APFloat f2(APFloat::IEEEdouble(), "-2.0");
3477 APFloat expected(APFloat::IEEEdouble(), "-0.0");
3478 EXPECT_EQ(f1.mod(f2), APFloat::opOK);
3479 EXPECT_TRUE(f1.bitwiseIsEqual(expected));
3480 }
3481 {
3482 APFloat f1(APFloat::IEEEdouble(), "-4.0");
3483 APFloat f2(APFloat::IEEEdouble(), "2.0");
3484 APFloat expected(APFloat::IEEEdouble(), "-0.0");
3485 EXPECT_EQ(f1.mod(f2), APFloat::opOK);
3486 EXPECT_TRUE(f1.bitwiseIsEqual(expected));
3487 }
3488 }
3489
TEST(APFloatTest,PPCDoubleDoubleAddSpecial)3490 TEST(APFloatTest, PPCDoubleDoubleAddSpecial) {
3491 using DataType = std::tuple<uint64_t, uint64_t, uint64_t, uint64_t,
3492 APFloat::fltCategory, APFloat::roundingMode>;
3493 DataType Data[] = {
3494 // (1 + 0) + (-1 + 0) = fcZero
3495 std::make_tuple(0x3ff0000000000000ull, 0, 0xbff0000000000000ull, 0,
3496 APFloat::fcZero, APFloat::rmNearestTiesToEven),
3497 // LDBL_MAX + (1.1 >> (1023 - 106) + 0)) = fcInfinity
3498 std::make_tuple(0x7fefffffffffffffull, 0x7c8ffffffffffffeull,
3499 0x7948000000000000ull, 0ull, APFloat::fcInfinity,
3500 APFloat::rmNearestTiesToEven),
3501 // TODO: change the 4th 0x75effffffffffffe to 0x75efffffffffffff when
3502 // semPPCDoubleDoubleLegacy is gone.
3503 // LDBL_MAX + (1.011111... >> (1023 - 106) + (1.1111111...0 >> (1023 -
3504 // 160))) = fcNormal
3505 std::make_tuple(0x7fefffffffffffffull, 0x7c8ffffffffffffeull,
3506 0x7947ffffffffffffull, 0x75effffffffffffeull,
3507 APFloat::fcNormal, APFloat::rmNearestTiesToEven),
3508 // LDBL_MAX + (1.1 >> (1023 - 106) + 0)) = fcInfinity
3509 std::make_tuple(0x7fefffffffffffffull, 0x7c8ffffffffffffeull,
3510 0x7fefffffffffffffull, 0x7c8ffffffffffffeull,
3511 APFloat::fcInfinity, APFloat::rmNearestTiesToEven),
3512 // NaN + (1 + 0) = fcNaN
3513 std::make_tuple(0x7ff8000000000000ull, 0, 0x3ff0000000000000ull, 0,
3514 APFloat::fcNaN, APFloat::rmNearestTiesToEven),
3515 };
3516
3517 for (auto Tp : Data) {
3518 uint64_t Op1[2], Op2[2];
3519 APFloat::fltCategory Expected;
3520 APFloat::roundingMode RM;
3521 std::tie(Op1[0], Op1[1], Op2[0], Op2[1], Expected, RM) = Tp;
3522
3523 {
3524 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
3525 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
3526 A1.add(A2, RM);
3527
3528 EXPECT_EQ(Expected, A1.getCategory())
3529 << formatv("({0:x} + {1:x}) + ({2:x} + {3:x})", Op1[0], Op1[1],
3530 Op2[0], Op2[1])
3531 .str();
3532 }
3533 {
3534 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
3535 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
3536 A2.add(A1, RM);
3537
3538 EXPECT_EQ(Expected, A2.getCategory())
3539 << formatv("({0:x} + {1:x}) + ({2:x} + {3:x})", Op2[0], Op2[1],
3540 Op1[0], Op1[1])
3541 .str();
3542 }
3543 }
3544 }
3545
TEST(APFloatTest,PPCDoubleDoubleAdd)3546 TEST(APFloatTest, PPCDoubleDoubleAdd) {
3547 using DataType = std::tuple<uint64_t, uint64_t, uint64_t, uint64_t, uint64_t,
3548 uint64_t, APFloat::roundingMode>;
3549 DataType Data[] = {
3550 // (1 + 0) + (1e-105 + 0) = (1 + 1e-105)
3551 std::make_tuple(0x3ff0000000000000ull, 0, 0x3960000000000000ull, 0,
3552 0x3ff0000000000000ull, 0x3960000000000000ull,
3553 APFloat::rmNearestTiesToEven),
3554 // (1 + 0) + (1e-106 + 0) = (1 + 1e-106)
3555 std::make_tuple(0x3ff0000000000000ull, 0, 0x3950000000000000ull, 0,
3556 0x3ff0000000000000ull, 0x3950000000000000ull,
3557 APFloat::rmNearestTiesToEven),
3558 // (1 + 1e-106) + (1e-106 + 0) = (1 + 1e-105)
3559 std::make_tuple(0x3ff0000000000000ull, 0x3950000000000000ull,
3560 0x3950000000000000ull, 0, 0x3ff0000000000000ull,
3561 0x3960000000000000ull, APFloat::rmNearestTiesToEven),
3562 // (1 + 0) + (epsilon + 0) = (1 + epsilon)
3563 std::make_tuple(0x3ff0000000000000ull, 0, 0x0000000000000001ull, 0,
3564 0x3ff0000000000000ull, 0x0000000000000001ull,
3565 APFloat::rmNearestTiesToEven),
3566 // TODO: change 0xf950000000000000 to 0xf940000000000000, when
3567 // semPPCDoubleDoubleLegacy is gone.
3568 // (DBL_MAX - 1 << (1023 - 105)) + (1 << (1023 - 53) + 0) = DBL_MAX +
3569 // 1.11111... << (1023 - 52)
3570 std::make_tuple(0x7fefffffffffffffull, 0xf950000000000000ull,
3571 0x7c90000000000000ull, 0, 0x7fefffffffffffffull,
3572 0x7c8ffffffffffffeull, APFloat::rmNearestTiesToEven),
3573 // TODO: change 0xf950000000000000 to 0xf940000000000000, when
3574 // semPPCDoubleDoubleLegacy is gone.
3575 // (1 << (1023 - 53) + 0) + (DBL_MAX - 1 << (1023 - 105)) = DBL_MAX +
3576 // 1.11111... << (1023 - 52)
3577 std::make_tuple(0x7c90000000000000ull, 0, 0x7fefffffffffffffull,
3578 0xf950000000000000ull, 0x7fefffffffffffffull,
3579 0x7c8ffffffffffffeull, APFloat::rmNearestTiesToEven),
3580 };
3581
3582 for (auto Tp : Data) {
3583 uint64_t Op1[2], Op2[2], Expected[2];
3584 APFloat::roundingMode RM;
3585 std::tie(Op1[0], Op1[1], Op2[0], Op2[1], Expected[0], Expected[1], RM) = Tp;
3586
3587 {
3588 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
3589 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
3590 A1.add(A2, RM);
3591
3592 EXPECT_EQ(Expected[0], A1.bitcastToAPInt().getRawData()[0])
3593 << formatv("({0:x} + {1:x}) + ({2:x} + {3:x})", Op1[0], Op1[1],
3594 Op2[0], Op2[1])
3595 .str();
3596 EXPECT_EQ(Expected[1], A1.bitcastToAPInt().getRawData()[1])
3597 << formatv("({0:x} + {1:x}) + ({2:x} + {3:x})", Op1[0], Op1[1],
3598 Op2[0], Op2[1])
3599 .str();
3600 }
3601 {
3602 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
3603 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
3604 A2.add(A1, RM);
3605
3606 EXPECT_EQ(Expected[0], A2.bitcastToAPInt().getRawData()[0])
3607 << formatv("({0:x} + {1:x}) + ({2:x} + {3:x})", Op2[0], Op2[1],
3608 Op1[0], Op1[1])
3609 .str();
3610 EXPECT_EQ(Expected[1], A2.bitcastToAPInt().getRawData()[1])
3611 << formatv("({0:x} + {1:x}) + ({2:x} + {3:x})", Op2[0], Op2[1],
3612 Op1[0], Op1[1])
3613 .str();
3614 }
3615 }
3616 }
3617
TEST(APFloatTest,PPCDoubleDoubleSubtract)3618 TEST(APFloatTest, PPCDoubleDoubleSubtract) {
3619 using DataType = std::tuple<uint64_t, uint64_t, uint64_t, uint64_t, uint64_t,
3620 uint64_t, APFloat::roundingMode>;
3621 DataType Data[] = {
3622 // (1 + 0) - (-1e-105 + 0) = (1 + 1e-105)
3623 std::make_tuple(0x3ff0000000000000ull, 0, 0xb960000000000000ull, 0,
3624 0x3ff0000000000000ull, 0x3960000000000000ull,
3625 APFloat::rmNearestTiesToEven),
3626 // (1 + 0) - (-1e-106 + 0) = (1 + 1e-106)
3627 std::make_tuple(0x3ff0000000000000ull, 0, 0xb950000000000000ull, 0,
3628 0x3ff0000000000000ull, 0x3950000000000000ull,
3629 APFloat::rmNearestTiesToEven),
3630 };
3631
3632 for (auto Tp : Data) {
3633 uint64_t Op1[2], Op2[2], Expected[2];
3634 APFloat::roundingMode RM;
3635 std::tie(Op1[0], Op1[1], Op2[0], Op2[1], Expected[0], Expected[1], RM) = Tp;
3636
3637 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
3638 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
3639 A1.subtract(A2, RM);
3640
3641 EXPECT_EQ(Expected[0], A1.bitcastToAPInt().getRawData()[0])
3642 << formatv("({0:x} + {1:x}) - ({2:x} + {3:x})", Op1[0], Op1[1], Op2[0],
3643 Op2[1])
3644 .str();
3645 EXPECT_EQ(Expected[1], A1.bitcastToAPInt().getRawData()[1])
3646 << formatv("({0:x} + {1:x}) - ({2:x} + {3:x})", Op1[0], Op1[1], Op2[0],
3647 Op2[1])
3648 .str();
3649 }
3650 }
3651
TEST(APFloatTest,PPCDoubleDoubleMultiplySpecial)3652 TEST(APFloatTest, PPCDoubleDoubleMultiplySpecial) {
3653 using DataType = std::tuple<uint64_t, uint64_t, uint64_t, uint64_t,
3654 APFloat::fltCategory, APFloat::roundingMode>;
3655 DataType Data[] = {
3656 // fcNaN * fcNaN = fcNaN
3657 std::make_tuple(0x7ff8000000000000ull, 0, 0x7ff8000000000000ull, 0,
3658 APFloat::fcNaN, APFloat::rmNearestTiesToEven),
3659 // fcNaN * fcZero = fcNaN
3660 std::make_tuple(0x7ff8000000000000ull, 0, 0, 0, APFloat::fcNaN,
3661 APFloat::rmNearestTiesToEven),
3662 // fcNaN * fcInfinity = fcNaN
3663 std::make_tuple(0x7ff8000000000000ull, 0, 0x7ff0000000000000ull, 0,
3664 APFloat::fcNaN, APFloat::rmNearestTiesToEven),
3665 // fcNaN * fcNormal = fcNaN
3666 std::make_tuple(0x7ff8000000000000ull, 0, 0x3ff0000000000000ull, 0,
3667 APFloat::fcNaN, APFloat::rmNearestTiesToEven),
3668 // fcInfinity * fcInfinity = fcInfinity
3669 std::make_tuple(0x7ff0000000000000ull, 0, 0x7ff0000000000000ull, 0,
3670 APFloat::fcInfinity, APFloat::rmNearestTiesToEven),
3671 // fcInfinity * fcZero = fcNaN
3672 std::make_tuple(0x7ff0000000000000ull, 0, 0, 0, APFloat::fcNaN,
3673 APFloat::rmNearestTiesToEven),
3674 // fcInfinity * fcNormal = fcInfinity
3675 std::make_tuple(0x7ff0000000000000ull, 0, 0x3ff0000000000000ull, 0,
3676 APFloat::fcInfinity, APFloat::rmNearestTiesToEven),
3677 // fcZero * fcZero = fcZero
3678 std::make_tuple(0, 0, 0, 0, APFloat::fcZero,
3679 APFloat::rmNearestTiesToEven),
3680 // fcZero * fcNormal = fcZero
3681 std::make_tuple(0, 0, 0x3ff0000000000000ull, 0, APFloat::fcZero,
3682 APFloat::rmNearestTiesToEven),
3683 };
3684
3685 for (auto Tp : Data) {
3686 uint64_t Op1[2], Op2[2];
3687 APFloat::fltCategory Expected;
3688 APFloat::roundingMode RM;
3689 std::tie(Op1[0], Op1[1], Op2[0], Op2[1], Expected, RM) = Tp;
3690
3691 {
3692 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
3693 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
3694 A1.multiply(A2, RM);
3695
3696 EXPECT_EQ(Expected, A1.getCategory())
3697 << formatv("({0:x} + {1:x}) * ({2:x} + {3:x})", Op1[0], Op1[1],
3698 Op2[0], Op2[1])
3699 .str();
3700 }
3701 {
3702 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
3703 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
3704 A2.multiply(A1, RM);
3705
3706 EXPECT_EQ(Expected, A2.getCategory())
3707 << formatv("({0:x} + {1:x}) * ({2:x} + {3:x})", Op2[0], Op2[1],
3708 Op1[0], Op1[1])
3709 .str();
3710 }
3711 }
3712 }
3713
TEST(APFloatTest,PPCDoubleDoubleMultiply)3714 TEST(APFloatTest, PPCDoubleDoubleMultiply) {
3715 using DataType = std::tuple<uint64_t, uint64_t, uint64_t, uint64_t, uint64_t,
3716 uint64_t, APFloat::roundingMode>;
3717 DataType Data[] = {
3718 // 1/3 * 3 = 1.0
3719 std::make_tuple(0x3fd5555555555555ull, 0x3c75555555555556ull,
3720 0x4008000000000000ull, 0, 0x3ff0000000000000ull, 0,
3721 APFloat::rmNearestTiesToEven),
3722 // (1 + epsilon) * (1 + 0) = fcZero
3723 std::make_tuple(0x3ff0000000000000ull, 0x0000000000000001ull,
3724 0x3ff0000000000000ull, 0, 0x3ff0000000000000ull,
3725 0x0000000000000001ull, APFloat::rmNearestTiesToEven),
3726 // (1 + epsilon) * (1 + epsilon) = 1 + 2 * epsilon
3727 std::make_tuple(0x3ff0000000000000ull, 0x0000000000000001ull,
3728 0x3ff0000000000000ull, 0x0000000000000001ull,
3729 0x3ff0000000000000ull, 0x0000000000000002ull,
3730 APFloat::rmNearestTiesToEven),
3731 // -(1 + epsilon) * (1 + epsilon) = -1
3732 std::make_tuple(0xbff0000000000000ull, 0x0000000000000001ull,
3733 0x3ff0000000000000ull, 0x0000000000000001ull,
3734 0xbff0000000000000ull, 0, APFloat::rmNearestTiesToEven),
3735 // (0.5 + 0) * (1 + 2 * epsilon) = 0.5 + epsilon
3736 std::make_tuple(0x3fe0000000000000ull, 0, 0x3ff0000000000000ull,
3737 0x0000000000000002ull, 0x3fe0000000000000ull,
3738 0x0000000000000001ull, APFloat::rmNearestTiesToEven),
3739 // (0.5 + 0) * (1 + epsilon) = 0.5
3740 std::make_tuple(0x3fe0000000000000ull, 0, 0x3ff0000000000000ull,
3741 0x0000000000000001ull, 0x3fe0000000000000ull, 0,
3742 APFloat::rmNearestTiesToEven),
3743 // __LDBL_MAX__ * (1 + 1 << 106) = inf
3744 std::make_tuple(0x7fefffffffffffffull, 0x7c8ffffffffffffeull,
3745 0x3ff0000000000000ull, 0x3950000000000000ull,
3746 0x7ff0000000000000ull, 0, APFloat::rmNearestTiesToEven),
3747 // __LDBL_MAX__ * (1 + 1 << 107) > __LDBL_MAX__, but not inf, yes =_=|||
3748 std::make_tuple(0x7fefffffffffffffull, 0x7c8ffffffffffffeull,
3749 0x3ff0000000000000ull, 0x3940000000000000ull,
3750 0x7fefffffffffffffull, 0x7c8fffffffffffffull,
3751 APFloat::rmNearestTiesToEven),
3752 // __LDBL_MAX__ * (1 + 1 << 108) = __LDBL_MAX__
3753 std::make_tuple(0x7fefffffffffffffull, 0x7c8ffffffffffffeull,
3754 0x3ff0000000000000ull, 0x3930000000000000ull,
3755 0x7fefffffffffffffull, 0x7c8ffffffffffffeull,
3756 APFloat::rmNearestTiesToEven),
3757 };
3758
3759 for (auto Tp : Data) {
3760 uint64_t Op1[2], Op2[2], Expected[2];
3761 APFloat::roundingMode RM;
3762 std::tie(Op1[0], Op1[1], Op2[0], Op2[1], Expected[0], Expected[1], RM) = Tp;
3763
3764 {
3765 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
3766 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
3767 A1.multiply(A2, RM);
3768
3769 EXPECT_EQ(Expected[0], A1.bitcastToAPInt().getRawData()[0])
3770 << formatv("({0:x} + {1:x}) * ({2:x} + {3:x})", Op1[0], Op1[1],
3771 Op2[0], Op2[1])
3772 .str();
3773 EXPECT_EQ(Expected[1], A1.bitcastToAPInt().getRawData()[1])
3774 << formatv("({0:x} + {1:x}) * ({2:x} + {3:x})", Op1[0], Op1[1],
3775 Op2[0], Op2[1])
3776 .str();
3777 }
3778 {
3779 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
3780 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
3781 A2.multiply(A1, RM);
3782
3783 EXPECT_EQ(Expected[0], A2.bitcastToAPInt().getRawData()[0])
3784 << formatv("({0:x} + {1:x}) * ({2:x} + {3:x})", Op2[0], Op2[1],
3785 Op1[0], Op1[1])
3786 .str();
3787 EXPECT_EQ(Expected[1], A2.bitcastToAPInt().getRawData()[1])
3788 << formatv("({0:x} + {1:x}) * ({2:x} + {3:x})", Op2[0], Op2[1],
3789 Op1[0], Op1[1])
3790 .str();
3791 }
3792 }
3793 }
3794
TEST(APFloatTest,PPCDoubleDoubleDivide)3795 TEST(APFloatTest, PPCDoubleDoubleDivide) {
3796 using DataType = std::tuple<uint64_t, uint64_t, uint64_t, uint64_t, uint64_t,
3797 uint64_t, APFloat::roundingMode>;
3798 // TODO: Only a sanity check for now. Add more edge cases when the
3799 // double-double algorithm is implemented.
3800 DataType Data[] = {
3801 // 1 / 3 = 1/3
3802 std::make_tuple(0x3ff0000000000000ull, 0, 0x4008000000000000ull, 0,
3803 0x3fd5555555555555ull, 0x3c75555555555556ull,
3804 APFloat::rmNearestTiesToEven),
3805 };
3806
3807 for (auto Tp : Data) {
3808 uint64_t Op1[2], Op2[2], Expected[2];
3809 APFloat::roundingMode RM;
3810 std::tie(Op1[0], Op1[1], Op2[0], Op2[1], Expected[0], Expected[1], RM) = Tp;
3811
3812 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
3813 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
3814 A1.divide(A2, RM);
3815
3816 EXPECT_EQ(Expected[0], A1.bitcastToAPInt().getRawData()[0])
3817 << formatv("({0:x} + {1:x}) / ({2:x} + {3:x})", Op1[0], Op1[1], Op2[0],
3818 Op2[1])
3819 .str();
3820 EXPECT_EQ(Expected[1], A1.bitcastToAPInt().getRawData()[1])
3821 << formatv("({0:x} + {1:x}) / ({2:x} + {3:x})", Op1[0], Op1[1], Op2[0],
3822 Op2[1])
3823 .str();
3824 }
3825 }
3826
TEST(APFloatTest,PPCDoubleDoubleRemainder)3827 TEST(APFloatTest, PPCDoubleDoubleRemainder) {
3828 using DataType =
3829 std::tuple<uint64_t, uint64_t, uint64_t, uint64_t, uint64_t, uint64_t>;
3830 DataType Data[] = {
3831 // remainder(3.0 + 3.0 << 53, 1.25 + 1.25 << 53) = (0.5 + 0.5 << 53)
3832 std::make_tuple(0x4008000000000000ull, 0x3cb8000000000000ull,
3833 0x3ff4000000000000ull, 0x3ca4000000000000ull,
3834 0x3fe0000000000000ull, 0x3c90000000000000ull),
3835 // remainder(3.0 + 3.0 << 53, 1.75 + 1.75 << 53) = (-0.5 - 0.5 << 53)
3836 std::make_tuple(0x4008000000000000ull, 0x3cb8000000000000ull,
3837 0x3ffc000000000000ull, 0x3cac000000000000ull,
3838 0xbfe0000000000000ull, 0xbc90000000000000ull),
3839 };
3840
3841 for (auto Tp : Data) {
3842 uint64_t Op1[2], Op2[2], Expected[2];
3843 std::tie(Op1[0], Op1[1], Op2[0], Op2[1], Expected[0], Expected[1]) = Tp;
3844
3845 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
3846 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
3847 A1.remainder(A2);
3848
3849 EXPECT_EQ(Expected[0], A1.bitcastToAPInt().getRawData()[0])
3850 << formatv("remainder({0:x} + {1:x}), ({2:x} + {3:x}))", Op1[0], Op1[1],
3851 Op2[0], Op2[1])
3852 .str();
3853 EXPECT_EQ(Expected[1], A1.bitcastToAPInt().getRawData()[1])
3854 << formatv("remainder(({0:x} + {1:x}), ({2:x} + {3:x}))", Op1[0],
3855 Op1[1], Op2[0], Op2[1])
3856 .str();
3857 }
3858 }
3859
TEST(APFloatTest,PPCDoubleDoubleMod)3860 TEST(APFloatTest, PPCDoubleDoubleMod) {
3861 using DataType =
3862 std::tuple<uint64_t, uint64_t, uint64_t, uint64_t, uint64_t, uint64_t>;
3863 DataType Data[] = {
3864 // mod(3.0 + 3.0 << 53, 1.25 + 1.25 << 53) = (0.5 + 0.5 << 53)
3865 std::make_tuple(0x4008000000000000ull, 0x3cb8000000000000ull,
3866 0x3ff4000000000000ull, 0x3ca4000000000000ull,
3867 0x3fe0000000000000ull, 0x3c90000000000000ull),
3868 // mod(3.0 + 3.0 << 53, 1.75 + 1.75 << 53) = (1.25 + 1.25 << 53)
3869 // 0xbc98000000000000 doesn't seem right, but it's what we currently have.
3870 // TODO: investigate
3871 std::make_tuple(0x4008000000000000ull, 0x3cb8000000000000ull,
3872 0x3ffc000000000000ull, 0x3cac000000000000ull,
3873 0x3ff4000000000001ull, 0xbc98000000000000ull),
3874 };
3875
3876 for (auto Tp : Data) {
3877 uint64_t Op1[2], Op2[2], Expected[2];
3878 std::tie(Op1[0], Op1[1], Op2[0], Op2[1], Expected[0], Expected[1]) = Tp;
3879
3880 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
3881 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
3882 A1.mod(A2);
3883
3884 EXPECT_EQ(Expected[0], A1.bitcastToAPInt().getRawData()[0])
3885 << formatv("fmod(({0:x} + {1:x}), ({2:x} + {3:x}))", Op1[0], Op1[1],
3886 Op2[0], Op2[1])
3887 .str();
3888 EXPECT_EQ(Expected[1], A1.bitcastToAPInt().getRawData()[1])
3889 << formatv("fmod(({0:x} + {1:x}), ({2:x} + {3:x}))", Op1[0], Op1[1],
3890 Op2[0], Op2[1])
3891 .str();
3892 }
3893 }
3894
TEST(APFloatTest,PPCDoubleDoubleFMA)3895 TEST(APFloatTest, PPCDoubleDoubleFMA) {
3896 // Sanity check for now.
3897 APFloat A(APFloat::PPCDoubleDouble(), "2");
3898 A.fusedMultiplyAdd(APFloat(APFloat::PPCDoubleDouble(), "3"),
3899 APFloat(APFloat::PPCDoubleDouble(), "4"),
3900 APFloat::rmNearestTiesToEven);
3901 EXPECT_EQ(APFloat::cmpEqual,
3902 APFloat(APFloat::PPCDoubleDouble(), "10").compare(A));
3903 }
3904
TEST(APFloatTest,PPCDoubleDoubleRoundToIntegral)3905 TEST(APFloatTest, PPCDoubleDoubleRoundToIntegral) {
3906 {
3907 APFloat A(APFloat::PPCDoubleDouble(), "1.5");
3908 A.roundToIntegral(APFloat::rmNearestTiesToEven);
3909 EXPECT_EQ(APFloat::cmpEqual,
3910 APFloat(APFloat::PPCDoubleDouble(), "2").compare(A));
3911 }
3912 {
3913 APFloat A(APFloat::PPCDoubleDouble(), "2.5");
3914 A.roundToIntegral(APFloat::rmNearestTiesToEven);
3915 EXPECT_EQ(APFloat::cmpEqual,
3916 APFloat(APFloat::PPCDoubleDouble(), "2").compare(A));
3917 }
3918 }
3919
TEST(APFloatTest,PPCDoubleDoubleCompare)3920 TEST(APFloatTest, PPCDoubleDoubleCompare) {
3921 using DataType =
3922 std::tuple<uint64_t, uint64_t, uint64_t, uint64_t, APFloat::cmpResult>;
3923
3924 DataType Data[] = {
3925 // (1 + 0) = (1 + 0)
3926 std::make_tuple(0x3ff0000000000000ull, 0, 0x3ff0000000000000ull, 0,
3927 APFloat::cmpEqual),
3928 // (1 + 0) < (1.00...1 + 0)
3929 std::make_tuple(0x3ff0000000000000ull, 0, 0x3ff0000000000001ull, 0,
3930 APFloat::cmpLessThan),
3931 // (1.00...1 + 0) > (1 + 0)
3932 std::make_tuple(0x3ff0000000000001ull, 0, 0x3ff0000000000000ull, 0,
3933 APFloat::cmpGreaterThan),
3934 // (1 + 0) < (1 + epsilon)
3935 std::make_tuple(0x3ff0000000000000ull, 0, 0x3ff0000000000001ull,
3936 0x0000000000000001ull, APFloat::cmpLessThan),
3937 // NaN != NaN
3938 std::make_tuple(0x7ff8000000000000ull, 0, 0x7ff8000000000000ull, 0,
3939 APFloat::cmpUnordered),
3940 // (1 + 0) != NaN
3941 std::make_tuple(0x3ff0000000000000ull, 0, 0x7ff8000000000000ull, 0,
3942 APFloat::cmpUnordered),
3943 // Inf = Inf
3944 std::make_tuple(0x7ff0000000000000ull, 0, 0x7ff0000000000000ull, 0,
3945 APFloat::cmpEqual),
3946 };
3947
3948 for (auto Tp : Data) {
3949 uint64_t Op1[2], Op2[2];
3950 APFloat::cmpResult Expected;
3951 std::tie(Op1[0], Op1[1], Op2[0], Op2[1], Expected) = Tp;
3952
3953 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
3954 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
3955 EXPECT_EQ(Expected, A1.compare(A2))
3956 << formatv("compare(({0:x} + {1:x}), ({2:x} + {3:x}))", Op1[0], Op1[1],
3957 Op2[0], Op2[1])
3958 .str();
3959 }
3960 }
3961
TEST(APFloatTest,PPCDoubleDoubleBitwiseIsEqual)3962 TEST(APFloatTest, PPCDoubleDoubleBitwiseIsEqual) {
3963 using DataType = std::tuple<uint64_t, uint64_t, uint64_t, uint64_t, bool>;
3964
3965 DataType Data[] = {
3966 // (1 + 0) = (1 + 0)
3967 std::make_tuple(0x3ff0000000000000ull, 0, 0x3ff0000000000000ull, 0, true),
3968 // (1 + 0) != (1.00...1 + 0)
3969 std::make_tuple(0x3ff0000000000000ull, 0, 0x3ff0000000000001ull, 0,
3970 false),
3971 // NaN = NaN
3972 std::make_tuple(0x7ff8000000000000ull, 0, 0x7ff8000000000000ull, 0, true),
3973 // NaN != NaN with a different bit pattern
3974 std::make_tuple(0x7ff8000000000000ull, 0, 0x7ff8000000000000ull,
3975 0x3ff0000000000000ull, false),
3976 // Inf = Inf
3977 std::make_tuple(0x7ff0000000000000ull, 0, 0x7ff0000000000000ull, 0, true),
3978 };
3979
3980 for (auto Tp : Data) {
3981 uint64_t Op1[2], Op2[2];
3982 bool Expected;
3983 std::tie(Op1[0], Op1[1], Op2[0], Op2[1], Expected) = Tp;
3984
3985 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
3986 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
3987 EXPECT_EQ(Expected, A1.bitwiseIsEqual(A2))
3988 << formatv("({0:x} + {1:x}) = ({2:x} + {3:x})", Op1[0], Op1[1], Op2[0],
3989 Op2[1])
3990 .str();
3991 }
3992 }
3993
TEST(APFloatTest,PPCDoubleDoubleHashValue)3994 TEST(APFloatTest, PPCDoubleDoubleHashValue) {
3995 uint64_t Data1[] = {0x3ff0000000000001ull, 0x0000000000000001ull};
3996 uint64_t Data2[] = {0x3ff0000000000001ull, 0};
3997 // The hash values are *hopefully* different.
3998 EXPECT_NE(
3999 hash_value(APFloat(APFloat::PPCDoubleDouble(), APInt(128, 2, Data1))),
4000 hash_value(APFloat(APFloat::PPCDoubleDouble(), APInt(128, 2, Data2))));
4001 }
4002
TEST(APFloatTest,PPCDoubleDoubleChangeSign)4003 TEST(APFloatTest, PPCDoubleDoubleChangeSign) {
4004 uint64_t Data[] = {
4005 0x400f000000000000ull, 0xbcb0000000000000ull,
4006 };
4007 APFloat Float(APFloat::PPCDoubleDouble(), APInt(128, 2, Data));
4008 {
4009 APFloat Actual =
4010 APFloat::copySign(Float, APFloat(APFloat::IEEEdouble(), "1"));
4011 EXPECT_EQ(0x400f000000000000ull, Actual.bitcastToAPInt().getRawData()[0]);
4012 EXPECT_EQ(0xbcb0000000000000ull, Actual.bitcastToAPInt().getRawData()[1]);
4013 }
4014 {
4015 APFloat Actual =
4016 APFloat::copySign(Float, APFloat(APFloat::IEEEdouble(), "-1"));
4017 EXPECT_EQ(0xc00f000000000000ull, Actual.bitcastToAPInt().getRawData()[0]);
4018 EXPECT_EQ(0x3cb0000000000000ull, Actual.bitcastToAPInt().getRawData()[1]);
4019 }
4020 }
4021
TEST(APFloatTest,PPCDoubleDoubleFactories)4022 TEST(APFloatTest, PPCDoubleDoubleFactories) {
4023 {
4024 uint64_t Data[] = {
4025 0, 0,
4026 };
4027 EXPECT_EQ(APInt(128, 2, Data),
4028 APFloat::getZero(APFloat::PPCDoubleDouble()).bitcastToAPInt());
4029 }
4030 {
4031 uint64_t Data[] = {
4032 0x7fefffffffffffffull, 0x7c8ffffffffffffeull,
4033 };
4034 EXPECT_EQ(APInt(128, 2, Data),
4035 APFloat::getLargest(APFloat::PPCDoubleDouble()).bitcastToAPInt());
4036 }
4037 {
4038 uint64_t Data[] = {
4039 0x0000000000000001ull, 0,
4040 };
4041 EXPECT_EQ(
4042 APInt(128, 2, Data),
4043 APFloat::getSmallest(APFloat::PPCDoubleDouble()).bitcastToAPInt());
4044 }
4045 {
4046 uint64_t Data[] = {0x0360000000000000ull, 0};
4047 EXPECT_EQ(APInt(128, 2, Data),
4048 APFloat::getSmallestNormalized(APFloat::PPCDoubleDouble())
4049 .bitcastToAPInt());
4050 }
4051 {
4052 uint64_t Data[] = {
4053 0x8000000000000000ull, 0x0000000000000000ull,
4054 };
4055 EXPECT_EQ(
4056 APInt(128, 2, Data),
4057 APFloat::getZero(APFloat::PPCDoubleDouble(), true).bitcastToAPInt());
4058 }
4059 {
4060 uint64_t Data[] = {
4061 0xffefffffffffffffull, 0xfc8ffffffffffffeull,
4062 };
4063 EXPECT_EQ(
4064 APInt(128, 2, Data),
4065 APFloat::getLargest(APFloat::PPCDoubleDouble(), true).bitcastToAPInt());
4066 }
4067 {
4068 uint64_t Data[] = {
4069 0x8000000000000001ull, 0x0000000000000000ull,
4070 };
4071 EXPECT_EQ(APInt(128, 2, Data),
4072 APFloat::getSmallest(APFloat::PPCDoubleDouble(), true)
4073 .bitcastToAPInt());
4074 }
4075 {
4076 uint64_t Data[] = {
4077 0x8360000000000000ull, 0x0000000000000000ull,
4078 };
4079 EXPECT_EQ(APInt(128, 2, Data),
4080 APFloat::getSmallestNormalized(APFloat::PPCDoubleDouble(), true)
4081 .bitcastToAPInt());
4082 }
4083 EXPECT_TRUE(APFloat::getSmallest(APFloat::PPCDoubleDouble()).isSmallest());
4084 EXPECT_TRUE(APFloat::getLargest(APFloat::PPCDoubleDouble()).isLargest());
4085 }
4086
TEST(APFloatTest,PPCDoubleDoubleIsDenormal)4087 TEST(APFloatTest, PPCDoubleDoubleIsDenormal) {
4088 EXPECT_TRUE(APFloat::getSmallest(APFloat::PPCDoubleDouble()).isDenormal());
4089 EXPECT_FALSE(APFloat::getLargest(APFloat::PPCDoubleDouble()).isDenormal());
4090 EXPECT_FALSE(
4091 APFloat::getSmallestNormalized(APFloat::PPCDoubleDouble()).isDenormal());
4092 {
4093 // (4 + 3) is not normalized
4094 uint64_t Data[] = {
4095 0x4010000000000000ull, 0x4008000000000000ull,
4096 };
4097 EXPECT_TRUE(
4098 APFloat(APFloat::PPCDoubleDouble(), APInt(128, 2, Data)).isDenormal());
4099 }
4100 }
4101
TEST(APFloatTest,PPCDoubleDoubleScalbn)4102 TEST(APFloatTest, PPCDoubleDoubleScalbn) {
4103 // 3.0 + 3.0 << 53
4104 uint64_t Input[] = {
4105 0x4008000000000000ull, 0x3cb8000000000000ull,
4106 };
4107 APFloat Result =
4108 scalbn(APFloat(APFloat::PPCDoubleDouble(), APInt(128, 2, Input)), 1,
4109 APFloat::rmNearestTiesToEven);
4110 // 6.0 + 6.0 << 53
4111 EXPECT_EQ(0x4018000000000000ull, Result.bitcastToAPInt().getRawData()[0]);
4112 EXPECT_EQ(0x3cc8000000000000ull, Result.bitcastToAPInt().getRawData()[1]);
4113 }
4114
TEST(APFloatTest,PPCDoubleDoubleFrexp)4115 TEST(APFloatTest, PPCDoubleDoubleFrexp) {
4116 // 3.0 + 3.0 << 53
4117 uint64_t Input[] = {
4118 0x4008000000000000ull, 0x3cb8000000000000ull,
4119 };
4120 int Exp;
4121 // 0.75 + 0.75 << 53
4122 APFloat Result =
4123 frexp(APFloat(APFloat::PPCDoubleDouble(), APInt(128, 2, Input)), Exp,
4124 APFloat::rmNearestTiesToEven);
4125 EXPECT_EQ(2, Exp);
4126 EXPECT_EQ(0x3fe8000000000000ull, Result.bitcastToAPInt().getRawData()[0]);
4127 EXPECT_EQ(0x3c98000000000000ull, Result.bitcastToAPInt().getRawData()[1]);
4128 }
4129 }
4130