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"
22 static double convertToDoubleFromString(const char *Str) {
24 F.convertFromString(Str, llvm::APFloat::rmNearestTiesToEven);
25 return F.convertToDouble();
28 static std::string convertToString(double d, unsigned Prec, unsigned Pad) {
29 llvm::SmallVector<char, 100> Buffer;
31 F.toString(Buffer, Prec, Pad);
32 return std::string(Buffer.data(), Buffer.size());
37 TEST(APFloatTest, isSignaling) {
38 // We test qNaN, -qNaN, +sNaN, -sNaN with and without payloads. *NOTE* The
39 // positive/negative distinction is included only since the getQNaN/getSNaN
40 // API provides the option.
41 APInt payload = APInt::getOneBitSet(4, 2);
42 EXPECT_FALSE(APFloat::getQNaN(APFloat::IEEEsingle, false).isSignaling());
43 EXPECT_FALSE(APFloat::getQNaN(APFloat::IEEEsingle, true).isSignaling());
44 EXPECT_FALSE(APFloat::getQNaN(APFloat::IEEEsingle, false, &payload).isSignaling());
45 EXPECT_FALSE(APFloat::getQNaN(APFloat::IEEEsingle, true, &payload).isSignaling());
46 EXPECT_TRUE(APFloat::getSNaN(APFloat::IEEEsingle, false).isSignaling());
47 EXPECT_TRUE(APFloat::getSNaN(APFloat::IEEEsingle, true).isSignaling());
48 EXPECT_TRUE(APFloat::getSNaN(APFloat::IEEEsingle, false, &payload).isSignaling());
49 EXPECT_TRUE(APFloat::getSNaN(APFloat::IEEEsingle, true, &payload).isSignaling());
52 TEST(APFloatTest, next) {
54 APFloat test(APFloat::IEEEquad, APFloat::uninitialized);
55 APFloat expected(APFloat::IEEEquad, APFloat::uninitialized);
57 // 1. Test Special Cases Values.
59 // Test all special values for nextUp and nextDown perscribed by IEEE-754R
72 // nextUp(+inf) = +inf.
73 test = APFloat::getInf(APFloat::IEEEquad, false);
74 expected = APFloat::getInf(APFloat::IEEEquad, false);
75 EXPECT_EQ(test.next(false), APFloat::opOK);
76 EXPECT_TRUE(test.isInfinity());
77 EXPECT_TRUE(!test.isNegative());
78 EXPECT_TRUE(test.bitwiseIsEqual(expected));
80 // nextDown(+inf) = -nextUp(-inf) = -(-getLargest()) = getLargest()
81 test = APFloat::getInf(APFloat::IEEEquad, false);
82 expected = APFloat::getLargest(APFloat::IEEEquad, false);
83 EXPECT_EQ(test.next(true), APFloat::opOK);
84 EXPECT_TRUE(!test.isNegative());
85 EXPECT_TRUE(test.bitwiseIsEqual(expected));
87 // nextUp(-inf) = -getLargest()
88 test = APFloat::getInf(APFloat::IEEEquad, true);
89 expected = APFloat::getLargest(APFloat::IEEEquad, true);
90 EXPECT_EQ(test.next(false), APFloat::opOK);
91 EXPECT_TRUE(test.isNegative());
92 EXPECT_TRUE(test.bitwiseIsEqual(expected));
94 // nextDown(-inf) = -nextUp(+inf) = -(+inf) = -inf.
95 test = APFloat::getInf(APFloat::IEEEquad, true);
96 expected = APFloat::getInf(APFloat::IEEEquad, true);
97 EXPECT_EQ(test.next(true), APFloat::opOK);
98 EXPECT_TRUE(test.isInfinity() && test.isNegative());
99 EXPECT_TRUE(test.bitwiseIsEqual(expected));
101 // nextUp(getLargest()) = +inf
102 test = APFloat::getLargest(APFloat::IEEEquad, false);
103 expected = APFloat::getInf(APFloat::IEEEquad, false);
104 EXPECT_EQ(test.next(false), APFloat::opOK);
105 EXPECT_TRUE(test.isInfinity() && !test.isNegative());
106 EXPECT_TRUE(test.bitwiseIsEqual(expected));
108 // nextDown(getLargest()) = -nextUp(-getLargest())
109 // = -(-getLargest() + inc)
110 // = getLargest() - inc.
111 test = APFloat::getLargest(APFloat::IEEEquad, false);
112 expected = APFloat(APFloat::IEEEquad,
113 "0x1.fffffffffffffffffffffffffffep+16383");
114 EXPECT_EQ(test.next(true), APFloat::opOK);
115 EXPECT_TRUE(!test.isInfinity() && !test.isNegative());
116 EXPECT_TRUE(test.bitwiseIsEqual(expected));
118 // nextUp(-getLargest()) = -getLargest() + inc.
119 test = APFloat::getLargest(APFloat::IEEEquad, true);
120 expected = APFloat(APFloat::IEEEquad,
121 "-0x1.fffffffffffffffffffffffffffep+16383");
122 EXPECT_EQ(test.next(false), APFloat::opOK);
123 EXPECT_TRUE(test.bitwiseIsEqual(expected));
125 // nextDown(-getLargest()) = -nextUp(getLargest()) = -(inf) = -inf.
126 test = APFloat::getLargest(APFloat::IEEEquad, true);
127 expected = APFloat::getInf(APFloat::IEEEquad, true);
128 EXPECT_EQ(test.next(true), APFloat::opOK);
129 EXPECT_TRUE(test.isInfinity() && test.isNegative());
130 EXPECT_TRUE(test.bitwiseIsEqual(expected));
132 // nextUp(getSmallest()) = getSmallest() + inc.
133 test = APFloat(APFloat::IEEEquad, "0x0.0000000000000000000000000001p-16382");
134 expected = APFloat(APFloat::IEEEquad,
135 "0x0.0000000000000000000000000002p-16382");
136 EXPECT_EQ(test.next(false), APFloat::opOK);
137 EXPECT_TRUE(test.bitwiseIsEqual(expected));
139 // nextDown(getSmallest()) = -nextUp(-getSmallest()) = -(-0) = +0.
140 test = APFloat(APFloat::IEEEquad, "0x0.0000000000000000000000000001p-16382");
141 expected = APFloat::getZero(APFloat::IEEEquad, false);
142 EXPECT_EQ(test.next(true), APFloat::opOK);
143 EXPECT_TRUE(test.isZero() && !test.isNegative());
144 EXPECT_TRUE(test.bitwiseIsEqual(expected));
146 // nextUp(-getSmallest()) = -0.
147 test = APFloat(APFloat::IEEEquad, "-0x0.0000000000000000000000000001p-16382");
148 expected = APFloat::getZero(APFloat::IEEEquad, true);
149 EXPECT_EQ(test.next(false), APFloat::opOK);
150 EXPECT_TRUE(test.isZero() && test.isNegative());
151 EXPECT_TRUE(test.bitwiseIsEqual(expected));
153 // nextDown(-getSmallest()) = -nextUp(getSmallest()) = -getSmallest() - inc.
154 test = APFloat(APFloat::IEEEquad, "-0x0.0000000000000000000000000001p-16382");
155 expected = APFloat(APFloat::IEEEquad,
156 "-0x0.0000000000000000000000000002p-16382");
157 EXPECT_EQ(test.next(true), APFloat::opOK);
158 EXPECT_TRUE(test.bitwiseIsEqual(expected));
160 // nextUp(qNaN) = qNaN
161 test = APFloat::getQNaN(APFloat::IEEEquad, false);
162 expected = APFloat::getQNaN(APFloat::IEEEquad, false);
163 EXPECT_EQ(test.next(false), APFloat::opOK);
164 EXPECT_TRUE(test.bitwiseIsEqual(expected));
166 // nextDown(qNaN) = qNaN
167 test = APFloat::getQNaN(APFloat::IEEEquad, false);
168 expected = APFloat::getQNaN(APFloat::IEEEquad, false);
169 EXPECT_EQ(test.next(true), APFloat::opOK);
170 EXPECT_TRUE(test.bitwiseIsEqual(expected));
172 // nextUp(sNaN) = qNaN
173 test = APFloat::getSNaN(APFloat::IEEEquad, false);
174 expected = APFloat::getQNaN(APFloat::IEEEquad, false);
175 EXPECT_EQ(test.next(false), APFloat::opInvalidOp);
176 EXPECT_TRUE(test.bitwiseIsEqual(expected));
178 // nextDown(sNaN) = qNaN
179 test = APFloat::getSNaN(APFloat::IEEEquad, false);
180 expected = APFloat::getQNaN(APFloat::IEEEquad, false);
181 EXPECT_EQ(test.next(true), APFloat::opInvalidOp);
182 EXPECT_TRUE(test.bitwiseIsEqual(expected));
184 // nextUp(+0) = +getSmallest()
185 test = APFloat::getZero(APFloat::IEEEquad, false);
186 expected = APFloat::getSmallest(APFloat::IEEEquad, false);
187 EXPECT_EQ(test.next(false), APFloat::opOK);
188 EXPECT_TRUE(test.bitwiseIsEqual(expected));
190 // nextDown(+0) = -nextUp(-0) = -getSmallest()
191 test = APFloat::getZero(APFloat::IEEEquad, false);
192 expected = APFloat::getSmallest(APFloat::IEEEquad, true);
193 EXPECT_EQ(test.next(true), APFloat::opOK);
194 EXPECT_TRUE(test.bitwiseIsEqual(expected));
196 // nextUp(-0) = +getSmallest()
197 test = APFloat::getZero(APFloat::IEEEquad, true);
198 expected = APFloat::getSmallest(APFloat::IEEEquad, false);
199 EXPECT_EQ(test.next(false), APFloat::opOK);
200 EXPECT_TRUE(test.bitwiseIsEqual(expected));
202 // nextDown(-0) = -nextUp(0) = -getSmallest()
203 test = APFloat::getZero(APFloat::IEEEquad, true);
204 expected = APFloat::getSmallest(APFloat::IEEEquad, true);
205 EXPECT_EQ(test.next(true), APFloat::opOK);
206 EXPECT_TRUE(test.bitwiseIsEqual(expected));
208 // 2. Binade Boundary Tests.
210 // 2a. Test denormal <-> normal binade boundaries.
211 // * nextUp(+Largest Denormal) -> +Smallest Normal.
212 // * nextDown(-Largest Denormal) -> -Smallest Normal.
213 // * nextUp(-Smallest Normal) -> -Largest Denormal.
214 // * nextDown(+Smallest Normal) -> +Largest Denormal.
216 // nextUp(+Largest Denormal) -> +Smallest Normal.
217 test = APFloat(APFloat::IEEEquad, "0x0.ffffffffffffffffffffffffffffp-16382");
218 expected = APFloat(APFloat::IEEEquad,
219 "0x1.0000000000000000000000000000p-16382");
220 EXPECT_EQ(test.next(false), APFloat::opOK);
221 EXPECT_FALSE(test.isDenormal());
222 EXPECT_TRUE(test.bitwiseIsEqual(expected));
224 // nextDown(-Largest Denormal) -> -Smallest Normal.
225 test = APFloat(APFloat::IEEEquad,
226 "-0x0.ffffffffffffffffffffffffffffp-16382");
227 expected = APFloat(APFloat::IEEEquad,
228 "-0x1.0000000000000000000000000000p-16382");
229 EXPECT_EQ(test.next(true), APFloat::opOK);
230 EXPECT_FALSE(test.isDenormal());
231 EXPECT_TRUE(test.bitwiseIsEqual(expected));
233 // nextUp(-Smallest Normal) -> -LargestDenormal.
234 test = APFloat(APFloat::IEEEquad,
235 "-0x1.0000000000000000000000000000p-16382");
236 expected = APFloat(APFloat::IEEEquad,
237 "-0x0.ffffffffffffffffffffffffffffp-16382");
238 EXPECT_EQ(test.next(false), APFloat::opOK);
239 EXPECT_TRUE(test.isDenormal());
240 EXPECT_TRUE(test.bitwiseIsEqual(expected));
242 // nextDown(+Smallest Normal) -> +Largest Denormal.
243 test = APFloat(APFloat::IEEEquad,
244 "+0x1.0000000000000000000000000000p-16382");
245 expected = APFloat(APFloat::IEEEquad,
246 "+0x0.ffffffffffffffffffffffffffffp-16382");
247 EXPECT_EQ(test.next(true), APFloat::opOK);
248 EXPECT_TRUE(test.isDenormal());
249 EXPECT_TRUE(test.bitwiseIsEqual(expected));
251 // 2b. Test normal <-> normal binade boundaries.
252 // * nextUp(-Normal Binade Boundary) -> -Normal Binade Boundary + 1.
253 // * nextDown(+Normal Binade Boundary) -> +Normal Binade Boundary - 1.
254 // * nextUp(+Normal Binade Boundary - 1) -> +Normal Binade Boundary.
255 // * nextDown(-Normal Binade Boundary + 1) -> -Normal Binade Boundary.
257 // nextUp(-Normal Binade Boundary) -> -Normal Binade Boundary + 1.
258 test = APFloat(APFloat::IEEEquad, "-0x1p+1");
259 expected = APFloat(APFloat::IEEEquad,
260 "-0x1.ffffffffffffffffffffffffffffp+0");
261 EXPECT_EQ(test.next(false), APFloat::opOK);
262 EXPECT_TRUE(test.bitwiseIsEqual(expected));
264 // nextDown(+Normal Binade Boundary) -> +Normal Binade Boundary - 1.
265 test = APFloat(APFloat::IEEEquad, "0x1p+1");
266 expected = APFloat(APFloat::IEEEquad, "0x1.ffffffffffffffffffffffffffffp+0");
267 EXPECT_EQ(test.next(true), APFloat::opOK);
268 EXPECT_TRUE(test.bitwiseIsEqual(expected));
270 // nextUp(+Normal Binade Boundary - 1) -> +Normal Binade Boundary.
271 test = APFloat(APFloat::IEEEquad, "0x1.ffffffffffffffffffffffffffffp+0");
272 expected = APFloat(APFloat::IEEEquad, "0x1p+1");
273 EXPECT_EQ(test.next(false), APFloat::opOK);
274 EXPECT_TRUE(test.bitwiseIsEqual(expected));
276 // nextDown(-Normal Binade Boundary + 1) -> -Normal Binade Boundary.
277 test = APFloat(APFloat::IEEEquad, "-0x1.ffffffffffffffffffffffffffffp+0");
278 expected = APFloat(APFloat::IEEEquad, "-0x1p+1");
279 EXPECT_EQ(test.next(true), APFloat::opOK);
280 EXPECT_TRUE(test.bitwiseIsEqual(expected));
282 // 2c. Test using next at binade boundaries with a direction away from the
283 // binade boundary. Away from denormal <-> normal boundaries.
285 // This is to make sure that even though we are at a binade boundary, since
286 // we are rounding away, we do not trigger the binade boundary code. Thus we
288 // * nextUp(-Largest Denormal) -> -Largest Denormal + inc.
289 // * nextDown(+Largest Denormal) -> +Largest Denormal - inc.
290 // * nextUp(+Smallest Normal) -> +Smallest Normal + inc.
291 // * nextDown(-Smallest Normal) -> -Smallest Normal - inc.
293 // nextUp(-Largest Denormal) -> -Largest Denormal + inc.
294 test = APFloat(APFloat::IEEEquad, "-0x0.ffffffffffffffffffffffffffffp-16382");
295 expected = APFloat(APFloat::IEEEquad,
296 "-0x0.fffffffffffffffffffffffffffep-16382");
297 EXPECT_EQ(test.next(false), APFloat::opOK);
298 EXPECT_TRUE(test.isDenormal());
299 EXPECT_TRUE(test.isNegative());
300 EXPECT_TRUE(test.bitwiseIsEqual(expected));
302 // nextDown(+Largest Denormal) -> +Largest Denormal - inc.
303 test = APFloat(APFloat::IEEEquad, "0x0.ffffffffffffffffffffffffffffp-16382");
304 expected = APFloat(APFloat::IEEEquad,
305 "0x0.fffffffffffffffffffffffffffep-16382");
306 EXPECT_EQ(test.next(true), APFloat::opOK);
307 EXPECT_TRUE(test.isDenormal());
308 EXPECT_TRUE(!test.isNegative());
309 EXPECT_TRUE(test.bitwiseIsEqual(expected));
311 // nextUp(+Smallest Normal) -> +Smallest Normal + inc.
312 test = APFloat(APFloat::IEEEquad, "0x1.0000000000000000000000000000p-16382");
313 expected = APFloat(APFloat::IEEEquad,
314 "0x1.0000000000000000000000000001p-16382");
315 EXPECT_EQ(test.next(false), APFloat::opOK);
316 EXPECT_TRUE(!test.isDenormal());
317 EXPECT_TRUE(!test.isNegative());
318 EXPECT_TRUE(test.bitwiseIsEqual(expected));
320 // nextDown(-Smallest Normal) -> -Smallest Normal - inc.
321 test = APFloat(APFloat::IEEEquad, "-0x1.0000000000000000000000000000p-16382");
322 expected = APFloat(APFloat::IEEEquad,
323 "-0x1.0000000000000000000000000001p-16382");
324 EXPECT_EQ(test.next(true), APFloat::opOK);
325 EXPECT_TRUE(!test.isDenormal());
326 EXPECT_TRUE(test.isNegative());
327 EXPECT_TRUE(test.bitwiseIsEqual(expected));
329 // 2d. Test values which cause our exponent to go to min exponent. This
330 // is to ensure that guards in the code to check for min exponent
332 // * nextUp(-0x1p-16381) -> -0x1.ffffffffffffffffffffffffffffp-16382
333 // * nextDown(-0x1.ffffffffffffffffffffffffffffp-16382) ->
335 // * nextUp(0x1.ffffffffffffffffffffffffffffp-16382) -> 0x1p-16382
336 // * nextDown(0x1p-16382) -> 0x1.ffffffffffffffffffffffffffffp-16382
338 // nextUp(-0x1p-16381) -> -0x1.ffffffffffffffffffffffffffffp-16382
339 test = APFloat(APFloat::IEEEquad, "-0x1p-16381");
340 expected = APFloat(APFloat::IEEEquad,
341 "-0x1.ffffffffffffffffffffffffffffp-16382");
342 EXPECT_EQ(test.next(false), APFloat::opOK);
343 EXPECT_TRUE(test.bitwiseIsEqual(expected));
345 // nextDown(-0x1.ffffffffffffffffffffffffffffp-16382) ->
347 test = APFloat(APFloat::IEEEquad, "-0x1.ffffffffffffffffffffffffffffp-16382");
348 expected = APFloat(APFloat::IEEEquad, "-0x1p-16381");
349 EXPECT_EQ(test.next(true), APFloat::opOK);
350 EXPECT_TRUE(test.bitwiseIsEqual(expected));
352 // nextUp(0x1.ffffffffffffffffffffffffffffp-16382) -> 0x1p-16381
353 test = APFloat(APFloat::IEEEquad, "0x1.ffffffffffffffffffffffffffffp-16382");
354 expected = APFloat(APFloat::IEEEquad, "0x1p-16381");
355 EXPECT_EQ(test.next(false), APFloat::opOK);
356 EXPECT_TRUE(test.bitwiseIsEqual(expected));
358 // nextDown(0x1p-16381) -> 0x1.ffffffffffffffffffffffffffffp-16382
359 test = APFloat(APFloat::IEEEquad, "0x1p-16381");
360 expected = APFloat(APFloat::IEEEquad,
361 "0x1.ffffffffffffffffffffffffffffp-16382");
362 EXPECT_EQ(test.next(true), APFloat::opOK);
363 EXPECT_TRUE(test.bitwiseIsEqual(expected));
365 // 3. Now we test both denormal/normal computation which will not cause us
366 // to go across binade boundaries. Specifically we test:
367 // * nextUp(+Denormal) -> +Denormal.
368 // * nextDown(+Denormal) -> +Denormal.
369 // * nextUp(-Denormal) -> -Denormal.
370 // * nextDown(-Denormal) -> -Denormal.
371 // * nextUp(+Normal) -> +Normal.
372 // * nextDown(+Normal) -> +Normal.
373 // * nextUp(-Normal) -> -Normal.
374 // * nextDown(-Normal) -> -Normal.
376 // nextUp(+Denormal) -> +Denormal.
377 test = APFloat(APFloat::IEEEquad,
378 "0x0.ffffffffffffffffffffffff000cp-16382");
379 expected = APFloat(APFloat::IEEEquad,
380 "0x0.ffffffffffffffffffffffff000dp-16382");
381 EXPECT_EQ(test.next(false), APFloat::opOK);
382 EXPECT_TRUE(test.isDenormal());
383 EXPECT_TRUE(!test.isNegative());
384 EXPECT_TRUE(test.bitwiseIsEqual(expected));
386 // nextDown(+Denormal) -> +Denormal.
387 test = APFloat(APFloat::IEEEquad,
388 "0x0.ffffffffffffffffffffffff000cp-16382");
389 expected = APFloat(APFloat::IEEEquad,
390 "0x0.ffffffffffffffffffffffff000bp-16382");
391 EXPECT_EQ(test.next(true), APFloat::opOK);
392 EXPECT_TRUE(test.isDenormal());
393 EXPECT_TRUE(!test.isNegative());
394 EXPECT_TRUE(test.bitwiseIsEqual(expected));
396 // nextUp(-Denormal) -> -Denormal.
397 test = APFloat(APFloat::IEEEquad,
398 "-0x0.ffffffffffffffffffffffff000cp-16382");
399 expected = APFloat(APFloat::IEEEquad,
400 "-0x0.ffffffffffffffffffffffff000bp-16382");
401 EXPECT_EQ(test.next(false), APFloat::opOK);
402 EXPECT_TRUE(test.isDenormal());
403 EXPECT_TRUE(test.isNegative());
404 EXPECT_TRUE(test.bitwiseIsEqual(expected));
406 // nextDown(-Denormal) -> -Denormal
407 test = APFloat(APFloat::IEEEquad,
408 "-0x0.ffffffffffffffffffffffff000cp-16382");
409 expected = APFloat(APFloat::IEEEquad,
410 "-0x0.ffffffffffffffffffffffff000dp-16382");
411 EXPECT_EQ(test.next(true), APFloat::opOK);
412 EXPECT_TRUE(test.isDenormal());
413 EXPECT_TRUE(test.isNegative());
414 EXPECT_TRUE(test.bitwiseIsEqual(expected));
416 // nextUp(+Normal) -> +Normal.
417 test = APFloat(APFloat::IEEEquad,
418 "0x1.ffffffffffffffffffffffff000cp-16000");
419 expected = APFloat(APFloat::IEEEquad,
420 "0x1.ffffffffffffffffffffffff000dp-16000");
421 EXPECT_EQ(test.next(false), APFloat::opOK);
422 EXPECT_TRUE(!test.isDenormal());
423 EXPECT_TRUE(!test.isNegative());
424 EXPECT_TRUE(test.bitwiseIsEqual(expected));
426 // nextDown(+Normal) -> +Normal.
427 test = APFloat(APFloat::IEEEquad,
428 "0x1.ffffffffffffffffffffffff000cp-16000");
429 expected = APFloat(APFloat::IEEEquad,
430 "0x1.ffffffffffffffffffffffff000bp-16000");
431 EXPECT_EQ(test.next(true), APFloat::opOK);
432 EXPECT_TRUE(!test.isDenormal());
433 EXPECT_TRUE(!test.isNegative());
434 EXPECT_TRUE(test.bitwiseIsEqual(expected));
436 // nextUp(-Normal) -> -Normal.
437 test = APFloat(APFloat::IEEEquad,
438 "-0x1.ffffffffffffffffffffffff000cp-16000");
439 expected = APFloat(APFloat::IEEEquad,
440 "-0x1.ffffffffffffffffffffffff000bp-16000");
441 EXPECT_EQ(test.next(false), APFloat::opOK);
442 EXPECT_TRUE(!test.isDenormal());
443 EXPECT_TRUE(test.isNegative());
444 EXPECT_TRUE(test.bitwiseIsEqual(expected));
446 // nextDown(-Normal) -> -Normal.
447 test = APFloat(APFloat::IEEEquad,
448 "-0x1.ffffffffffffffffffffffff000cp-16000");
449 expected = APFloat(APFloat::IEEEquad,
450 "-0x1.ffffffffffffffffffffffff000dp-16000");
451 EXPECT_EQ(test.next(true), APFloat::opOK);
452 EXPECT_TRUE(!test.isDenormal());
453 EXPECT_TRUE(test.isNegative());
454 EXPECT_TRUE(test.bitwiseIsEqual(expected));
457 TEST(APFloatTest, FMA) {
458 APFloat::roundingMode rdmd = APFloat::rmNearestTiesToEven;
464 f1.fusedMultiplyAdd(f2, f3, APFloat::rmNearestTiesToEven);
465 EXPECT_EQ(14.75f, f1.convertToFloat());
470 APFloat f1((float)1.17549435e-38F);
471 APFloat f2((float)1.17549435e-38F);
472 f1.divide(Val2, rdmd);
473 f2.divide(Val2, rdmd);
475 f1.fusedMultiplyAdd(f2, f3, APFloat::rmNearestTiesToEven);
476 EXPECT_EQ(12.0f, f1.convertToFloat());
479 // Test for correct zero sign when answer is exactly zero.
480 // fma(1.0, -1.0, 1.0) -> +ve 0.
485 f1.fusedMultiplyAdd(f2, f3, APFloat::rmNearestTiesToEven);
486 EXPECT_TRUE(!f1.isNegative() && f1.isZero());
489 // Test for correct zero sign when answer is exactly zero and rounding towards
491 // fma(1.0, -1.0, 1.0) -> +ve 0.
496 f1.fusedMultiplyAdd(f2, f3, APFloat::rmTowardNegative);
497 EXPECT_TRUE(f1.isNegative() && f1.isZero());
500 // Test for correct (in this case -ve) sign when adding like signed zeros.
501 // Test fma(0.0, -0.0, -0.0) -> -ve 0.
506 f1.fusedMultiplyAdd(f2, f3, APFloat::rmNearestTiesToEven);
507 EXPECT_TRUE(f1.isNegative() && f1.isZero());
510 // Test -ve sign preservation when small negative results underflow.
512 APFloat f1(APFloat::IEEEdouble, "-0x1p-1074");
513 APFloat f2(APFloat::IEEEdouble, "+0x1p-1074");
515 f1.fusedMultiplyAdd(f2, f3, APFloat::rmNearestTiesToEven);
516 EXPECT_TRUE(f1.isNegative() && f1.isZero());
519 // Test x87 extended precision case from http://llvm.org/PR20728.
521 APFloat M1(APFloat::x87DoubleExtended, 1.0);
522 APFloat M2(APFloat::x87DoubleExtended, 1.0);
523 APFloat A(APFloat::x87DoubleExtended, 3.0);
525 bool losesInfo = false;
526 M1.fusedMultiplyAdd(M1, A, APFloat::rmNearestTiesToEven);
527 M1.convert(APFloat::IEEEsingle, APFloat::rmNearestTiesToEven, &losesInfo);
528 EXPECT_FALSE(losesInfo);
529 EXPECT_EQ(4.0f, M1.convertToFloat());
533 TEST(APFloatTest, MinNum) {
536 APFloat nan = APFloat::getNaN(APFloat::IEEEdouble);
538 EXPECT_EQ(1.0, minnum(f1, f2).convertToDouble());
539 EXPECT_EQ(1.0, minnum(f2, f1).convertToDouble());
540 EXPECT_EQ(1.0, minnum(f1, nan).convertToDouble());
541 EXPECT_EQ(1.0, minnum(nan, f1).convertToDouble());
544 TEST(APFloatTest, MaxNum) {
547 APFloat nan = APFloat::getNaN(APFloat::IEEEdouble);
549 EXPECT_EQ(2.0, maxnum(f1, f2).convertToDouble());
550 EXPECT_EQ(2.0, maxnum(f2, f1).convertToDouble());
551 EXPECT_EQ(1.0, maxnum(f1, nan).convertToDouble());
552 EXPECT_EQ(1.0, minnum(nan, f1).convertToDouble());
555 TEST(APFloatTest, Denormal) {
556 APFloat::roundingMode rdmd = APFloat::rmNearestTiesToEven;
558 // Test single precision
560 const char *MinNormalStr = "1.17549435082228750797e-38";
561 EXPECT_FALSE(APFloat(APFloat::IEEEsingle, MinNormalStr).isDenormal());
562 EXPECT_FALSE(APFloat(APFloat::IEEEsingle, 0.0).isDenormal());
564 APFloat Val2(APFloat::IEEEsingle, 2.0e0);
565 APFloat T(APFloat::IEEEsingle, MinNormalStr);
566 T.divide(Val2, rdmd);
567 EXPECT_TRUE(T.isDenormal());
570 // Test double precision
572 const char *MinNormalStr = "2.22507385850720138309e-308";
573 EXPECT_FALSE(APFloat(APFloat::IEEEdouble, MinNormalStr).isDenormal());
574 EXPECT_FALSE(APFloat(APFloat::IEEEdouble, 0.0).isDenormal());
576 APFloat Val2(APFloat::IEEEdouble, 2.0e0);
577 APFloat T(APFloat::IEEEdouble, MinNormalStr);
578 T.divide(Val2, rdmd);
579 EXPECT_TRUE(T.isDenormal());
582 // Test Intel double-ext
584 const char *MinNormalStr = "3.36210314311209350626e-4932";
585 EXPECT_FALSE(APFloat(APFloat::x87DoubleExtended, MinNormalStr).isDenormal());
586 EXPECT_FALSE(APFloat(APFloat::x87DoubleExtended, 0.0).isDenormal());
588 APFloat Val2(APFloat::x87DoubleExtended, 2.0e0);
589 APFloat T(APFloat::x87DoubleExtended, MinNormalStr);
590 T.divide(Val2, rdmd);
591 EXPECT_TRUE(T.isDenormal());
594 // Test quadruple precision
596 const char *MinNormalStr = "3.36210314311209350626267781732175260e-4932";
597 EXPECT_FALSE(APFloat(APFloat::IEEEquad, MinNormalStr).isDenormal());
598 EXPECT_FALSE(APFloat(APFloat::IEEEquad, 0.0).isDenormal());
600 APFloat Val2(APFloat::IEEEquad, 2.0e0);
601 APFloat T(APFloat::IEEEquad, MinNormalStr);
602 T.divide(Val2, rdmd);
603 EXPECT_TRUE(T.isDenormal());
607 TEST(APFloatTest, Zero) {
608 EXPECT_EQ(0.0f, APFloat(0.0f).convertToFloat());
609 EXPECT_EQ(-0.0f, APFloat(-0.0f).convertToFloat());
610 EXPECT_TRUE(APFloat(-0.0f).isNegative());
612 EXPECT_EQ(0.0, APFloat(0.0).convertToDouble());
613 EXPECT_EQ(-0.0, APFloat(-0.0).convertToDouble());
614 EXPECT_TRUE(APFloat(-0.0).isNegative());
617 TEST(APFloatTest, DecimalStringsWithoutNullTerminators) {
618 // Make sure that we can parse strings without null terminators.
620 APFloat Val(APFloat::IEEEdouble);
621 Val.convertFromString(StringRef("0.00", 3),
622 llvm::APFloat::rmNearestTiesToEven);
623 EXPECT_EQ(Val.convertToDouble(), 0.0);
624 Val.convertFromString(StringRef("0.01", 3),
625 llvm::APFloat::rmNearestTiesToEven);
626 EXPECT_EQ(Val.convertToDouble(), 0.0);
627 Val.convertFromString(StringRef("0.09", 3),
628 llvm::APFloat::rmNearestTiesToEven);
629 EXPECT_EQ(Val.convertToDouble(), 0.0);
630 Val.convertFromString(StringRef("0.095", 4),
631 llvm::APFloat::rmNearestTiesToEven);
632 EXPECT_EQ(Val.convertToDouble(), 0.09);
633 Val.convertFromString(StringRef("0.00e+3", 7),
634 llvm::APFloat::rmNearestTiesToEven);
635 EXPECT_EQ(Val.convertToDouble(), 0.00);
636 Val.convertFromString(StringRef("0e+3", 4),
637 llvm::APFloat::rmNearestTiesToEven);
638 EXPECT_EQ(Val.convertToDouble(), 0.00);
642 TEST(APFloatTest, fromZeroDecimalString) {
643 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0").convertToDouble());
644 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0").convertToDouble());
645 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0").convertToDouble());
647 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0.").convertToDouble());
648 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0.").convertToDouble());
649 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0.").convertToDouble());
651 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, ".0").convertToDouble());
652 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+.0").convertToDouble());
653 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-.0").convertToDouble());
655 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0.0").convertToDouble());
656 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0.0").convertToDouble());
657 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0.0").convertToDouble());
659 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "00000.").convertToDouble());
660 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+00000.").convertToDouble());
661 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-00000.").convertToDouble());
663 EXPECT_EQ(0.0, APFloat(APFloat::IEEEdouble, ".00000").convertToDouble());
664 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+.00000").convertToDouble());
665 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-.00000").convertToDouble());
667 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0000.00000").convertToDouble());
668 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0000.00000").convertToDouble());
669 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0000.00000").convertToDouble());
672 TEST(APFloatTest, fromZeroDecimalSingleExponentString) {
673 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0e1").convertToDouble());
674 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0e1").convertToDouble());
675 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0e1").convertToDouble());
677 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0e+1").convertToDouble());
678 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0e+1").convertToDouble());
679 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0e+1").convertToDouble());
681 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0e-1").convertToDouble());
682 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0e-1").convertToDouble());
683 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0e-1").convertToDouble());
686 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0.e1").convertToDouble());
687 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0.e1").convertToDouble());
688 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0.e1").convertToDouble());
690 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0.e+1").convertToDouble());
691 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0.e+1").convertToDouble());
692 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0.e+1").convertToDouble());
694 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0.e-1").convertToDouble());
695 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0.e-1").convertToDouble());
696 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0.e-1").convertToDouble());
698 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, ".0e1").convertToDouble());
699 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+.0e1").convertToDouble());
700 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-.0e1").convertToDouble());
702 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, ".0e+1").convertToDouble());
703 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+.0e+1").convertToDouble());
704 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-.0e+1").convertToDouble());
706 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, ".0e-1").convertToDouble());
707 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+.0e-1").convertToDouble());
708 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-.0e-1").convertToDouble());
711 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0.0e1").convertToDouble());
712 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0.0e1").convertToDouble());
713 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0.0e1").convertToDouble());
715 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0.0e+1").convertToDouble());
716 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0.0e+1").convertToDouble());
717 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0.0e+1").convertToDouble());
719 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0.0e-1").convertToDouble());
720 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0.0e-1").convertToDouble());
721 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0.0e-1").convertToDouble());
724 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "000.0000e1").convertToDouble());
725 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+000.0000e+1").convertToDouble());
726 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-000.0000e+1").convertToDouble());
729 TEST(APFloatTest, fromZeroDecimalLargeExponentString) {
730 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0e1234").convertToDouble());
731 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0e1234").convertToDouble());
732 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0e1234").convertToDouble());
734 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0e+1234").convertToDouble());
735 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0e+1234").convertToDouble());
736 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0e+1234").convertToDouble());
738 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0e-1234").convertToDouble());
739 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0e-1234").convertToDouble());
740 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0e-1234").convertToDouble());
742 EXPECT_EQ(0.0, APFloat(APFloat::IEEEdouble, "000.0000e1234").convertToDouble());
743 EXPECT_EQ(0.0, APFloat(APFloat::IEEEdouble, "000.0000e-1234").convertToDouble());
745 EXPECT_EQ(0.0, APFloat(APFloat::IEEEdouble, StringRef("0e1234\02", 6)).convertToDouble());
748 TEST(APFloatTest, fromZeroHexadecimalString) {
749 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x0p1").convertToDouble());
750 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0x0p1").convertToDouble());
751 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0x0p1").convertToDouble());
753 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x0p+1").convertToDouble());
754 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0x0p+1").convertToDouble());
755 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0x0p+1").convertToDouble());
757 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x0p-1").convertToDouble());
758 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0x0p-1").convertToDouble());
759 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0x0p-1").convertToDouble());
762 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x0.p1").convertToDouble());
763 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0x0.p1").convertToDouble());
764 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0x0.p1").convertToDouble());
766 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x0.p+1").convertToDouble());
767 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0x0.p+1").convertToDouble());
768 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0x0.p+1").convertToDouble());
770 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x0.p-1").convertToDouble());
771 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0x0.p-1").convertToDouble());
772 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0x0.p-1").convertToDouble());
775 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x.0p1").convertToDouble());
776 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0x.0p1").convertToDouble());
777 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0x.0p1").convertToDouble());
779 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x.0p+1").convertToDouble());
780 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0x.0p+1").convertToDouble());
781 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0x.0p+1").convertToDouble());
783 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x.0p-1").convertToDouble());
784 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0x.0p-1").convertToDouble());
785 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0x.0p-1").convertToDouble());
788 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x0.0p1").convertToDouble());
789 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0x0.0p1").convertToDouble());
790 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0x0.0p1").convertToDouble());
792 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x0.0p+1").convertToDouble());
793 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0x0.0p+1").convertToDouble());
794 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0x0.0p+1").convertToDouble());
796 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x0.0p-1").convertToDouble());
797 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0x0.0p-1").convertToDouble());
798 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0x0.0p-1").convertToDouble());
801 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x00000.p1").convertToDouble());
802 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x0000.00000p1").convertToDouble());
803 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x.00000p1").convertToDouble());
804 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x0.p1").convertToDouble());
805 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x0p1234").convertToDouble());
806 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0x0p1234").convertToDouble());
807 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x00000.p1234").convertToDouble());
808 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x0000.00000p1234").convertToDouble());
809 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x.00000p1234").convertToDouble());
810 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x0.p1234").convertToDouble());
813 TEST(APFloatTest, fromDecimalString) {
814 EXPECT_EQ(1.0, APFloat(APFloat::IEEEdouble, "1").convertToDouble());
815 EXPECT_EQ(2.0, APFloat(APFloat::IEEEdouble, "2.").convertToDouble());
816 EXPECT_EQ(0.5, APFloat(APFloat::IEEEdouble, ".5").convertToDouble());
817 EXPECT_EQ(1.0, APFloat(APFloat::IEEEdouble, "1.0").convertToDouble());
818 EXPECT_EQ(-2.0, APFloat(APFloat::IEEEdouble, "-2").convertToDouble());
819 EXPECT_EQ(-4.0, APFloat(APFloat::IEEEdouble, "-4.").convertToDouble());
820 EXPECT_EQ(-0.5, APFloat(APFloat::IEEEdouble, "-.5").convertToDouble());
821 EXPECT_EQ(-1.5, APFloat(APFloat::IEEEdouble, "-1.5").convertToDouble());
822 EXPECT_EQ(1.25e12, APFloat(APFloat::IEEEdouble, "1.25e12").convertToDouble());
823 EXPECT_EQ(1.25e+12, APFloat(APFloat::IEEEdouble, "1.25e+12").convertToDouble());
824 EXPECT_EQ(1.25e-12, APFloat(APFloat::IEEEdouble, "1.25e-12").convertToDouble());
825 EXPECT_EQ(1024.0, APFloat(APFloat::IEEEdouble, "1024.").convertToDouble());
826 EXPECT_EQ(1024.05, APFloat(APFloat::IEEEdouble, "1024.05000").convertToDouble());
827 EXPECT_EQ(0.05, APFloat(APFloat::IEEEdouble, ".05000").convertToDouble());
828 EXPECT_EQ(2.0, APFloat(APFloat::IEEEdouble, "2.").convertToDouble());
829 EXPECT_EQ(2.0e2, APFloat(APFloat::IEEEdouble, "2.e2").convertToDouble());
830 EXPECT_EQ(2.0e+2, APFloat(APFloat::IEEEdouble, "2.e+2").convertToDouble());
831 EXPECT_EQ(2.0e-2, APFloat(APFloat::IEEEdouble, "2.e-2").convertToDouble());
832 EXPECT_EQ(2.05e2, APFloat(APFloat::IEEEdouble, "002.05000e2").convertToDouble());
833 EXPECT_EQ(2.05e+2, APFloat(APFloat::IEEEdouble, "002.05000e+2").convertToDouble());
834 EXPECT_EQ(2.05e-2, APFloat(APFloat::IEEEdouble, "002.05000e-2").convertToDouble());
835 EXPECT_EQ(2.05e12, APFloat(APFloat::IEEEdouble, "002.05000e12").convertToDouble());
836 EXPECT_EQ(2.05e+12, APFloat(APFloat::IEEEdouble, "002.05000e+12").convertToDouble());
837 EXPECT_EQ(2.05e-12, APFloat(APFloat::IEEEdouble, "002.05000e-12").convertToDouble());
839 // These are "carefully selected" to overflow the fast log-base
840 // calculations in APFloat.cpp
841 EXPECT_TRUE(APFloat(APFloat::IEEEdouble, "99e99999").isInfinity());
842 EXPECT_TRUE(APFloat(APFloat::IEEEdouble, "-99e99999").isInfinity());
843 EXPECT_TRUE(APFloat(APFloat::IEEEdouble, "1e-99999").isPosZero());
844 EXPECT_TRUE(APFloat(APFloat::IEEEdouble, "-1e-99999").isNegZero());
846 EXPECT_EQ(2.71828, convertToDoubleFromString("2.71828"));
849 TEST(APFloatTest, fromHexadecimalString) {
850 EXPECT_EQ( 1.0, APFloat(APFloat::IEEEdouble, "0x1p0").convertToDouble());
851 EXPECT_EQ(+1.0, APFloat(APFloat::IEEEdouble, "+0x1p0").convertToDouble());
852 EXPECT_EQ(-1.0, APFloat(APFloat::IEEEdouble, "-0x1p0").convertToDouble());
854 EXPECT_EQ( 1.0, APFloat(APFloat::IEEEdouble, "0x1p+0").convertToDouble());
855 EXPECT_EQ(+1.0, APFloat(APFloat::IEEEdouble, "+0x1p+0").convertToDouble());
856 EXPECT_EQ(-1.0, APFloat(APFloat::IEEEdouble, "-0x1p+0").convertToDouble());
858 EXPECT_EQ( 1.0, APFloat(APFloat::IEEEdouble, "0x1p-0").convertToDouble());
859 EXPECT_EQ(+1.0, APFloat(APFloat::IEEEdouble, "+0x1p-0").convertToDouble());
860 EXPECT_EQ(-1.0, APFloat(APFloat::IEEEdouble, "-0x1p-0").convertToDouble());
863 EXPECT_EQ( 2.0, APFloat(APFloat::IEEEdouble, "0x1p1").convertToDouble());
864 EXPECT_EQ(+2.0, APFloat(APFloat::IEEEdouble, "+0x1p1").convertToDouble());
865 EXPECT_EQ(-2.0, APFloat(APFloat::IEEEdouble, "-0x1p1").convertToDouble());
867 EXPECT_EQ( 2.0, APFloat(APFloat::IEEEdouble, "0x1p+1").convertToDouble());
868 EXPECT_EQ(+2.0, APFloat(APFloat::IEEEdouble, "+0x1p+1").convertToDouble());
869 EXPECT_EQ(-2.0, APFloat(APFloat::IEEEdouble, "-0x1p+1").convertToDouble());
871 EXPECT_EQ( 0.5, APFloat(APFloat::IEEEdouble, "0x1p-1").convertToDouble());
872 EXPECT_EQ(+0.5, APFloat(APFloat::IEEEdouble, "+0x1p-1").convertToDouble());
873 EXPECT_EQ(-0.5, APFloat(APFloat::IEEEdouble, "-0x1p-1").convertToDouble());
876 EXPECT_EQ( 3.0, APFloat(APFloat::IEEEdouble, "0x1.8p1").convertToDouble());
877 EXPECT_EQ(+3.0, APFloat(APFloat::IEEEdouble, "+0x1.8p1").convertToDouble());
878 EXPECT_EQ(-3.0, APFloat(APFloat::IEEEdouble, "-0x1.8p1").convertToDouble());
880 EXPECT_EQ( 3.0, APFloat(APFloat::IEEEdouble, "0x1.8p+1").convertToDouble());
881 EXPECT_EQ(+3.0, APFloat(APFloat::IEEEdouble, "+0x1.8p+1").convertToDouble());
882 EXPECT_EQ(-3.0, APFloat(APFloat::IEEEdouble, "-0x1.8p+1").convertToDouble());
884 EXPECT_EQ( 0.75, APFloat(APFloat::IEEEdouble, "0x1.8p-1").convertToDouble());
885 EXPECT_EQ(+0.75, APFloat(APFloat::IEEEdouble, "+0x1.8p-1").convertToDouble());
886 EXPECT_EQ(-0.75, APFloat(APFloat::IEEEdouble, "-0x1.8p-1").convertToDouble());
889 EXPECT_EQ( 8192.0, APFloat(APFloat::IEEEdouble, "0x1000.000p1").convertToDouble());
890 EXPECT_EQ(+8192.0, APFloat(APFloat::IEEEdouble, "+0x1000.000p1").convertToDouble());
891 EXPECT_EQ(-8192.0, APFloat(APFloat::IEEEdouble, "-0x1000.000p1").convertToDouble());
893 EXPECT_EQ( 8192.0, APFloat(APFloat::IEEEdouble, "0x1000.000p+1").convertToDouble());
894 EXPECT_EQ(+8192.0, APFloat(APFloat::IEEEdouble, "+0x1000.000p+1").convertToDouble());
895 EXPECT_EQ(-8192.0, APFloat(APFloat::IEEEdouble, "-0x1000.000p+1").convertToDouble());
897 EXPECT_EQ( 2048.0, APFloat(APFloat::IEEEdouble, "0x1000.000p-1").convertToDouble());
898 EXPECT_EQ(+2048.0, APFloat(APFloat::IEEEdouble, "+0x1000.000p-1").convertToDouble());
899 EXPECT_EQ(-2048.0, APFloat(APFloat::IEEEdouble, "-0x1000.000p-1").convertToDouble());
902 EXPECT_EQ( 8192.0, APFloat(APFloat::IEEEdouble, "0x1000p1").convertToDouble());
903 EXPECT_EQ(+8192.0, APFloat(APFloat::IEEEdouble, "+0x1000p1").convertToDouble());
904 EXPECT_EQ(-8192.0, APFloat(APFloat::IEEEdouble, "-0x1000p1").convertToDouble());
906 EXPECT_EQ( 8192.0, APFloat(APFloat::IEEEdouble, "0x1000p+1").convertToDouble());
907 EXPECT_EQ(+8192.0, APFloat(APFloat::IEEEdouble, "+0x1000p+1").convertToDouble());
908 EXPECT_EQ(-8192.0, APFloat(APFloat::IEEEdouble, "-0x1000p+1").convertToDouble());
910 EXPECT_EQ( 2048.0, APFloat(APFloat::IEEEdouble, "0x1000p-1").convertToDouble());
911 EXPECT_EQ(+2048.0, APFloat(APFloat::IEEEdouble, "+0x1000p-1").convertToDouble());
912 EXPECT_EQ(-2048.0, APFloat(APFloat::IEEEdouble, "-0x1000p-1").convertToDouble());
915 EXPECT_EQ( 16384.0, APFloat(APFloat::IEEEdouble, "0x10p10").convertToDouble());
916 EXPECT_EQ(+16384.0, APFloat(APFloat::IEEEdouble, "+0x10p10").convertToDouble());
917 EXPECT_EQ(-16384.0, APFloat(APFloat::IEEEdouble, "-0x10p10").convertToDouble());
919 EXPECT_EQ( 16384.0, APFloat(APFloat::IEEEdouble, "0x10p+10").convertToDouble());
920 EXPECT_EQ(+16384.0, APFloat(APFloat::IEEEdouble, "+0x10p+10").convertToDouble());
921 EXPECT_EQ(-16384.0, APFloat(APFloat::IEEEdouble, "-0x10p+10").convertToDouble());
923 EXPECT_EQ( 0.015625, APFloat(APFloat::IEEEdouble, "0x10p-10").convertToDouble());
924 EXPECT_EQ(+0.015625, APFloat(APFloat::IEEEdouble, "+0x10p-10").convertToDouble());
925 EXPECT_EQ(-0.015625, APFloat(APFloat::IEEEdouble, "-0x10p-10").convertToDouble());
927 EXPECT_EQ(1.0625, APFloat(APFloat::IEEEdouble, "0x1.1p0").convertToDouble());
928 EXPECT_EQ(1.0, APFloat(APFloat::IEEEdouble, "0x1p0").convertToDouble());
930 EXPECT_EQ(convertToDoubleFromString("0x1p-150"),
931 convertToDoubleFromString("+0x800000000000000001.p-221"));
932 EXPECT_EQ(2251799813685248.5,
933 convertToDoubleFromString("0x80000000000004000000.010p-28"));
936 TEST(APFloatTest, toString) {
937 ASSERT_EQ("10", convertToString(10.0, 6, 3));
938 ASSERT_EQ("1.0E+1", convertToString(10.0, 6, 0));
939 ASSERT_EQ("10100", convertToString(1.01E+4, 5, 2));
940 ASSERT_EQ("1.01E+4", convertToString(1.01E+4, 4, 2));
941 ASSERT_EQ("1.01E+4", convertToString(1.01E+4, 5, 1));
942 ASSERT_EQ("0.0101", convertToString(1.01E-2, 5, 2));
943 ASSERT_EQ("0.0101", convertToString(1.01E-2, 4, 2));
944 ASSERT_EQ("1.01E-2", convertToString(1.01E-2, 5, 1));
945 ASSERT_EQ("0.78539816339744828", convertToString(0.78539816339744830961, 0, 3));
946 ASSERT_EQ("4.9406564584124654E-324", convertToString(4.9406564584124654e-324, 0, 3));
947 ASSERT_EQ("873.18340000000001", convertToString(873.1834, 0, 1));
948 ASSERT_EQ("8.7318340000000001E+2", convertToString(873.1834, 0, 0));
949 ASSERT_EQ("1.7976931348623157E+308", convertToString(1.7976931348623157E+308, 0, 0));
952 TEST(APFloatTest, toInteger) {
953 bool isExact = false;
954 APSInt result(5, /*isUnsigned=*/true);
956 EXPECT_EQ(APFloat::opOK,
957 APFloat(APFloat::IEEEdouble, "10")
958 .convertToInteger(result, APFloat::rmTowardZero, &isExact));
959 EXPECT_TRUE(isExact);
960 EXPECT_EQ(APSInt(APInt(5, 10), true), result);
962 EXPECT_EQ(APFloat::opInvalidOp,
963 APFloat(APFloat::IEEEdouble, "-10")
964 .convertToInteger(result, APFloat::rmTowardZero, &isExact));
965 EXPECT_FALSE(isExact);
966 EXPECT_EQ(APSInt::getMinValue(5, true), result);
968 EXPECT_EQ(APFloat::opInvalidOp,
969 APFloat(APFloat::IEEEdouble, "32")
970 .convertToInteger(result, APFloat::rmTowardZero, &isExact));
971 EXPECT_FALSE(isExact);
972 EXPECT_EQ(APSInt::getMaxValue(5, true), result);
974 EXPECT_EQ(APFloat::opInexact,
975 APFloat(APFloat::IEEEdouble, "7.9")
976 .convertToInteger(result, APFloat::rmTowardZero, &isExact));
977 EXPECT_FALSE(isExact);
978 EXPECT_EQ(APSInt(APInt(5, 7), true), result);
980 result.setIsUnsigned(false);
981 EXPECT_EQ(APFloat::opOK,
982 APFloat(APFloat::IEEEdouble, "-10")
983 .convertToInteger(result, APFloat::rmTowardZero, &isExact));
984 EXPECT_TRUE(isExact);
985 EXPECT_EQ(APSInt(APInt(5, -10, true), false), result);
987 EXPECT_EQ(APFloat::opInvalidOp,
988 APFloat(APFloat::IEEEdouble, "-17")
989 .convertToInteger(result, APFloat::rmTowardZero, &isExact));
990 EXPECT_FALSE(isExact);
991 EXPECT_EQ(APSInt::getMinValue(5, false), result);
993 EXPECT_EQ(APFloat::opInvalidOp,
994 APFloat(APFloat::IEEEdouble, "16")
995 .convertToInteger(result, APFloat::rmTowardZero, &isExact));
996 EXPECT_FALSE(isExact);
997 EXPECT_EQ(APSInt::getMaxValue(5, false), result);
1000 static APInt nanbits(const fltSemantics &Sem,
1001 bool SNaN, bool Negative, uint64_t fill) {
1002 APInt apfill(64, fill);
1004 return APFloat::getSNaN(Sem, Negative, &apfill).bitcastToAPInt();
1006 return APFloat::getQNaN(Sem, Negative, &apfill).bitcastToAPInt();
1009 TEST(APFloatTest, makeNaN) {
1010 ASSERT_EQ(0x7fc00000, nanbits(APFloat::IEEEsingle, false, false, 0));
1011 ASSERT_EQ(0xffc00000, nanbits(APFloat::IEEEsingle, false, true, 0));
1012 ASSERT_EQ(0x7fc0ae72, nanbits(APFloat::IEEEsingle, false, false, 0xae72));
1013 ASSERT_EQ(0x7fffae72, nanbits(APFloat::IEEEsingle, false, false, 0xffffae72));
1014 ASSERT_EQ(0x7fa00000, nanbits(APFloat::IEEEsingle, true, false, 0));
1015 ASSERT_EQ(0xffa00000, nanbits(APFloat::IEEEsingle, true, true, 0));
1016 ASSERT_EQ(0x7f80ae72, nanbits(APFloat::IEEEsingle, true, false, 0xae72));
1017 ASSERT_EQ(0x7fbfae72, nanbits(APFloat::IEEEsingle, true, false, 0xffffae72));
1019 ASSERT_EQ(0x7ff8000000000000ULL, nanbits(APFloat::IEEEdouble, false, false, 0));
1020 ASSERT_EQ(0xfff8000000000000ULL, nanbits(APFloat::IEEEdouble, false, true, 0));
1021 ASSERT_EQ(0x7ff800000000ae72ULL, nanbits(APFloat::IEEEdouble, false, false, 0xae72));
1022 ASSERT_EQ(0x7fffffffffffae72ULL, nanbits(APFloat::IEEEdouble, false, false, 0xffffffffffffae72ULL));
1023 ASSERT_EQ(0x7ff4000000000000ULL, nanbits(APFloat::IEEEdouble, true, false, 0));
1024 ASSERT_EQ(0xfff4000000000000ULL, nanbits(APFloat::IEEEdouble, true, true, 0));
1025 ASSERT_EQ(0x7ff000000000ae72ULL, nanbits(APFloat::IEEEdouble, true, false, 0xae72));
1026 ASSERT_EQ(0x7ff7ffffffffae72ULL, nanbits(APFloat::IEEEdouble, true, false, 0xffffffffffffae72ULL));
1029 #ifdef GTEST_HAS_DEATH_TEST
1031 TEST(APFloatTest, SemanticsDeath) {
1032 EXPECT_DEATH(APFloat(APFloat::IEEEsingle, 0.0f).convertToDouble(), "Float semantics are not IEEEdouble");
1033 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, 0.0 ).convertToFloat(), "Float semantics are not IEEEsingle");
1036 TEST(APFloatTest, StringDecimalDeath) {
1037 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, ""), "Invalid string length");
1038 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+"), "String has no digits");
1039 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-"), "String has no digits");
1041 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("\0", 1)), "Invalid character in significand");
1042 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("1\0", 2)), "Invalid character in significand");
1043 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("1\02", 3)), "Invalid character in significand");
1044 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("1\02e1", 5)), "Invalid character in significand");
1045 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("1e\0", 3)), "Invalid character in exponent");
1046 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("1e1\0", 4)), "Invalid character in exponent");
1047 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("1e1\02", 5)), "Invalid character in exponent");
1049 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "1.0f"), "Invalid character in significand");
1051 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, ".."), "String contains multiple dots");
1052 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "..0"), "String contains multiple dots");
1053 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "1.0.0"), "String contains multiple dots");
1056 TEST(APFloatTest, StringDecimalSignificandDeath) {
1057 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "."), "Significand has no digits");
1058 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+."), "Significand has no digits");
1059 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-."), "Significand has no digits");
1062 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "e"), "Significand has no digits");
1063 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+e"), "Significand has no digits");
1064 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-e"), "Significand has no digits");
1066 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "e1"), "Significand has no digits");
1067 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+e1"), "Significand has no digits");
1068 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-e1"), "Significand has no digits");
1070 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, ".e1"), "Significand has no digits");
1071 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+.e1"), "Significand has no digits");
1072 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-.e1"), "Significand has no digits");
1075 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, ".e"), "Significand has no digits");
1076 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+.e"), "Significand has no digits");
1077 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-.e"), "Significand has no digits");
1080 TEST(APFloatTest, StringDecimalExponentDeath) {
1081 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "1e"), "Exponent has no digits");
1082 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+1e"), "Exponent has no digits");
1083 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-1e"), "Exponent has no digits");
1085 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "1.e"), "Exponent has no digits");
1086 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+1.e"), "Exponent has no digits");
1087 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-1.e"), "Exponent has no digits");
1089 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, ".1e"), "Exponent has no digits");
1090 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+.1e"), "Exponent has no digits");
1091 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-.1e"), "Exponent has no digits");
1093 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "1.1e"), "Exponent has no digits");
1094 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+1.1e"), "Exponent has no digits");
1095 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-1.1e"), "Exponent has no digits");
1098 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "1e+"), "Exponent has no digits");
1099 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "1e-"), "Exponent has no digits");
1101 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, ".1e"), "Exponent has no digits");
1102 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, ".1e+"), "Exponent has no digits");
1103 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, ".1e-"), "Exponent has no digits");
1105 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "1.0e"), "Exponent has no digits");
1106 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "1.0e+"), "Exponent has no digits");
1107 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "1.0e-"), "Exponent has no digits");
1110 TEST(APFloatTest, StringHexadecimalDeath) {
1111 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x"), "Invalid string");
1112 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x"), "Invalid string");
1113 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x"), "Invalid string");
1115 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x0"), "Hex strings require an exponent");
1116 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x0"), "Hex strings require an exponent");
1117 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x0"), "Hex strings require an exponent");
1119 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x0."), "Hex strings require an exponent");
1120 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x0."), "Hex strings require an exponent");
1121 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x0."), "Hex strings require an exponent");
1123 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x.0"), "Hex strings require an exponent");
1124 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x.0"), "Hex strings require an exponent");
1125 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x.0"), "Hex strings require an exponent");
1127 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x0.0"), "Hex strings require an exponent");
1128 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x0.0"), "Hex strings require an exponent");
1129 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x0.0"), "Hex strings require an exponent");
1131 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("0x\0", 3)), "Invalid character in significand");
1132 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("0x1\0", 4)), "Invalid character in significand");
1133 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("0x1\02", 5)), "Invalid character in significand");
1134 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("0x1\02p1", 7)), "Invalid character in significand");
1135 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("0x1p\0", 5)), "Invalid character in exponent");
1136 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("0x1p1\0", 6)), "Invalid character in exponent");
1137 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("0x1p1\02", 7)), "Invalid character in exponent");
1139 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x1p0f"), "Invalid character in exponent");
1141 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x..p1"), "String contains multiple dots");
1142 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x..0p1"), "String contains multiple dots");
1143 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x1.0.0p1"), "String contains multiple dots");
1146 TEST(APFloatTest, StringHexadecimalSignificandDeath) {
1147 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x."), "Significand has no digits");
1148 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x."), "Significand has no digits");
1149 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x."), "Significand has no digits");
1151 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0xp"), "Significand has no digits");
1152 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0xp"), "Significand has no digits");
1153 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0xp"), "Significand has no digits");
1155 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0xp+"), "Significand has no digits");
1156 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0xp+"), "Significand has no digits");
1157 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0xp+"), "Significand has no digits");
1159 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0xp-"), "Significand has no digits");
1160 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0xp-"), "Significand has no digits");
1161 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0xp-"), "Significand has no digits");
1164 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x.p"), "Significand has no digits");
1165 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x.p"), "Significand has no digits");
1166 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x.p"), "Significand has no digits");
1168 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x.p+"), "Significand has no digits");
1169 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x.p+"), "Significand has no digits");
1170 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x.p+"), "Significand has no digits");
1172 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x.p-"), "Significand has no digits");
1173 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x.p-"), "Significand has no digits");
1174 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x.p-"), "Significand has no digits");
1177 TEST(APFloatTest, StringHexadecimalExponentDeath) {
1178 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x1p"), "Exponent has no digits");
1179 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x1p"), "Exponent has no digits");
1180 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x1p"), "Exponent has no digits");
1182 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x1p+"), "Exponent has no digits");
1183 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x1p+"), "Exponent has no digits");
1184 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x1p+"), "Exponent has no digits");
1186 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x1p-"), "Exponent has no digits");
1187 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x1p-"), "Exponent has no digits");
1188 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x1p-"), "Exponent has no digits");
1191 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x1.p"), "Exponent has no digits");
1192 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x1.p"), "Exponent has no digits");
1193 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x1.p"), "Exponent has no digits");
1195 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x1.p+"), "Exponent has no digits");
1196 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x1.p+"), "Exponent has no digits");
1197 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x1.p+"), "Exponent has no digits");
1199 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x1.p-"), "Exponent has no digits");
1200 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x1.p-"), "Exponent has no digits");
1201 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x1.p-"), "Exponent has no digits");
1204 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x.1p"), "Exponent has no digits");
1205 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x.1p"), "Exponent has no digits");
1206 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x.1p"), "Exponent has no digits");
1208 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x.1p+"), "Exponent has no digits");
1209 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x.1p+"), "Exponent has no digits");
1210 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x.1p+"), "Exponent has no digits");
1212 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x.1p-"), "Exponent has no digits");
1213 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x.1p-"), "Exponent has no digits");
1214 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x.1p-"), "Exponent has no digits");
1217 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x1.1p"), "Exponent has no digits");
1218 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x1.1p"), "Exponent has no digits");
1219 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x1.1p"), "Exponent has no digits");
1221 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x1.1p+"), "Exponent has no digits");
1222 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x1.1p+"), "Exponent has no digits");
1223 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x1.1p+"), "Exponent has no digits");
1225 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x1.1p-"), "Exponent has no digits");
1226 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x1.1p-"), "Exponent has no digits");
1227 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x1.1p-"), "Exponent has no digits");
1232 TEST(APFloatTest, exactInverse) {
1235 // Trivial operation.
1236 EXPECT_TRUE(APFloat(2.0).getExactInverse(&inv));
1237 EXPECT_TRUE(inv.bitwiseIsEqual(APFloat(0.5)));
1238 EXPECT_TRUE(APFloat(2.0f).getExactInverse(&inv));
1239 EXPECT_TRUE(inv.bitwiseIsEqual(APFloat(0.5f)));
1240 EXPECT_TRUE(APFloat(APFloat::IEEEquad, "2.0").getExactInverse(&inv));
1241 EXPECT_TRUE(inv.bitwiseIsEqual(APFloat(APFloat::IEEEquad, "0.5")));
1242 EXPECT_TRUE(APFloat(APFloat::PPCDoubleDouble, "2.0").getExactInverse(&inv));
1243 EXPECT_TRUE(inv.bitwiseIsEqual(APFloat(APFloat::PPCDoubleDouble, "0.5")));
1244 EXPECT_TRUE(APFloat(APFloat::x87DoubleExtended, "2.0").getExactInverse(&inv));
1245 EXPECT_TRUE(inv.bitwiseIsEqual(APFloat(APFloat::x87DoubleExtended, "0.5")));
1248 EXPECT_TRUE(APFloat(1.17549435e-38f).getExactInverse(&inv));
1249 EXPECT_TRUE(inv.bitwiseIsEqual(APFloat(8.5070592e+37f)));
1251 // Large float, inverse is a denormal.
1252 EXPECT_FALSE(APFloat(1.7014118e38f).getExactInverse(nullptr));
1254 EXPECT_FALSE(APFloat(0.0).getExactInverse(nullptr));
1255 // Denormalized float
1256 EXPECT_FALSE(APFloat(1.40129846e-45f).getExactInverse(nullptr));
1259 TEST(APFloatTest, roundToIntegral) {
1260 APFloat T(-0.5), S(3.14), R(APFloat::getLargest(APFloat::IEEEdouble)), P(0.0);
1263 P.roundToIntegral(APFloat::rmTowardZero);
1264 EXPECT_EQ(-0.0, P.convertToDouble());
1266 P.roundToIntegral(APFloat::rmTowardNegative);
1267 EXPECT_EQ(-1.0, P.convertToDouble());
1269 P.roundToIntegral(APFloat::rmTowardPositive);
1270 EXPECT_EQ(-0.0, P.convertToDouble());
1272 P.roundToIntegral(APFloat::rmNearestTiesToEven);
1273 EXPECT_EQ(-0.0, P.convertToDouble());
1276 P.roundToIntegral(APFloat::rmTowardZero);
1277 EXPECT_EQ(3.0, P.convertToDouble());
1279 P.roundToIntegral(APFloat::rmTowardNegative);
1280 EXPECT_EQ(3.0, P.convertToDouble());
1282 P.roundToIntegral(APFloat::rmTowardPositive);
1283 EXPECT_EQ(4.0, P.convertToDouble());
1285 P.roundToIntegral(APFloat::rmNearestTiesToEven);
1286 EXPECT_EQ(3.0, P.convertToDouble());
1289 P.roundToIntegral(APFloat::rmTowardZero);
1290 EXPECT_EQ(R.convertToDouble(), P.convertToDouble());
1292 P.roundToIntegral(APFloat::rmTowardNegative);
1293 EXPECT_EQ(R.convertToDouble(), P.convertToDouble());
1295 P.roundToIntegral(APFloat::rmTowardPositive);
1296 EXPECT_EQ(R.convertToDouble(), P.convertToDouble());
1298 P.roundToIntegral(APFloat::rmNearestTiesToEven);
1299 EXPECT_EQ(R.convertToDouble(), P.convertToDouble());
1301 P = APFloat::getZero(APFloat::IEEEdouble);
1302 P.roundToIntegral(APFloat::rmTowardZero);
1303 EXPECT_EQ(0.0, P.convertToDouble());
1304 P = APFloat::getZero(APFloat::IEEEdouble, true);
1305 P.roundToIntegral(APFloat::rmTowardZero);
1306 EXPECT_EQ(-0.0, P.convertToDouble());
1307 P = APFloat::getNaN(APFloat::IEEEdouble);
1308 P.roundToIntegral(APFloat::rmTowardZero);
1309 EXPECT_TRUE(std::isnan(P.convertToDouble()));
1310 P = APFloat::getInf(APFloat::IEEEdouble);
1311 P.roundToIntegral(APFloat::rmTowardZero);
1312 EXPECT_TRUE(std::isinf(P.convertToDouble()) && P.convertToDouble() > 0.0);
1313 P = APFloat::getInf(APFloat::IEEEdouble, true);
1314 P.roundToIntegral(APFloat::rmTowardZero);
1315 EXPECT_TRUE(std::isinf(P.convertToDouble()) && P.convertToDouble() < 0.0);
1319 TEST(APFloatTest, getLargest) {
1320 EXPECT_EQ(3.402823466e+38f, APFloat::getLargest(APFloat::IEEEsingle).convertToFloat());
1321 EXPECT_EQ(1.7976931348623158e+308, APFloat::getLargest(APFloat::IEEEdouble).convertToDouble());
1324 TEST(APFloatTest, getSmallest) {
1325 APFloat test = APFloat::getSmallest(APFloat::IEEEsingle, false);
1326 APFloat expected = APFloat(APFloat::IEEEsingle, "0x0.000002p-126");
1327 EXPECT_FALSE(test.isNegative());
1328 EXPECT_TRUE(test.isFiniteNonZero());
1329 EXPECT_TRUE(test.isDenormal());
1330 EXPECT_TRUE(test.bitwiseIsEqual(expected));
1332 test = APFloat::getSmallest(APFloat::IEEEsingle, true);
1333 expected = APFloat(APFloat::IEEEsingle, "-0x0.000002p-126");
1334 EXPECT_TRUE(test.isNegative());
1335 EXPECT_TRUE(test.isFiniteNonZero());
1336 EXPECT_TRUE(test.isDenormal());
1337 EXPECT_TRUE(test.bitwiseIsEqual(expected));
1339 test = APFloat::getSmallest(APFloat::IEEEquad, false);
1340 expected = APFloat(APFloat::IEEEquad, "0x0.0000000000000000000000000001p-16382");
1341 EXPECT_FALSE(test.isNegative());
1342 EXPECT_TRUE(test.isFiniteNonZero());
1343 EXPECT_TRUE(test.isDenormal());
1344 EXPECT_TRUE(test.bitwiseIsEqual(expected));
1346 test = APFloat::getSmallest(APFloat::IEEEquad, true);
1347 expected = APFloat(APFloat::IEEEquad, "-0x0.0000000000000000000000000001p-16382");
1348 EXPECT_TRUE(test.isNegative());
1349 EXPECT_TRUE(test.isFiniteNonZero());
1350 EXPECT_TRUE(test.isDenormal());
1351 EXPECT_TRUE(test.bitwiseIsEqual(expected));
1354 TEST(APFloatTest, getSmallestNormalized) {
1355 APFloat test = APFloat::getSmallestNormalized(APFloat::IEEEsingle, false);
1356 APFloat expected = APFloat(APFloat::IEEEsingle, "0x1p-126");
1357 EXPECT_FALSE(test.isNegative());
1358 EXPECT_TRUE(test.isFiniteNonZero());
1359 EXPECT_FALSE(test.isDenormal());
1360 EXPECT_TRUE(test.bitwiseIsEqual(expected));
1362 test = APFloat::getSmallestNormalized(APFloat::IEEEsingle, true);
1363 expected = APFloat(APFloat::IEEEsingle, "-0x1p-126");
1364 EXPECT_TRUE(test.isNegative());
1365 EXPECT_TRUE(test.isFiniteNonZero());
1366 EXPECT_FALSE(test.isDenormal());
1367 EXPECT_TRUE(test.bitwiseIsEqual(expected));
1369 test = APFloat::getSmallestNormalized(APFloat::IEEEquad, false);
1370 expected = APFloat(APFloat::IEEEquad, "0x1p-16382");
1371 EXPECT_FALSE(test.isNegative());
1372 EXPECT_TRUE(test.isFiniteNonZero());
1373 EXPECT_FALSE(test.isDenormal());
1374 EXPECT_TRUE(test.bitwiseIsEqual(expected));
1376 test = APFloat::getSmallestNormalized(APFloat::IEEEquad, true);
1377 expected = APFloat(APFloat::IEEEquad, "-0x1p-16382");
1378 EXPECT_TRUE(test.isNegative());
1379 EXPECT_TRUE(test.isFiniteNonZero());
1380 EXPECT_FALSE(test.isDenormal());
1381 EXPECT_TRUE(test.bitwiseIsEqual(expected));
1384 TEST(APFloatTest, getZero) {
1386 const fltSemantics *semantics;
1388 const unsigned long long bitPattern[2];
1389 const unsigned bitPatternLength;
1390 } const GetZeroTest[] = {
1391 { &APFloat::IEEEhalf, false, {0, 0}, 1},
1392 { &APFloat::IEEEhalf, true, {0x8000ULL, 0}, 1},
1393 { &APFloat::IEEEsingle, false, {0, 0}, 1},
1394 { &APFloat::IEEEsingle, true, {0x80000000ULL, 0}, 1},
1395 { &APFloat::IEEEdouble, false, {0, 0}, 1},
1396 { &APFloat::IEEEdouble, true, {0x8000000000000000ULL, 0}, 1},
1397 { &APFloat::IEEEquad, false, {0, 0}, 2},
1398 { &APFloat::IEEEquad, true, {0, 0x8000000000000000ULL}, 2},
1399 { &APFloat::PPCDoubleDouble, false, {0, 0}, 2},
1400 { &APFloat::PPCDoubleDouble, true, {0x8000000000000000ULL, 0}, 2},
1401 { &APFloat::x87DoubleExtended, false, {0, 0}, 2},
1402 { &APFloat::x87DoubleExtended, true, {0, 0x8000ULL}, 2},
1404 const unsigned NumGetZeroTests = 12;
1405 for (unsigned i = 0; i < NumGetZeroTests; ++i) {
1406 APFloat test = APFloat::getZero(*GetZeroTest[i].semantics,
1407 GetZeroTest[i].sign);
1408 const char *pattern = GetZeroTest[i].sign? "-0x0p+0" : "0x0p+0";
1409 APFloat expected = APFloat(*GetZeroTest[i].semantics,
1411 EXPECT_TRUE(test.isZero());
1412 EXPECT_TRUE(GetZeroTest[i].sign? test.isNegative() : !test.isNegative());
1413 EXPECT_TRUE(test.bitwiseIsEqual(expected));
1414 for (unsigned j = 0, je = GetZeroTest[i].bitPatternLength; j < je; ++j) {
1415 EXPECT_EQ(GetZeroTest[i].bitPattern[j],
1416 test.bitcastToAPInt().getRawData()[j]);
1421 TEST(APFloatTest, copySign) {
1422 EXPECT_TRUE(APFloat(-42.0).bitwiseIsEqual(
1423 APFloat::copySign(APFloat(42.0), APFloat(-1.0))));
1424 EXPECT_TRUE(APFloat(42.0).bitwiseIsEqual(
1425 APFloat::copySign(APFloat(-42.0), APFloat(1.0))));
1426 EXPECT_TRUE(APFloat(-42.0).bitwiseIsEqual(
1427 APFloat::copySign(APFloat(-42.0), APFloat(-1.0))));
1428 EXPECT_TRUE(APFloat(42.0).bitwiseIsEqual(
1429 APFloat::copySign(APFloat(42.0), APFloat(1.0))));
1432 TEST(APFloatTest, convert) {
1434 APFloat test(APFloat::IEEEdouble, "1.0");
1435 test.convert(APFloat::IEEEsingle, APFloat::rmNearestTiesToEven, &losesInfo);
1436 EXPECT_EQ(1.0f, test.convertToFloat());
1437 EXPECT_FALSE(losesInfo);
1439 test = APFloat(APFloat::x87DoubleExtended, "0x1p-53");
1440 test.add(APFloat(APFloat::x87DoubleExtended, "1.0"), APFloat::rmNearestTiesToEven);
1441 test.convert(APFloat::IEEEdouble, APFloat::rmNearestTiesToEven, &losesInfo);
1442 EXPECT_EQ(1.0, test.convertToDouble());
1443 EXPECT_TRUE(losesInfo);
1445 test = APFloat(APFloat::IEEEquad, "0x1p-53");
1446 test.add(APFloat(APFloat::IEEEquad, "1.0"), APFloat::rmNearestTiesToEven);
1447 test.convert(APFloat::IEEEdouble, APFloat::rmNearestTiesToEven, &losesInfo);
1448 EXPECT_EQ(1.0, test.convertToDouble());
1449 EXPECT_TRUE(losesInfo);
1451 test = APFloat(APFloat::x87DoubleExtended, "0xf.fffffffp+28");
1452 test.convert(APFloat::IEEEdouble, APFloat::rmNearestTiesToEven, &losesInfo);
1453 EXPECT_EQ(4294967295.0, test.convertToDouble());
1454 EXPECT_FALSE(losesInfo);
1456 test = APFloat::getSNaN(APFloat::IEEEsingle);
1457 APFloat X87SNaN = APFloat::getSNaN(APFloat::x87DoubleExtended);
1458 test.convert(APFloat::x87DoubleExtended, APFloat::rmNearestTiesToEven,
1460 EXPECT_TRUE(test.bitwiseIsEqual(X87SNaN));
1461 EXPECT_FALSE(losesInfo);
1463 test = APFloat::getQNaN(APFloat::IEEEsingle);
1464 APFloat X87QNaN = APFloat::getQNaN(APFloat::x87DoubleExtended);
1465 test.convert(APFloat::x87DoubleExtended, APFloat::rmNearestTiesToEven,
1467 EXPECT_TRUE(test.bitwiseIsEqual(X87QNaN));
1468 EXPECT_FALSE(losesInfo);
1470 test = APFloat::getSNaN(APFloat::x87DoubleExtended);
1471 test.convert(APFloat::x87DoubleExtended, APFloat::rmNearestTiesToEven,
1473 EXPECT_TRUE(test.bitwiseIsEqual(X87SNaN));
1474 EXPECT_FALSE(losesInfo);
1476 test = APFloat::getQNaN(APFloat::x87DoubleExtended);
1477 test.convert(APFloat::x87DoubleExtended, APFloat::rmNearestTiesToEven,
1479 EXPECT_TRUE(test.bitwiseIsEqual(X87QNaN));
1480 EXPECT_FALSE(losesInfo);
1483 TEST(APFloatTest, PPCDoubleDouble) {
1484 APFloat test(APFloat::PPCDoubleDouble, "1.0");
1485 EXPECT_EQ(0x3ff0000000000000ull, test.bitcastToAPInt().getRawData()[0]);
1486 EXPECT_EQ(0x0000000000000000ull, test.bitcastToAPInt().getRawData()[1]);
1488 test.divide(APFloat(APFloat::PPCDoubleDouble, "3.0"), APFloat::rmNearestTiesToEven);
1489 EXPECT_EQ(0x3fd5555555555555ull, test.bitcastToAPInt().getRawData()[0]);
1490 EXPECT_EQ(0x3c75555555555556ull, test.bitcastToAPInt().getRawData()[1]);
1493 test = APFloat(APFloat::PPCDoubleDouble, "1.79769313486231580793728971405301e+308");
1494 EXPECT_EQ(0x7fefffffffffffffull, test.bitcastToAPInt().getRawData()[0]);
1495 EXPECT_EQ(0x7c8ffffffffffffeull, test.bitcastToAPInt().getRawData()[1]);
1498 test = APFloat(APFloat::PPCDoubleDouble, "2.00416836000897277799610805135016e-292");
1499 EXPECT_EQ(0x0360000000000000ull, test.bitcastToAPInt().getRawData()[0]);
1500 EXPECT_EQ(0x0000000000000000ull, test.bitcastToAPInt().getRawData()[1]);
1502 test = APFloat(APFloat::PPCDoubleDouble, "1.0");
1503 test.add(APFloat(APFloat::PPCDoubleDouble, "0x1p-105"), APFloat::rmNearestTiesToEven);
1504 EXPECT_EQ(0x3ff0000000000000ull, test.bitcastToAPInt().getRawData()[0]);
1505 EXPECT_EQ(0x3960000000000000ull, test.bitcastToAPInt().getRawData()[1]);
1507 test = APFloat(APFloat::PPCDoubleDouble, "1.0");
1508 test.add(APFloat(APFloat::PPCDoubleDouble, "0x1p-106"), APFloat::rmNearestTiesToEven);
1509 EXPECT_EQ(0x3ff0000000000000ull, test.bitcastToAPInt().getRawData()[0]);
1511 // This is what we would expect with a true double-double implementation
1512 EXPECT_EQ(0x3950000000000000ull, test.bitcastToAPInt().getRawData()[1]);
1514 // This is what we get with our 106-bit mantissa approximation
1515 EXPECT_EQ(0x0000000000000000ull, test.bitcastToAPInt().getRawData()[1]);
1519 TEST(APFloatTest, isNegative) {
1520 APFloat t(APFloat::IEEEsingle, "0x1p+0");
1521 EXPECT_FALSE(t.isNegative());
1522 t = APFloat(APFloat::IEEEsingle, "-0x1p+0");
1523 EXPECT_TRUE(t.isNegative());
1525 EXPECT_FALSE(APFloat::getInf(APFloat::IEEEsingle, false).isNegative());
1526 EXPECT_TRUE(APFloat::getInf(APFloat::IEEEsingle, true).isNegative());
1528 EXPECT_FALSE(APFloat::getZero(APFloat::IEEEsingle, false).isNegative());
1529 EXPECT_TRUE(APFloat::getZero(APFloat::IEEEsingle, true).isNegative());
1531 EXPECT_FALSE(APFloat::getNaN(APFloat::IEEEsingle, false).isNegative());
1532 EXPECT_TRUE(APFloat::getNaN(APFloat::IEEEsingle, true).isNegative());
1534 EXPECT_FALSE(APFloat::getSNaN(APFloat::IEEEsingle, false).isNegative());
1535 EXPECT_TRUE(APFloat::getSNaN(APFloat::IEEEsingle, true).isNegative());
1538 TEST(APFloatTest, isNormal) {
1539 APFloat t(APFloat::IEEEsingle, "0x1p+0");
1540 EXPECT_TRUE(t.isNormal());
1542 EXPECT_FALSE(APFloat::getInf(APFloat::IEEEsingle, false).isNormal());
1543 EXPECT_FALSE(APFloat::getZero(APFloat::IEEEsingle, false).isNormal());
1544 EXPECT_FALSE(APFloat::getNaN(APFloat::IEEEsingle, false).isNormal());
1545 EXPECT_FALSE(APFloat::getSNaN(APFloat::IEEEsingle, false).isNormal());
1546 EXPECT_FALSE(APFloat(APFloat::IEEEsingle, "0x1p-149").isNormal());
1549 TEST(APFloatTest, isFinite) {
1550 APFloat t(APFloat::IEEEsingle, "0x1p+0");
1551 EXPECT_TRUE(t.isFinite());
1552 EXPECT_FALSE(APFloat::getInf(APFloat::IEEEsingle, false).isFinite());
1553 EXPECT_TRUE(APFloat::getZero(APFloat::IEEEsingle, false).isFinite());
1554 EXPECT_FALSE(APFloat::getNaN(APFloat::IEEEsingle, false).isFinite());
1555 EXPECT_FALSE(APFloat::getSNaN(APFloat::IEEEsingle, false).isFinite());
1556 EXPECT_TRUE(APFloat(APFloat::IEEEsingle, "0x1p-149").isFinite());
1559 TEST(APFloatTest, isInfinity) {
1560 APFloat t(APFloat::IEEEsingle, "0x1p+0");
1561 EXPECT_FALSE(t.isInfinity());
1562 EXPECT_TRUE(APFloat::getInf(APFloat::IEEEsingle, false).isInfinity());
1563 EXPECT_FALSE(APFloat::getZero(APFloat::IEEEsingle, false).isInfinity());
1564 EXPECT_FALSE(APFloat::getNaN(APFloat::IEEEsingle, false).isInfinity());
1565 EXPECT_FALSE(APFloat::getSNaN(APFloat::IEEEsingle, false).isInfinity());
1566 EXPECT_FALSE(APFloat(APFloat::IEEEsingle, "0x1p-149").isInfinity());
1569 TEST(APFloatTest, isNaN) {
1570 APFloat t(APFloat::IEEEsingle, "0x1p+0");
1571 EXPECT_FALSE(t.isNaN());
1572 EXPECT_FALSE(APFloat::getInf(APFloat::IEEEsingle, false).isNaN());
1573 EXPECT_FALSE(APFloat::getZero(APFloat::IEEEsingle, false).isNaN());
1574 EXPECT_TRUE(APFloat::getNaN(APFloat::IEEEsingle, false).isNaN());
1575 EXPECT_TRUE(APFloat::getSNaN(APFloat::IEEEsingle, false).isNaN());
1576 EXPECT_FALSE(APFloat(APFloat::IEEEsingle, "0x1p-149").isNaN());
1579 TEST(APFloatTest, isFiniteNonZero) {
1580 // Test positive/negative normal value.
1581 EXPECT_TRUE(APFloat(APFloat::IEEEsingle, "0x1p+0").isFiniteNonZero());
1582 EXPECT_TRUE(APFloat(APFloat::IEEEsingle, "-0x1p+0").isFiniteNonZero());
1584 // Test positive/negative denormal value.
1585 EXPECT_TRUE(APFloat(APFloat::IEEEsingle, "0x1p-149").isFiniteNonZero());
1586 EXPECT_TRUE(APFloat(APFloat::IEEEsingle, "-0x1p-149").isFiniteNonZero());
1588 // Test +/- Infinity.
1589 EXPECT_FALSE(APFloat::getInf(APFloat::IEEEsingle, false).isFiniteNonZero());
1590 EXPECT_FALSE(APFloat::getInf(APFloat::IEEEsingle, true).isFiniteNonZero());
1593 EXPECT_FALSE(APFloat::getZero(APFloat::IEEEsingle, false).isFiniteNonZero());
1594 EXPECT_FALSE(APFloat::getZero(APFloat::IEEEsingle, true).isFiniteNonZero());
1596 // Test +/- qNaN. +/- dont mean anything with qNaN but paranoia can't hurt in
1598 EXPECT_FALSE(APFloat::getNaN(APFloat::IEEEsingle, false).isFiniteNonZero());
1599 EXPECT_FALSE(APFloat::getNaN(APFloat::IEEEsingle, true).isFiniteNonZero());
1601 // Test +/- sNaN. +/- dont mean anything with sNaN but paranoia can't hurt in
1603 EXPECT_FALSE(APFloat::getSNaN(APFloat::IEEEsingle, false).isFiniteNonZero());
1604 EXPECT_FALSE(APFloat::getSNaN(APFloat::IEEEsingle, true).isFiniteNonZero());
1607 TEST(APFloatTest, add) {
1608 // Test Special Cases against each other and normal values.
1611 // 1. Since we perform only default exception handling all operations with
1612 // signaling NaNs should have a result that is a quiet NaN. Currently they
1615 APFloat PInf = APFloat::getInf(APFloat::IEEEsingle, false);
1616 APFloat MInf = APFloat::getInf(APFloat::IEEEsingle, true);
1617 APFloat PZero = APFloat::getZero(APFloat::IEEEsingle, false);
1618 APFloat MZero = APFloat::getZero(APFloat::IEEEsingle, true);
1619 APFloat QNaN = APFloat::getNaN(APFloat::IEEEsingle, false);
1620 APFloat SNaN = APFloat::getSNaN(APFloat::IEEEsingle, false);
1621 APFloat PNormalValue = APFloat(APFloat::IEEEsingle, "0x1p+0");
1622 APFloat MNormalValue = APFloat(APFloat::IEEEsingle, "-0x1p+0");
1623 APFloat PLargestValue = APFloat::getLargest(APFloat::IEEEsingle, false);
1624 APFloat MLargestValue = APFloat::getLargest(APFloat::IEEEsingle, true);
1625 APFloat PSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle, false);
1626 APFloat MSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle, true);
1627 APFloat PSmallestNormalized =
1628 APFloat::getSmallestNormalized(APFloat::IEEEsingle, false);
1629 APFloat MSmallestNormalized =
1630 APFloat::getSmallestNormalized(APFloat::IEEEsingle, true);
1632 const int OverflowStatus = APFloat::opOverflow | APFloat::opInexact;
1634 const unsigned NumTests = 169;
1641 } SpecialCaseTests[NumTests] = {
1642 { PInf, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1643 { PInf, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1644 { PInf, PZero, "inf", APFloat::opOK, APFloat::fcInfinity },
1645 { PInf, MZero, "inf", APFloat::opOK, APFloat::fcInfinity },
1646 { PInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1649 { PInf, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1651 { PInf, PNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
1652 { PInf, MNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
1653 { PInf, PLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
1654 { PInf, MLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
1655 { PInf, PSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
1656 { PInf, MSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
1657 { PInf, PSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity },
1658 { PInf, MSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity },
1659 { MInf, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1660 { MInf, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1661 { MInf, PZero, "-inf", APFloat::opOK, APFloat::fcInfinity },
1662 { MInf, MZero, "-inf", APFloat::opOK, APFloat::fcInfinity },
1663 { MInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1666 { MInf, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1668 { MInf, PNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
1669 { MInf, MNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
1670 { MInf, PLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
1671 { MInf, MLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
1672 { MInf, PSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
1673 { MInf, MSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
1674 { MInf, PSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity },
1675 { MInf, MSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity },
1676 { PZero, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1677 { PZero, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1678 { PZero, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1679 { PZero, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1680 { PZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1683 { PZero, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1685 { PZero, PNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
1686 { PZero, MNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
1687 { PZero, PLargestValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
1688 { PZero, MLargestValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
1689 { PZero, PSmallestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
1690 { PZero, MSmallestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
1691 { PZero, PSmallestNormalized, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
1692 { PZero, MSmallestNormalized, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
1693 { MZero, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1694 { MZero, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1695 { MZero, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1696 { MZero, MZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
1697 { MZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1700 { MZero, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1702 { MZero, PNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
1703 { MZero, MNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
1704 { MZero, PLargestValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
1705 { MZero, MLargestValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
1706 { MZero, PSmallestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
1707 { MZero, MSmallestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
1708 { MZero, PSmallestNormalized, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
1709 { MZero, MSmallestNormalized, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
1710 { QNaN, PInf, "nan", APFloat::opOK, APFloat::fcNaN },
1711 { QNaN, MInf, "nan", APFloat::opOK, APFloat::fcNaN },
1712 { QNaN, PZero, "nan", APFloat::opOK, APFloat::fcNaN },
1713 { QNaN, MZero, "nan", APFloat::opOK, APFloat::fcNaN },
1714 { QNaN, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1717 { QNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1719 { QNaN, PNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
1720 { QNaN, MNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
1721 { QNaN, PLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
1722 { QNaN, MLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
1723 { QNaN, PSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
1724 { QNaN, MSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
1725 { QNaN, PSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
1726 { QNaN, MSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
1729 { SNaN, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1730 { SNaN, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1731 { SNaN, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1732 { SNaN, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1733 { SNaN, QNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1734 { SNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1735 { SNaN, PNormalValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1736 { SNaN, MNormalValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1737 { SNaN, PLargestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1738 { SNaN, MLargestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1739 { SNaN, PSmallestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1740 { SNaN, MSmallestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1741 { SNaN, PSmallestNormalized, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1742 { SNaN, MSmallestNormalized, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1744 { PNormalValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1745 { PNormalValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1746 { PNormalValue, PZero, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
1747 { PNormalValue, MZero, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
1748 { PNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1751 { PNormalValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1753 { PNormalValue, PNormalValue, "0x1p+1", APFloat::opOK, APFloat::fcNormal },
1754 { PNormalValue, MNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1755 { PNormalValue, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1756 { PNormalValue, MLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1757 { PNormalValue, PSmallestValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1758 { PNormalValue, MSmallestValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1759 { PNormalValue, PSmallestNormalized, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1760 { PNormalValue, MSmallestNormalized, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1761 { MNormalValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1762 { MNormalValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1763 { MNormalValue, PZero, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
1764 { MNormalValue, MZero, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
1765 { MNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1768 { MNormalValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1770 { MNormalValue, PNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1771 { MNormalValue, MNormalValue, "-0x1p+1", APFloat::opOK, APFloat::fcNormal },
1772 { MNormalValue, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1773 { MNormalValue, MLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1774 { MNormalValue, PSmallestValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1775 { MNormalValue, MSmallestValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1776 { MNormalValue, PSmallestNormalized, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1777 { MNormalValue, MSmallestNormalized, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1778 { PLargestValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1779 { PLargestValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1780 { PLargestValue, PZero, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
1781 { PLargestValue, MZero, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
1782 { PLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1785 { PLargestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1787 { PLargestValue, PNormalValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1788 { PLargestValue, MNormalValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1789 { PLargestValue, PLargestValue, "inf", OverflowStatus, APFloat::fcInfinity },
1790 { PLargestValue, MLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1791 { PLargestValue, PSmallestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1792 { PLargestValue, MSmallestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1793 { PLargestValue, PSmallestNormalized, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1794 { PLargestValue, MSmallestNormalized, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1795 { MLargestValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1796 { MLargestValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1797 { MLargestValue, PZero, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
1798 { MLargestValue, MZero, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
1799 { MLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1802 { MLargestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1804 { MLargestValue, PNormalValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1805 { MLargestValue, MNormalValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1806 { MLargestValue, PLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1807 { MLargestValue, MLargestValue, "-inf", OverflowStatus, APFloat::fcInfinity },
1808 { MLargestValue, PSmallestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1809 { MLargestValue, MSmallestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1810 { MLargestValue, PSmallestNormalized, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1811 { MLargestValue, MSmallestNormalized, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1812 { PSmallestValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1813 { PSmallestValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1814 { PSmallestValue, PZero, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
1815 { PSmallestValue, MZero, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
1816 { PSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1819 { PSmallestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1821 { PSmallestValue, PNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1822 { PSmallestValue, MNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1823 { PSmallestValue, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1824 { PSmallestValue, MLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1825 { PSmallestValue, PSmallestValue, "0x1p-148", APFloat::opOK, APFloat::fcNormal },
1826 { PSmallestValue, MSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1827 { PSmallestValue, PSmallestNormalized, "0x1.000002p-126", APFloat::opOK, APFloat::fcNormal },
1828 { PSmallestValue, MSmallestNormalized, "-0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal },
1829 { MSmallestValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1830 { MSmallestValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1831 { MSmallestValue, PZero, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
1832 { MSmallestValue, MZero, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
1833 { MSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1836 { MSmallestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1838 { MSmallestValue, PNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1839 { MSmallestValue, MNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1840 { MSmallestValue, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1841 { MSmallestValue, MLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1842 { MSmallestValue, PSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1843 { MSmallestValue, MSmallestValue, "-0x1p-148", APFloat::opOK, APFloat::fcNormal },
1844 { MSmallestValue, PSmallestNormalized, "0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal },
1845 { MSmallestValue, MSmallestNormalized, "-0x1.000002p-126", APFloat::opOK, APFloat::fcNormal },
1846 { PSmallestNormalized, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1847 { PSmallestNormalized, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1848 { PSmallestNormalized, PZero, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
1849 { PSmallestNormalized, MZero, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
1850 { PSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1853 { PSmallestNormalized, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1855 { PSmallestNormalized, PNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1856 { PSmallestNormalized, MNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1857 { PSmallestNormalized, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1858 { PSmallestNormalized, MLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1859 { PSmallestNormalized, PSmallestValue, "0x1.000002p-126", APFloat::opOK, APFloat::fcNormal },
1860 { PSmallestNormalized, MSmallestValue, "0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal },
1861 { PSmallestNormalized, PSmallestNormalized, "0x1p-125", APFloat::opOK, APFloat::fcNormal },
1862 { PSmallestNormalized, MSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1863 { MSmallestNormalized, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1864 { MSmallestNormalized, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1865 { MSmallestNormalized, PZero, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
1866 { MSmallestNormalized, MZero, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
1867 { MSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1870 { MSmallestNormalized, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1872 { MSmallestNormalized, PNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1873 { MSmallestNormalized, MNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1874 { MSmallestNormalized, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1875 { MSmallestNormalized, MLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1876 { MSmallestNormalized, PSmallestValue, "-0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal },
1877 { MSmallestNormalized, MSmallestValue, "-0x1.000002p-126", APFloat::opOK, APFloat::fcNormal },
1878 { MSmallestNormalized, PSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1879 { MSmallestNormalized, MSmallestNormalized, "-0x1p-125", APFloat::opOK, APFloat::fcNormal }
1882 for (size_t i = 0; i < NumTests; ++i) {
1883 APFloat x(SpecialCaseTests[i].x);
1884 APFloat y(SpecialCaseTests[i].y);
1885 APFloat::opStatus status = x.add(y, APFloat::rmNearestTiesToEven);
1887 APFloat result(APFloat::IEEEsingle, SpecialCaseTests[i].result);
1889 EXPECT_TRUE(result.bitwiseIsEqual(x));
1890 EXPECT_TRUE((int)status == SpecialCaseTests[i].status);
1891 EXPECT_TRUE((int)x.getCategory() == SpecialCaseTests[i].category);
1895 TEST(APFloatTest, subtract) {
1896 // Test Special Cases against each other and normal values.
1899 // 1. Since we perform only default exception handling all operations with
1900 // signaling NaNs should have a result that is a quiet NaN. Currently they
1903 APFloat PInf = APFloat::getInf(APFloat::IEEEsingle, false);
1904 APFloat MInf = APFloat::getInf(APFloat::IEEEsingle, true);
1905 APFloat PZero = APFloat::getZero(APFloat::IEEEsingle, false);
1906 APFloat MZero = APFloat::getZero(APFloat::IEEEsingle, true);
1907 APFloat QNaN = APFloat::getNaN(APFloat::IEEEsingle, false);
1908 APFloat SNaN = APFloat::getSNaN(APFloat::IEEEsingle, false);
1909 APFloat PNormalValue = APFloat(APFloat::IEEEsingle, "0x1p+0");
1910 APFloat MNormalValue = APFloat(APFloat::IEEEsingle, "-0x1p+0");
1911 APFloat PLargestValue = APFloat::getLargest(APFloat::IEEEsingle, false);
1912 APFloat MLargestValue = APFloat::getLargest(APFloat::IEEEsingle, true);
1913 APFloat PSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle, false);
1914 APFloat MSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle, true);
1915 APFloat PSmallestNormalized =
1916 APFloat::getSmallestNormalized(APFloat::IEEEsingle, false);
1917 APFloat MSmallestNormalized =
1918 APFloat::getSmallestNormalized(APFloat::IEEEsingle, true);
1920 const int OverflowStatus = APFloat::opOverflow | APFloat::opInexact;
1922 const unsigned NumTests = 169;
1929 } SpecialCaseTests[NumTests] = {
1930 { PInf, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1931 { PInf, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1932 { PInf, PZero, "inf", APFloat::opOK, APFloat::fcInfinity },
1933 { PInf, MZero, "inf", APFloat::opOK, APFloat::fcInfinity },
1934 { PInf, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
1937 { PInf, SNaN, "-nan", APFloat::opInvalidOp, APFloat::fcNaN },
1939 { PInf, PNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
1940 { PInf, MNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
1941 { PInf, PLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
1942 { PInf, MLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
1943 { PInf, PSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
1944 { PInf, MSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
1945 { PInf, PSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity },
1946 { PInf, MSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity },
1947 { MInf, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1948 { MInf, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1949 { MInf, PZero, "-inf", APFloat::opOK, APFloat::fcInfinity },
1950 { MInf, MZero, "-inf", APFloat::opOK, APFloat::fcInfinity },
1951 { MInf, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
1954 { MInf, SNaN, "-nan", APFloat::opInvalidOp, APFloat::fcNaN },
1956 { MInf, PNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
1957 { MInf, MNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
1958 { MInf, PLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
1959 { MInf, MLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
1960 { MInf, PSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
1961 { MInf, MSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
1962 { MInf, PSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity },
1963 { MInf, MSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity },
1964 { PZero, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1965 { PZero, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1966 { PZero, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1967 { PZero, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1968 { PZero, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
1971 { PZero, SNaN, "-nan", APFloat::opInvalidOp, APFloat::fcNaN },
1973 { PZero, PNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
1974 { PZero, MNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
1975 { PZero, PLargestValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
1976 { PZero, MLargestValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
1977 { PZero, PSmallestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
1978 { PZero, MSmallestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
1979 { PZero, PSmallestNormalized, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
1980 { PZero, MSmallestNormalized, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
1981 { MZero, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1982 { MZero, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1983 { MZero, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
1984 { MZero, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1985 { MZero, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
1988 { MZero, SNaN, "-nan", APFloat::opInvalidOp, APFloat::fcNaN },
1990 { MZero, PNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
1991 { MZero, MNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
1992 { MZero, PLargestValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
1993 { MZero, MLargestValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
1994 { MZero, PSmallestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
1995 { MZero, MSmallestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
1996 { MZero, PSmallestNormalized, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
1997 { MZero, MSmallestNormalized, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
1998 { QNaN, PInf, "nan", APFloat::opOK, APFloat::fcNaN },
1999 { QNaN, MInf, "nan", APFloat::opOK, APFloat::fcNaN },
2000 { QNaN, PZero, "nan", APFloat::opOK, APFloat::fcNaN },
2001 { QNaN, MZero, "nan", APFloat::opOK, APFloat::fcNaN },
2002 { QNaN, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2005 { QNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2007 { QNaN, PNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
2008 { QNaN, MNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
2009 { QNaN, PLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2010 { QNaN, MLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2011 { QNaN, PSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2012 { QNaN, MSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2013 { QNaN, PSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
2014 { QNaN, MSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
2017 { SNaN, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2018 { SNaN, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2019 { SNaN, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2020 { SNaN, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2021 { SNaN, QNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2022 { SNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2023 { SNaN, PNormalValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2024 { SNaN, MNormalValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2025 { SNaN, PLargestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2026 { SNaN, MLargestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2027 { SNaN, PSmallestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2028 { SNaN, MSmallestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2029 { SNaN, PSmallestNormalized, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2030 { SNaN, MSmallestNormalized, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2032 { PNormalValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2033 { PNormalValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2034 { PNormalValue, PZero, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2035 { PNormalValue, MZero, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2036 { PNormalValue, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
2039 { PNormalValue, SNaN, "-nan", APFloat::opInvalidOp, APFloat::fcNaN },
2041 { PNormalValue, PNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2042 { PNormalValue, MNormalValue, "0x1p+1", APFloat::opOK, APFloat::fcNormal },
2043 { PNormalValue, PLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2044 { PNormalValue, MLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2045 { PNormalValue, PSmallestValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2046 { PNormalValue, MSmallestValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2047 { PNormalValue, PSmallestNormalized, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2048 { PNormalValue, MSmallestNormalized, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2049 { MNormalValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2050 { MNormalValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2051 { MNormalValue, PZero, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2052 { MNormalValue, MZero, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2053 { MNormalValue, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
2056 { MNormalValue, SNaN, "-nan", APFloat::opInvalidOp, APFloat::fcNaN },
2058 { MNormalValue, PNormalValue, "-0x1p+1", APFloat::opOK, APFloat::fcNormal },
2059 { MNormalValue, MNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2060 { MNormalValue, PLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2061 { MNormalValue, MLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2062 { MNormalValue, PSmallestValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2063 { MNormalValue, MSmallestValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2064 { MNormalValue, PSmallestNormalized, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2065 { MNormalValue, MSmallestNormalized, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2066 { PLargestValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2067 { PLargestValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2068 { PLargestValue, PZero, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2069 { PLargestValue, MZero, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2070 { PLargestValue, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
2073 { PLargestValue, SNaN, "-nan", APFloat::opInvalidOp, APFloat::fcNaN },
2075 { PLargestValue, PNormalValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2076 { PLargestValue, MNormalValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2077 { PLargestValue, PLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2078 { PLargestValue, MLargestValue, "inf", OverflowStatus, APFloat::fcInfinity },
2079 { PLargestValue, PSmallestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2080 { PLargestValue, MSmallestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2081 { PLargestValue, PSmallestNormalized, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2082 { PLargestValue, MSmallestNormalized, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2083 { MLargestValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2084 { MLargestValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2085 { MLargestValue, PZero, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2086 { MLargestValue, MZero, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2087 { MLargestValue, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
2090 { MLargestValue, SNaN, "-nan", APFloat::opInvalidOp, APFloat::fcNaN },
2092 { MLargestValue, PNormalValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2093 { MLargestValue, MNormalValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2094 { MLargestValue, PLargestValue, "-inf", OverflowStatus, APFloat::fcInfinity },
2095 { MLargestValue, MLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2096 { MLargestValue, PSmallestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2097 { MLargestValue, MSmallestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2098 { MLargestValue, PSmallestNormalized, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2099 { MLargestValue, MSmallestNormalized, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2100 { PSmallestValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2101 { PSmallestValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2102 { PSmallestValue, PZero, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2103 { PSmallestValue, MZero, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2104 { PSmallestValue, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
2107 { PSmallestValue, SNaN, "-nan", APFloat::opInvalidOp, APFloat::fcNaN },
2109 { PSmallestValue, PNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2110 { PSmallestValue, MNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2111 { PSmallestValue, PLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2112 { PSmallestValue, MLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2113 { PSmallestValue, PSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2114 { PSmallestValue, MSmallestValue, "0x1p-148", APFloat::opOK, APFloat::fcNormal },
2115 { PSmallestValue, PSmallestNormalized, "-0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal },
2116 { PSmallestValue, MSmallestNormalized, "0x1.000002p-126", APFloat::opOK, APFloat::fcNormal },
2117 { MSmallestValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2118 { MSmallestValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2119 { MSmallestValue, PZero, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2120 { MSmallestValue, MZero, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2121 { MSmallestValue, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
2124 { MSmallestValue, SNaN, "-nan", APFloat::opInvalidOp, APFloat::fcNaN },
2126 { MSmallestValue, PNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2127 { MSmallestValue, MNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2128 { MSmallestValue, PLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2129 { MSmallestValue, MLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2130 { MSmallestValue, PSmallestValue, "-0x1p-148", APFloat::opOK, APFloat::fcNormal },
2131 { MSmallestValue, MSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2132 { MSmallestValue, PSmallestNormalized, "-0x1.000002p-126", APFloat::opOK, APFloat::fcNormal },
2133 { MSmallestValue, MSmallestNormalized, "0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal },
2134 { PSmallestNormalized, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2135 { PSmallestNormalized, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2136 { PSmallestNormalized, PZero, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2137 { PSmallestNormalized, MZero, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2138 { PSmallestNormalized, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
2141 { PSmallestNormalized, SNaN, "-nan", APFloat::opInvalidOp, APFloat::fcNaN },
2143 { PSmallestNormalized, PNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2144 { PSmallestNormalized, MNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2145 { PSmallestNormalized, PLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2146 { PSmallestNormalized, MLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2147 { PSmallestNormalized, PSmallestValue, "0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal },
2148 { PSmallestNormalized, MSmallestValue, "0x1.000002p-126", APFloat::opOK, APFloat::fcNormal },
2149 { PSmallestNormalized, PSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2150 { PSmallestNormalized, MSmallestNormalized, "0x1p-125", APFloat::opOK, APFloat::fcNormal },
2151 { MSmallestNormalized, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2152 { MSmallestNormalized, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2153 { MSmallestNormalized, PZero, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2154 { MSmallestNormalized, MZero, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2155 { MSmallestNormalized, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
2158 { MSmallestNormalized, SNaN, "-nan", APFloat::opInvalidOp, APFloat::fcNaN },
2160 { MSmallestNormalized, PNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2161 { MSmallestNormalized, MNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2162 { MSmallestNormalized, PLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2163 { MSmallestNormalized, MLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2164 { MSmallestNormalized, PSmallestValue, "-0x1.000002p-126", APFloat::opOK, APFloat::fcNormal },
2165 { MSmallestNormalized, MSmallestValue, "-0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal },
2166 { MSmallestNormalized, PSmallestNormalized, "-0x1p-125", APFloat::opOK, APFloat::fcNormal },
2167 { MSmallestNormalized, MSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero }
2170 for (size_t i = 0; i < NumTests; ++i) {
2171 APFloat x(SpecialCaseTests[i].x);
2172 APFloat y(SpecialCaseTests[i].y);
2173 APFloat::opStatus status = x.subtract(y, APFloat::rmNearestTiesToEven);
2175 APFloat result(APFloat::IEEEsingle, SpecialCaseTests[i].result);
2177 EXPECT_TRUE(result.bitwiseIsEqual(x));
2178 EXPECT_TRUE((int)status == SpecialCaseTests[i].status);
2179 EXPECT_TRUE((int)x.getCategory() == SpecialCaseTests[i].category);
2183 TEST(APFloatTest, multiply) {
2184 // Test Special Cases against each other and normal values.
2187 // 1. Since we perform only default exception handling all operations with
2188 // signaling NaNs should have a result that is a quiet NaN. Currently they
2191 APFloat PInf = APFloat::getInf(APFloat::IEEEsingle, false);
2192 APFloat MInf = APFloat::getInf(APFloat::IEEEsingle, true);
2193 APFloat PZero = APFloat::getZero(APFloat::IEEEsingle, false);
2194 APFloat MZero = APFloat::getZero(APFloat::IEEEsingle, true);
2195 APFloat QNaN = APFloat::getNaN(APFloat::IEEEsingle, false);
2196 APFloat SNaN = APFloat::getSNaN(APFloat::IEEEsingle, false);
2197 APFloat PNormalValue = APFloat(APFloat::IEEEsingle, "0x1p+0");
2198 APFloat MNormalValue = APFloat(APFloat::IEEEsingle, "-0x1p+0");
2199 APFloat PLargestValue = APFloat::getLargest(APFloat::IEEEsingle, false);
2200 APFloat MLargestValue = APFloat::getLargest(APFloat::IEEEsingle, true);
2201 APFloat PSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle, false);
2202 APFloat MSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle, true);
2203 APFloat PSmallestNormalized =
2204 APFloat::getSmallestNormalized(APFloat::IEEEsingle, false);
2205 APFloat MSmallestNormalized =
2206 APFloat::getSmallestNormalized(APFloat::IEEEsingle, true);
2208 const int OverflowStatus = APFloat::opOverflow | APFloat::opInexact;
2209 const int UnderflowStatus = APFloat::opUnderflow | APFloat::opInexact;
2211 const unsigned NumTests = 169;
2218 } SpecialCaseTests[NumTests] = {
2219 { PInf, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2220 { PInf, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2221 { PInf, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2222 { PInf, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2223 { PInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2226 { PInf, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2228 { PInf, PNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2229 { PInf, MNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2230 { PInf, PLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2231 { PInf, MLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2232 { PInf, PSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2233 { PInf, MSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2234 { PInf, PSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity },
2235 { PInf, MSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity },
2236 { MInf, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2237 { MInf, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2238 { MInf, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2239 { MInf, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2240 { MInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2243 { MInf, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2245 { MInf, PNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2246 { MInf, MNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2247 { MInf, PLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2248 { MInf, MLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2249 { MInf, PSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2250 { MInf, MSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2251 { MInf, PSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity },
2252 { MInf, MSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity },
2253 { PZero, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2254 { PZero, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2255 { PZero, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2256 { PZero, MZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2257 { PZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2260 { PZero, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2262 { PZero, PNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2263 { PZero, MNormalValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2264 { PZero, PLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2265 { PZero, MLargestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2266 { PZero, PSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2267 { PZero, MSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2268 { PZero, PSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2269 { PZero, MSmallestNormalized, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2270 { MZero, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2271 { MZero, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2272 { MZero, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2273 { MZero, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2274 { MZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2277 { MZero, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2279 { MZero, PNormalValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2280 { MZero, MNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2281 { MZero, PLargestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2282 { MZero, MLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2283 { MZero, PSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2284 { MZero, MSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2285 { MZero, PSmallestNormalized, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2286 { MZero, MSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2287 { QNaN, PInf, "nan", APFloat::opOK, APFloat::fcNaN },
2288 { QNaN, MInf, "nan", APFloat::opOK, APFloat::fcNaN },
2289 { QNaN, PZero, "nan", APFloat::opOK, APFloat::fcNaN },
2290 { QNaN, MZero, "nan", APFloat::opOK, APFloat::fcNaN },
2291 { QNaN, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2294 { QNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2296 { QNaN, PNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
2297 { QNaN, MNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
2298 { QNaN, PLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2299 { QNaN, MLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2300 { QNaN, PSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2301 { QNaN, MSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2302 { QNaN, PSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
2303 { QNaN, MSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
2306 { SNaN, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2307 { SNaN, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2308 { SNaN, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2309 { SNaN, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2310 { SNaN, QNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2311 { SNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2312 { SNaN, PNormalValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2313 { SNaN, MNormalValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2314 { SNaN, PLargestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2315 { SNaN, MLargestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2316 { SNaN, PSmallestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2317 { SNaN, MSmallestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2318 { SNaN, PSmallestNormalized, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2319 { SNaN, MSmallestNormalized, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2321 { PNormalValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2322 { PNormalValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2323 { PNormalValue, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2324 { PNormalValue, MZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2325 { PNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2328 { PNormalValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2330 { PNormalValue, PNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2331 { PNormalValue, MNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2332 { PNormalValue, PLargestValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2333 { PNormalValue, MLargestValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2334 { PNormalValue, PSmallestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2335 { PNormalValue, MSmallestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2336 { PNormalValue, PSmallestNormalized, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2337 { PNormalValue, MSmallestNormalized, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2338 { MNormalValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2339 { MNormalValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2340 { MNormalValue, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2341 { MNormalValue, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2342 { MNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2345 { MNormalValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2347 { MNormalValue, PNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2348 { MNormalValue, MNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2349 { MNormalValue, PLargestValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2350 { MNormalValue, MLargestValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2351 { MNormalValue, PSmallestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2352 { MNormalValue, MSmallestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2353 { MNormalValue, PSmallestNormalized, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2354 { MNormalValue, MSmallestNormalized, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2355 { PLargestValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2356 { PLargestValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2357 { PLargestValue, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2358 { PLargestValue, MZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2359 { PLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2362 { PLargestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2364 { PLargestValue, PNormalValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2365 { PLargestValue, MNormalValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2366 { PLargestValue, PLargestValue, "inf", OverflowStatus, APFloat::fcInfinity },
2367 { PLargestValue, MLargestValue, "-inf", OverflowStatus, APFloat::fcInfinity },
2368 { PLargestValue, PSmallestValue, "0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal },
2369 { PLargestValue, MSmallestValue, "-0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal },
2370 { PLargestValue, PSmallestNormalized, "0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal },
2371 { PLargestValue, MSmallestNormalized, "-0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal },
2372 { MLargestValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2373 { MLargestValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2374 { MLargestValue, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2375 { MLargestValue, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2376 { MLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2379 { MLargestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2381 { MLargestValue, PNormalValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2382 { MLargestValue, MNormalValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2383 { MLargestValue, PLargestValue, "-inf", OverflowStatus, APFloat::fcInfinity },
2384 { MLargestValue, MLargestValue, "inf", OverflowStatus, APFloat::fcInfinity },
2385 { MLargestValue, PSmallestValue, "-0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal },
2386 { MLargestValue, MSmallestValue, "0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal },
2387 { MLargestValue, PSmallestNormalized, "-0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal },
2388 { MLargestValue, MSmallestNormalized, "0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal },
2389 { PSmallestValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2390 { PSmallestValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2391 { PSmallestValue, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2392 { PSmallestValue, MZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2393 { PSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2396 { PSmallestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2398 { PSmallestValue, PNormalValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2399 { PSmallestValue, MNormalValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2400 { PSmallestValue, PLargestValue, "0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal },
2401 { PSmallestValue, MLargestValue, "-0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal },
2402 { PSmallestValue, PSmallestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero },
2403 { PSmallestValue, MSmallestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2404 { PSmallestValue, PSmallestNormalized, "0x0p+0", UnderflowStatus, APFloat::fcZero },
2405 { PSmallestValue, MSmallestNormalized, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2406 { MSmallestValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2407 { MSmallestValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2408 { MSmallestValue, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2409 { MSmallestValue, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2410 { MSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2413 { MSmallestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2415 { MSmallestValue, PNormalValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2416 { MSmallestValue, MNormalValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2417 { MSmallestValue, PLargestValue, "-0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal },
2418 { MSmallestValue, MLargestValue, "0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal },
2419 { MSmallestValue, PSmallestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2420 { MSmallestValue, MSmallestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero },
2421 { MSmallestValue, PSmallestNormalized, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2422 { MSmallestValue, MSmallestNormalized, "0x0p+0", UnderflowStatus, APFloat::fcZero },
2423 { PSmallestNormalized, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2424 { PSmallestNormalized, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2425 { PSmallestNormalized, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2426 { PSmallestNormalized, MZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2427 { PSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2430 { PSmallestNormalized, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2432 { PSmallestNormalized, PNormalValue, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2433 { PSmallestNormalized, MNormalValue, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2434 { PSmallestNormalized, PLargestValue, "0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal },
2435 { PSmallestNormalized, MLargestValue, "-0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal },
2436 { PSmallestNormalized, PSmallestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero },
2437 { PSmallestNormalized, MSmallestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2438 { PSmallestNormalized, PSmallestNormalized, "0x0p+0", UnderflowStatus, APFloat::fcZero },
2439 { PSmallestNormalized, MSmallestNormalized, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2440 { MSmallestNormalized, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2441 { MSmallestNormalized, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2442 { MSmallestNormalized, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2443 { MSmallestNormalized, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2444 { MSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2447 { MSmallestNormalized, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2449 { MSmallestNormalized, PNormalValue, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2450 { MSmallestNormalized, MNormalValue, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2451 { MSmallestNormalized, PLargestValue, "-0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal },
2452 { MSmallestNormalized, MLargestValue, "0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal },
2453 { MSmallestNormalized, PSmallestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2454 { MSmallestNormalized, MSmallestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero },
2455 { MSmallestNormalized, PSmallestNormalized, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2456 { MSmallestNormalized, MSmallestNormalized, "0x0p+0", UnderflowStatus, APFloat::fcZero }
2459 for (size_t i = 0; i < NumTests; ++i) {
2460 APFloat x(SpecialCaseTests[i].x);
2461 APFloat y(SpecialCaseTests[i].y);
2462 APFloat::opStatus status = x.multiply(y, APFloat::rmNearestTiesToEven);
2464 APFloat result(APFloat::IEEEsingle, SpecialCaseTests[i].result);
2466 EXPECT_TRUE(result.bitwiseIsEqual(x));
2467 EXPECT_TRUE((int)status == SpecialCaseTests[i].status);
2468 EXPECT_TRUE((int)x.getCategory() == SpecialCaseTests[i].category);
2472 TEST(APFloatTest, divide) {
2473 // Test Special Cases against each other and normal values.
2476 // 1. Since we perform only default exception handling all operations with
2477 // signaling NaNs should have a result that is a quiet NaN. Currently they
2480 APFloat PInf = APFloat::getInf(APFloat::IEEEsingle, false);
2481 APFloat MInf = APFloat::getInf(APFloat::IEEEsingle, true);
2482 APFloat PZero = APFloat::getZero(APFloat::IEEEsingle, false);
2483 APFloat MZero = APFloat::getZero(APFloat::IEEEsingle, true);
2484 APFloat QNaN = APFloat::getNaN(APFloat::IEEEsingle, false);
2485 APFloat SNaN = APFloat::getSNaN(APFloat::IEEEsingle, false);
2486 APFloat PNormalValue = APFloat(APFloat::IEEEsingle, "0x1p+0");
2487 APFloat MNormalValue = APFloat(APFloat::IEEEsingle, "-0x1p+0");
2488 APFloat PLargestValue = APFloat::getLargest(APFloat::IEEEsingle, false);
2489 APFloat MLargestValue = APFloat::getLargest(APFloat::IEEEsingle, true);
2490 APFloat PSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle, false);
2491 APFloat MSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle, true);
2492 APFloat PSmallestNormalized =
2493 APFloat::getSmallestNormalized(APFloat::IEEEsingle, false);
2494 APFloat MSmallestNormalized =
2495 APFloat::getSmallestNormalized(APFloat::IEEEsingle, true);
2497 const int OverflowStatus = APFloat::opOverflow | APFloat::opInexact;
2498 const int UnderflowStatus = APFloat::opUnderflow | APFloat::opInexact;
2500 const unsigned NumTests = 169;
2507 } SpecialCaseTests[NumTests] = {
2508 { PInf, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2509 { PInf, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2510 { PInf, PZero, "inf", APFloat::opOK, APFloat::fcInfinity },
2511 { PInf, MZero, "-inf", APFloat::opOK, APFloat::fcInfinity },
2512 { PInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2515 { PInf, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2517 { PInf, PNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2518 { PInf, MNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2519 { PInf, PLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2520 { PInf, MLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2521 { PInf, PSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2522 { PInf, MSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2523 { PInf, PSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity },
2524 { PInf, MSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity },
2525 { MInf, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2526 { MInf, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2527 { MInf, PZero, "-inf", APFloat::opOK, APFloat::fcInfinity },
2528 { MInf, MZero, "inf", APFloat::opOK, APFloat::fcInfinity },
2529 { MInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2532 { MInf, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2534 { MInf, PNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2535 { MInf, MNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2536 { MInf, PLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2537 { MInf, MLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2538 { MInf, PSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2539 { MInf, MSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2540 { MInf, PSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity },
2541 { MInf, MSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity },
2542 { PZero, PInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2543 { PZero, MInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2544 { PZero, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2545 { PZero, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2546 { PZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2549 { PZero, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2551 { PZero, PNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2552 { PZero, MNormalValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2553 { PZero, PLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2554 { PZero, MLargestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2555 { PZero, PSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2556 { PZero, MSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2557 { PZero, PSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2558 { PZero, MSmallestNormalized, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2559 { MZero, PInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2560 { MZero, MInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2561 { MZero, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2562 { MZero, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2563 { MZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2566 { MZero, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2568 { MZero, PNormalValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2569 { MZero, MNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2570 { MZero, PLargestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2571 { MZero, MLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2572 { MZero, PSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2573 { MZero, MSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2574 { MZero, PSmallestNormalized, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2575 { MZero, MSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2576 { QNaN, PInf, "nan", APFloat::opOK, APFloat::fcNaN },
2577 { QNaN, MInf, "nan", APFloat::opOK, APFloat::fcNaN },
2578 { QNaN, PZero, "nan", APFloat::opOK, APFloat::fcNaN },
2579 { QNaN, MZero, "nan", APFloat::opOK, APFloat::fcNaN },
2580 { QNaN, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2583 { QNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2585 { QNaN, PNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
2586 { QNaN, MNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
2587 { QNaN, PLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2588 { QNaN, MLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2589 { QNaN, PSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2590 { QNaN, MSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2591 { QNaN, PSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
2592 { QNaN, MSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
2595 { SNaN, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2596 { SNaN, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2597 { SNaN, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2598 { SNaN, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2599 { SNaN, QNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2600 { SNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2601 { SNaN, PNormalValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2602 { SNaN, MNormalValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2603 { SNaN, PLargestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2604 { SNaN, MLargestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2605 { SNaN, PSmallestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2606 { SNaN, MSmallestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2607 { SNaN, PSmallestNormalized, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2608 { SNaN, MSmallestNormalized, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2610 { PNormalValue, PInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2611 { PNormalValue, MInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2612 { PNormalValue, PZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
2613 { PNormalValue, MZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
2614 { PNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2617 { PNormalValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2619 { PNormalValue, PNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2620 { PNormalValue, MNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2621 { PNormalValue, PLargestValue, "0x1p-128", UnderflowStatus, APFloat::fcNormal },
2622 { PNormalValue, MLargestValue, "-0x1p-128", UnderflowStatus, APFloat::fcNormal },
2623 { PNormalValue, PSmallestValue, "inf", OverflowStatus, APFloat::fcInfinity },
2624 { PNormalValue, MSmallestValue, "-inf", OverflowStatus, APFloat::fcInfinity },
2625 { PNormalValue, PSmallestNormalized, "0x1p+126", APFloat::opOK, APFloat::fcNormal },
2626 { PNormalValue, MSmallestNormalized, "-0x1p+126", APFloat::opOK, APFloat::fcNormal },
2627 { MNormalValue, PInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2628 { MNormalValue, MInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2629 { MNormalValue, PZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
2630 { MNormalValue, MZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
2631 { MNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2634 { MNormalValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2636 { MNormalValue, PNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2637 { MNormalValue, MNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2638 { MNormalValue, PLargestValue, "-0x1p-128", UnderflowStatus, APFloat::fcNormal },
2639 { MNormalValue, MLargestValue, "0x1p-128", UnderflowStatus, APFloat::fcNormal },
2640 { MNormalValue, PSmallestValue, "-inf", OverflowStatus, APFloat::fcInfinity },
2641 { MNormalValue, MSmallestValue, "inf", OverflowStatus, APFloat::fcInfinity },
2642 { MNormalValue, PSmallestNormalized, "-0x1p+126", APFloat::opOK, APFloat::fcNormal },
2643 { MNormalValue, MSmallestNormalized, "0x1p+126", APFloat::opOK, APFloat::fcNormal },
2644 { PLargestValue, PInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2645 { PLargestValue, MInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2646 { PLargestValue, PZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
2647 { PLargestValue, MZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
2648 { PLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2651 { PLargestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2653 { PLargestValue, PNormalValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2654 { PLargestValue, MNormalValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2655 { PLargestValue, PLargestValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2656 { PLargestValue, MLargestValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2657 { PLargestValue, PSmallestValue, "inf", OverflowStatus, APFloat::fcInfinity },
2658 { PLargestValue, MSmallestValue, "-inf", OverflowStatus, APFloat::fcInfinity },
2659 { PLargestValue, PSmallestNormalized, "inf", OverflowStatus, APFloat::fcInfinity },
2660 { PLargestValue, MSmallestNormalized, "-inf", OverflowStatus, APFloat::fcInfinity },
2661 { MLargestValue, PInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2662 { MLargestValue, MInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2663 { MLargestValue, PZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
2664 { MLargestValue, MZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
2665 { MLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2668 { MLargestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2670 { MLargestValue, PNormalValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2671 { MLargestValue, MNormalValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2672 { MLargestValue, PLargestValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2673 { MLargestValue, MLargestValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2674 { MLargestValue, PSmallestValue, "-inf", OverflowStatus, APFloat::fcInfinity },
2675 { MLargestValue, MSmallestValue, "inf", OverflowStatus, APFloat::fcInfinity },
2676 { MLargestValue, PSmallestNormalized, "-inf", OverflowStatus, APFloat::fcInfinity },
2677 { MLargestValue, MSmallestNormalized, "inf", OverflowStatus, APFloat::fcInfinity },
2678 { PSmallestValue, PInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2679 { PSmallestValue, MInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2680 { PSmallestValue, PZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
2681 { PSmallestValue, MZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
2682 { PSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2685 { PSmallestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2687 { PSmallestValue, PNormalValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2688 { PSmallestValue, MNormalValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2689 { PSmallestValue, PLargestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero },
2690 { PSmallestValue, MLargestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2691 { PSmallestValue, PSmallestValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2692 { PSmallestValue, MSmallestValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2693 { PSmallestValue, PSmallestNormalized, "0x1p-23", APFloat::opOK, APFloat::fcNormal },
2694 { PSmallestValue, MSmallestNormalized, "-0x1p-23", APFloat::opOK, APFloat::fcNormal },
2695 { MSmallestValue, PInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2696 { MSmallestValue, MInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2697 { MSmallestValue, PZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
2698 { MSmallestValue, MZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
2699 { MSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2702 { MSmallestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2704 { MSmallestValue, PNormalValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2705 { MSmallestValue, MNormalValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2706 { MSmallestValue, PLargestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2707 { MSmallestValue, MLargestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero },
2708 { MSmallestValue, PSmallestValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2709 { MSmallestValue, MSmallestValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2710 { MSmallestValue, PSmallestNormalized, "-0x1p-23", APFloat::opOK, APFloat::fcNormal },
2711 { MSmallestValue, MSmallestNormalized, "0x1p-23", APFloat::opOK, APFloat::fcNormal },
2712 { PSmallestNormalized, PInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2713 { PSmallestNormalized, MInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2714 { PSmallestNormalized, PZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
2715 { PSmallestNormalized, MZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
2716 { PSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2719 { PSmallestNormalized, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2721 { PSmallestNormalized, PNormalValue, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2722 { PSmallestNormalized, MNormalValue, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2723 { PSmallestNormalized, PLargestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero },
2724 { PSmallestNormalized, MLargestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2725 { PSmallestNormalized, PSmallestValue, "0x1p+23", APFloat::opOK, APFloat::fcNormal },
2726 { PSmallestNormalized, MSmallestValue, "-0x1p+23", APFloat::opOK, APFloat::fcNormal },
2727 { PSmallestNormalized, PSmallestNormalized, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2728 { PSmallestNormalized, MSmallestNormalized, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2729 { MSmallestNormalized, PInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2730 { MSmallestNormalized, MInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2731 { MSmallestNormalized, PZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
2732 { MSmallestNormalized, MZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
2733 { MSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2736 { MSmallestNormalized, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2738 { MSmallestNormalized, PNormalValue, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2739 { MSmallestNormalized, MNormalValue, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2740 { MSmallestNormalized, PLargestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2741 { MSmallestNormalized, MLargestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero },
2742 { MSmallestNormalized, PSmallestValue, "-0x1p+23", APFloat::opOK, APFloat::fcNormal },
2743 { MSmallestNormalized, MSmallestValue, "0x1p+23", APFloat::opOK, APFloat::fcNormal },
2744 { MSmallestNormalized, PSmallestNormalized, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2745 { MSmallestNormalized, MSmallestNormalized, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2748 for (size_t i = 0; i < NumTests; ++i) {
2749 APFloat x(SpecialCaseTests[i].x);
2750 APFloat y(SpecialCaseTests[i].y);
2751 APFloat::opStatus status = x.divide(y, APFloat::rmNearestTiesToEven);
2753 APFloat result(APFloat::IEEEsingle, SpecialCaseTests[i].result);
2755 EXPECT_TRUE(result.bitwiseIsEqual(x));
2756 EXPECT_TRUE((int)status == SpecialCaseTests[i].status);
2757 EXPECT_TRUE((int)x.getCategory() == SpecialCaseTests[i].category);
2761 TEST(APFloatTest, operatorOverloads) {
2762 // This is mostly testing that these operator overloads compile.
2763 APFloat One = APFloat(APFloat::IEEEsingle, "0x1p+0");
2764 APFloat Two = APFloat(APFloat::IEEEsingle, "0x2p+0");
2765 EXPECT_TRUE(Two.bitwiseIsEqual(One + One));
2766 EXPECT_TRUE(One.bitwiseIsEqual(Two - One));
2767 EXPECT_TRUE(Two.bitwiseIsEqual(One * Two));
2768 EXPECT_TRUE(One.bitwiseIsEqual(Two / Two));
2771 TEST(APFloatTest, abs) {
2772 APFloat PInf = APFloat::getInf(APFloat::IEEEsingle, false);
2773 APFloat MInf = APFloat::getInf(APFloat::IEEEsingle, true);
2774 APFloat PZero = APFloat::getZero(APFloat::IEEEsingle, false);
2775 APFloat MZero = APFloat::getZero(APFloat::IEEEsingle, true);
2776 APFloat PQNaN = APFloat::getNaN(APFloat::IEEEsingle, false);
2777 APFloat MQNaN = APFloat::getNaN(APFloat::IEEEsingle, true);
2778 APFloat PSNaN = APFloat::getSNaN(APFloat::IEEEsingle, false);
2779 APFloat MSNaN = APFloat::getSNaN(APFloat::IEEEsingle, true);
2780 APFloat PNormalValue = APFloat(APFloat::IEEEsingle, "0x1p+0");
2781 APFloat MNormalValue = APFloat(APFloat::IEEEsingle, "-0x1p+0");
2782 APFloat PLargestValue = APFloat::getLargest(APFloat::IEEEsingle, false);
2783 APFloat MLargestValue = APFloat::getLargest(APFloat::IEEEsingle, true);
2784 APFloat PSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle, false);
2785 APFloat MSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle, true);
2786 APFloat PSmallestNormalized =
2787 APFloat::getSmallestNormalized(APFloat::IEEEsingle, false);
2788 APFloat MSmallestNormalized =
2789 APFloat::getSmallestNormalized(APFloat::IEEEsingle, true);
2791 EXPECT_TRUE(PInf.bitwiseIsEqual(abs(PInf)));
2792 EXPECT_TRUE(PInf.bitwiseIsEqual(abs(MInf)));
2793 EXPECT_TRUE(PZero.bitwiseIsEqual(abs(PZero)));
2794 EXPECT_TRUE(PZero.bitwiseIsEqual(abs(MZero)));
2795 EXPECT_TRUE(PQNaN.bitwiseIsEqual(abs(PQNaN)));
2796 EXPECT_TRUE(PQNaN.bitwiseIsEqual(abs(MQNaN)));
2797 EXPECT_TRUE(PSNaN.bitwiseIsEqual(abs(PSNaN)));
2798 EXPECT_TRUE(PSNaN.bitwiseIsEqual(abs(MSNaN)));
2799 EXPECT_TRUE(PNormalValue.bitwiseIsEqual(abs(PNormalValue)));
2800 EXPECT_TRUE(PNormalValue.bitwiseIsEqual(abs(MNormalValue)));
2801 EXPECT_TRUE(PLargestValue.bitwiseIsEqual(abs(PLargestValue)));
2802 EXPECT_TRUE(PLargestValue.bitwiseIsEqual(abs(MLargestValue)));
2803 EXPECT_TRUE(PSmallestValue.bitwiseIsEqual(abs(PSmallestValue)));
2804 EXPECT_TRUE(PSmallestValue.bitwiseIsEqual(abs(MSmallestValue)));
2805 EXPECT_TRUE(PSmallestNormalized.bitwiseIsEqual(abs(PSmallestNormalized)));
2806 EXPECT_TRUE(PSmallestNormalized.bitwiseIsEqual(abs(MSmallestNormalized)));
2809 TEST(APFloatTest, ilogb) {
2810 EXPECT_EQ(0, ilogb(APFloat(APFloat::IEEEsingle, "0x1p+0")));
2811 EXPECT_EQ(0, ilogb(APFloat(APFloat::IEEEsingle, "-0x1p+0")));
2812 EXPECT_EQ(42, ilogb(APFloat(APFloat::IEEEsingle, "0x1p+42")));
2813 EXPECT_EQ(-42, ilogb(APFloat(APFloat::IEEEsingle, "0x1p-42")));
2815 EXPECT_EQ(APFloat::IEK_Inf,
2816 ilogb(APFloat::getInf(APFloat::IEEEsingle, false)));
2817 EXPECT_EQ(APFloat::IEK_Inf,
2818 ilogb(APFloat::getInf(APFloat::IEEEsingle, true)));
2819 EXPECT_EQ(APFloat::IEK_Zero,
2820 ilogb(APFloat::getZero(APFloat::IEEEsingle, false)));
2821 EXPECT_EQ(APFloat::IEK_Zero,
2822 ilogb(APFloat::getZero(APFloat::IEEEsingle, true)));
2823 EXPECT_EQ(APFloat::IEK_NaN,
2824 ilogb(APFloat::getNaN(APFloat::IEEEsingle, false)));
2825 EXPECT_EQ(APFloat::IEK_NaN,
2826 ilogb(APFloat::getSNaN(APFloat::IEEEsingle, false)));
2828 EXPECT_EQ(127, ilogb(APFloat::getLargest(APFloat::IEEEsingle, false)));
2829 EXPECT_EQ(127, ilogb(APFloat::getLargest(APFloat::IEEEsingle, true)));
2830 EXPECT_EQ(-126, ilogb(APFloat::getSmallest(APFloat::IEEEsingle, false)));
2831 EXPECT_EQ(-126, ilogb(APFloat::getSmallest(APFloat::IEEEsingle, true)));
2833 ilogb(APFloat::getSmallestNormalized(APFloat::IEEEsingle, false)));
2835 ilogb(APFloat::getSmallestNormalized(APFloat::IEEEsingle, true)));
2838 TEST(APFloatTest, scalbn) {
2840 APFloat(APFloat::IEEEsingle, "0x1p+0")
2841 .bitwiseIsEqual(scalbn(APFloat(APFloat::IEEEsingle, "0x1p+0"), 0)));
2843 APFloat(APFloat::IEEEsingle, "0x1p+42")
2844 .bitwiseIsEqual(scalbn(APFloat(APFloat::IEEEsingle, "0x1p+0"), 42)));
2846 APFloat(APFloat::IEEEsingle, "0x1p-42")
2847 .bitwiseIsEqual(scalbn(APFloat(APFloat::IEEEsingle, "0x1p+0"), -42)));
2849 APFloat PInf = APFloat::getInf(APFloat::IEEEsingle, false);
2850 APFloat MInf = APFloat::getInf(APFloat::IEEEsingle, true);
2851 APFloat PZero = APFloat::getZero(APFloat::IEEEsingle, false);
2852 APFloat MZero = APFloat::getZero(APFloat::IEEEsingle, true);
2853 APFloat QPNaN = APFloat::getNaN(APFloat::IEEEsingle, false);
2854 APFloat QMNaN = APFloat::getNaN(APFloat::IEEEsingle, true);
2855 APFloat SNaN = APFloat::getSNaN(APFloat::IEEEsingle, false);
2857 EXPECT_TRUE(PInf.bitwiseIsEqual(scalbn(PInf, 0)));
2858 EXPECT_TRUE(MInf.bitwiseIsEqual(scalbn(MInf, 0)));
2859 EXPECT_TRUE(PZero.bitwiseIsEqual(scalbn(PZero, 0)));
2860 EXPECT_TRUE(MZero.bitwiseIsEqual(scalbn(MZero, 0)));
2861 EXPECT_TRUE(QPNaN.bitwiseIsEqual(scalbn(QPNaN, 0)));
2862 EXPECT_TRUE(QMNaN.bitwiseIsEqual(scalbn(QMNaN, 0)));
2863 EXPECT_TRUE(SNaN.bitwiseIsEqual(scalbn(SNaN, 0)));
2866 PInf.bitwiseIsEqual(scalbn(APFloat(APFloat::IEEEsingle, "0x1p+0"), 128)));
2867 EXPECT_TRUE(MInf.bitwiseIsEqual(
2868 scalbn(APFloat(APFloat::IEEEsingle, "-0x1p+0"), 128)));
2870 PInf.bitwiseIsEqual(scalbn(APFloat(APFloat::IEEEsingle, "0x1p+127"), 1)));
2871 EXPECT_TRUE(PZero.bitwiseIsEqual(
2872 scalbn(APFloat(APFloat::IEEEsingle, "0x1p+0"), -127)));
2873 EXPECT_TRUE(MZero.bitwiseIsEqual(
2874 scalbn(APFloat(APFloat::IEEEsingle, "-0x1p+0"), -127)));
2875 EXPECT_TRUE(PZero.bitwiseIsEqual(
2876 scalbn(APFloat(APFloat::IEEEsingle, "0x1p-126"), -1)));
2877 EXPECT_TRUE(PZero.bitwiseIsEqual(
2878 scalbn(APFloat(APFloat::IEEEsingle, "0x1p-126"), -1)));