1 //===- llvm/unittest/ADT/APFloat.cpp - APFloat unit tests ---------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 #include "llvm/ADT/APFloat.h"
11 #include "llvm/ADT/APSInt.h"
12 #include "llvm/ADT/SmallString.h"
13 #include "llvm/ADT/SmallVector.h"
14 #include "llvm/Support/raw_ostream.h"
15 #include "gtest/gtest.h"
21 static double convertToDoubleFromString(const char *Str) {
23 F.convertFromString(Str, llvm::APFloat::rmNearestTiesToEven);
24 return F.convertToDouble();
27 static std::string convertToString(double d, unsigned Prec, unsigned Pad) {
28 llvm::SmallVector<char, 100> Buffer;
30 F.toString(Buffer, Prec, Pad);
31 return std::string(Buffer.data(), Buffer.size());
36 TEST(APFloatTest, isSignaling) {
37 // We test qNaN, -qNaN, +sNaN, -sNaN with and without payloads. *NOTE* The
38 // positive/negative distinction is included only since the getQNaN/getSNaN
39 // API provides the option.
40 APInt payload = APInt::getOneBitSet(4, 2);
41 EXPECT_FALSE(APFloat::getQNaN(APFloat::IEEEsingle, false).isSignaling());
42 EXPECT_FALSE(APFloat::getQNaN(APFloat::IEEEsingle, true).isSignaling());
43 EXPECT_FALSE(APFloat::getQNaN(APFloat::IEEEsingle, false, &payload).isSignaling());
44 EXPECT_FALSE(APFloat::getQNaN(APFloat::IEEEsingle, true, &payload).isSignaling());
45 EXPECT_TRUE(APFloat::getSNaN(APFloat::IEEEsingle, false).isSignaling());
46 EXPECT_TRUE(APFloat::getSNaN(APFloat::IEEEsingle, true).isSignaling());
47 EXPECT_TRUE(APFloat::getSNaN(APFloat::IEEEsingle, false, &payload).isSignaling());
48 EXPECT_TRUE(APFloat::getSNaN(APFloat::IEEEsingle, true, &payload).isSignaling());
51 TEST(APFloatTest, next) {
53 APFloat test(APFloat::IEEEquad, APFloat::uninitialized);
54 APFloat expected(APFloat::IEEEquad, APFloat::uninitialized);
56 // 1. Test Special Cases Values.
58 // Test all special values for nextUp and nextDown perscribed by IEEE-754R
71 // nextUp(+inf) = +inf.
72 test = APFloat::getInf(APFloat::IEEEquad, false);
73 expected = APFloat::getInf(APFloat::IEEEquad, false);
74 EXPECT_EQ(test.next(false), APFloat::opOK);
75 EXPECT_TRUE(test.isInfinity());
76 EXPECT_TRUE(!test.isNegative());
77 EXPECT_TRUE(test.bitwiseIsEqual(expected));
79 // nextDown(+inf) = -nextUp(-inf) = -(-getLargest()) = getLargest()
80 test = APFloat::getInf(APFloat::IEEEquad, false);
81 expected = APFloat::getLargest(APFloat::IEEEquad, false);
82 EXPECT_EQ(test.next(true), APFloat::opOK);
83 EXPECT_TRUE(!test.isNegative());
84 EXPECT_TRUE(test.bitwiseIsEqual(expected));
86 // nextUp(-inf) = -getLargest()
87 test = APFloat::getInf(APFloat::IEEEquad, true);
88 expected = APFloat::getLargest(APFloat::IEEEquad, true);
89 EXPECT_EQ(test.next(false), APFloat::opOK);
90 EXPECT_TRUE(test.isNegative());
91 EXPECT_TRUE(test.bitwiseIsEqual(expected));
93 // nextDown(-inf) = -nextUp(+inf) = -(+inf) = -inf.
94 test = APFloat::getInf(APFloat::IEEEquad, true);
95 expected = APFloat::getInf(APFloat::IEEEquad, true);
96 EXPECT_EQ(test.next(true), APFloat::opOK);
97 EXPECT_TRUE(test.isInfinity() && test.isNegative());
98 EXPECT_TRUE(test.bitwiseIsEqual(expected));
100 // nextUp(getLargest()) = +inf
101 test = APFloat::getLargest(APFloat::IEEEquad, false);
102 expected = APFloat::getInf(APFloat::IEEEquad, false);
103 EXPECT_EQ(test.next(false), APFloat::opOK);
104 EXPECT_TRUE(test.isInfinity() && !test.isNegative());
105 EXPECT_TRUE(test.bitwiseIsEqual(expected));
107 // nextDown(getLargest()) = -nextUp(-getLargest())
108 // = -(-getLargest() + inc)
109 // = getLargest() - inc.
110 test = APFloat::getLargest(APFloat::IEEEquad, false);
111 expected = APFloat(APFloat::IEEEquad,
112 "0x1.fffffffffffffffffffffffffffep+16383");
113 EXPECT_EQ(test.next(true), APFloat::opOK);
114 EXPECT_TRUE(!test.isInfinity() && !test.isNegative());
115 EXPECT_TRUE(test.bitwiseIsEqual(expected));
117 // nextUp(-getLargest()) = -getLargest() + inc.
118 test = APFloat::getLargest(APFloat::IEEEquad, true);
119 expected = APFloat(APFloat::IEEEquad,
120 "-0x1.fffffffffffffffffffffffffffep+16383");
121 EXPECT_EQ(test.next(false), APFloat::opOK);
122 EXPECT_TRUE(test.bitwiseIsEqual(expected));
124 // nextDown(-getLargest()) = -nextUp(getLargest()) = -(inf) = -inf.
125 test = APFloat::getLargest(APFloat::IEEEquad, true);
126 expected = APFloat::getInf(APFloat::IEEEquad, true);
127 EXPECT_EQ(test.next(true), APFloat::opOK);
128 EXPECT_TRUE(test.isInfinity() && test.isNegative());
129 EXPECT_TRUE(test.bitwiseIsEqual(expected));
131 // nextUp(getSmallest()) = getSmallest() + inc.
132 test = APFloat(APFloat::IEEEquad, "0x0.0000000000000000000000000001p-16382");
133 expected = APFloat(APFloat::IEEEquad,
134 "0x0.0000000000000000000000000002p-16382");
135 EXPECT_EQ(test.next(false), APFloat::opOK);
136 EXPECT_TRUE(test.bitwiseIsEqual(expected));
138 // nextDown(getSmallest()) = -nextUp(-getSmallest()) = -(-0) = +0.
139 test = APFloat(APFloat::IEEEquad, "0x0.0000000000000000000000000001p-16382");
140 expected = APFloat::getZero(APFloat::IEEEquad, false);
141 EXPECT_EQ(test.next(true), APFloat::opOK);
142 EXPECT_TRUE(test.isZero() && !test.isNegative());
143 EXPECT_TRUE(test.bitwiseIsEqual(expected));
145 // nextUp(-getSmallest()) = -0.
146 test = APFloat(APFloat::IEEEquad, "-0x0.0000000000000000000000000001p-16382");
147 expected = APFloat::getZero(APFloat::IEEEquad, true);
148 EXPECT_EQ(test.next(false), APFloat::opOK);
149 EXPECT_TRUE(test.isZero() && test.isNegative());
150 EXPECT_TRUE(test.bitwiseIsEqual(expected));
152 // nextDown(-getSmallest()) = -nextUp(getSmallest()) = -getSmallest() - inc.
153 test = APFloat(APFloat::IEEEquad, "-0x0.0000000000000000000000000001p-16382");
154 expected = APFloat(APFloat::IEEEquad,
155 "-0x0.0000000000000000000000000002p-16382");
156 EXPECT_EQ(test.next(true), APFloat::opOK);
157 EXPECT_TRUE(test.bitwiseIsEqual(expected));
159 // nextUp(qNaN) = qNaN
160 test = APFloat::getQNaN(APFloat::IEEEquad, false);
161 expected = APFloat::getQNaN(APFloat::IEEEquad, false);
162 EXPECT_EQ(test.next(false), APFloat::opOK);
163 EXPECT_TRUE(test.bitwiseIsEqual(expected));
165 // nextDown(qNaN) = qNaN
166 test = APFloat::getQNaN(APFloat::IEEEquad, false);
167 expected = APFloat::getQNaN(APFloat::IEEEquad, false);
168 EXPECT_EQ(test.next(true), APFloat::opOK);
169 EXPECT_TRUE(test.bitwiseIsEqual(expected));
171 // nextUp(sNaN) = qNaN
172 test = APFloat::getSNaN(APFloat::IEEEquad, false);
173 expected = APFloat::getQNaN(APFloat::IEEEquad, false);
174 EXPECT_EQ(test.next(false), APFloat::opInvalidOp);
175 EXPECT_TRUE(test.bitwiseIsEqual(expected));
177 // nextDown(sNaN) = qNaN
178 test = APFloat::getSNaN(APFloat::IEEEquad, false);
179 expected = APFloat::getQNaN(APFloat::IEEEquad, false);
180 EXPECT_EQ(test.next(true), APFloat::opInvalidOp);
181 EXPECT_TRUE(test.bitwiseIsEqual(expected));
183 // nextUp(+0) = +getSmallest()
184 test = APFloat::getZero(APFloat::IEEEquad, false);
185 expected = APFloat::getSmallest(APFloat::IEEEquad, false);
186 EXPECT_EQ(test.next(false), APFloat::opOK);
187 EXPECT_TRUE(test.bitwiseIsEqual(expected));
189 // nextDown(+0) = -nextUp(-0) = -getSmallest()
190 test = APFloat::getZero(APFloat::IEEEquad, false);
191 expected = APFloat::getSmallest(APFloat::IEEEquad, true);
192 EXPECT_EQ(test.next(true), APFloat::opOK);
193 EXPECT_TRUE(test.bitwiseIsEqual(expected));
195 // nextUp(-0) = +getSmallest()
196 test = APFloat::getZero(APFloat::IEEEquad, true);
197 expected = APFloat::getSmallest(APFloat::IEEEquad, false);
198 EXPECT_EQ(test.next(false), APFloat::opOK);
199 EXPECT_TRUE(test.bitwiseIsEqual(expected));
201 // nextDown(-0) = -nextUp(0) = -getSmallest()
202 test = APFloat::getZero(APFloat::IEEEquad, true);
203 expected = APFloat::getSmallest(APFloat::IEEEquad, true);
204 EXPECT_EQ(test.next(true), APFloat::opOK);
205 EXPECT_TRUE(test.bitwiseIsEqual(expected));
207 // 2. Binade Boundary Tests.
209 // 2a. Test denormal <-> normal binade boundaries.
210 // * nextUp(+Largest Denormal) -> +Smallest Normal.
211 // * nextDown(-Largest Denormal) -> -Smallest Normal.
212 // * nextUp(-Smallest Normal) -> -Largest Denormal.
213 // * nextDown(+Smallest Normal) -> +Largest Denormal.
215 // nextUp(+Largest Denormal) -> +Smallest Normal.
216 test = APFloat(APFloat::IEEEquad, "0x0.ffffffffffffffffffffffffffffp-16382");
217 expected = APFloat(APFloat::IEEEquad,
218 "0x1.0000000000000000000000000000p-16382");
219 EXPECT_EQ(test.next(false), APFloat::opOK);
220 EXPECT_FALSE(test.isDenormal());
221 EXPECT_TRUE(test.bitwiseIsEqual(expected));
223 // nextDown(-Largest Denormal) -> -Smallest Normal.
224 test = APFloat(APFloat::IEEEquad,
225 "-0x0.ffffffffffffffffffffffffffffp-16382");
226 expected = APFloat(APFloat::IEEEquad,
227 "-0x1.0000000000000000000000000000p-16382");
228 EXPECT_EQ(test.next(true), APFloat::opOK);
229 EXPECT_FALSE(test.isDenormal());
230 EXPECT_TRUE(test.bitwiseIsEqual(expected));
232 // nextUp(-Smallest Normal) -> -LargestDenormal.
233 test = APFloat(APFloat::IEEEquad,
234 "-0x1.0000000000000000000000000000p-16382");
235 expected = APFloat(APFloat::IEEEquad,
236 "-0x0.ffffffffffffffffffffffffffffp-16382");
237 EXPECT_EQ(test.next(false), APFloat::opOK);
238 EXPECT_TRUE(test.isDenormal());
239 EXPECT_TRUE(test.bitwiseIsEqual(expected));
241 // nextDown(+Smallest Normal) -> +Largest Denormal.
242 test = APFloat(APFloat::IEEEquad,
243 "+0x1.0000000000000000000000000000p-16382");
244 expected = APFloat(APFloat::IEEEquad,
245 "+0x0.ffffffffffffffffffffffffffffp-16382");
246 EXPECT_EQ(test.next(true), APFloat::opOK);
247 EXPECT_TRUE(test.isDenormal());
248 EXPECT_TRUE(test.bitwiseIsEqual(expected));
250 // 2b. Test normal <-> normal binade boundaries.
251 // * nextUp(-Normal Binade Boundary) -> -Normal Binade Boundary + 1.
252 // * nextDown(+Normal Binade Boundary) -> +Normal Binade Boundary - 1.
253 // * nextUp(+Normal Binade Boundary - 1) -> +Normal Binade Boundary.
254 // * nextDown(-Normal Binade Boundary + 1) -> -Normal Binade Boundary.
256 // nextUp(-Normal Binade Boundary) -> -Normal Binade Boundary + 1.
257 test = APFloat(APFloat::IEEEquad, "-0x1p+1");
258 expected = APFloat(APFloat::IEEEquad,
259 "-0x1.ffffffffffffffffffffffffffffp+0");
260 EXPECT_EQ(test.next(false), APFloat::opOK);
261 EXPECT_TRUE(test.bitwiseIsEqual(expected));
263 // nextDown(+Normal Binade Boundary) -> +Normal Binade Boundary - 1.
264 test = APFloat(APFloat::IEEEquad, "0x1p+1");
265 expected = APFloat(APFloat::IEEEquad, "0x1.ffffffffffffffffffffffffffffp+0");
266 EXPECT_EQ(test.next(true), APFloat::opOK);
267 EXPECT_TRUE(test.bitwiseIsEqual(expected));
269 // nextUp(+Normal Binade Boundary - 1) -> +Normal Binade Boundary.
270 test = APFloat(APFloat::IEEEquad, "0x1.ffffffffffffffffffffffffffffp+0");
271 expected = APFloat(APFloat::IEEEquad, "0x1p+1");
272 EXPECT_EQ(test.next(false), APFloat::opOK);
273 EXPECT_TRUE(test.bitwiseIsEqual(expected));
275 // nextDown(-Normal Binade Boundary + 1) -> -Normal Binade Boundary.
276 test = APFloat(APFloat::IEEEquad, "-0x1.ffffffffffffffffffffffffffffp+0");
277 expected = APFloat(APFloat::IEEEquad, "-0x1p+1");
278 EXPECT_EQ(test.next(true), APFloat::opOK);
279 EXPECT_TRUE(test.bitwiseIsEqual(expected));
281 // 2c. Test using next at binade boundaries with a direction away from the
282 // binade boundary. Away from denormal <-> normal boundaries.
284 // This is to make sure that even though we are at a binade boundary, since
285 // we are rounding away, we do not trigger the binade boundary code. Thus we
287 // * nextUp(-Largest Denormal) -> -Largest Denormal + inc.
288 // * nextDown(+Largest Denormal) -> +Largest Denormal - inc.
289 // * nextUp(+Smallest Normal) -> +Smallest Normal + inc.
290 // * nextDown(-Smallest Normal) -> -Smallest Normal - inc.
292 // nextUp(-Largest Denormal) -> -Largest Denormal + inc.
293 test = APFloat(APFloat::IEEEquad, "-0x0.ffffffffffffffffffffffffffffp-16382");
294 expected = APFloat(APFloat::IEEEquad,
295 "-0x0.fffffffffffffffffffffffffffep-16382");
296 EXPECT_EQ(test.next(false), APFloat::opOK);
297 EXPECT_TRUE(test.isDenormal());
298 EXPECT_TRUE(test.isNegative());
299 EXPECT_TRUE(test.bitwiseIsEqual(expected));
301 // nextDown(+Largest Denormal) -> +Largest Denormal - inc.
302 test = APFloat(APFloat::IEEEquad, "0x0.ffffffffffffffffffffffffffffp-16382");
303 expected = APFloat(APFloat::IEEEquad,
304 "0x0.fffffffffffffffffffffffffffep-16382");
305 EXPECT_EQ(test.next(true), APFloat::opOK);
306 EXPECT_TRUE(test.isDenormal());
307 EXPECT_TRUE(!test.isNegative());
308 EXPECT_TRUE(test.bitwiseIsEqual(expected));
310 // nextUp(+Smallest Normal) -> +Smallest Normal + inc.
311 test = APFloat(APFloat::IEEEquad, "0x1.0000000000000000000000000000p-16382");
312 expected = APFloat(APFloat::IEEEquad,
313 "0x1.0000000000000000000000000001p-16382");
314 EXPECT_EQ(test.next(false), APFloat::opOK);
315 EXPECT_TRUE(!test.isDenormal());
316 EXPECT_TRUE(!test.isNegative());
317 EXPECT_TRUE(test.bitwiseIsEqual(expected));
319 // nextDown(-Smallest Normal) -> -Smallest Normal - inc.
320 test = APFloat(APFloat::IEEEquad, "-0x1.0000000000000000000000000000p-16382");
321 expected = APFloat(APFloat::IEEEquad,
322 "-0x1.0000000000000000000000000001p-16382");
323 EXPECT_EQ(test.next(true), APFloat::opOK);
324 EXPECT_TRUE(!test.isDenormal());
325 EXPECT_TRUE(test.isNegative());
326 EXPECT_TRUE(test.bitwiseIsEqual(expected));
328 // 2d. Test values which cause our exponent to go to min exponent. This
329 // is to ensure that guards in the code to check for min exponent
331 // * nextUp(-0x1p-16381) -> -0x1.ffffffffffffffffffffffffffffp-16382
332 // * nextDown(-0x1.ffffffffffffffffffffffffffffp-16382) ->
334 // * nextUp(0x1.ffffffffffffffffffffffffffffp-16382) -> 0x1p-16382
335 // * nextDown(0x1p-16382) -> 0x1.ffffffffffffffffffffffffffffp-16382
337 // nextUp(-0x1p-16381) -> -0x1.ffffffffffffffffffffffffffffp-16382
338 test = APFloat(APFloat::IEEEquad, "-0x1p-16381");
339 expected = APFloat(APFloat::IEEEquad,
340 "-0x1.ffffffffffffffffffffffffffffp-16382");
341 EXPECT_EQ(test.next(false), APFloat::opOK);
342 EXPECT_TRUE(test.bitwiseIsEqual(expected));
344 // nextDown(-0x1.ffffffffffffffffffffffffffffp-16382) ->
346 test = APFloat(APFloat::IEEEquad, "-0x1.ffffffffffffffffffffffffffffp-16382");
347 expected = APFloat(APFloat::IEEEquad, "-0x1p-16381");
348 EXPECT_EQ(test.next(true), APFloat::opOK);
349 EXPECT_TRUE(test.bitwiseIsEqual(expected));
351 // nextUp(0x1.ffffffffffffffffffffffffffffp-16382) -> 0x1p-16381
352 test = APFloat(APFloat::IEEEquad, "0x1.ffffffffffffffffffffffffffffp-16382");
353 expected = APFloat(APFloat::IEEEquad, "0x1p-16381");
354 EXPECT_EQ(test.next(false), APFloat::opOK);
355 EXPECT_TRUE(test.bitwiseIsEqual(expected));
357 // nextDown(0x1p-16381) -> 0x1.ffffffffffffffffffffffffffffp-16382
358 test = APFloat(APFloat::IEEEquad, "0x1p-16381");
359 expected = APFloat(APFloat::IEEEquad,
360 "0x1.ffffffffffffffffffffffffffffp-16382");
361 EXPECT_EQ(test.next(true), APFloat::opOK);
362 EXPECT_TRUE(test.bitwiseIsEqual(expected));
364 // 3. Now we test both denormal/normal computation which will not cause us
365 // to go across binade boundaries. Specifically we test:
366 // * nextUp(+Denormal) -> +Denormal.
367 // * nextDown(+Denormal) -> +Denormal.
368 // * nextUp(-Denormal) -> -Denormal.
369 // * nextDown(-Denormal) -> -Denormal.
370 // * nextUp(+Normal) -> +Normal.
371 // * nextDown(+Normal) -> +Normal.
372 // * nextUp(-Normal) -> -Normal.
373 // * nextDown(-Normal) -> -Normal.
375 // nextUp(+Denormal) -> +Denormal.
376 test = APFloat(APFloat::IEEEquad,
377 "0x0.ffffffffffffffffffffffff000cp-16382");
378 expected = APFloat(APFloat::IEEEquad,
379 "0x0.ffffffffffffffffffffffff000dp-16382");
380 EXPECT_EQ(test.next(false), APFloat::opOK);
381 EXPECT_TRUE(test.isDenormal());
382 EXPECT_TRUE(!test.isNegative());
383 EXPECT_TRUE(test.bitwiseIsEqual(expected));
385 // nextDown(+Denormal) -> +Denormal.
386 test = APFloat(APFloat::IEEEquad,
387 "0x0.ffffffffffffffffffffffff000cp-16382");
388 expected = APFloat(APFloat::IEEEquad,
389 "0x0.ffffffffffffffffffffffff000bp-16382");
390 EXPECT_EQ(test.next(true), APFloat::opOK);
391 EXPECT_TRUE(test.isDenormal());
392 EXPECT_TRUE(!test.isNegative());
393 EXPECT_TRUE(test.bitwiseIsEqual(expected));
395 // nextUp(-Denormal) -> -Denormal.
396 test = APFloat(APFloat::IEEEquad,
397 "-0x0.ffffffffffffffffffffffff000cp-16382");
398 expected = APFloat(APFloat::IEEEquad,
399 "-0x0.ffffffffffffffffffffffff000bp-16382");
400 EXPECT_EQ(test.next(false), APFloat::opOK);
401 EXPECT_TRUE(test.isDenormal());
402 EXPECT_TRUE(test.isNegative());
403 EXPECT_TRUE(test.bitwiseIsEqual(expected));
405 // nextDown(-Denormal) -> -Denormal
406 test = APFloat(APFloat::IEEEquad,
407 "-0x0.ffffffffffffffffffffffff000cp-16382");
408 expected = APFloat(APFloat::IEEEquad,
409 "-0x0.ffffffffffffffffffffffff000dp-16382");
410 EXPECT_EQ(test.next(true), APFloat::opOK);
411 EXPECT_TRUE(test.isDenormal());
412 EXPECT_TRUE(test.isNegative());
413 EXPECT_TRUE(test.bitwiseIsEqual(expected));
415 // nextUp(+Normal) -> +Normal.
416 test = APFloat(APFloat::IEEEquad,
417 "0x1.ffffffffffffffffffffffff000cp-16000");
418 expected = APFloat(APFloat::IEEEquad,
419 "0x1.ffffffffffffffffffffffff000dp-16000");
420 EXPECT_EQ(test.next(false), APFloat::opOK);
421 EXPECT_TRUE(!test.isDenormal());
422 EXPECT_TRUE(!test.isNegative());
423 EXPECT_TRUE(test.bitwiseIsEqual(expected));
425 // nextDown(+Normal) -> +Normal.
426 test = APFloat(APFloat::IEEEquad,
427 "0x1.ffffffffffffffffffffffff000cp-16000");
428 expected = APFloat(APFloat::IEEEquad,
429 "0x1.ffffffffffffffffffffffff000bp-16000");
430 EXPECT_EQ(test.next(true), APFloat::opOK);
431 EXPECT_TRUE(!test.isDenormal());
432 EXPECT_TRUE(!test.isNegative());
433 EXPECT_TRUE(test.bitwiseIsEqual(expected));
435 // nextUp(-Normal) -> -Normal.
436 test = APFloat(APFloat::IEEEquad,
437 "-0x1.ffffffffffffffffffffffff000cp-16000");
438 expected = APFloat(APFloat::IEEEquad,
439 "-0x1.ffffffffffffffffffffffff000bp-16000");
440 EXPECT_EQ(test.next(false), APFloat::opOK);
441 EXPECT_TRUE(!test.isDenormal());
442 EXPECT_TRUE(test.isNegative());
443 EXPECT_TRUE(test.bitwiseIsEqual(expected));
445 // nextDown(-Normal) -> -Normal.
446 test = APFloat(APFloat::IEEEquad,
447 "-0x1.ffffffffffffffffffffffff000cp-16000");
448 expected = APFloat(APFloat::IEEEquad,
449 "-0x1.ffffffffffffffffffffffff000dp-16000");
450 EXPECT_EQ(test.next(true), APFloat::opOK);
451 EXPECT_TRUE(!test.isDenormal());
452 EXPECT_TRUE(test.isNegative());
453 EXPECT_TRUE(test.bitwiseIsEqual(expected));
456 TEST(APFloatTest, FMA) {
457 APFloat::roundingMode rdmd = APFloat::rmNearestTiesToEven;
463 f1.fusedMultiplyAdd(f2, f3, APFloat::rmNearestTiesToEven);
464 EXPECT_EQ(14.75f, f1.convertToFloat());
469 APFloat f1((float)1.17549435e-38F);
470 APFloat f2((float)1.17549435e-38F);
471 f1.divide(Val2, rdmd);
472 f2.divide(Val2, rdmd);
474 f1.fusedMultiplyAdd(f2, f3, APFloat::rmNearestTiesToEven);
475 EXPECT_EQ(12.0f, f1.convertToFloat());
479 APFloat M1(APFloat::x87DoubleExtended, 1.0);
480 APFloat M2(APFloat::x87DoubleExtended, 1.0);
481 APFloat A(APFloat::x87DoubleExtended, 3.0);
483 bool losesInfo = false;
484 M1.fusedMultiplyAdd(M1, A, APFloat::rmNearestTiesToEven);
485 M1.convert(APFloat::IEEEsingle, APFloat::rmNearestTiesToEven, &losesInfo);
486 EXPECT_FALSE(losesInfo);
487 EXPECT_EQ(4.0f, M1.convertToFloat());
491 TEST(APFloatTest, MinNum) {
494 APFloat nan = APFloat::getNaN(APFloat::IEEEdouble);
496 EXPECT_EQ(1.0, minnum(f1, f2).convertToDouble());
497 EXPECT_EQ(1.0, minnum(f2, f1).convertToDouble());
498 EXPECT_EQ(1.0, minnum(f1, nan).convertToDouble());
499 EXPECT_EQ(1.0, minnum(nan, f1).convertToDouble());
502 TEST(APFloatTest, MaxNum) {
505 APFloat nan = APFloat::getNaN(APFloat::IEEEdouble);
507 EXPECT_EQ(2.0, maxnum(f1, f2).convertToDouble());
508 EXPECT_EQ(2.0, maxnum(f2, f1).convertToDouble());
509 EXPECT_EQ(1.0, maxnum(f1, nan).convertToDouble());
510 EXPECT_EQ(1.0, minnum(nan, f1).convertToDouble());
513 TEST(APFloatTest, Denormal) {
514 APFloat::roundingMode rdmd = APFloat::rmNearestTiesToEven;
516 // Test single precision
518 const char *MinNormalStr = "1.17549435082228750797e-38";
519 EXPECT_FALSE(APFloat(APFloat::IEEEsingle, MinNormalStr).isDenormal());
520 EXPECT_FALSE(APFloat(APFloat::IEEEsingle, 0.0).isDenormal());
522 APFloat Val2(APFloat::IEEEsingle, 2.0e0);
523 APFloat T(APFloat::IEEEsingle, MinNormalStr);
524 T.divide(Val2, rdmd);
525 EXPECT_TRUE(T.isDenormal());
528 // Test double precision
530 const char *MinNormalStr = "2.22507385850720138309e-308";
531 EXPECT_FALSE(APFloat(APFloat::IEEEdouble, MinNormalStr).isDenormal());
532 EXPECT_FALSE(APFloat(APFloat::IEEEdouble, 0.0).isDenormal());
534 APFloat Val2(APFloat::IEEEdouble, 2.0e0);
535 APFloat T(APFloat::IEEEdouble, MinNormalStr);
536 T.divide(Val2, rdmd);
537 EXPECT_TRUE(T.isDenormal());
540 // Test Intel double-ext
542 const char *MinNormalStr = "3.36210314311209350626e-4932";
543 EXPECT_FALSE(APFloat(APFloat::x87DoubleExtended, MinNormalStr).isDenormal());
544 EXPECT_FALSE(APFloat(APFloat::x87DoubleExtended, 0.0).isDenormal());
546 APFloat Val2(APFloat::x87DoubleExtended, 2.0e0);
547 APFloat T(APFloat::x87DoubleExtended, MinNormalStr);
548 T.divide(Val2, rdmd);
549 EXPECT_TRUE(T.isDenormal());
552 // Test quadruple precision
554 const char *MinNormalStr = "3.36210314311209350626267781732175260e-4932";
555 EXPECT_FALSE(APFloat(APFloat::IEEEquad, MinNormalStr).isDenormal());
556 EXPECT_FALSE(APFloat(APFloat::IEEEquad, 0.0).isDenormal());
558 APFloat Val2(APFloat::IEEEquad, 2.0e0);
559 APFloat T(APFloat::IEEEquad, MinNormalStr);
560 T.divide(Val2, rdmd);
561 EXPECT_TRUE(T.isDenormal());
565 TEST(APFloatTest, Zero) {
566 EXPECT_EQ(0.0f, APFloat(0.0f).convertToFloat());
567 EXPECT_EQ(-0.0f, APFloat(-0.0f).convertToFloat());
568 EXPECT_TRUE(APFloat(-0.0f).isNegative());
570 EXPECT_EQ(0.0, APFloat(0.0).convertToDouble());
571 EXPECT_EQ(-0.0, APFloat(-0.0).convertToDouble());
572 EXPECT_TRUE(APFloat(-0.0).isNegative());
575 TEST(APFloatTest, DecimalStringsWithoutNullTerminators) {
576 // Make sure that we can parse strings without null terminators.
578 APFloat Val(APFloat::IEEEdouble);
579 Val.convertFromString(StringRef("0.00", 3),
580 llvm::APFloat::rmNearestTiesToEven);
581 EXPECT_EQ(Val.convertToDouble(), 0.0);
582 Val.convertFromString(StringRef("0.01", 3),
583 llvm::APFloat::rmNearestTiesToEven);
584 EXPECT_EQ(Val.convertToDouble(), 0.0);
585 Val.convertFromString(StringRef("0.09", 3),
586 llvm::APFloat::rmNearestTiesToEven);
587 EXPECT_EQ(Val.convertToDouble(), 0.0);
588 Val.convertFromString(StringRef("0.095", 4),
589 llvm::APFloat::rmNearestTiesToEven);
590 EXPECT_EQ(Val.convertToDouble(), 0.09);
591 Val.convertFromString(StringRef("0.00e+3", 7),
592 llvm::APFloat::rmNearestTiesToEven);
593 EXPECT_EQ(Val.convertToDouble(), 0.00);
594 Val.convertFromString(StringRef("0e+3", 4),
595 llvm::APFloat::rmNearestTiesToEven);
596 EXPECT_EQ(Val.convertToDouble(), 0.00);
600 TEST(APFloatTest, fromZeroDecimalString) {
601 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0").convertToDouble());
602 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0").convertToDouble());
603 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0").convertToDouble());
605 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0.").convertToDouble());
606 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0.").convertToDouble());
607 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0.").convertToDouble());
609 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, ".0").convertToDouble());
610 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+.0").convertToDouble());
611 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-.0").convertToDouble());
613 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0.0").convertToDouble());
614 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0.0").convertToDouble());
615 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0.0").convertToDouble());
617 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "00000.").convertToDouble());
618 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+00000.").convertToDouble());
619 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-00000.").convertToDouble());
621 EXPECT_EQ(0.0, APFloat(APFloat::IEEEdouble, ".00000").convertToDouble());
622 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+.00000").convertToDouble());
623 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-.00000").convertToDouble());
625 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0000.00000").convertToDouble());
626 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0000.00000").convertToDouble());
627 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0000.00000").convertToDouble());
630 TEST(APFloatTest, fromZeroDecimalSingleExponentString) {
631 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0e1").convertToDouble());
632 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0e1").convertToDouble());
633 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0e1").convertToDouble());
635 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0e+1").convertToDouble());
636 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0e+1").convertToDouble());
637 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0e+1").convertToDouble());
639 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0e-1").convertToDouble());
640 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0e-1").convertToDouble());
641 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0e-1").convertToDouble());
644 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0.e1").convertToDouble());
645 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0.e1").convertToDouble());
646 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0.e1").convertToDouble());
648 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0.e+1").convertToDouble());
649 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0.e+1").convertToDouble());
650 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0.e+1").convertToDouble());
652 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0.e-1").convertToDouble());
653 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0.e-1").convertToDouble());
654 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0.e-1").convertToDouble());
656 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, ".0e1").convertToDouble());
657 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+.0e1").convertToDouble());
658 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-.0e1").convertToDouble());
660 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, ".0e+1").convertToDouble());
661 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+.0e+1").convertToDouble());
662 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-.0e+1").convertToDouble());
664 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, ".0e-1").convertToDouble());
665 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+.0e-1").convertToDouble());
666 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-.0e-1").convertToDouble());
669 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0.0e1").convertToDouble());
670 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0.0e1").convertToDouble());
671 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0.0e1").convertToDouble());
673 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0.0e+1").convertToDouble());
674 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0.0e+1").convertToDouble());
675 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0.0e+1").convertToDouble());
677 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0.0e-1").convertToDouble());
678 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0.0e-1").convertToDouble());
679 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0.0e-1").convertToDouble());
682 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "000.0000e1").convertToDouble());
683 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+000.0000e+1").convertToDouble());
684 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-000.0000e+1").convertToDouble());
687 TEST(APFloatTest, fromZeroDecimalLargeExponentString) {
688 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0e1234").convertToDouble());
689 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0e1234").convertToDouble());
690 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0e1234").convertToDouble());
692 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0e+1234").convertToDouble());
693 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0e+1234").convertToDouble());
694 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0e+1234").convertToDouble());
696 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0e-1234").convertToDouble());
697 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0e-1234").convertToDouble());
698 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0e-1234").convertToDouble());
700 EXPECT_EQ(0.0, APFloat(APFloat::IEEEdouble, "000.0000e1234").convertToDouble());
701 EXPECT_EQ(0.0, APFloat(APFloat::IEEEdouble, "000.0000e-1234").convertToDouble());
703 EXPECT_EQ(0.0, APFloat(APFloat::IEEEdouble, StringRef("0e1234\02", 6)).convertToDouble());
706 TEST(APFloatTest, fromZeroHexadecimalString) {
707 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x0p1").convertToDouble());
708 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0x0p1").convertToDouble());
709 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0x0p1").convertToDouble());
711 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x0p+1").convertToDouble());
712 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0x0p+1").convertToDouble());
713 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0x0p+1").convertToDouble());
715 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x0p-1").convertToDouble());
716 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0x0p-1").convertToDouble());
717 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0x0p-1").convertToDouble());
720 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x0.p1").convertToDouble());
721 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0x0.p1").convertToDouble());
722 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0x0.p1").convertToDouble());
724 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x0.p+1").convertToDouble());
725 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0x0.p+1").convertToDouble());
726 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0x0.p+1").convertToDouble());
728 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x0.p-1").convertToDouble());
729 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0x0.p-1").convertToDouble());
730 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0x0.p-1").convertToDouble());
733 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x.0p1").convertToDouble());
734 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0x.0p1").convertToDouble());
735 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0x.0p1").convertToDouble());
737 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x.0p+1").convertToDouble());
738 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0x.0p+1").convertToDouble());
739 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0x.0p+1").convertToDouble());
741 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x.0p-1").convertToDouble());
742 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0x.0p-1").convertToDouble());
743 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0x.0p-1").convertToDouble());
746 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x0.0p1").convertToDouble());
747 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0x0.0p1").convertToDouble());
748 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0x0.0p1").convertToDouble());
750 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x0.0p+1").convertToDouble());
751 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0x0.0p+1").convertToDouble());
752 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0x0.0p+1").convertToDouble());
754 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x0.0p-1").convertToDouble());
755 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0x0.0p-1").convertToDouble());
756 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0x0.0p-1").convertToDouble());
759 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x00000.p1").convertToDouble());
760 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x0000.00000p1").convertToDouble());
761 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x.00000p1").convertToDouble());
762 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x0.p1").convertToDouble());
763 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x0p1234").convertToDouble());
764 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0x0p1234").convertToDouble());
765 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x00000.p1234").convertToDouble());
766 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x0000.00000p1234").convertToDouble());
767 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x.00000p1234").convertToDouble());
768 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x0.p1234").convertToDouble());
771 TEST(APFloatTest, fromDecimalString) {
772 EXPECT_EQ(1.0, APFloat(APFloat::IEEEdouble, "1").convertToDouble());
773 EXPECT_EQ(2.0, APFloat(APFloat::IEEEdouble, "2.").convertToDouble());
774 EXPECT_EQ(0.5, APFloat(APFloat::IEEEdouble, ".5").convertToDouble());
775 EXPECT_EQ(1.0, APFloat(APFloat::IEEEdouble, "1.0").convertToDouble());
776 EXPECT_EQ(-2.0, APFloat(APFloat::IEEEdouble, "-2").convertToDouble());
777 EXPECT_EQ(-4.0, APFloat(APFloat::IEEEdouble, "-4.").convertToDouble());
778 EXPECT_EQ(-0.5, APFloat(APFloat::IEEEdouble, "-.5").convertToDouble());
779 EXPECT_EQ(-1.5, APFloat(APFloat::IEEEdouble, "-1.5").convertToDouble());
780 EXPECT_EQ(1.25e12, APFloat(APFloat::IEEEdouble, "1.25e12").convertToDouble());
781 EXPECT_EQ(1.25e+12, APFloat(APFloat::IEEEdouble, "1.25e+12").convertToDouble());
782 EXPECT_EQ(1.25e-12, APFloat(APFloat::IEEEdouble, "1.25e-12").convertToDouble());
783 EXPECT_EQ(1024.0, APFloat(APFloat::IEEEdouble, "1024.").convertToDouble());
784 EXPECT_EQ(1024.05, APFloat(APFloat::IEEEdouble, "1024.05000").convertToDouble());
785 EXPECT_EQ(0.05, APFloat(APFloat::IEEEdouble, ".05000").convertToDouble());
786 EXPECT_EQ(2.0, APFloat(APFloat::IEEEdouble, "2.").convertToDouble());
787 EXPECT_EQ(2.0e2, APFloat(APFloat::IEEEdouble, "2.e2").convertToDouble());
788 EXPECT_EQ(2.0e+2, APFloat(APFloat::IEEEdouble, "2.e+2").convertToDouble());
789 EXPECT_EQ(2.0e-2, APFloat(APFloat::IEEEdouble, "2.e-2").convertToDouble());
790 EXPECT_EQ(2.05e2, APFloat(APFloat::IEEEdouble, "002.05000e2").convertToDouble());
791 EXPECT_EQ(2.05e+2, APFloat(APFloat::IEEEdouble, "002.05000e+2").convertToDouble());
792 EXPECT_EQ(2.05e-2, APFloat(APFloat::IEEEdouble, "002.05000e-2").convertToDouble());
793 EXPECT_EQ(2.05e12, APFloat(APFloat::IEEEdouble, "002.05000e12").convertToDouble());
794 EXPECT_EQ(2.05e+12, APFloat(APFloat::IEEEdouble, "002.05000e+12").convertToDouble());
795 EXPECT_EQ(2.05e-12, APFloat(APFloat::IEEEdouble, "002.05000e-12").convertToDouble());
797 // These are "carefully selected" to overflow the fast log-base
798 // calculations in APFloat.cpp
799 EXPECT_TRUE(APFloat(APFloat::IEEEdouble, "99e99999").isInfinity());
800 EXPECT_TRUE(APFloat(APFloat::IEEEdouble, "-99e99999").isInfinity());
801 EXPECT_TRUE(APFloat(APFloat::IEEEdouble, "1e-99999").isPosZero());
802 EXPECT_TRUE(APFloat(APFloat::IEEEdouble, "-1e-99999").isNegZero());
804 EXPECT_EQ(2.71828, convertToDoubleFromString("2.71828"));
807 TEST(APFloatTest, fromHexadecimalString) {
808 EXPECT_EQ( 1.0, APFloat(APFloat::IEEEdouble, "0x1p0").convertToDouble());
809 EXPECT_EQ(+1.0, APFloat(APFloat::IEEEdouble, "+0x1p0").convertToDouble());
810 EXPECT_EQ(-1.0, APFloat(APFloat::IEEEdouble, "-0x1p0").convertToDouble());
812 EXPECT_EQ( 1.0, APFloat(APFloat::IEEEdouble, "0x1p+0").convertToDouble());
813 EXPECT_EQ(+1.0, APFloat(APFloat::IEEEdouble, "+0x1p+0").convertToDouble());
814 EXPECT_EQ(-1.0, APFloat(APFloat::IEEEdouble, "-0x1p+0").convertToDouble());
816 EXPECT_EQ( 1.0, APFloat(APFloat::IEEEdouble, "0x1p-0").convertToDouble());
817 EXPECT_EQ(+1.0, APFloat(APFloat::IEEEdouble, "+0x1p-0").convertToDouble());
818 EXPECT_EQ(-1.0, APFloat(APFloat::IEEEdouble, "-0x1p-0").convertToDouble());
821 EXPECT_EQ( 2.0, APFloat(APFloat::IEEEdouble, "0x1p1").convertToDouble());
822 EXPECT_EQ(+2.0, APFloat(APFloat::IEEEdouble, "+0x1p1").convertToDouble());
823 EXPECT_EQ(-2.0, APFloat(APFloat::IEEEdouble, "-0x1p1").convertToDouble());
825 EXPECT_EQ( 2.0, APFloat(APFloat::IEEEdouble, "0x1p+1").convertToDouble());
826 EXPECT_EQ(+2.0, APFloat(APFloat::IEEEdouble, "+0x1p+1").convertToDouble());
827 EXPECT_EQ(-2.0, APFloat(APFloat::IEEEdouble, "-0x1p+1").convertToDouble());
829 EXPECT_EQ( 0.5, APFloat(APFloat::IEEEdouble, "0x1p-1").convertToDouble());
830 EXPECT_EQ(+0.5, APFloat(APFloat::IEEEdouble, "+0x1p-1").convertToDouble());
831 EXPECT_EQ(-0.5, APFloat(APFloat::IEEEdouble, "-0x1p-1").convertToDouble());
834 EXPECT_EQ( 3.0, APFloat(APFloat::IEEEdouble, "0x1.8p1").convertToDouble());
835 EXPECT_EQ(+3.0, APFloat(APFloat::IEEEdouble, "+0x1.8p1").convertToDouble());
836 EXPECT_EQ(-3.0, APFloat(APFloat::IEEEdouble, "-0x1.8p1").convertToDouble());
838 EXPECT_EQ( 3.0, APFloat(APFloat::IEEEdouble, "0x1.8p+1").convertToDouble());
839 EXPECT_EQ(+3.0, APFloat(APFloat::IEEEdouble, "+0x1.8p+1").convertToDouble());
840 EXPECT_EQ(-3.0, APFloat(APFloat::IEEEdouble, "-0x1.8p+1").convertToDouble());
842 EXPECT_EQ( 0.75, APFloat(APFloat::IEEEdouble, "0x1.8p-1").convertToDouble());
843 EXPECT_EQ(+0.75, APFloat(APFloat::IEEEdouble, "+0x1.8p-1").convertToDouble());
844 EXPECT_EQ(-0.75, APFloat(APFloat::IEEEdouble, "-0x1.8p-1").convertToDouble());
847 EXPECT_EQ( 8192.0, APFloat(APFloat::IEEEdouble, "0x1000.000p1").convertToDouble());
848 EXPECT_EQ(+8192.0, APFloat(APFloat::IEEEdouble, "+0x1000.000p1").convertToDouble());
849 EXPECT_EQ(-8192.0, APFloat(APFloat::IEEEdouble, "-0x1000.000p1").convertToDouble());
851 EXPECT_EQ( 8192.0, APFloat(APFloat::IEEEdouble, "0x1000.000p+1").convertToDouble());
852 EXPECT_EQ(+8192.0, APFloat(APFloat::IEEEdouble, "+0x1000.000p+1").convertToDouble());
853 EXPECT_EQ(-8192.0, APFloat(APFloat::IEEEdouble, "-0x1000.000p+1").convertToDouble());
855 EXPECT_EQ( 2048.0, APFloat(APFloat::IEEEdouble, "0x1000.000p-1").convertToDouble());
856 EXPECT_EQ(+2048.0, APFloat(APFloat::IEEEdouble, "+0x1000.000p-1").convertToDouble());
857 EXPECT_EQ(-2048.0, APFloat(APFloat::IEEEdouble, "-0x1000.000p-1").convertToDouble());
860 EXPECT_EQ( 8192.0, APFloat(APFloat::IEEEdouble, "0x1000p1").convertToDouble());
861 EXPECT_EQ(+8192.0, APFloat(APFloat::IEEEdouble, "+0x1000p1").convertToDouble());
862 EXPECT_EQ(-8192.0, APFloat(APFloat::IEEEdouble, "-0x1000p1").convertToDouble());
864 EXPECT_EQ( 8192.0, APFloat(APFloat::IEEEdouble, "0x1000p+1").convertToDouble());
865 EXPECT_EQ(+8192.0, APFloat(APFloat::IEEEdouble, "+0x1000p+1").convertToDouble());
866 EXPECT_EQ(-8192.0, APFloat(APFloat::IEEEdouble, "-0x1000p+1").convertToDouble());
868 EXPECT_EQ( 2048.0, APFloat(APFloat::IEEEdouble, "0x1000p-1").convertToDouble());
869 EXPECT_EQ(+2048.0, APFloat(APFloat::IEEEdouble, "+0x1000p-1").convertToDouble());
870 EXPECT_EQ(-2048.0, APFloat(APFloat::IEEEdouble, "-0x1000p-1").convertToDouble());
873 EXPECT_EQ( 16384.0, APFloat(APFloat::IEEEdouble, "0x10p10").convertToDouble());
874 EXPECT_EQ(+16384.0, APFloat(APFloat::IEEEdouble, "+0x10p10").convertToDouble());
875 EXPECT_EQ(-16384.0, APFloat(APFloat::IEEEdouble, "-0x10p10").convertToDouble());
877 EXPECT_EQ( 16384.0, APFloat(APFloat::IEEEdouble, "0x10p+10").convertToDouble());
878 EXPECT_EQ(+16384.0, APFloat(APFloat::IEEEdouble, "+0x10p+10").convertToDouble());
879 EXPECT_EQ(-16384.0, APFloat(APFloat::IEEEdouble, "-0x10p+10").convertToDouble());
881 EXPECT_EQ( 0.015625, APFloat(APFloat::IEEEdouble, "0x10p-10").convertToDouble());
882 EXPECT_EQ(+0.015625, APFloat(APFloat::IEEEdouble, "+0x10p-10").convertToDouble());
883 EXPECT_EQ(-0.015625, APFloat(APFloat::IEEEdouble, "-0x10p-10").convertToDouble());
885 EXPECT_EQ(1.0625, APFloat(APFloat::IEEEdouble, "0x1.1p0").convertToDouble());
886 EXPECT_EQ(1.0, APFloat(APFloat::IEEEdouble, "0x1p0").convertToDouble());
888 EXPECT_EQ(convertToDoubleFromString("0x1p-150"),
889 convertToDoubleFromString("+0x800000000000000001.p-221"));
890 EXPECT_EQ(2251799813685248.5,
891 convertToDoubleFromString("0x80000000000004000000.010p-28"));
894 TEST(APFloatTest, toString) {
895 ASSERT_EQ("10", convertToString(10.0, 6, 3));
896 ASSERT_EQ("1.0E+1", convertToString(10.0, 6, 0));
897 ASSERT_EQ("10100", convertToString(1.01E+4, 5, 2));
898 ASSERT_EQ("1.01E+4", convertToString(1.01E+4, 4, 2));
899 ASSERT_EQ("1.01E+4", convertToString(1.01E+4, 5, 1));
900 ASSERT_EQ("0.0101", convertToString(1.01E-2, 5, 2));
901 ASSERT_EQ("0.0101", convertToString(1.01E-2, 4, 2));
902 ASSERT_EQ("1.01E-2", convertToString(1.01E-2, 5, 1));
903 ASSERT_EQ("0.78539816339744828", convertToString(0.78539816339744830961, 0, 3));
904 ASSERT_EQ("4.9406564584124654E-324", convertToString(4.9406564584124654e-324, 0, 3));
905 ASSERT_EQ("873.18340000000001", convertToString(873.1834, 0, 1));
906 ASSERT_EQ("8.7318340000000001E+2", convertToString(873.1834, 0, 0));
907 ASSERT_EQ("1.7976931348623157E+308", convertToString(1.7976931348623157E+308, 0, 0));
910 TEST(APFloatTest, toInteger) {
911 bool isExact = false;
912 APSInt result(5, /*isUnsigned=*/true);
914 EXPECT_EQ(APFloat::opOK,
915 APFloat(APFloat::IEEEdouble, "10")
916 .convertToInteger(result, APFloat::rmTowardZero, &isExact));
917 EXPECT_TRUE(isExact);
918 EXPECT_EQ(APSInt(APInt(5, 10), true), result);
920 EXPECT_EQ(APFloat::opInvalidOp,
921 APFloat(APFloat::IEEEdouble, "-10")
922 .convertToInteger(result, APFloat::rmTowardZero, &isExact));
923 EXPECT_FALSE(isExact);
924 EXPECT_EQ(APSInt::getMinValue(5, true), result);
926 EXPECT_EQ(APFloat::opInvalidOp,
927 APFloat(APFloat::IEEEdouble, "32")
928 .convertToInteger(result, APFloat::rmTowardZero, &isExact));
929 EXPECT_FALSE(isExact);
930 EXPECT_EQ(APSInt::getMaxValue(5, true), result);
932 EXPECT_EQ(APFloat::opInexact,
933 APFloat(APFloat::IEEEdouble, "7.9")
934 .convertToInteger(result, APFloat::rmTowardZero, &isExact));
935 EXPECT_FALSE(isExact);
936 EXPECT_EQ(APSInt(APInt(5, 7), true), result);
938 result.setIsUnsigned(false);
939 EXPECT_EQ(APFloat::opOK,
940 APFloat(APFloat::IEEEdouble, "-10")
941 .convertToInteger(result, APFloat::rmTowardZero, &isExact));
942 EXPECT_TRUE(isExact);
943 EXPECT_EQ(APSInt(APInt(5, -10, true), false), result);
945 EXPECT_EQ(APFloat::opInvalidOp,
946 APFloat(APFloat::IEEEdouble, "-17")
947 .convertToInteger(result, APFloat::rmTowardZero, &isExact));
948 EXPECT_FALSE(isExact);
949 EXPECT_EQ(APSInt::getMinValue(5, false), result);
951 EXPECT_EQ(APFloat::opInvalidOp,
952 APFloat(APFloat::IEEEdouble, "16")
953 .convertToInteger(result, APFloat::rmTowardZero, &isExact));
954 EXPECT_FALSE(isExact);
955 EXPECT_EQ(APSInt::getMaxValue(5, false), result);
958 static APInt nanbits(const fltSemantics &Sem,
959 bool SNaN, bool Negative, uint64_t fill) {
960 APInt apfill(64, fill);
962 return APFloat::getSNaN(Sem, Negative, &apfill).bitcastToAPInt();
964 return APFloat::getQNaN(Sem, Negative, &apfill).bitcastToAPInt();
967 TEST(APFloatTest, makeNaN) {
968 ASSERT_EQ(0x7fc00000, nanbits(APFloat::IEEEsingle, false, false, 0));
969 ASSERT_EQ(0xffc00000, nanbits(APFloat::IEEEsingle, false, true, 0));
970 ASSERT_EQ(0x7fc0ae72, nanbits(APFloat::IEEEsingle, false, false, 0xae72));
971 ASSERT_EQ(0x7fffae72, nanbits(APFloat::IEEEsingle, false, false, 0xffffae72));
972 ASSERT_EQ(0x7fa00000, nanbits(APFloat::IEEEsingle, true, false, 0));
973 ASSERT_EQ(0xffa00000, nanbits(APFloat::IEEEsingle, true, true, 0));
974 ASSERT_EQ(0x7f80ae72, nanbits(APFloat::IEEEsingle, true, false, 0xae72));
975 ASSERT_EQ(0x7fbfae72, nanbits(APFloat::IEEEsingle, true, false, 0xffffae72));
977 ASSERT_EQ(0x7ff8000000000000ULL, nanbits(APFloat::IEEEdouble, false, false, 0));
978 ASSERT_EQ(0xfff8000000000000ULL, nanbits(APFloat::IEEEdouble, false, true, 0));
979 ASSERT_EQ(0x7ff800000000ae72ULL, nanbits(APFloat::IEEEdouble, false, false, 0xae72));
980 ASSERT_EQ(0x7fffffffffffae72ULL, nanbits(APFloat::IEEEdouble, false, false, 0xffffffffffffae72ULL));
981 ASSERT_EQ(0x7ff4000000000000ULL, nanbits(APFloat::IEEEdouble, true, false, 0));
982 ASSERT_EQ(0xfff4000000000000ULL, nanbits(APFloat::IEEEdouble, true, true, 0));
983 ASSERT_EQ(0x7ff000000000ae72ULL, nanbits(APFloat::IEEEdouble, true, false, 0xae72));
984 ASSERT_EQ(0x7ff7ffffffffae72ULL, nanbits(APFloat::IEEEdouble, true, false, 0xffffffffffffae72ULL));
987 #ifdef GTEST_HAS_DEATH_TEST
989 TEST(APFloatTest, SemanticsDeath) {
990 EXPECT_DEATH(APFloat(APFloat::IEEEsingle, 0.0f).convertToDouble(), "Float semantics are not IEEEdouble");
991 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, 0.0 ).convertToFloat(), "Float semantics are not IEEEsingle");
994 TEST(APFloatTest, StringDecimalDeath) {
995 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, ""), "Invalid string length");
996 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+"), "String has no digits");
997 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-"), "String has no digits");
999 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("\0", 1)), "Invalid character in significand");
1000 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("1\0", 2)), "Invalid character in significand");
1001 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("1\02", 3)), "Invalid character in significand");
1002 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("1\02e1", 5)), "Invalid character in significand");
1003 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("1e\0", 3)), "Invalid character in exponent");
1004 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("1e1\0", 4)), "Invalid character in exponent");
1005 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("1e1\02", 5)), "Invalid character in exponent");
1007 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "1.0f"), "Invalid character in significand");
1009 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, ".."), "String contains multiple dots");
1010 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "..0"), "String contains multiple dots");
1011 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "1.0.0"), "String contains multiple dots");
1014 TEST(APFloatTest, StringDecimalSignificandDeath) {
1015 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "."), "Significand has no digits");
1016 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+."), "Significand has no digits");
1017 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-."), "Significand has no digits");
1020 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "e"), "Significand has no digits");
1021 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+e"), "Significand has no digits");
1022 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-e"), "Significand has no digits");
1024 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "e1"), "Significand has no digits");
1025 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+e1"), "Significand has no digits");
1026 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-e1"), "Significand has no digits");
1028 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, ".e1"), "Significand has no digits");
1029 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+.e1"), "Significand has no digits");
1030 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-.e1"), "Significand has no digits");
1033 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, ".e"), "Significand has no digits");
1034 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+.e"), "Significand has no digits");
1035 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-.e"), "Significand has no digits");
1038 TEST(APFloatTest, StringDecimalExponentDeath) {
1039 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "1e"), "Exponent has no digits");
1040 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+1e"), "Exponent has no digits");
1041 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-1e"), "Exponent has no digits");
1043 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "1.e"), "Exponent has no digits");
1044 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+1.e"), "Exponent has no digits");
1045 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-1.e"), "Exponent has no digits");
1047 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, ".1e"), "Exponent has no digits");
1048 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+.1e"), "Exponent has no digits");
1049 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-.1e"), "Exponent has no digits");
1051 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "1.1e"), "Exponent has no digits");
1052 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+1.1e"), "Exponent has no digits");
1053 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-1.1e"), "Exponent has no digits");
1056 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "1e+"), "Exponent has no digits");
1057 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "1e-"), "Exponent has no digits");
1059 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, ".1e"), "Exponent has no digits");
1060 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, ".1e+"), "Exponent has no digits");
1061 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, ".1e-"), "Exponent has no digits");
1063 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "1.0e"), "Exponent has no digits");
1064 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "1.0e+"), "Exponent has no digits");
1065 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "1.0e-"), "Exponent has no digits");
1068 TEST(APFloatTest, StringHexadecimalDeath) {
1069 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x"), "Invalid string");
1070 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x"), "Invalid string");
1071 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x"), "Invalid string");
1073 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x0"), "Hex strings require an exponent");
1074 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x0"), "Hex strings require an exponent");
1075 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x0"), "Hex strings require an exponent");
1077 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x0."), "Hex strings require an exponent");
1078 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x0."), "Hex strings require an exponent");
1079 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x0."), "Hex strings require an exponent");
1081 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x.0"), "Hex strings require an exponent");
1082 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x.0"), "Hex strings require an exponent");
1083 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x.0"), "Hex strings require an exponent");
1085 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x0.0"), "Hex strings require an exponent");
1086 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x0.0"), "Hex strings require an exponent");
1087 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x0.0"), "Hex strings require an exponent");
1089 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("0x\0", 3)), "Invalid character in significand");
1090 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("0x1\0", 4)), "Invalid character in significand");
1091 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("0x1\02", 5)), "Invalid character in significand");
1092 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("0x1\02p1", 7)), "Invalid character in significand");
1093 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("0x1p\0", 5)), "Invalid character in exponent");
1094 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("0x1p1\0", 6)), "Invalid character in exponent");
1095 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("0x1p1\02", 7)), "Invalid character in exponent");
1097 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x1p0f"), "Invalid character in exponent");
1099 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x..p1"), "String contains multiple dots");
1100 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x..0p1"), "String contains multiple dots");
1101 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x1.0.0p1"), "String contains multiple dots");
1104 TEST(APFloatTest, StringHexadecimalSignificandDeath) {
1105 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x."), "Significand has no digits");
1106 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x."), "Significand has no digits");
1107 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x."), "Significand has no digits");
1109 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0xp"), "Significand has no digits");
1110 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0xp"), "Significand has no digits");
1111 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0xp"), "Significand has no digits");
1113 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0xp+"), "Significand has no digits");
1114 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0xp+"), "Significand has no digits");
1115 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0xp+"), "Significand has no digits");
1117 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0xp-"), "Significand has no digits");
1118 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0xp-"), "Significand has no digits");
1119 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0xp-"), "Significand has no digits");
1122 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x.p"), "Significand has no digits");
1123 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x.p"), "Significand has no digits");
1124 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x.p"), "Significand has no digits");
1126 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x.p+"), "Significand has no digits");
1127 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x.p+"), "Significand has no digits");
1128 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x.p+"), "Significand has no digits");
1130 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x.p-"), "Significand has no digits");
1131 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x.p-"), "Significand has no digits");
1132 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x.p-"), "Significand has no digits");
1135 TEST(APFloatTest, StringHexadecimalExponentDeath) {
1136 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x1p"), "Exponent has no digits");
1137 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x1p"), "Exponent has no digits");
1138 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x1p"), "Exponent has no digits");
1140 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x1p+"), "Exponent has no digits");
1141 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x1p+"), "Exponent has no digits");
1142 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x1p+"), "Exponent has no digits");
1144 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x1p-"), "Exponent has no digits");
1145 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x1p-"), "Exponent has no digits");
1146 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x1p-"), "Exponent has no digits");
1149 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x1.p"), "Exponent has no digits");
1150 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x1.p"), "Exponent has no digits");
1151 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x1.p"), "Exponent has no digits");
1153 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x1.p+"), "Exponent has no digits");
1154 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x1.p+"), "Exponent has no digits");
1155 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x1.p+"), "Exponent has no digits");
1157 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x1.p-"), "Exponent has no digits");
1158 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x1.p-"), "Exponent has no digits");
1159 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x1.p-"), "Exponent has no digits");
1162 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x.1p"), "Exponent has no digits");
1163 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x.1p"), "Exponent has no digits");
1164 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x.1p"), "Exponent has no digits");
1166 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x.1p+"), "Exponent has no digits");
1167 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x.1p+"), "Exponent has no digits");
1168 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x.1p+"), "Exponent has no digits");
1170 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x.1p-"), "Exponent has no digits");
1171 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x.1p-"), "Exponent has no digits");
1172 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x.1p-"), "Exponent has no digits");
1175 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x1.1p"), "Exponent has no digits");
1176 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x1.1p"), "Exponent has no digits");
1177 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x1.1p"), "Exponent has no digits");
1179 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x1.1p+"), "Exponent has no digits");
1180 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x1.1p+"), "Exponent has no digits");
1181 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x1.1p+"), "Exponent has no digits");
1183 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x1.1p-"), "Exponent has no digits");
1184 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x1.1p-"), "Exponent has no digits");
1185 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x1.1p-"), "Exponent has no digits");
1190 TEST(APFloatTest, exactInverse) {
1193 // Trivial operation.
1194 EXPECT_TRUE(APFloat(2.0).getExactInverse(&inv));
1195 EXPECT_TRUE(inv.bitwiseIsEqual(APFloat(0.5)));
1196 EXPECT_TRUE(APFloat(2.0f).getExactInverse(&inv));
1197 EXPECT_TRUE(inv.bitwiseIsEqual(APFloat(0.5f)));
1198 EXPECT_TRUE(APFloat(APFloat::IEEEquad, "2.0").getExactInverse(&inv));
1199 EXPECT_TRUE(inv.bitwiseIsEqual(APFloat(APFloat::IEEEquad, "0.5")));
1200 EXPECT_TRUE(APFloat(APFloat::PPCDoubleDouble, "2.0").getExactInverse(&inv));
1201 EXPECT_TRUE(inv.bitwiseIsEqual(APFloat(APFloat::PPCDoubleDouble, "0.5")));
1202 EXPECT_TRUE(APFloat(APFloat::x87DoubleExtended, "2.0").getExactInverse(&inv));
1203 EXPECT_TRUE(inv.bitwiseIsEqual(APFloat(APFloat::x87DoubleExtended, "0.5")));
1206 EXPECT_TRUE(APFloat(1.17549435e-38f).getExactInverse(&inv));
1207 EXPECT_TRUE(inv.bitwiseIsEqual(APFloat(8.5070592e+37f)));
1209 // Large float, inverse is a denormal.
1210 EXPECT_FALSE(APFloat(1.7014118e38f).getExactInverse(nullptr));
1212 EXPECT_FALSE(APFloat(0.0).getExactInverse(nullptr));
1213 // Denormalized float
1214 EXPECT_FALSE(APFloat(1.40129846e-45f).getExactInverse(nullptr));
1217 TEST(APFloatTest, roundToIntegral) {
1218 APFloat T(-0.5), S(3.14), R(APFloat::getLargest(APFloat::IEEEdouble)), P(0.0);
1221 P.roundToIntegral(APFloat::rmTowardZero);
1222 EXPECT_EQ(-0.0, P.convertToDouble());
1224 P.roundToIntegral(APFloat::rmTowardNegative);
1225 EXPECT_EQ(-1.0, P.convertToDouble());
1227 P.roundToIntegral(APFloat::rmTowardPositive);
1228 EXPECT_EQ(-0.0, P.convertToDouble());
1230 P.roundToIntegral(APFloat::rmNearestTiesToEven);
1231 EXPECT_EQ(-0.0, P.convertToDouble());
1234 P.roundToIntegral(APFloat::rmTowardZero);
1235 EXPECT_EQ(3.0, P.convertToDouble());
1237 P.roundToIntegral(APFloat::rmTowardNegative);
1238 EXPECT_EQ(3.0, P.convertToDouble());
1240 P.roundToIntegral(APFloat::rmTowardPositive);
1241 EXPECT_EQ(4.0, P.convertToDouble());
1243 P.roundToIntegral(APFloat::rmNearestTiesToEven);
1244 EXPECT_EQ(3.0, P.convertToDouble());
1247 P.roundToIntegral(APFloat::rmTowardZero);
1248 EXPECT_EQ(R.convertToDouble(), P.convertToDouble());
1250 P.roundToIntegral(APFloat::rmTowardNegative);
1251 EXPECT_EQ(R.convertToDouble(), P.convertToDouble());
1253 P.roundToIntegral(APFloat::rmTowardPositive);
1254 EXPECT_EQ(R.convertToDouble(), P.convertToDouble());
1256 P.roundToIntegral(APFloat::rmNearestTiesToEven);
1257 EXPECT_EQ(R.convertToDouble(), P.convertToDouble());
1259 P = APFloat::getZero(APFloat::IEEEdouble);
1260 P.roundToIntegral(APFloat::rmTowardZero);
1261 EXPECT_EQ(0.0, P.convertToDouble());
1262 P = APFloat::getZero(APFloat::IEEEdouble, true);
1263 P.roundToIntegral(APFloat::rmTowardZero);
1264 EXPECT_EQ(-0.0, P.convertToDouble());
1265 P = APFloat::getNaN(APFloat::IEEEdouble);
1266 P.roundToIntegral(APFloat::rmTowardZero);
1267 EXPECT_TRUE(IsNAN(P.convertToDouble()));
1268 P = APFloat::getInf(APFloat::IEEEdouble);
1269 P.roundToIntegral(APFloat::rmTowardZero);
1270 EXPECT_TRUE(IsInf(P.convertToDouble()) && P.convertToDouble() > 0.0);
1271 P = APFloat::getInf(APFloat::IEEEdouble, true);
1272 P.roundToIntegral(APFloat::rmTowardZero);
1273 EXPECT_TRUE(IsInf(P.convertToDouble()) && P.convertToDouble() < 0.0);
1277 TEST(APFloatTest, getLargest) {
1278 EXPECT_EQ(3.402823466e+38f, APFloat::getLargest(APFloat::IEEEsingle).convertToFloat());
1279 EXPECT_EQ(1.7976931348623158e+308, APFloat::getLargest(APFloat::IEEEdouble).convertToDouble());
1282 TEST(APFloatTest, getSmallest) {
1283 APFloat test = APFloat::getSmallest(APFloat::IEEEsingle, false);
1284 APFloat expected = APFloat(APFloat::IEEEsingle, "0x0.000002p-126");
1285 EXPECT_FALSE(test.isNegative());
1286 EXPECT_TRUE(test.isFiniteNonZero());
1287 EXPECT_TRUE(test.isDenormal());
1288 EXPECT_TRUE(test.bitwiseIsEqual(expected));
1290 test = APFloat::getSmallest(APFloat::IEEEsingle, true);
1291 expected = APFloat(APFloat::IEEEsingle, "-0x0.000002p-126");
1292 EXPECT_TRUE(test.isNegative());
1293 EXPECT_TRUE(test.isFiniteNonZero());
1294 EXPECT_TRUE(test.isDenormal());
1295 EXPECT_TRUE(test.bitwiseIsEqual(expected));
1297 test = APFloat::getSmallest(APFloat::IEEEquad, false);
1298 expected = APFloat(APFloat::IEEEquad, "0x0.0000000000000000000000000001p-16382");
1299 EXPECT_FALSE(test.isNegative());
1300 EXPECT_TRUE(test.isFiniteNonZero());
1301 EXPECT_TRUE(test.isDenormal());
1302 EXPECT_TRUE(test.bitwiseIsEqual(expected));
1304 test = APFloat::getSmallest(APFloat::IEEEquad, true);
1305 expected = APFloat(APFloat::IEEEquad, "-0x0.0000000000000000000000000001p-16382");
1306 EXPECT_TRUE(test.isNegative());
1307 EXPECT_TRUE(test.isFiniteNonZero());
1308 EXPECT_TRUE(test.isDenormal());
1309 EXPECT_TRUE(test.bitwiseIsEqual(expected));
1312 TEST(APFloatTest, getSmallestNormalized) {
1313 APFloat test = APFloat::getSmallestNormalized(APFloat::IEEEsingle, false);
1314 APFloat expected = APFloat(APFloat::IEEEsingle, "0x1p-126");
1315 EXPECT_FALSE(test.isNegative());
1316 EXPECT_TRUE(test.isFiniteNonZero());
1317 EXPECT_FALSE(test.isDenormal());
1318 EXPECT_TRUE(test.bitwiseIsEqual(expected));
1320 test = APFloat::getSmallestNormalized(APFloat::IEEEsingle, true);
1321 expected = APFloat(APFloat::IEEEsingle, "-0x1p-126");
1322 EXPECT_TRUE(test.isNegative());
1323 EXPECT_TRUE(test.isFiniteNonZero());
1324 EXPECT_FALSE(test.isDenormal());
1325 EXPECT_TRUE(test.bitwiseIsEqual(expected));
1327 test = APFloat::getSmallestNormalized(APFloat::IEEEquad, false);
1328 expected = APFloat(APFloat::IEEEquad, "0x1p-16382");
1329 EXPECT_FALSE(test.isNegative());
1330 EXPECT_TRUE(test.isFiniteNonZero());
1331 EXPECT_FALSE(test.isDenormal());
1332 EXPECT_TRUE(test.bitwiseIsEqual(expected));
1334 test = APFloat::getSmallestNormalized(APFloat::IEEEquad, true);
1335 expected = APFloat(APFloat::IEEEquad, "-0x1p-16382");
1336 EXPECT_TRUE(test.isNegative());
1337 EXPECT_TRUE(test.isFiniteNonZero());
1338 EXPECT_FALSE(test.isDenormal());
1339 EXPECT_TRUE(test.bitwiseIsEqual(expected));
1342 TEST(APFloatTest, getZero) {
1344 const fltSemantics *semantics;
1346 const unsigned long long bitPattern[2];
1347 const unsigned bitPatternLength;
1348 } const GetZeroTest[] = {
1349 { &APFloat::IEEEhalf, false, {0, 0}, 1},
1350 { &APFloat::IEEEhalf, true, {0x8000ULL, 0}, 1},
1351 { &APFloat::IEEEsingle, false, {0, 0}, 1},
1352 { &APFloat::IEEEsingle, true, {0x80000000ULL, 0}, 1},
1353 { &APFloat::IEEEdouble, false, {0, 0}, 1},
1354 { &APFloat::IEEEdouble, true, {0x8000000000000000ULL, 0}, 1},
1355 { &APFloat::IEEEquad, false, {0, 0}, 2},
1356 { &APFloat::IEEEquad, true, {0, 0x8000000000000000ULL}, 2},
1357 { &APFloat::PPCDoubleDouble, false, {0, 0}, 2},
1358 { &APFloat::PPCDoubleDouble, true, {0x8000000000000000ULL, 0}, 2},
1359 { &APFloat::x87DoubleExtended, false, {0, 0}, 2},
1360 { &APFloat::x87DoubleExtended, true, {0, 0x8000ULL}, 2},
1362 const unsigned NumGetZeroTests = 12;
1363 for (unsigned i = 0; i < NumGetZeroTests; ++i) {
1364 APFloat test = APFloat::getZero(*GetZeroTest[i].semantics,
1365 GetZeroTest[i].sign);
1366 const char *pattern = GetZeroTest[i].sign? "-0x0p+0" : "0x0p+0";
1367 APFloat expected = APFloat(*GetZeroTest[i].semantics,
1369 EXPECT_TRUE(test.isZero());
1370 EXPECT_TRUE(GetZeroTest[i].sign? test.isNegative() : !test.isNegative());
1371 EXPECT_TRUE(test.bitwiseIsEqual(expected));
1372 for (unsigned j = 0, je = GetZeroTest[i].bitPatternLength; j < je; ++j) {
1373 EXPECT_EQ(GetZeroTest[i].bitPattern[j],
1374 test.bitcastToAPInt().getRawData()[j]);
1379 TEST(APFloatTest, copySign) {
1380 EXPECT_TRUE(APFloat(-42.0).bitwiseIsEqual(
1381 APFloat::copySign(APFloat(42.0), APFloat(-1.0))));
1382 EXPECT_TRUE(APFloat(42.0).bitwiseIsEqual(
1383 APFloat::copySign(APFloat(-42.0), APFloat(1.0))));
1384 EXPECT_TRUE(APFloat(-42.0).bitwiseIsEqual(
1385 APFloat::copySign(APFloat(-42.0), APFloat(-1.0))));
1386 EXPECT_TRUE(APFloat(42.0).bitwiseIsEqual(
1387 APFloat::copySign(APFloat(42.0), APFloat(1.0))));
1390 TEST(APFloatTest, convert) {
1392 APFloat test(APFloat::IEEEdouble, "1.0");
1393 test.convert(APFloat::IEEEsingle, APFloat::rmNearestTiesToEven, &losesInfo);
1394 EXPECT_EQ(1.0f, test.convertToFloat());
1395 EXPECT_FALSE(losesInfo);
1397 test = APFloat(APFloat::x87DoubleExtended, "0x1p-53");
1398 test.add(APFloat(APFloat::x87DoubleExtended, "1.0"), APFloat::rmNearestTiesToEven);
1399 test.convert(APFloat::IEEEdouble, APFloat::rmNearestTiesToEven, &losesInfo);
1400 EXPECT_EQ(1.0, test.convertToDouble());
1401 EXPECT_TRUE(losesInfo);
1403 test = APFloat(APFloat::IEEEquad, "0x1p-53");
1404 test.add(APFloat(APFloat::IEEEquad, "1.0"), APFloat::rmNearestTiesToEven);
1405 test.convert(APFloat::IEEEdouble, APFloat::rmNearestTiesToEven, &losesInfo);
1406 EXPECT_EQ(1.0, test.convertToDouble());
1407 EXPECT_TRUE(losesInfo);
1409 test = APFloat(APFloat::x87DoubleExtended, "0xf.fffffffp+28");
1410 test.convert(APFloat::IEEEdouble, APFloat::rmNearestTiesToEven, &losesInfo);
1411 EXPECT_EQ(4294967295.0, test.convertToDouble());
1412 EXPECT_FALSE(losesInfo);
1414 test = APFloat::getSNaN(APFloat::IEEEsingle);
1415 APFloat X87SNaN = APFloat::getSNaN(APFloat::x87DoubleExtended);
1416 test.convert(APFloat::x87DoubleExtended, APFloat::rmNearestTiesToEven,
1418 EXPECT_TRUE(test.bitwiseIsEqual(X87SNaN));
1419 EXPECT_FALSE(losesInfo);
1421 test = APFloat::getQNaN(APFloat::IEEEsingle);
1422 APFloat X87QNaN = APFloat::getQNaN(APFloat::x87DoubleExtended);
1423 test.convert(APFloat::x87DoubleExtended, APFloat::rmNearestTiesToEven,
1425 EXPECT_TRUE(test.bitwiseIsEqual(X87QNaN));
1426 EXPECT_FALSE(losesInfo);
1428 test = APFloat::getSNaN(APFloat::x87DoubleExtended);
1429 test.convert(APFloat::x87DoubleExtended, APFloat::rmNearestTiesToEven,
1431 EXPECT_TRUE(test.bitwiseIsEqual(X87SNaN));
1432 EXPECT_FALSE(losesInfo);
1434 test = APFloat::getQNaN(APFloat::x87DoubleExtended);
1435 test.convert(APFloat::x87DoubleExtended, APFloat::rmNearestTiesToEven,
1437 EXPECT_TRUE(test.bitwiseIsEqual(X87QNaN));
1438 EXPECT_FALSE(losesInfo);
1441 TEST(APFloatTest, PPCDoubleDouble) {
1442 APFloat test(APFloat::PPCDoubleDouble, "1.0");
1443 EXPECT_EQ(0x3ff0000000000000ull, test.bitcastToAPInt().getRawData()[0]);
1444 EXPECT_EQ(0x0000000000000000ull, test.bitcastToAPInt().getRawData()[1]);
1446 test.divide(APFloat(APFloat::PPCDoubleDouble, "3.0"), APFloat::rmNearestTiesToEven);
1447 EXPECT_EQ(0x3fd5555555555555ull, test.bitcastToAPInt().getRawData()[0]);
1448 EXPECT_EQ(0x3c75555555555556ull, test.bitcastToAPInt().getRawData()[1]);
1451 test = APFloat(APFloat::PPCDoubleDouble, "1.79769313486231580793728971405301e+308");
1452 EXPECT_EQ(0x7fefffffffffffffull, test.bitcastToAPInt().getRawData()[0]);
1453 EXPECT_EQ(0x7c8ffffffffffffeull, test.bitcastToAPInt().getRawData()[1]);
1456 test = APFloat(APFloat::PPCDoubleDouble, "2.00416836000897277799610805135016e-292");
1457 EXPECT_EQ(0x0360000000000000ull, test.bitcastToAPInt().getRawData()[0]);
1458 EXPECT_EQ(0x0000000000000000ull, test.bitcastToAPInt().getRawData()[1]);
1460 test = APFloat(APFloat::PPCDoubleDouble, "1.0");
1461 test.add(APFloat(APFloat::PPCDoubleDouble, "0x1p-105"), APFloat::rmNearestTiesToEven);
1462 EXPECT_EQ(0x3ff0000000000000ull, test.bitcastToAPInt().getRawData()[0]);
1463 EXPECT_EQ(0x3960000000000000ull, test.bitcastToAPInt().getRawData()[1]);
1465 test = APFloat(APFloat::PPCDoubleDouble, "1.0");
1466 test.add(APFloat(APFloat::PPCDoubleDouble, "0x1p-106"), APFloat::rmNearestTiesToEven);
1467 EXPECT_EQ(0x3ff0000000000000ull, test.bitcastToAPInt().getRawData()[0]);
1469 // This is what we would expect with a true double-double implementation
1470 EXPECT_EQ(0x3950000000000000ull, test.bitcastToAPInt().getRawData()[1]);
1472 // This is what we get with our 106-bit mantissa approximation
1473 EXPECT_EQ(0x0000000000000000ull, test.bitcastToAPInt().getRawData()[1]);
1477 TEST(APFloatTest, isNegative) {
1478 APFloat t(APFloat::IEEEsingle, "0x1p+0");
1479 EXPECT_FALSE(t.isNegative());
1480 t = APFloat(APFloat::IEEEsingle, "-0x1p+0");
1481 EXPECT_TRUE(t.isNegative());
1483 EXPECT_FALSE(APFloat::getInf(APFloat::IEEEsingle, false).isNegative());
1484 EXPECT_TRUE(APFloat::getInf(APFloat::IEEEsingle, true).isNegative());
1486 EXPECT_FALSE(APFloat::getZero(APFloat::IEEEsingle, false).isNegative());
1487 EXPECT_TRUE(APFloat::getZero(APFloat::IEEEsingle, true).isNegative());
1489 EXPECT_FALSE(APFloat::getNaN(APFloat::IEEEsingle, false).isNegative());
1490 EXPECT_TRUE(APFloat::getNaN(APFloat::IEEEsingle, true).isNegative());
1492 EXPECT_FALSE(APFloat::getSNaN(APFloat::IEEEsingle, false).isNegative());
1493 EXPECT_TRUE(APFloat::getSNaN(APFloat::IEEEsingle, true).isNegative());
1496 TEST(APFloatTest, isNormal) {
1497 APFloat t(APFloat::IEEEsingle, "0x1p+0");
1498 EXPECT_TRUE(t.isNormal());
1500 EXPECT_FALSE(APFloat::getInf(APFloat::IEEEsingle, false).isNormal());
1501 EXPECT_FALSE(APFloat::getZero(APFloat::IEEEsingle, false).isNormal());
1502 EXPECT_FALSE(APFloat::getNaN(APFloat::IEEEsingle, false).isNormal());
1503 EXPECT_FALSE(APFloat::getSNaN(APFloat::IEEEsingle, false).isNormal());
1504 EXPECT_FALSE(APFloat(APFloat::IEEEsingle, "0x1p-149").isNormal());
1507 TEST(APFloatTest, isFinite) {
1508 APFloat t(APFloat::IEEEsingle, "0x1p+0");
1509 EXPECT_TRUE(t.isFinite());
1510 EXPECT_FALSE(APFloat::getInf(APFloat::IEEEsingle, false).isFinite());
1511 EXPECT_TRUE(APFloat::getZero(APFloat::IEEEsingle, false).isFinite());
1512 EXPECT_FALSE(APFloat::getNaN(APFloat::IEEEsingle, false).isFinite());
1513 EXPECT_FALSE(APFloat::getSNaN(APFloat::IEEEsingle, false).isFinite());
1514 EXPECT_TRUE(APFloat(APFloat::IEEEsingle, "0x1p-149").isFinite());
1517 TEST(APFloatTest, isInfinity) {
1518 APFloat t(APFloat::IEEEsingle, "0x1p+0");
1519 EXPECT_FALSE(t.isInfinity());
1520 EXPECT_TRUE(APFloat::getInf(APFloat::IEEEsingle, false).isInfinity());
1521 EXPECT_FALSE(APFloat::getZero(APFloat::IEEEsingle, false).isInfinity());
1522 EXPECT_FALSE(APFloat::getNaN(APFloat::IEEEsingle, false).isInfinity());
1523 EXPECT_FALSE(APFloat::getSNaN(APFloat::IEEEsingle, false).isInfinity());
1524 EXPECT_FALSE(APFloat(APFloat::IEEEsingle, "0x1p-149").isInfinity());
1527 TEST(APFloatTest, isNaN) {
1528 APFloat t(APFloat::IEEEsingle, "0x1p+0");
1529 EXPECT_FALSE(t.isNaN());
1530 EXPECT_FALSE(APFloat::getInf(APFloat::IEEEsingle, false).isNaN());
1531 EXPECT_FALSE(APFloat::getZero(APFloat::IEEEsingle, false).isNaN());
1532 EXPECT_TRUE(APFloat::getNaN(APFloat::IEEEsingle, false).isNaN());
1533 EXPECT_TRUE(APFloat::getSNaN(APFloat::IEEEsingle, false).isNaN());
1534 EXPECT_FALSE(APFloat(APFloat::IEEEsingle, "0x1p-149").isNaN());
1537 TEST(APFloatTest, isFiniteNonZero) {
1538 // Test positive/negative normal value.
1539 EXPECT_TRUE(APFloat(APFloat::IEEEsingle, "0x1p+0").isFiniteNonZero());
1540 EXPECT_TRUE(APFloat(APFloat::IEEEsingle, "-0x1p+0").isFiniteNonZero());
1542 // Test positive/negative denormal value.
1543 EXPECT_TRUE(APFloat(APFloat::IEEEsingle, "0x1p-149").isFiniteNonZero());
1544 EXPECT_TRUE(APFloat(APFloat::IEEEsingle, "-0x1p-149").isFiniteNonZero());
1546 // Test +/- Infinity.
1547 EXPECT_FALSE(APFloat::getInf(APFloat::IEEEsingle, false).isFiniteNonZero());
1548 EXPECT_FALSE(APFloat::getInf(APFloat::IEEEsingle, true).isFiniteNonZero());
1551 EXPECT_FALSE(APFloat::getZero(APFloat::IEEEsingle, false).isFiniteNonZero());
1552 EXPECT_FALSE(APFloat::getZero(APFloat::IEEEsingle, true).isFiniteNonZero());
1554 // Test +/- qNaN. +/- dont mean anything with qNaN but paranoia can't hurt in
1556 EXPECT_FALSE(APFloat::getNaN(APFloat::IEEEsingle, false).isFiniteNonZero());
1557 EXPECT_FALSE(APFloat::getNaN(APFloat::IEEEsingle, true).isFiniteNonZero());
1559 // Test +/- sNaN. +/- dont mean anything with sNaN but paranoia can't hurt in
1561 EXPECT_FALSE(APFloat::getSNaN(APFloat::IEEEsingle, false).isFiniteNonZero());
1562 EXPECT_FALSE(APFloat::getSNaN(APFloat::IEEEsingle, true).isFiniteNonZero());
1565 TEST(APFloatTest, add) {
1566 // Test Special Cases against each other and normal values.
1569 // 1. Since we perform only default exception handling all operations with
1570 // signaling NaNs should have a result that is a quiet NaN. Currently they
1573 APFloat PInf = APFloat::getInf(APFloat::IEEEsingle, false);
1574 APFloat MInf = APFloat::getInf(APFloat::IEEEsingle, true);
1575 APFloat PZero = APFloat::getZero(APFloat::IEEEsingle, false);
1576 APFloat MZero = APFloat::getZero(APFloat::IEEEsingle, true);
1577 APFloat QNaN = APFloat::getNaN(APFloat::IEEEsingle, false);
1578 APFloat SNaN = APFloat::getSNaN(APFloat::IEEEsingle, false);
1579 APFloat PNormalValue = APFloat(APFloat::IEEEsingle, "0x1p+0");
1580 APFloat MNormalValue = APFloat(APFloat::IEEEsingle, "-0x1p+0");
1581 APFloat PLargestValue = APFloat::getLargest(APFloat::IEEEsingle, false);
1582 APFloat MLargestValue = APFloat::getLargest(APFloat::IEEEsingle, true);
1583 APFloat PSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle, false);
1584 APFloat MSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle, true);
1585 APFloat PSmallestNormalized =
1586 APFloat::getSmallestNormalized(APFloat::IEEEsingle, false);
1587 APFloat MSmallestNormalized =
1588 APFloat::getSmallestNormalized(APFloat::IEEEsingle, true);
1590 const int OverflowStatus = APFloat::opOverflow | APFloat::opInexact;
1592 const unsigned NumTests = 169;
1599 } SpecialCaseTests[NumTests] = {
1600 { PInf, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1601 { PInf, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1602 { PInf, PZero, "inf", APFloat::opOK, APFloat::fcInfinity },
1603 { PInf, MZero, "inf", APFloat::opOK, APFloat::fcInfinity },
1604 { PInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1607 { PInf, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1609 { PInf, PNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
1610 { PInf, MNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
1611 { PInf, PLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
1612 { PInf, MLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
1613 { PInf, PSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
1614 { PInf, MSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
1615 { PInf, PSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity },
1616 { PInf, MSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity },
1617 { MInf, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1618 { MInf, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1619 { MInf, PZero, "-inf", APFloat::opOK, APFloat::fcInfinity },
1620 { MInf, MZero, "-inf", APFloat::opOK, APFloat::fcInfinity },
1621 { MInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1624 { MInf, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1626 { MInf, PNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
1627 { MInf, MNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
1628 { MInf, PLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
1629 { MInf, MLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
1630 { MInf, PSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
1631 { MInf, MSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
1632 { MInf, PSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity },
1633 { MInf, MSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity },
1634 { PZero, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1635 { PZero, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1636 { PZero, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1637 { PZero, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1638 { PZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1641 { PZero, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1643 { PZero, PNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
1644 { PZero, MNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
1645 { PZero, PLargestValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
1646 { PZero, MLargestValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
1647 { PZero, PSmallestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
1648 { PZero, MSmallestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
1649 { PZero, PSmallestNormalized, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
1650 { PZero, MSmallestNormalized, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
1651 { MZero, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1652 { MZero, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1653 { MZero, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1654 { MZero, MZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
1655 { MZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1658 { MZero, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1660 { MZero, PNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
1661 { MZero, MNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
1662 { MZero, PLargestValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
1663 { MZero, MLargestValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
1664 { MZero, PSmallestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
1665 { MZero, MSmallestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
1666 { MZero, PSmallestNormalized, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
1667 { MZero, MSmallestNormalized, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
1668 { QNaN, PInf, "nan", APFloat::opOK, APFloat::fcNaN },
1669 { QNaN, MInf, "nan", APFloat::opOK, APFloat::fcNaN },
1670 { QNaN, PZero, "nan", APFloat::opOK, APFloat::fcNaN },
1671 { QNaN, MZero, "nan", APFloat::opOK, APFloat::fcNaN },
1672 { QNaN, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1675 { QNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1677 { QNaN, PNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
1678 { QNaN, MNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
1679 { QNaN, PLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
1680 { QNaN, MLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
1681 { QNaN, PSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
1682 { QNaN, MSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
1683 { QNaN, PSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
1684 { QNaN, MSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
1687 { SNaN, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1688 { SNaN, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1689 { SNaN, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1690 { SNaN, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1691 { SNaN, QNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1692 { SNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1693 { SNaN, PNormalValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1694 { SNaN, MNormalValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1695 { SNaN, PLargestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1696 { SNaN, MLargestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1697 { SNaN, PSmallestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1698 { SNaN, MSmallestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1699 { SNaN, PSmallestNormalized, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1700 { SNaN, MSmallestNormalized, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1702 { PNormalValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1703 { PNormalValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1704 { PNormalValue, PZero, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
1705 { PNormalValue, MZero, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
1706 { PNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1709 { PNormalValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1711 { PNormalValue, PNormalValue, "0x1p+1", APFloat::opOK, APFloat::fcNormal },
1712 { PNormalValue, MNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1713 { PNormalValue, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1714 { PNormalValue, MLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1715 { PNormalValue, PSmallestValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1716 { PNormalValue, MSmallestValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1717 { PNormalValue, PSmallestNormalized, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1718 { PNormalValue, MSmallestNormalized, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1719 { MNormalValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1720 { MNormalValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1721 { MNormalValue, PZero, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
1722 { MNormalValue, MZero, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
1723 { MNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1726 { MNormalValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1728 { MNormalValue, PNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1729 { MNormalValue, MNormalValue, "-0x1p+1", APFloat::opOK, APFloat::fcNormal },
1730 { MNormalValue, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1731 { MNormalValue, MLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1732 { MNormalValue, PSmallestValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1733 { MNormalValue, MSmallestValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1734 { MNormalValue, PSmallestNormalized, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1735 { MNormalValue, MSmallestNormalized, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1736 { PLargestValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1737 { PLargestValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1738 { PLargestValue, PZero, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
1739 { PLargestValue, MZero, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
1740 { PLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1743 { PLargestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1745 { PLargestValue, PNormalValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1746 { PLargestValue, MNormalValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1747 { PLargestValue, PLargestValue, "inf", OverflowStatus, APFloat::fcInfinity },
1748 { PLargestValue, MLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1749 { PLargestValue, PSmallestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1750 { PLargestValue, MSmallestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1751 { PLargestValue, PSmallestNormalized, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1752 { PLargestValue, MSmallestNormalized, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1753 { MLargestValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1754 { MLargestValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1755 { MLargestValue, PZero, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
1756 { MLargestValue, MZero, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
1757 { MLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1760 { MLargestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1762 { MLargestValue, PNormalValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1763 { MLargestValue, MNormalValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1764 { MLargestValue, PLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1765 { MLargestValue, MLargestValue, "-inf", OverflowStatus, APFloat::fcInfinity },
1766 { MLargestValue, PSmallestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1767 { MLargestValue, MSmallestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1768 { MLargestValue, PSmallestNormalized, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1769 { MLargestValue, MSmallestNormalized, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1770 { PSmallestValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1771 { PSmallestValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1772 { PSmallestValue, PZero, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
1773 { PSmallestValue, MZero, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
1774 { PSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1777 { PSmallestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1779 { PSmallestValue, PNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1780 { PSmallestValue, MNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1781 { PSmallestValue, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1782 { PSmallestValue, MLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1783 { PSmallestValue, PSmallestValue, "0x1p-148", APFloat::opOK, APFloat::fcNormal },
1784 { PSmallestValue, MSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1785 { PSmallestValue, PSmallestNormalized, "0x1.000002p-126", APFloat::opOK, APFloat::fcNormal },
1786 { PSmallestValue, MSmallestNormalized, "-0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal },
1787 { MSmallestValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1788 { MSmallestValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1789 { MSmallestValue, PZero, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
1790 { MSmallestValue, MZero, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
1791 { MSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1794 { MSmallestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1796 { MSmallestValue, PNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1797 { MSmallestValue, MNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1798 { MSmallestValue, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1799 { MSmallestValue, MLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1800 { MSmallestValue, PSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1801 { MSmallestValue, MSmallestValue, "-0x1p-148", APFloat::opOK, APFloat::fcNormal },
1802 { MSmallestValue, PSmallestNormalized, "0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal },
1803 { MSmallestValue, MSmallestNormalized, "-0x1.000002p-126", APFloat::opOK, APFloat::fcNormal },
1804 { PSmallestNormalized, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1805 { PSmallestNormalized, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1806 { PSmallestNormalized, PZero, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
1807 { PSmallestNormalized, MZero, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
1808 { PSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1811 { PSmallestNormalized, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1813 { PSmallestNormalized, PNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1814 { PSmallestNormalized, MNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1815 { PSmallestNormalized, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1816 { PSmallestNormalized, MLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1817 { PSmallestNormalized, PSmallestValue, "0x1.000002p-126", APFloat::opOK, APFloat::fcNormal },
1818 { PSmallestNormalized, MSmallestValue, "0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal },
1819 { PSmallestNormalized, PSmallestNormalized, "0x1p-125", APFloat::opOK, APFloat::fcNormal },
1820 { PSmallestNormalized, MSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1821 { MSmallestNormalized, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1822 { MSmallestNormalized, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1823 { MSmallestNormalized, PZero, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
1824 { MSmallestNormalized, MZero, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
1825 { MSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1828 { MSmallestNormalized, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1830 { MSmallestNormalized, PNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1831 { MSmallestNormalized, MNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1832 { MSmallestNormalized, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1833 { MSmallestNormalized, MLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1834 { MSmallestNormalized, PSmallestValue, "-0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal },
1835 { MSmallestNormalized, MSmallestValue, "-0x1.000002p-126", APFloat::opOK, APFloat::fcNormal },
1836 { MSmallestNormalized, PSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1837 { MSmallestNormalized, MSmallestNormalized, "-0x1p-125", APFloat::opOK, APFloat::fcNormal }
1840 for (size_t i = 0; i < NumTests; ++i) {
1841 APFloat x(SpecialCaseTests[i].x);
1842 APFloat y(SpecialCaseTests[i].y);
1843 APFloat::opStatus status = x.add(y, APFloat::rmNearestTiesToEven);
1845 APFloat result(APFloat::IEEEsingle, SpecialCaseTests[i].result);
1847 EXPECT_TRUE(result.bitwiseIsEqual(x));
1848 EXPECT_TRUE((int)status == SpecialCaseTests[i].status);
1849 EXPECT_TRUE((int)x.getCategory() == SpecialCaseTests[i].category);
1853 TEST(APFloatTest, subtract) {
1854 // Test Special Cases against each other and normal values.
1857 // 1. Since we perform only default exception handling all operations with
1858 // signaling NaNs should have a result that is a quiet NaN. Currently they
1861 APFloat PInf = APFloat::getInf(APFloat::IEEEsingle, false);
1862 APFloat MInf = APFloat::getInf(APFloat::IEEEsingle, true);
1863 APFloat PZero = APFloat::getZero(APFloat::IEEEsingle, false);
1864 APFloat MZero = APFloat::getZero(APFloat::IEEEsingle, true);
1865 APFloat QNaN = APFloat::getNaN(APFloat::IEEEsingle, false);
1866 APFloat SNaN = APFloat::getSNaN(APFloat::IEEEsingle, false);
1867 APFloat PNormalValue = APFloat(APFloat::IEEEsingle, "0x1p+0");
1868 APFloat MNormalValue = APFloat(APFloat::IEEEsingle, "-0x1p+0");
1869 APFloat PLargestValue = APFloat::getLargest(APFloat::IEEEsingle, false);
1870 APFloat MLargestValue = APFloat::getLargest(APFloat::IEEEsingle, true);
1871 APFloat PSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle, false);
1872 APFloat MSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle, true);
1873 APFloat PSmallestNormalized =
1874 APFloat::getSmallestNormalized(APFloat::IEEEsingle, false);
1875 APFloat MSmallestNormalized =
1876 APFloat::getSmallestNormalized(APFloat::IEEEsingle, true);
1878 const int OverflowStatus = APFloat::opOverflow | APFloat::opInexact;
1880 const unsigned NumTests = 169;
1887 } SpecialCaseTests[NumTests] = {
1888 { PInf, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1889 { PInf, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1890 { PInf, PZero, "inf", APFloat::opOK, APFloat::fcInfinity },
1891 { PInf, MZero, "inf", APFloat::opOK, APFloat::fcInfinity },
1892 { PInf, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
1895 { PInf, SNaN, "-nan", APFloat::opInvalidOp, APFloat::fcNaN },
1897 { PInf, PNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
1898 { PInf, MNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
1899 { PInf, PLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
1900 { PInf, MLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
1901 { PInf, PSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
1902 { PInf, MSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
1903 { PInf, PSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity },
1904 { PInf, MSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity },
1905 { MInf, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1906 { MInf, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1907 { MInf, PZero, "-inf", APFloat::opOK, APFloat::fcInfinity },
1908 { MInf, MZero, "-inf", APFloat::opOK, APFloat::fcInfinity },
1909 { MInf, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
1912 { MInf, SNaN, "-nan", APFloat::opInvalidOp, APFloat::fcNaN },
1914 { MInf, PNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
1915 { MInf, MNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
1916 { MInf, PLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
1917 { MInf, MLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
1918 { MInf, PSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
1919 { MInf, MSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
1920 { MInf, PSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity },
1921 { MInf, MSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity },
1922 { PZero, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1923 { PZero, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1924 { PZero, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1925 { PZero, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1926 { PZero, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
1929 { PZero, SNaN, "-nan", APFloat::opInvalidOp, APFloat::fcNaN },
1931 { PZero, PNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
1932 { PZero, MNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
1933 { PZero, PLargestValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
1934 { PZero, MLargestValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
1935 { PZero, PSmallestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
1936 { PZero, MSmallestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
1937 { PZero, PSmallestNormalized, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
1938 { PZero, MSmallestNormalized, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
1939 { MZero, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1940 { MZero, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1941 { MZero, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
1942 { MZero, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1943 { MZero, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
1946 { MZero, SNaN, "-nan", APFloat::opInvalidOp, APFloat::fcNaN },
1948 { MZero, PNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
1949 { MZero, MNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
1950 { MZero, PLargestValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
1951 { MZero, MLargestValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
1952 { MZero, PSmallestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
1953 { MZero, MSmallestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
1954 { MZero, PSmallestNormalized, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
1955 { MZero, MSmallestNormalized, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
1956 { QNaN, PInf, "nan", APFloat::opOK, APFloat::fcNaN },
1957 { QNaN, MInf, "nan", APFloat::opOK, APFloat::fcNaN },
1958 { QNaN, PZero, "nan", APFloat::opOK, APFloat::fcNaN },
1959 { QNaN, MZero, "nan", APFloat::opOK, APFloat::fcNaN },
1960 { QNaN, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1963 { QNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1965 { QNaN, PNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
1966 { QNaN, MNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
1967 { QNaN, PLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
1968 { QNaN, MLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
1969 { QNaN, PSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
1970 { QNaN, MSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
1971 { QNaN, PSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
1972 { QNaN, MSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
1975 { SNaN, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1976 { SNaN, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1977 { SNaN, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1978 { SNaN, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1979 { SNaN, QNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1980 { SNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1981 { SNaN, PNormalValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1982 { SNaN, MNormalValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1983 { SNaN, PLargestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1984 { SNaN, MLargestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1985 { SNaN, PSmallestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1986 { SNaN, MSmallestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1987 { SNaN, PSmallestNormalized, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1988 { SNaN, MSmallestNormalized, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1990 { PNormalValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1991 { PNormalValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1992 { PNormalValue, PZero, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
1993 { PNormalValue, MZero, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
1994 { PNormalValue, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
1997 { PNormalValue, SNaN, "-nan", APFloat::opInvalidOp, APFloat::fcNaN },
1999 { PNormalValue, PNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2000 { PNormalValue, MNormalValue, "0x1p+1", APFloat::opOK, APFloat::fcNormal },
2001 { PNormalValue, PLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2002 { PNormalValue, MLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2003 { PNormalValue, PSmallestValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2004 { PNormalValue, MSmallestValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2005 { PNormalValue, PSmallestNormalized, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2006 { PNormalValue, MSmallestNormalized, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2007 { MNormalValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2008 { MNormalValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2009 { MNormalValue, PZero, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2010 { MNormalValue, MZero, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2011 { MNormalValue, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
2014 { MNormalValue, SNaN, "-nan", APFloat::opInvalidOp, APFloat::fcNaN },
2016 { MNormalValue, PNormalValue, "-0x1p+1", APFloat::opOK, APFloat::fcNormal },
2017 { MNormalValue, MNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2018 { MNormalValue, PLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2019 { MNormalValue, MLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2020 { MNormalValue, PSmallestValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2021 { MNormalValue, MSmallestValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2022 { MNormalValue, PSmallestNormalized, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2023 { MNormalValue, MSmallestNormalized, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2024 { PLargestValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2025 { PLargestValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2026 { PLargestValue, PZero, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2027 { PLargestValue, MZero, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2028 { PLargestValue, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
2031 { PLargestValue, SNaN, "-nan", APFloat::opInvalidOp, APFloat::fcNaN },
2033 { PLargestValue, PNormalValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2034 { PLargestValue, MNormalValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2035 { PLargestValue, PLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2036 { PLargestValue, MLargestValue, "inf", OverflowStatus, APFloat::fcInfinity },
2037 { PLargestValue, PSmallestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2038 { PLargestValue, MSmallestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2039 { PLargestValue, PSmallestNormalized, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2040 { PLargestValue, MSmallestNormalized, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2041 { MLargestValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2042 { MLargestValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2043 { MLargestValue, PZero, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2044 { MLargestValue, MZero, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2045 { MLargestValue, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
2048 { MLargestValue, SNaN, "-nan", APFloat::opInvalidOp, APFloat::fcNaN },
2050 { MLargestValue, PNormalValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2051 { MLargestValue, MNormalValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2052 { MLargestValue, PLargestValue, "-inf", OverflowStatus, APFloat::fcInfinity },
2053 { MLargestValue, MLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2054 { MLargestValue, PSmallestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2055 { MLargestValue, MSmallestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2056 { MLargestValue, PSmallestNormalized, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2057 { MLargestValue, MSmallestNormalized, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2058 { PSmallestValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2059 { PSmallestValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2060 { PSmallestValue, PZero, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2061 { PSmallestValue, MZero, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2062 { PSmallestValue, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
2065 { PSmallestValue, SNaN, "-nan", APFloat::opInvalidOp, APFloat::fcNaN },
2067 { PSmallestValue, PNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2068 { PSmallestValue, MNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2069 { PSmallestValue, PLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2070 { PSmallestValue, MLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2071 { PSmallestValue, PSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2072 { PSmallestValue, MSmallestValue, "0x1p-148", APFloat::opOK, APFloat::fcNormal },
2073 { PSmallestValue, PSmallestNormalized, "-0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal },
2074 { PSmallestValue, MSmallestNormalized, "0x1.000002p-126", APFloat::opOK, APFloat::fcNormal },
2075 { MSmallestValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2076 { MSmallestValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2077 { MSmallestValue, PZero, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2078 { MSmallestValue, MZero, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2079 { MSmallestValue, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
2082 { MSmallestValue, SNaN, "-nan", APFloat::opInvalidOp, APFloat::fcNaN },
2084 { MSmallestValue, PNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2085 { MSmallestValue, MNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2086 { MSmallestValue, PLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2087 { MSmallestValue, MLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2088 { MSmallestValue, PSmallestValue, "-0x1p-148", APFloat::opOK, APFloat::fcNormal },
2089 { MSmallestValue, MSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2090 { MSmallestValue, PSmallestNormalized, "-0x1.000002p-126", APFloat::opOK, APFloat::fcNormal },
2091 { MSmallestValue, MSmallestNormalized, "0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal },
2092 { PSmallestNormalized, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2093 { PSmallestNormalized, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2094 { PSmallestNormalized, PZero, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2095 { PSmallestNormalized, MZero, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2096 { PSmallestNormalized, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
2099 { PSmallestNormalized, SNaN, "-nan", APFloat::opInvalidOp, APFloat::fcNaN },
2101 { PSmallestNormalized, PNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2102 { PSmallestNormalized, MNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2103 { PSmallestNormalized, PLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2104 { PSmallestNormalized, MLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2105 { PSmallestNormalized, PSmallestValue, "0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal },
2106 { PSmallestNormalized, MSmallestValue, "0x1.000002p-126", APFloat::opOK, APFloat::fcNormal },
2107 { PSmallestNormalized, PSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2108 { PSmallestNormalized, MSmallestNormalized, "0x1p-125", APFloat::opOK, APFloat::fcNormal },
2109 { MSmallestNormalized, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2110 { MSmallestNormalized, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2111 { MSmallestNormalized, PZero, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2112 { MSmallestNormalized, MZero, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2113 { MSmallestNormalized, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
2116 { MSmallestNormalized, SNaN, "-nan", APFloat::opInvalidOp, APFloat::fcNaN },
2118 { MSmallestNormalized, PNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2119 { MSmallestNormalized, MNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2120 { MSmallestNormalized, PLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2121 { MSmallestNormalized, MLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2122 { MSmallestNormalized, PSmallestValue, "-0x1.000002p-126", APFloat::opOK, APFloat::fcNormal },
2123 { MSmallestNormalized, MSmallestValue, "-0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal },
2124 { MSmallestNormalized, PSmallestNormalized, "-0x1p-125", APFloat::opOK, APFloat::fcNormal },
2125 { MSmallestNormalized, MSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero }
2128 for (size_t i = 0; i < NumTests; ++i) {
2129 APFloat x(SpecialCaseTests[i].x);
2130 APFloat y(SpecialCaseTests[i].y);
2131 APFloat::opStatus status = x.subtract(y, APFloat::rmNearestTiesToEven);
2133 APFloat result(APFloat::IEEEsingle, SpecialCaseTests[i].result);
2135 EXPECT_TRUE(result.bitwiseIsEqual(x));
2136 EXPECT_TRUE((int)status == SpecialCaseTests[i].status);
2137 EXPECT_TRUE((int)x.getCategory() == SpecialCaseTests[i].category);
2141 TEST(APFloatTest, multiply) {
2142 // Test Special Cases against each other and normal values.
2145 // 1. Since we perform only default exception handling all operations with
2146 // signaling NaNs should have a result that is a quiet NaN. Currently they
2149 APFloat PInf = APFloat::getInf(APFloat::IEEEsingle, false);
2150 APFloat MInf = APFloat::getInf(APFloat::IEEEsingle, true);
2151 APFloat PZero = APFloat::getZero(APFloat::IEEEsingle, false);
2152 APFloat MZero = APFloat::getZero(APFloat::IEEEsingle, true);
2153 APFloat QNaN = APFloat::getNaN(APFloat::IEEEsingle, false);
2154 APFloat SNaN = APFloat::getSNaN(APFloat::IEEEsingle, false);
2155 APFloat PNormalValue = APFloat(APFloat::IEEEsingle, "0x1p+0");
2156 APFloat MNormalValue = APFloat(APFloat::IEEEsingle, "-0x1p+0");
2157 APFloat PLargestValue = APFloat::getLargest(APFloat::IEEEsingle, false);
2158 APFloat MLargestValue = APFloat::getLargest(APFloat::IEEEsingle, true);
2159 APFloat PSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle, false);
2160 APFloat MSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle, true);
2161 APFloat PSmallestNormalized =
2162 APFloat::getSmallestNormalized(APFloat::IEEEsingle, false);
2163 APFloat MSmallestNormalized =
2164 APFloat::getSmallestNormalized(APFloat::IEEEsingle, true);
2166 const int OverflowStatus = APFloat::opOverflow | APFloat::opInexact;
2167 const int UnderflowStatus = APFloat::opUnderflow | APFloat::opInexact;
2169 const unsigned NumTests = 169;
2176 } SpecialCaseTests[NumTests] = {
2177 { PInf, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2178 { PInf, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2179 { PInf, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2180 { PInf, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2181 { PInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2184 { PInf, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2186 { PInf, PNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2187 { PInf, MNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2188 { PInf, PLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2189 { PInf, MLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2190 { PInf, PSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2191 { PInf, MSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2192 { PInf, PSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity },
2193 { PInf, MSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity },
2194 { MInf, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2195 { MInf, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2196 { MInf, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2197 { MInf, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2198 { MInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2201 { MInf, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2203 { MInf, PNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2204 { MInf, MNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2205 { MInf, PLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2206 { MInf, MLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2207 { MInf, PSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2208 { MInf, MSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2209 { MInf, PSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity },
2210 { MInf, MSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity },
2211 { PZero, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2212 { PZero, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2213 { PZero, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2214 { PZero, MZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2215 { PZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2218 { PZero, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2220 { PZero, PNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2221 { PZero, MNormalValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2222 { PZero, PLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2223 { PZero, MLargestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2224 { PZero, PSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2225 { PZero, MSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2226 { PZero, PSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2227 { PZero, MSmallestNormalized, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2228 { MZero, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2229 { MZero, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2230 { MZero, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2231 { MZero, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2232 { MZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2235 { MZero, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2237 { MZero, PNormalValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2238 { MZero, MNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2239 { MZero, PLargestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2240 { MZero, MLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2241 { MZero, PSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2242 { MZero, MSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2243 { MZero, PSmallestNormalized, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2244 { MZero, MSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2245 { QNaN, PInf, "nan", APFloat::opOK, APFloat::fcNaN },
2246 { QNaN, MInf, "nan", APFloat::opOK, APFloat::fcNaN },
2247 { QNaN, PZero, "nan", APFloat::opOK, APFloat::fcNaN },
2248 { QNaN, MZero, "nan", APFloat::opOK, APFloat::fcNaN },
2249 { QNaN, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2252 { QNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2254 { QNaN, PNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
2255 { QNaN, MNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
2256 { QNaN, PLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2257 { QNaN, MLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2258 { QNaN, PSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2259 { QNaN, MSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2260 { QNaN, PSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
2261 { QNaN, MSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
2264 { SNaN, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2265 { SNaN, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2266 { SNaN, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2267 { SNaN, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2268 { SNaN, QNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2269 { SNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2270 { SNaN, PNormalValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2271 { SNaN, MNormalValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2272 { SNaN, PLargestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2273 { SNaN, MLargestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2274 { SNaN, PSmallestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2275 { SNaN, MSmallestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2276 { SNaN, PSmallestNormalized, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2277 { SNaN, MSmallestNormalized, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2279 { PNormalValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2280 { PNormalValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2281 { PNormalValue, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2282 { PNormalValue, MZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2283 { PNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2286 { PNormalValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2288 { PNormalValue, PNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2289 { PNormalValue, MNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2290 { PNormalValue, PLargestValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2291 { PNormalValue, MLargestValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2292 { PNormalValue, PSmallestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2293 { PNormalValue, MSmallestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2294 { PNormalValue, PSmallestNormalized, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2295 { PNormalValue, MSmallestNormalized, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2296 { MNormalValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2297 { MNormalValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2298 { MNormalValue, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2299 { MNormalValue, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2300 { MNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2303 { MNormalValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2305 { MNormalValue, PNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2306 { MNormalValue, MNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2307 { MNormalValue, PLargestValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2308 { MNormalValue, MLargestValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2309 { MNormalValue, PSmallestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2310 { MNormalValue, MSmallestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2311 { MNormalValue, PSmallestNormalized, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2312 { MNormalValue, MSmallestNormalized, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2313 { PLargestValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2314 { PLargestValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2315 { PLargestValue, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2316 { PLargestValue, MZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2317 { PLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2320 { PLargestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2322 { PLargestValue, PNormalValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2323 { PLargestValue, MNormalValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2324 { PLargestValue, PLargestValue, "inf", OverflowStatus, APFloat::fcInfinity },
2325 { PLargestValue, MLargestValue, "-inf", OverflowStatus, APFloat::fcInfinity },
2326 { PLargestValue, PSmallestValue, "0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal },
2327 { PLargestValue, MSmallestValue, "-0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal },
2328 { PLargestValue, PSmallestNormalized, "0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal },
2329 { PLargestValue, MSmallestNormalized, "-0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal },
2330 { MLargestValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2331 { MLargestValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2332 { MLargestValue, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2333 { MLargestValue, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2334 { MLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2337 { MLargestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2339 { MLargestValue, PNormalValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2340 { MLargestValue, MNormalValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2341 { MLargestValue, PLargestValue, "-inf", OverflowStatus, APFloat::fcInfinity },
2342 { MLargestValue, MLargestValue, "inf", OverflowStatus, APFloat::fcInfinity },
2343 { MLargestValue, PSmallestValue, "-0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal },
2344 { MLargestValue, MSmallestValue, "0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal },
2345 { MLargestValue, PSmallestNormalized, "-0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal },
2346 { MLargestValue, MSmallestNormalized, "0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal },
2347 { PSmallestValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2348 { PSmallestValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2349 { PSmallestValue, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2350 { PSmallestValue, MZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2351 { PSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2354 { PSmallestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2356 { PSmallestValue, PNormalValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2357 { PSmallestValue, MNormalValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2358 { PSmallestValue, PLargestValue, "0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal },
2359 { PSmallestValue, MLargestValue, "-0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal },
2360 { PSmallestValue, PSmallestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero },
2361 { PSmallestValue, MSmallestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2362 { PSmallestValue, PSmallestNormalized, "0x0p+0", UnderflowStatus, APFloat::fcZero },
2363 { PSmallestValue, MSmallestNormalized, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2364 { MSmallestValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2365 { MSmallestValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2366 { MSmallestValue, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2367 { MSmallestValue, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2368 { MSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2371 { MSmallestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2373 { MSmallestValue, PNormalValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2374 { MSmallestValue, MNormalValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2375 { MSmallestValue, PLargestValue, "-0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal },
2376 { MSmallestValue, MLargestValue, "0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal },
2377 { MSmallestValue, PSmallestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2378 { MSmallestValue, MSmallestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero },
2379 { MSmallestValue, PSmallestNormalized, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2380 { MSmallestValue, MSmallestNormalized, "0x0p+0", UnderflowStatus, APFloat::fcZero },
2381 { PSmallestNormalized, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2382 { PSmallestNormalized, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2383 { PSmallestNormalized, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2384 { PSmallestNormalized, MZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2385 { PSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2388 { PSmallestNormalized, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2390 { PSmallestNormalized, PNormalValue, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2391 { PSmallestNormalized, MNormalValue, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2392 { PSmallestNormalized, PLargestValue, "0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal },
2393 { PSmallestNormalized, MLargestValue, "-0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal },
2394 { PSmallestNormalized, PSmallestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero },
2395 { PSmallestNormalized, MSmallestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2396 { PSmallestNormalized, PSmallestNormalized, "0x0p+0", UnderflowStatus, APFloat::fcZero },
2397 { PSmallestNormalized, MSmallestNormalized, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2398 { MSmallestNormalized, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2399 { MSmallestNormalized, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2400 { MSmallestNormalized, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2401 { MSmallestNormalized, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2402 { MSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2405 { MSmallestNormalized, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2407 { MSmallestNormalized, PNormalValue, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2408 { MSmallestNormalized, MNormalValue, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2409 { MSmallestNormalized, PLargestValue, "-0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal },
2410 { MSmallestNormalized, MLargestValue, "0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal },
2411 { MSmallestNormalized, PSmallestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2412 { MSmallestNormalized, MSmallestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero },
2413 { MSmallestNormalized, PSmallestNormalized, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2414 { MSmallestNormalized, MSmallestNormalized, "0x0p+0", UnderflowStatus, APFloat::fcZero }
2417 for (size_t i = 0; i < NumTests; ++i) {
2418 APFloat x(SpecialCaseTests[i].x);
2419 APFloat y(SpecialCaseTests[i].y);
2420 APFloat::opStatus status = x.multiply(y, APFloat::rmNearestTiesToEven);
2422 APFloat result(APFloat::IEEEsingle, SpecialCaseTests[i].result);
2424 EXPECT_TRUE(result.bitwiseIsEqual(x));
2425 EXPECT_TRUE((int)status == SpecialCaseTests[i].status);
2426 EXPECT_TRUE((int)x.getCategory() == SpecialCaseTests[i].category);
2430 TEST(APFloatTest, divide) {
2431 // Test Special Cases against each other and normal values.
2434 // 1. Since we perform only default exception handling all operations with
2435 // signaling NaNs should have a result that is a quiet NaN. Currently they
2438 APFloat PInf = APFloat::getInf(APFloat::IEEEsingle, false);
2439 APFloat MInf = APFloat::getInf(APFloat::IEEEsingle, true);
2440 APFloat PZero = APFloat::getZero(APFloat::IEEEsingle, false);
2441 APFloat MZero = APFloat::getZero(APFloat::IEEEsingle, true);
2442 APFloat QNaN = APFloat::getNaN(APFloat::IEEEsingle, false);
2443 APFloat SNaN = APFloat::getSNaN(APFloat::IEEEsingle, false);
2444 APFloat PNormalValue = APFloat(APFloat::IEEEsingle, "0x1p+0");
2445 APFloat MNormalValue = APFloat(APFloat::IEEEsingle, "-0x1p+0");
2446 APFloat PLargestValue = APFloat::getLargest(APFloat::IEEEsingle, false);
2447 APFloat MLargestValue = APFloat::getLargest(APFloat::IEEEsingle, true);
2448 APFloat PSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle, false);
2449 APFloat MSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle, true);
2450 APFloat PSmallestNormalized =
2451 APFloat::getSmallestNormalized(APFloat::IEEEsingle, false);
2452 APFloat MSmallestNormalized =
2453 APFloat::getSmallestNormalized(APFloat::IEEEsingle, true);
2455 const int OverflowStatus = APFloat::opOverflow | APFloat::opInexact;
2456 const int UnderflowStatus = APFloat::opUnderflow | APFloat::opInexact;
2458 const unsigned NumTests = 169;
2465 } SpecialCaseTests[NumTests] = {
2466 { PInf, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2467 { PInf, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2468 { PInf, PZero, "inf", APFloat::opOK, APFloat::fcInfinity },
2469 { PInf, MZero, "-inf", APFloat::opOK, APFloat::fcInfinity },
2470 { PInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2473 { PInf, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2475 { PInf, PNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2476 { PInf, MNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2477 { PInf, PLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2478 { PInf, MLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2479 { PInf, PSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2480 { PInf, MSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2481 { PInf, PSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity },
2482 { PInf, MSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity },
2483 { MInf, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2484 { MInf, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2485 { MInf, PZero, "-inf", APFloat::opOK, APFloat::fcInfinity },
2486 { MInf, MZero, "inf", APFloat::opOK, APFloat::fcInfinity },
2487 { MInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2490 { MInf, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2492 { MInf, PNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2493 { MInf, MNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2494 { MInf, PLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2495 { MInf, MLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2496 { MInf, PSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2497 { MInf, MSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2498 { MInf, PSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity },
2499 { MInf, MSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity },
2500 { PZero, PInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2501 { PZero, MInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2502 { PZero, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2503 { PZero, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2504 { PZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2507 { PZero, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2509 { PZero, PNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2510 { PZero, MNormalValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2511 { PZero, PLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2512 { PZero, MLargestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2513 { PZero, PSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2514 { PZero, MSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2515 { PZero, PSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2516 { PZero, MSmallestNormalized, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2517 { MZero, PInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2518 { MZero, MInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2519 { MZero, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2520 { MZero, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2521 { MZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2524 { MZero, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2526 { MZero, PNormalValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2527 { MZero, MNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2528 { MZero, PLargestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2529 { MZero, MLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2530 { MZero, PSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2531 { MZero, MSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2532 { MZero, PSmallestNormalized, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2533 { MZero, MSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2534 { QNaN, PInf, "nan", APFloat::opOK, APFloat::fcNaN },
2535 { QNaN, MInf, "nan", APFloat::opOK, APFloat::fcNaN },
2536 { QNaN, PZero, "nan", APFloat::opOK, APFloat::fcNaN },
2537 { QNaN, MZero, "nan", APFloat::opOK, APFloat::fcNaN },
2538 { QNaN, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2541 { QNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2543 { QNaN, PNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
2544 { QNaN, MNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
2545 { QNaN, PLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2546 { QNaN, MLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2547 { QNaN, PSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2548 { QNaN, MSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2549 { QNaN, PSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
2550 { QNaN, MSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
2553 { SNaN, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2554 { SNaN, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2555 { SNaN, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2556 { SNaN, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2557 { SNaN, QNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2558 { SNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2559 { SNaN, PNormalValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2560 { SNaN, MNormalValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2561 { SNaN, PLargestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2562 { SNaN, MLargestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2563 { SNaN, PSmallestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2564 { SNaN, MSmallestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2565 { SNaN, PSmallestNormalized, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2566 { SNaN, MSmallestNormalized, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2568 { PNormalValue, PInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2569 { PNormalValue, MInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2570 { PNormalValue, PZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
2571 { PNormalValue, MZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
2572 { PNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2575 { PNormalValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2577 { PNormalValue, PNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2578 { PNormalValue, MNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2579 { PNormalValue, PLargestValue, "0x1p-128", UnderflowStatus, APFloat::fcNormal },
2580 { PNormalValue, MLargestValue, "-0x1p-128", UnderflowStatus, APFloat::fcNormal },
2581 { PNormalValue, PSmallestValue, "inf", OverflowStatus, APFloat::fcInfinity },
2582 { PNormalValue, MSmallestValue, "-inf", OverflowStatus, APFloat::fcInfinity },
2583 { PNormalValue, PSmallestNormalized, "0x1p+126", APFloat::opOK, APFloat::fcNormal },
2584 { PNormalValue, MSmallestNormalized, "-0x1p+126", APFloat::opOK, APFloat::fcNormal },
2585 { MNormalValue, PInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2586 { MNormalValue, MInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2587 { MNormalValue, PZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
2588 { MNormalValue, MZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
2589 { MNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2592 { MNormalValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2594 { MNormalValue, PNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2595 { MNormalValue, MNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2596 { MNormalValue, PLargestValue, "-0x1p-128", UnderflowStatus, APFloat::fcNormal },
2597 { MNormalValue, MLargestValue, "0x1p-128", UnderflowStatus, APFloat::fcNormal },
2598 { MNormalValue, PSmallestValue, "-inf", OverflowStatus, APFloat::fcInfinity },
2599 { MNormalValue, MSmallestValue, "inf", OverflowStatus, APFloat::fcInfinity },
2600 { MNormalValue, PSmallestNormalized, "-0x1p+126", APFloat::opOK, APFloat::fcNormal },
2601 { MNormalValue, MSmallestNormalized, "0x1p+126", APFloat::opOK, APFloat::fcNormal },
2602 { PLargestValue, PInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2603 { PLargestValue, MInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2604 { PLargestValue, PZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
2605 { PLargestValue, MZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
2606 { PLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2609 { PLargestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2611 { PLargestValue, PNormalValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2612 { PLargestValue, MNormalValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2613 { PLargestValue, PLargestValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2614 { PLargestValue, MLargestValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2615 { PLargestValue, PSmallestValue, "inf", OverflowStatus, APFloat::fcInfinity },
2616 { PLargestValue, MSmallestValue, "-inf", OverflowStatus, APFloat::fcInfinity },
2617 { PLargestValue, PSmallestNormalized, "inf", OverflowStatus, APFloat::fcInfinity },
2618 { PLargestValue, MSmallestNormalized, "-inf", OverflowStatus, APFloat::fcInfinity },
2619 { MLargestValue, PInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2620 { MLargestValue, MInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2621 { MLargestValue, PZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
2622 { MLargestValue, MZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
2623 { MLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2626 { MLargestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2628 { MLargestValue, PNormalValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2629 { MLargestValue, MNormalValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2630 { MLargestValue, PLargestValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2631 { MLargestValue, MLargestValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2632 { MLargestValue, PSmallestValue, "-inf", OverflowStatus, APFloat::fcInfinity },
2633 { MLargestValue, MSmallestValue, "inf", OverflowStatus, APFloat::fcInfinity },
2634 { MLargestValue, PSmallestNormalized, "-inf", OverflowStatus, APFloat::fcInfinity },
2635 { MLargestValue, MSmallestNormalized, "inf", OverflowStatus, APFloat::fcInfinity },
2636 { PSmallestValue, PInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2637 { PSmallestValue, MInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2638 { PSmallestValue, PZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
2639 { PSmallestValue, MZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
2640 { PSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2643 { PSmallestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2645 { PSmallestValue, PNormalValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2646 { PSmallestValue, MNormalValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2647 { PSmallestValue, PLargestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero },
2648 { PSmallestValue, MLargestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2649 { PSmallestValue, PSmallestValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2650 { PSmallestValue, MSmallestValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2651 { PSmallestValue, PSmallestNormalized, "0x1p-23", APFloat::opOK, APFloat::fcNormal },
2652 { PSmallestValue, MSmallestNormalized, "-0x1p-23", APFloat::opOK, APFloat::fcNormal },
2653 { MSmallestValue, PInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2654 { MSmallestValue, MInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2655 { MSmallestValue, PZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
2656 { MSmallestValue, MZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
2657 { MSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2660 { MSmallestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2662 { MSmallestValue, PNormalValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2663 { MSmallestValue, MNormalValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2664 { MSmallestValue, PLargestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2665 { MSmallestValue, MLargestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero },
2666 { MSmallestValue, PSmallestValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2667 { MSmallestValue, MSmallestValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2668 { MSmallestValue, PSmallestNormalized, "-0x1p-23", APFloat::opOK, APFloat::fcNormal },
2669 { MSmallestValue, MSmallestNormalized, "0x1p-23", APFloat::opOK, APFloat::fcNormal },
2670 { PSmallestNormalized, PInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2671 { PSmallestNormalized, MInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2672 { PSmallestNormalized, PZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
2673 { PSmallestNormalized, MZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
2674 { PSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2677 { PSmallestNormalized, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2679 { PSmallestNormalized, PNormalValue, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2680 { PSmallestNormalized, MNormalValue, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2681 { PSmallestNormalized, PLargestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero },
2682 { PSmallestNormalized, MLargestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2683 { PSmallestNormalized, PSmallestValue, "0x1p+23", APFloat::opOK, APFloat::fcNormal },
2684 { PSmallestNormalized, MSmallestValue, "-0x1p+23", APFloat::opOK, APFloat::fcNormal },
2685 { PSmallestNormalized, PSmallestNormalized, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2686 { PSmallestNormalized, MSmallestNormalized, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2687 { MSmallestNormalized, PInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2688 { MSmallestNormalized, MInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2689 { MSmallestNormalized, PZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
2690 { MSmallestNormalized, MZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
2691 { MSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2694 { MSmallestNormalized, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2696 { MSmallestNormalized, PNormalValue, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2697 { MSmallestNormalized, MNormalValue, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2698 { MSmallestNormalized, PLargestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2699 { MSmallestNormalized, MLargestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero },
2700 { MSmallestNormalized, PSmallestValue, "-0x1p+23", APFloat::opOK, APFloat::fcNormal },
2701 { MSmallestNormalized, MSmallestValue, "0x1p+23", APFloat::opOK, APFloat::fcNormal },
2702 { MSmallestNormalized, PSmallestNormalized, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2703 { MSmallestNormalized, MSmallestNormalized, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2706 for (size_t i = 0; i < NumTests; ++i) {
2707 APFloat x(SpecialCaseTests[i].x);
2708 APFloat y(SpecialCaseTests[i].y);
2709 APFloat::opStatus status = x.divide(y, APFloat::rmNearestTiesToEven);
2711 APFloat result(APFloat::IEEEsingle, SpecialCaseTests[i].result);
2713 EXPECT_TRUE(result.bitwiseIsEqual(x));
2714 EXPECT_TRUE((int)status == SpecialCaseTests[i].status);
2715 EXPECT_TRUE((int)x.getCategory() == SpecialCaseTests[i].category);
2719 TEST(APFloatTest, operatorOverloads) {
2720 // This is mostly testing that these operator overloads compile.
2721 APFloat One = APFloat(APFloat::IEEEsingle, "0x1p+0");
2722 APFloat Two = APFloat(APFloat::IEEEsingle, "0x2p+0");
2723 EXPECT_TRUE(Two.bitwiseIsEqual(One + One));
2724 EXPECT_TRUE(One.bitwiseIsEqual(Two - One));
2725 EXPECT_TRUE(Two.bitwiseIsEqual(One * Two));
2726 EXPECT_TRUE(One.bitwiseIsEqual(Two / Two));
2729 TEST(APFloatTest, abs) {
2730 APFloat PInf = APFloat::getInf(APFloat::IEEEsingle, false);
2731 APFloat MInf = APFloat::getInf(APFloat::IEEEsingle, true);
2732 APFloat PZero = APFloat::getZero(APFloat::IEEEsingle, false);
2733 APFloat MZero = APFloat::getZero(APFloat::IEEEsingle, true);
2734 APFloat PQNaN = APFloat::getNaN(APFloat::IEEEsingle, false);
2735 APFloat MQNaN = APFloat::getNaN(APFloat::IEEEsingle, true);
2736 APFloat PSNaN = APFloat::getSNaN(APFloat::IEEEsingle, false);
2737 APFloat MSNaN = APFloat::getSNaN(APFloat::IEEEsingle, true);
2738 APFloat PNormalValue = APFloat(APFloat::IEEEsingle, "0x1p+0");
2739 APFloat MNormalValue = APFloat(APFloat::IEEEsingle, "-0x1p+0");
2740 APFloat PLargestValue = APFloat::getLargest(APFloat::IEEEsingle, false);
2741 APFloat MLargestValue = APFloat::getLargest(APFloat::IEEEsingle, true);
2742 APFloat PSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle, false);
2743 APFloat MSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle, true);
2744 APFloat PSmallestNormalized =
2745 APFloat::getSmallestNormalized(APFloat::IEEEsingle, false);
2746 APFloat MSmallestNormalized =
2747 APFloat::getSmallestNormalized(APFloat::IEEEsingle, true);
2749 EXPECT_TRUE(PInf.bitwiseIsEqual(abs(PInf)));
2750 EXPECT_TRUE(PInf.bitwiseIsEqual(abs(MInf)));
2751 EXPECT_TRUE(PZero.bitwiseIsEqual(abs(PZero)));
2752 EXPECT_TRUE(PZero.bitwiseIsEqual(abs(MZero)));
2753 EXPECT_TRUE(PQNaN.bitwiseIsEqual(abs(PQNaN)));
2754 EXPECT_TRUE(PQNaN.bitwiseIsEqual(abs(MQNaN)));
2755 EXPECT_TRUE(PSNaN.bitwiseIsEqual(abs(PSNaN)));
2756 EXPECT_TRUE(PSNaN.bitwiseIsEqual(abs(MSNaN)));
2757 EXPECT_TRUE(PNormalValue.bitwiseIsEqual(abs(PNormalValue)));
2758 EXPECT_TRUE(PNormalValue.bitwiseIsEqual(abs(MNormalValue)));
2759 EXPECT_TRUE(PLargestValue.bitwiseIsEqual(abs(PLargestValue)));
2760 EXPECT_TRUE(PLargestValue.bitwiseIsEqual(abs(MLargestValue)));
2761 EXPECT_TRUE(PSmallestValue.bitwiseIsEqual(abs(PSmallestValue)));
2762 EXPECT_TRUE(PSmallestValue.bitwiseIsEqual(abs(MSmallestValue)));
2763 EXPECT_TRUE(PSmallestNormalized.bitwiseIsEqual(abs(PSmallestNormalized)));
2764 EXPECT_TRUE(PSmallestNormalized.bitwiseIsEqual(abs(MSmallestNormalized)));
2767 TEST(APFloatTest, ilogb) {
2768 EXPECT_EQ(0, ilogb(APFloat(APFloat::IEEEsingle, "0x1p+0")));
2769 EXPECT_EQ(0, ilogb(APFloat(APFloat::IEEEsingle, "-0x1p+0")));
2770 EXPECT_EQ(42, ilogb(APFloat(APFloat::IEEEsingle, "0x1p+42")));
2771 EXPECT_EQ(-42, ilogb(APFloat(APFloat::IEEEsingle, "0x1p-42")));
2773 EXPECT_EQ(APFloat::IEK_Inf,
2774 ilogb(APFloat::getInf(APFloat::IEEEsingle, false)));
2775 EXPECT_EQ(APFloat::IEK_Inf,
2776 ilogb(APFloat::getInf(APFloat::IEEEsingle, true)));
2777 EXPECT_EQ(APFloat::IEK_Zero,
2778 ilogb(APFloat::getZero(APFloat::IEEEsingle, false)));
2779 EXPECT_EQ(APFloat::IEK_Zero,
2780 ilogb(APFloat::getZero(APFloat::IEEEsingle, true)));
2781 EXPECT_EQ(APFloat::IEK_NaN,
2782 ilogb(APFloat::getNaN(APFloat::IEEEsingle, false)));
2783 EXPECT_EQ(APFloat::IEK_NaN,
2784 ilogb(APFloat::getSNaN(APFloat::IEEEsingle, false)));
2786 EXPECT_EQ(127, ilogb(APFloat::getLargest(APFloat::IEEEsingle, false)));
2787 EXPECT_EQ(127, ilogb(APFloat::getLargest(APFloat::IEEEsingle, true)));
2788 EXPECT_EQ(-126, ilogb(APFloat::getSmallest(APFloat::IEEEsingle, false)));
2789 EXPECT_EQ(-126, ilogb(APFloat::getSmallest(APFloat::IEEEsingle, true)));
2791 ilogb(APFloat::getSmallestNormalized(APFloat::IEEEsingle, false)));
2793 ilogb(APFloat::getSmallestNormalized(APFloat::IEEEsingle, true)));
2796 TEST(APFloatTest, scalbn) {
2798 APFloat(APFloat::IEEEsingle, "0x1p+0")
2799 .bitwiseIsEqual(scalbn(APFloat(APFloat::IEEEsingle, "0x1p+0"), 0)));
2801 APFloat(APFloat::IEEEsingle, "0x1p+42")
2802 .bitwiseIsEqual(scalbn(APFloat(APFloat::IEEEsingle, "0x1p+0"), 42)));
2804 APFloat(APFloat::IEEEsingle, "0x1p-42")
2805 .bitwiseIsEqual(scalbn(APFloat(APFloat::IEEEsingle, "0x1p+0"), -42)));
2807 APFloat PInf = APFloat::getInf(APFloat::IEEEsingle, false);
2808 APFloat MInf = APFloat::getInf(APFloat::IEEEsingle, true);
2809 APFloat PZero = APFloat::getZero(APFloat::IEEEsingle, false);
2810 APFloat MZero = APFloat::getZero(APFloat::IEEEsingle, true);
2811 APFloat QPNaN = APFloat::getNaN(APFloat::IEEEsingle, false);
2812 APFloat QMNaN = APFloat::getNaN(APFloat::IEEEsingle, true);
2813 APFloat SNaN = APFloat::getSNaN(APFloat::IEEEsingle, false);
2815 EXPECT_TRUE(PInf.bitwiseIsEqual(scalbn(PInf, 0)));
2816 EXPECT_TRUE(MInf.bitwiseIsEqual(scalbn(MInf, 0)));
2817 EXPECT_TRUE(PZero.bitwiseIsEqual(scalbn(PZero, 0)));
2818 EXPECT_TRUE(MZero.bitwiseIsEqual(scalbn(MZero, 0)));
2819 EXPECT_TRUE(QPNaN.bitwiseIsEqual(scalbn(QPNaN, 0)));
2820 EXPECT_TRUE(QMNaN.bitwiseIsEqual(scalbn(QMNaN, 0)));
2821 EXPECT_TRUE(SNaN.bitwiseIsEqual(scalbn(SNaN, 0)));
2824 PInf.bitwiseIsEqual(scalbn(APFloat(APFloat::IEEEsingle, "0x1p+0"), 128)));
2825 EXPECT_TRUE(MInf.bitwiseIsEqual(
2826 scalbn(APFloat(APFloat::IEEEsingle, "-0x1p+0"), 128)));
2828 PInf.bitwiseIsEqual(scalbn(APFloat(APFloat::IEEEsingle, "0x1p+127"), 1)));
2829 EXPECT_TRUE(PZero.bitwiseIsEqual(
2830 scalbn(APFloat(APFloat::IEEEsingle, "0x1p+0"), -127)));
2831 EXPECT_TRUE(MZero.bitwiseIsEqual(
2832 scalbn(APFloat(APFloat::IEEEsingle, "-0x1p+0"), -127)));
2833 EXPECT_TRUE(PZero.bitwiseIsEqual(
2834 scalbn(APFloat(APFloat::IEEEsingle, "0x1p-126"), -1)));
2835 EXPECT_TRUE(PZero.bitwiseIsEqual(
2836 scalbn(APFloat(APFloat::IEEEsingle, "0x1p-126"), -1)));