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/SmallVector.h"
13 #include "llvm/Support/FormatVariadic.h"
14 #include "llvm/Support/raw_ostream.h"
15 #include "gtest/gtest.h"
23 static double convertToDoubleFromString(const char *Str) {
25 F.convertFromString(Str, llvm::APFloat::rmNearestTiesToEven);
26 return F.convertToDouble();
29 static std::string convertToString(double d, unsigned Prec, unsigned Pad) {
30 llvm::SmallVector<char, 100> Buffer;
32 F.toString(Buffer, Prec, Pad);
33 return std::string(Buffer.data(), Buffer.size());
38 TEST(APFloatTest, isSignaling) {
39 // We test qNaN, -qNaN, +sNaN, -sNaN with and without payloads. *NOTE* The
40 // positive/negative distinction is included only since the getQNaN/getSNaN
41 // API provides the option.
42 APInt payload = APInt::getOneBitSet(4, 2);
43 EXPECT_FALSE(APFloat::getQNaN(APFloat::IEEEsingle(), false).isSignaling());
44 EXPECT_FALSE(APFloat::getQNaN(APFloat::IEEEsingle(), true).isSignaling());
45 EXPECT_FALSE(APFloat::getQNaN(APFloat::IEEEsingle(), false, &payload).isSignaling());
46 EXPECT_FALSE(APFloat::getQNaN(APFloat::IEEEsingle(), true, &payload).isSignaling());
47 EXPECT_TRUE(APFloat::getSNaN(APFloat::IEEEsingle(), false).isSignaling());
48 EXPECT_TRUE(APFloat::getSNaN(APFloat::IEEEsingle(), true).isSignaling());
49 EXPECT_TRUE(APFloat::getSNaN(APFloat::IEEEsingle(), false, &payload).isSignaling());
50 EXPECT_TRUE(APFloat::getSNaN(APFloat::IEEEsingle(), true, &payload).isSignaling());
53 TEST(APFloatTest, next) {
55 APFloat test(APFloat::IEEEquad(), APFloat::uninitialized);
56 APFloat expected(APFloat::IEEEquad(), APFloat::uninitialized);
58 // 1. Test Special Cases Values.
60 // Test all special values for nextUp and nextDown perscribed by IEEE-754R
73 // nextUp(+inf) = +inf.
74 test = APFloat::getInf(APFloat::IEEEquad(), false);
75 expected = APFloat::getInf(APFloat::IEEEquad(), false);
76 EXPECT_EQ(test.next(false), APFloat::opOK);
77 EXPECT_TRUE(test.isInfinity());
78 EXPECT_TRUE(!test.isNegative());
79 EXPECT_TRUE(test.bitwiseIsEqual(expected));
81 // nextDown(+inf) = -nextUp(-inf) = -(-getLargest()) = getLargest()
82 test = APFloat::getInf(APFloat::IEEEquad(), false);
83 expected = APFloat::getLargest(APFloat::IEEEquad(), false);
84 EXPECT_EQ(test.next(true), APFloat::opOK);
85 EXPECT_TRUE(!test.isNegative());
86 EXPECT_TRUE(test.bitwiseIsEqual(expected));
88 // nextUp(-inf) = -getLargest()
89 test = APFloat::getInf(APFloat::IEEEquad(), true);
90 expected = APFloat::getLargest(APFloat::IEEEquad(), true);
91 EXPECT_EQ(test.next(false), APFloat::opOK);
92 EXPECT_TRUE(test.isNegative());
93 EXPECT_TRUE(test.bitwiseIsEqual(expected));
95 // nextDown(-inf) = -nextUp(+inf) = -(+inf) = -inf.
96 test = APFloat::getInf(APFloat::IEEEquad(), true);
97 expected = APFloat::getInf(APFloat::IEEEquad(), true);
98 EXPECT_EQ(test.next(true), APFloat::opOK);
99 EXPECT_TRUE(test.isInfinity() && test.isNegative());
100 EXPECT_TRUE(test.bitwiseIsEqual(expected));
102 // nextUp(getLargest()) = +inf
103 test = APFloat::getLargest(APFloat::IEEEquad(), false);
104 expected = APFloat::getInf(APFloat::IEEEquad(), false);
105 EXPECT_EQ(test.next(false), APFloat::opOK);
106 EXPECT_TRUE(test.isInfinity() && !test.isNegative());
107 EXPECT_TRUE(test.bitwiseIsEqual(expected));
109 // nextDown(getLargest()) = -nextUp(-getLargest())
110 // = -(-getLargest() + inc)
111 // = getLargest() - inc.
112 test = APFloat::getLargest(APFloat::IEEEquad(), false);
113 expected = APFloat(APFloat::IEEEquad(),
114 "0x1.fffffffffffffffffffffffffffep+16383");
115 EXPECT_EQ(test.next(true), APFloat::opOK);
116 EXPECT_TRUE(!test.isInfinity() && !test.isNegative());
117 EXPECT_TRUE(test.bitwiseIsEqual(expected));
119 // nextUp(-getLargest()) = -getLargest() + inc.
120 test = APFloat::getLargest(APFloat::IEEEquad(), true);
121 expected = APFloat(APFloat::IEEEquad(),
122 "-0x1.fffffffffffffffffffffffffffep+16383");
123 EXPECT_EQ(test.next(false), APFloat::opOK);
124 EXPECT_TRUE(test.bitwiseIsEqual(expected));
126 // nextDown(-getLargest()) = -nextUp(getLargest()) = -(inf) = -inf.
127 test = APFloat::getLargest(APFloat::IEEEquad(), true);
128 expected = APFloat::getInf(APFloat::IEEEquad(), true);
129 EXPECT_EQ(test.next(true), APFloat::opOK);
130 EXPECT_TRUE(test.isInfinity() && test.isNegative());
131 EXPECT_TRUE(test.bitwiseIsEqual(expected));
133 // nextUp(getSmallest()) = getSmallest() + inc.
134 test = APFloat(APFloat::IEEEquad(), "0x0.0000000000000000000000000001p-16382");
135 expected = APFloat(APFloat::IEEEquad(),
136 "0x0.0000000000000000000000000002p-16382");
137 EXPECT_EQ(test.next(false), APFloat::opOK);
138 EXPECT_TRUE(test.bitwiseIsEqual(expected));
140 // nextDown(getSmallest()) = -nextUp(-getSmallest()) = -(-0) = +0.
141 test = APFloat(APFloat::IEEEquad(), "0x0.0000000000000000000000000001p-16382");
142 expected = APFloat::getZero(APFloat::IEEEquad(), false);
143 EXPECT_EQ(test.next(true), APFloat::opOK);
144 EXPECT_TRUE(test.isPosZero());
145 EXPECT_TRUE(test.bitwiseIsEqual(expected));
147 // nextUp(-getSmallest()) = -0.
148 test = APFloat(APFloat::IEEEquad(), "-0x0.0000000000000000000000000001p-16382");
149 expected = APFloat::getZero(APFloat::IEEEquad(), true);
150 EXPECT_EQ(test.next(false), APFloat::opOK);
151 EXPECT_TRUE(test.isNegZero());
152 EXPECT_TRUE(test.bitwiseIsEqual(expected));
154 // nextDown(-getSmallest()) = -nextUp(getSmallest()) = -getSmallest() - inc.
155 test = APFloat(APFloat::IEEEquad(), "-0x0.0000000000000000000000000001p-16382");
156 expected = APFloat(APFloat::IEEEquad(),
157 "-0x0.0000000000000000000000000002p-16382");
158 EXPECT_EQ(test.next(true), APFloat::opOK);
159 EXPECT_TRUE(test.bitwiseIsEqual(expected));
161 // nextUp(qNaN) = qNaN
162 test = APFloat::getQNaN(APFloat::IEEEquad(), false);
163 expected = APFloat::getQNaN(APFloat::IEEEquad(), false);
164 EXPECT_EQ(test.next(false), APFloat::opOK);
165 EXPECT_TRUE(test.bitwiseIsEqual(expected));
167 // nextDown(qNaN) = qNaN
168 test = APFloat::getQNaN(APFloat::IEEEquad(), false);
169 expected = APFloat::getQNaN(APFloat::IEEEquad(), false);
170 EXPECT_EQ(test.next(true), APFloat::opOK);
171 EXPECT_TRUE(test.bitwiseIsEqual(expected));
173 // nextUp(sNaN) = qNaN
174 test = APFloat::getSNaN(APFloat::IEEEquad(), false);
175 expected = APFloat::getQNaN(APFloat::IEEEquad(), false);
176 EXPECT_EQ(test.next(false), APFloat::opInvalidOp);
177 EXPECT_TRUE(test.bitwiseIsEqual(expected));
179 // nextDown(sNaN) = qNaN
180 test = APFloat::getSNaN(APFloat::IEEEquad(), false);
181 expected = APFloat::getQNaN(APFloat::IEEEquad(), false);
182 EXPECT_EQ(test.next(true), APFloat::opInvalidOp);
183 EXPECT_TRUE(test.bitwiseIsEqual(expected));
185 // nextUp(+0) = +getSmallest()
186 test = APFloat::getZero(APFloat::IEEEquad(), false);
187 expected = APFloat::getSmallest(APFloat::IEEEquad(), false);
188 EXPECT_EQ(test.next(false), APFloat::opOK);
189 EXPECT_TRUE(test.bitwiseIsEqual(expected));
191 // nextDown(+0) = -nextUp(-0) = -getSmallest()
192 test = APFloat::getZero(APFloat::IEEEquad(), false);
193 expected = APFloat::getSmallest(APFloat::IEEEquad(), true);
194 EXPECT_EQ(test.next(true), APFloat::opOK);
195 EXPECT_TRUE(test.bitwiseIsEqual(expected));
197 // nextUp(-0) = +getSmallest()
198 test = APFloat::getZero(APFloat::IEEEquad(), true);
199 expected = APFloat::getSmallest(APFloat::IEEEquad(), false);
200 EXPECT_EQ(test.next(false), APFloat::opOK);
201 EXPECT_TRUE(test.bitwiseIsEqual(expected));
203 // nextDown(-0) = -nextUp(0) = -getSmallest()
204 test = APFloat::getZero(APFloat::IEEEquad(), true);
205 expected = APFloat::getSmallest(APFloat::IEEEquad(), true);
206 EXPECT_EQ(test.next(true), APFloat::opOK);
207 EXPECT_TRUE(test.bitwiseIsEqual(expected));
209 // 2. Binade Boundary Tests.
211 // 2a. Test denormal <-> normal binade boundaries.
212 // * nextUp(+Largest Denormal) -> +Smallest Normal.
213 // * nextDown(-Largest Denormal) -> -Smallest Normal.
214 // * nextUp(-Smallest Normal) -> -Largest Denormal.
215 // * nextDown(+Smallest Normal) -> +Largest Denormal.
217 // nextUp(+Largest Denormal) -> +Smallest Normal.
218 test = APFloat(APFloat::IEEEquad(), "0x0.ffffffffffffffffffffffffffffp-16382");
219 expected = APFloat(APFloat::IEEEquad(),
220 "0x1.0000000000000000000000000000p-16382");
221 EXPECT_EQ(test.next(false), APFloat::opOK);
222 EXPECT_FALSE(test.isDenormal());
223 EXPECT_TRUE(test.bitwiseIsEqual(expected));
225 // nextDown(-Largest Denormal) -> -Smallest Normal.
226 test = APFloat(APFloat::IEEEquad(),
227 "-0x0.ffffffffffffffffffffffffffffp-16382");
228 expected = APFloat(APFloat::IEEEquad(),
229 "-0x1.0000000000000000000000000000p-16382");
230 EXPECT_EQ(test.next(true), APFloat::opOK);
231 EXPECT_FALSE(test.isDenormal());
232 EXPECT_TRUE(test.bitwiseIsEqual(expected));
234 // nextUp(-Smallest Normal) -> -LargestDenormal.
235 test = APFloat(APFloat::IEEEquad(),
236 "-0x1.0000000000000000000000000000p-16382");
237 expected = APFloat(APFloat::IEEEquad(),
238 "-0x0.ffffffffffffffffffffffffffffp-16382");
239 EXPECT_EQ(test.next(false), APFloat::opOK);
240 EXPECT_TRUE(test.isDenormal());
241 EXPECT_TRUE(test.bitwiseIsEqual(expected));
243 // nextDown(+Smallest Normal) -> +Largest Denormal.
244 test = APFloat(APFloat::IEEEquad(),
245 "+0x1.0000000000000000000000000000p-16382");
246 expected = APFloat(APFloat::IEEEquad(),
247 "+0x0.ffffffffffffffffffffffffffffp-16382");
248 EXPECT_EQ(test.next(true), APFloat::opOK);
249 EXPECT_TRUE(test.isDenormal());
250 EXPECT_TRUE(test.bitwiseIsEqual(expected));
252 // 2b. Test normal <-> normal binade boundaries.
253 // * nextUp(-Normal Binade Boundary) -> -Normal Binade Boundary + 1.
254 // * nextDown(+Normal Binade Boundary) -> +Normal Binade Boundary - 1.
255 // * nextUp(+Normal Binade Boundary - 1) -> +Normal Binade Boundary.
256 // * nextDown(-Normal Binade Boundary + 1) -> -Normal Binade Boundary.
258 // nextUp(-Normal Binade Boundary) -> -Normal Binade Boundary + 1.
259 test = APFloat(APFloat::IEEEquad(), "-0x1p+1");
260 expected = APFloat(APFloat::IEEEquad(),
261 "-0x1.ffffffffffffffffffffffffffffp+0");
262 EXPECT_EQ(test.next(false), APFloat::opOK);
263 EXPECT_TRUE(test.bitwiseIsEqual(expected));
265 // nextDown(+Normal Binade Boundary) -> +Normal Binade Boundary - 1.
266 test = APFloat(APFloat::IEEEquad(), "0x1p+1");
267 expected = APFloat(APFloat::IEEEquad(), "0x1.ffffffffffffffffffffffffffffp+0");
268 EXPECT_EQ(test.next(true), APFloat::opOK);
269 EXPECT_TRUE(test.bitwiseIsEqual(expected));
271 // nextUp(+Normal Binade Boundary - 1) -> +Normal Binade Boundary.
272 test = APFloat(APFloat::IEEEquad(), "0x1.ffffffffffffffffffffffffffffp+0");
273 expected = APFloat(APFloat::IEEEquad(), "0x1p+1");
274 EXPECT_EQ(test.next(false), APFloat::opOK);
275 EXPECT_TRUE(test.bitwiseIsEqual(expected));
277 // nextDown(-Normal Binade Boundary + 1) -> -Normal Binade Boundary.
278 test = APFloat(APFloat::IEEEquad(), "-0x1.ffffffffffffffffffffffffffffp+0");
279 expected = APFloat(APFloat::IEEEquad(), "-0x1p+1");
280 EXPECT_EQ(test.next(true), APFloat::opOK);
281 EXPECT_TRUE(test.bitwiseIsEqual(expected));
283 // 2c. Test using next at binade boundaries with a direction away from the
284 // binade boundary. Away from denormal <-> normal boundaries.
286 // This is to make sure that even though we are at a binade boundary, since
287 // we are rounding away, we do not trigger the binade boundary code. Thus we
289 // * nextUp(-Largest Denormal) -> -Largest Denormal + inc.
290 // * nextDown(+Largest Denormal) -> +Largest Denormal - inc.
291 // * nextUp(+Smallest Normal) -> +Smallest Normal + inc.
292 // * nextDown(-Smallest Normal) -> -Smallest Normal - inc.
294 // nextUp(-Largest Denormal) -> -Largest Denormal + inc.
295 test = APFloat(APFloat::IEEEquad(), "-0x0.ffffffffffffffffffffffffffffp-16382");
296 expected = APFloat(APFloat::IEEEquad(),
297 "-0x0.fffffffffffffffffffffffffffep-16382");
298 EXPECT_EQ(test.next(false), APFloat::opOK);
299 EXPECT_TRUE(test.isDenormal());
300 EXPECT_TRUE(test.isNegative());
301 EXPECT_TRUE(test.bitwiseIsEqual(expected));
303 // nextDown(+Largest Denormal) -> +Largest Denormal - inc.
304 test = APFloat(APFloat::IEEEquad(), "0x0.ffffffffffffffffffffffffffffp-16382");
305 expected = APFloat(APFloat::IEEEquad(),
306 "0x0.fffffffffffffffffffffffffffep-16382");
307 EXPECT_EQ(test.next(true), APFloat::opOK);
308 EXPECT_TRUE(test.isDenormal());
309 EXPECT_TRUE(!test.isNegative());
310 EXPECT_TRUE(test.bitwiseIsEqual(expected));
312 // nextUp(+Smallest Normal) -> +Smallest Normal + inc.
313 test = APFloat(APFloat::IEEEquad(), "0x1.0000000000000000000000000000p-16382");
314 expected = APFloat(APFloat::IEEEquad(),
315 "0x1.0000000000000000000000000001p-16382");
316 EXPECT_EQ(test.next(false), APFloat::opOK);
317 EXPECT_TRUE(!test.isDenormal());
318 EXPECT_TRUE(!test.isNegative());
319 EXPECT_TRUE(test.bitwiseIsEqual(expected));
321 // nextDown(-Smallest Normal) -> -Smallest Normal - inc.
322 test = APFloat(APFloat::IEEEquad(), "-0x1.0000000000000000000000000000p-16382");
323 expected = APFloat(APFloat::IEEEquad(),
324 "-0x1.0000000000000000000000000001p-16382");
325 EXPECT_EQ(test.next(true), APFloat::opOK);
326 EXPECT_TRUE(!test.isDenormal());
327 EXPECT_TRUE(test.isNegative());
328 EXPECT_TRUE(test.bitwiseIsEqual(expected));
330 // 2d. Test values which cause our exponent to go to min exponent. This
331 // is to ensure that guards in the code to check for min exponent
333 // * nextUp(-0x1p-16381) -> -0x1.ffffffffffffffffffffffffffffp-16382
334 // * nextDown(-0x1.ffffffffffffffffffffffffffffp-16382) ->
336 // * nextUp(0x1.ffffffffffffffffffffffffffffp-16382) -> 0x1p-16382
337 // * nextDown(0x1p-16382) -> 0x1.ffffffffffffffffffffffffffffp-16382
339 // nextUp(-0x1p-16381) -> -0x1.ffffffffffffffffffffffffffffp-16382
340 test = APFloat(APFloat::IEEEquad(), "-0x1p-16381");
341 expected = APFloat(APFloat::IEEEquad(),
342 "-0x1.ffffffffffffffffffffffffffffp-16382");
343 EXPECT_EQ(test.next(false), APFloat::opOK);
344 EXPECT_TRUE(test.bitwiseIsEqual(expected));
346 // nextDown(-0x1.ffffffffffffffffffffffffffffp-16382) ->
348 test = APFloat(APFloat::IEEEquad(), "-0x1.ffffffffffffffffffffffffffffp-16382");
349 expected = APFloat(APFloat::IEEEquad(), "-0x1p-16381");
350 EXPECT_EQ(test.next(true), APFloat::opOK);
351 EXPECT_TRUE(test.bitwiseIsEqual(expected));
353 // nextUp(0x1.ffffffffffffffffffffffffffffp-16382) -> 0x1p-16381
354 test = APFloat(APFloat::IEEEquad(), "0x1.ffffffffffffffffffffffffffffp-16382");
355 expected = APFloat(APFloat::IEEEquad(), "0x1p-16381");
356 EXPECT_EQ(test.next(false), APFloat::opOK);
357 EXPECT_TRUE(test.bitwiseIsEqual(expected));
359 // nextDown(0x1p-16381) -> 0x1.ffffffffffffffffffffffffffffp-16382
360 test = APFloat(APFloat::IEEEquad(), "0x1p-16381");
361 expected = APFloat(APFloat::IEEEquad(),
362 "0x1.ffffffffffffffffffffffffffffp-16382");
363 EXPECT_EQ(test.next(true), APFloat::opOK);
364 EXPECT_TRUE(test.bitwiseIsEqual(expected));
366 // 3. Now we test both denormal/normal computation which will not cause us
367 // to go across binade boundaries. Specifically we test:
368 // * nextUp(+Denormal) -> +Denormal.
369 // * nextDown(+Denormal) -> +Denormal.
370 // * nextUp(-Denormal) -> -Denormal.
371 // * nextDown(-Denormal) -> -Denormal.
372 // * nextUp(+Normal) -> +Normal.
373 // * nextDown(+Normal) -> +Normal.
374 // * nextUp(-Normal) -> -Normal.
375 // * nextDown(-Normal) -> -Normal.
377 // nextUp(+Denormal) -> +Denormal.
378 test = APFloat(APFloat::IEEEquad(),
379 "0x0.ffffffffffffffffffffffff000cp-16382");
380 expected = APFloat(APFloat::IEEEquad(),
381 "0x0.ffffffffffffffffffffffff000dp-16382");
382 EXPECT_EQ(test.next(false), APFloat::opOK);
383 EXPECT_TRUE(test.isDenormal());
384 EXPECT_TRUE(!test.isNegative());
385 EXPECT_TRUE(test.bitwiseIsEqual(expected));
387 // nextDown(+Denormal) -> +Denormal.
388 test = APFloat(APFloat::IEEEquad(),
389 "0x0.ffffffffffffffffffffffff000cp-16382");
390 expected = APFloat(APFloat::IEEEquad(),
391 "0x0.ffffffffffffffffffffffff000bp-16382");
392 EXPECT_EQ(test.next(true), APFloat::opOK);
393 EXPECT_TRUE(test.isDenormal());
394 EXPECT_TRUE(!test.isNegative());
395 EXPECT_TRUE(test.bitwiseIsEqual(expected));
397 // nextUp(-Denormal) -> -Denormal.
398 test = APFloat(APFloat::IEEEquad(),
399 "-0x0.ffffffffffffffffffffffff000cp-16382");
400 expected = APFloat(APFloat::IEEEquad(),
401 "-0x0.ffffffffffffffffffffffff000bp-16382");
402 EXPECT_EQ(test.next(false), APFloat::opOK);
403 EXPECT_TRUE(test.isDenormal());
404 EXPECT_TRUE(test.isNegative());
405 EXPECT_TRUE(test.bitwiseIsEqual(expected));
407 // nextDown(-Denormal) -> -Denormal
408 test = APFloat(APFloat::IEEEquad(),
409 "-0x0.ffffffffffffffffffffffff000cp-16382");
410 expected = APFloat(APFloat::IEEEquad(),
411 "-0x0.ffffffffffffffffffffffff000dp-16382");
412 EXPECT_EQ(test.next(true), APFloat::opOK);
413 EXPECT_TRUE(test.isDenormal());
414 EXPECT_TRUE(test.isNegative());
415 EXPECT_TRUE(test.bitwiseIsEqual(expected));
417 // nextUp(+Normal) -> +Normal.
418 test = APFloat(APFloat::IEEEquad(),
419 "0x1.ffffffffffffffffffffffff000cp-16000");
420 expected = APFloat(APFloat::IEEEquad(),
421 "0x1.ffffffffffffffffffffffff000dp-16000");
422 EXPECT_EQ(test.next(false), APFloat::opOK);
423 EXPECT_TRUE(!test.isDenormal());
424 EXPECT_TRUE(!test.isNegative());
425 EXPECT_TRUE(test.bitwiseIsEqual(expected));
427 // nextDown(+Normal) -> +Normal.
428 test = APFloat(APFloat::IEEEquad(),
429 "0x1.ffffffffffffffffffffffff000cp-16000");
430 expected = APFloat(APFloat::IEEEquad(),
431 "0x1.ffffffffffffffffffffffff000bp-16000");
432 EXPECT_EQ(test.next(true), APFloat::opOK);
433 EXPECT_TRUE(!test.isDenormal());
434 EXPECT_TRUE(!test.isNegative());
435 EXPECT_TRUE(test.bitwiseIsEqual(expected));
437 // nextUp(-Normal) -> -Normal.
438 test = APFloat(APFloat::IEEEquad(),
439 "-0x1.ffffffffffffffffffffffff000cp-16000");
440 expected = APFloat(APFloat::IEEEquad(),
441 "-0x1.ffffffffffffffffffffffff000bp-16000");
442 EXPECT_EQ(test.next(false), APFloat::opOK);
443 EXPECT_TRUE(!test.isDenormal());
444 EXPECT_TRUE(test.isNegative());
445 EXPECT_TRUE(test.bitwiseIsEqual(expected));
447 // nextDown(-Normal) -> -Normal.
448 test = APFloat(APFloat::IEEEquad(),
449 "-0x1.ffffffffffffffffffffffff000cp-16000");
450 expected = APFloat(APFloat::IEEEquad(),
451 "-0x1.ffffffffffffffffffffffff000dp-16000");
452 EXPECT_EQ(test.next(true), APFloat::opOK);
453 EXPECT_TRUE(!test.isDenormal());
454 EXPECT_TRUE(test.isNegative());
455 EXPECT_TRUE(test.bitwiseIsEqual(expected));
458 TEST(APFloatTest, FMA) {
459 APFloat::roundingMode rdmd = APFloat::rmNearestTiesToEven;
465 f1.fusedMultiplyAdd(f2, f3, APFloat::rmNearestTiesToEven);
466 EXPECT_EQ(14.75f, f1.convertToFloat());
471 APFloat f1((float)1.17549435e-38F);
472 APFloat f2((float)1.17549435e-38F);
473 f1.divide(Val2, rdmd);
474 f2.divide(Val2, rdmd);
476 f1.fusedMultiplyAdd(f2, f3, APFloat::rmNearestTiesToEven);
477 EXPECT_EQ(12.0f, f1.convertToFloat());
480 // Test for correct zero sign when answer is exactly zero.
481 // fma(1.0, -1.0, 1.0) -> +ve 0.
486 f1.fusedMultiplyAdd(f2, f3, APFloat::rmNearestTiesToEven);
487 EXPECT_TRUE(!f1.isNegative() && f1.isZero());
490 // Test for correct zero sign when answer is exactly zero and rounding towards
492 // fma(1.0, -1.0, 1.0) -> +ve 0.
497 f1.fusedMultiplyAdd(f2, f3, APFloat::rmTowardNegative);
498 EXPECT_TRUE(f1.isNegative() && f1.isZero());
501 // Test for correct (in this case -ve) sign when adding like signed zeros.
502 // Test fma(0.0, -0.0, -0.0) -> -ve 0.
507 f1.fusedMultiplyAdd(f2, f3, APFloat::rmNearestTiesToEven);
508 EXPECT_TRUE(f1.isNegative() && f1.isZero());
511 // Test -ve sign preservation when small negative results underflow.
513 APFloat f1(APFloat::IEEEdouble(), "-0x1p-1074");
514 APFloat f2(APFloat::IEEEdouble(), "+0x1p-1074");
516 f1.fusedMultiplyAdd(f2, f3, APFloat::rmNearestTiesToEven);
517 EXPECT_TRUE(f1.isNegative() && f1.isZero());
520 // Test x87 extended precision case from http://llvm.org/PR20728.
522 APFloat M1(APFloat::x87DoubleExtended(), 1.0);
523 APFloat M2(APFloat::x87DoubleExtended(), 1.0);
524 APFloat A(APFloat::x87DoubleExtended(), 3.0);
526 bool losesInfo = false;
527 M1.fusedMultiplyAdd(M1, A, APFloat::rmNearestTiesToEven);
528 M1.convert(APFloat::IEEEsingle(), APFloat::rmNearestTiesToEven, &losesInfo);
529 EXPECT_FALSE(losesInfo);
530 EXPECT_EQ(4.0f, M1.convertToFloat());
534 TEST(APFloatTest, MinNum) {
537 APFloat nan = APFloat::getNaN(APFloat::IEEEdouble());
539 EXPECT_EQ(1.0, minnum(f1, f2).convertToDouble());
540 EXPECT_EQ(1.0, minnum(f2, f1).convertToDouble());
541 EXPECT_EQ(1.0, minnum(f1, nan).convertToDouble());
542 EXPECT_EQ(1.0, minnum(nan, f1).convertToDouble());
545 TEST(APFloatTest, MaxNum) {
548 APFloat nan = APFloat::getNaN(APFloat::IEEEdouble());
550 EXPECT_EQ(2.0, maxnum(f1, f2).convertToDouble());
551 EXPECT_EQ(2.0, maxnum(f2, f1).convertToDouble());
552 EXPECT_EQ(1.0, maxnum(f1, nan).convertToDouble());
553 EXPECT_EQ(1.0, minnum(nan, f1).convertToDouble());
556 TEST(APFloatTest, Denormal) {
557 APFloat::roundingMode rdmd = APFloat::rmNearestTiesToEven;
559 // Test single precision
561 const char *MinNormalStr = "1.17549435082228750797e-38";
562 EXPECT_FALSE(APFloat(APFloat::IEEEsingle(), MinNormalStr).isDenormal());
563 EXPECT_FALSE(APFloat(APFloat::IEEEsingle(), 0.0).isDenormal());
565 APFloat Val2(APFloat::IEEEsingle(), 2.0e0);
566 APFloat T(APFloat::IEEEsingle(), MinNormalStr);
567 T.divide(Val2, rdmd);
568 EXPECT_TRUE(T.isDenormal());
571 // Test double precision
573 const char *MinNormalStr = "2.22507385850720138309e-308";
574 EXPECT_FALSE(APFloat(APFloat::IEEEdouble(), MinNormalStr).isDenormal());
575 EXPECT_FALSE(APFloat(APFloat::IEEEdouble(), 0.0).isDenormal());
577 APFloat Val2(APFloat::IEEEdouble(), 2.0e0);
578 APFloat T(APFloat::IEEEdouble(), MinNormalStr);
579 T.divide(Val2, rdmd);
580 EXPECT_TRUE(T.isDenormal());
583 // Test Intel double-ext
585 const char *MinNormalStr = "3.36210314311209350626e-4932";
586 EXPECT_FALSE(APFloat(APFloat::x87DoubleExtended(), MinNormalStr).isDenormal());
587 EXPECT_FALSE(APFloat(APFloat::x87DoubleExtended(), 0.0).isDenormal());
589 APFloat Val2(APFloat::x87DoubleExtended(), 2.0e0);
590 APFloat T(APFloat::x87DoubleExtended(), MinNormalStr);
591 T.divide(Val2, rdmd);
592 EXPECT_TRUE(T.isDenormal());
595 // Test quadruple precision
597 const char *MinNormalStr = "3.36210314311209350626267781732175260e-4932";
598 EXPECT_FALSE(APFloat(APFloat::IEEEquad(), MinNormalStr).isDenormal());
599 EXPECT_FALSE(APFloat(APFloat::IEEEquad(), 0.0).isDenormal());
601 APFloat Val2(APFloat::IEEEquad(), 2.0e0);
602 APFloat T(APFloat::IEEEquad(), MinNormalStr);
603 T.divide(Val2, rdmd);
604 EXPECT_TRUE(T.isDenormal());
608 TEST(APFloatTest, Zero) {
609 EXPECT_EQ(0.0f, APFloat(0.0f).convertToFloat());
610 EXPECT_EQ(-0.0f, APFloat(-0.0f).convertToFloat());
611 EXPECT_TRUE(APFloat(-0.0f).isNegative());
613 EXPECT_EQ(0.0, APFloat(0.0).convertToDouble());
614 EXPECT_EQ(-0.0, APFloat(-0.0).convertToDouble());
615 EXPECT_TRUE(APFloat(-0.0).isNegative());
618 TEST(APFloatTest, DecimalStringsWithoutNullTerminators) {
619 // Make sure that we can parse strings without null terminators.
621 APFloat Val(APFloat::IEEEdouble());
622 Val.convertFromString(StringRef("0.00", 3),
623 llvm::APFloat::rmNearestTiesToEven);
624 EXPECT_EQ(Val.convertToDouble(), 0.0);
625 Val.convertFromString(StringRef("0.01", 3),
626 llvm::APFloat::rmNearestTiesToEven);
627 EXPECT_EQ(Val.convertToDouble(), 0.0);
628 Val.convertFromString(StringRef("0.09", 3),
629 llvm::APFloat::rmNearestTiesToEven);
630 EXPECT_EQ(Val.convertToDouble(), 0.0);
631 Val.convertFromString(StringRef("0.095", 4),
632 llvm::APFloat::rmNearestTiesToEven);
633 EXPECT_EQ(Val.convertToDouble(), 0.09);
634 Val.convertFromString(StringRef("0.00e+3", 7),
635 llvm::APFloat::rmNearestTiesToEven);
636 EXPECT_EQ(Val.convertToDouble(), 0.00);
637 Val.convertFromString(StringRef("0e+3", 4),
638 llvm::APFloat::rmNearestTiesToEven);
639 EXPECT_EQ(Val.convertToDouble(), 0.00);
643 TEST(APFloatTest, fromZeroDecimalString) {
644 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0").convertToDouble());
645 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0").convertToDouble());
646 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());
650 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());
654 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-.0").convertToDouble());
656 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0.0").convertToDouble());
657 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0.0").convertToDouble());
658 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0.0").convertToDouble());
660 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "00000.").convertToDouble());
661 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+00000.").convertToDouble());
662 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());
666 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-.00000").convertToDouble());
668 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0000.00000").convertToDouble());
669 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0000.00000").convertToDouble());
670 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0000.00000").convertToDouble());
673 TEST(APFloatTest, fromZeroDecimalSingleExponentString) {
674 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0e1").convertToDouble());
675 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0e1").convertToDouble());
676 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0e1").convertToDouble());
678 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0e+1").convertToDouble());
679 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0e+1").convertToDouble());
680 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());
684 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0e-1").convertToDouble());
687 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0.e1").convertToDouble());
688 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0.e1").convertToDouble());
689 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0.e1").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());
693 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());
697 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0.e-1").convertToDouble());
699 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), ".0e1").convertToDouble());
700 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+.0e1").convertToDouble());
701 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-.0e1").convertToDouble());
703 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), ".0e+1").convertToDouble());
704 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+.0e+1").convertToDouble());
705 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());
709 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-.0e-1").convertToDouble());
712 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0.0e1").convertToDouble());
713 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0.0e1").convertToDouble());
714 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0.0e1").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());
718 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());
722 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0.0e-1").convertToDouble());
725 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "000.0000e1").convertToDouble());
726 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+000.0000e+1").convertToDouble());
727 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-000.0000e+1").convertToDouble());
730 TEST(APFloatTest, fromZeroDecimalLargeExponentString) {
731 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0e1234").convertToDouble());
732 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0e1234").convertToDouble());
733 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0e1234").convertToDouble());
735 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0e+1234").convertToDouble());
736 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0e+1234").convertToDouble());
737 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());
741 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0e-1234").convertToDouble());
743 EXPECT_EQ(0.0, APFloat(APFloat::IEEEdouble(), "000.0000e1234").convertToDouble());
744 EXPECT_EQ(0.0, APFloat(APFloat::IEEEdouble(), "000.0000e-1234").convertToDouble());
746 EXPECT_EQ(0.0, APFloat(APFloat::IEEEdouble(), StringRef("0e1234\02", 6)).convertToDouble());
749 TEST(APFloatTest, fromZeroHexadecimalString) {
750 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x0p1").convertToDouble());
751 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0x0p1").convertToDouble());
752 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0x0p1").convertToDouble());
754 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x0p+1").convertToDouble());
755 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0x0p+1").convertToDouble());
756 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());
760 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0x0p-1").convertToDouble());
763 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x0.p1").convertToDouble());
764 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0x0.p1").convertToDouble());
765 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0x0.p1").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());
769 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());
773 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0x0.p-1").convertToDouble());
776 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x.0p1").convertToDouble());
777 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0x.0p1").convertToDouble());
778 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0x.0p1").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());
782 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());
786 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0x.0p-1").convertToDouble());
789 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x0.0p1").convertToDouble());
790 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0x0.0p1").convertToDouble());
791 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0x0.0p1").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());
795 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());
799 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0x0.0p-1").convertToDouble());
802 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x00000.p1").convertToDouble());
803 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x0000.00000p1").convertToDouble());
804 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x.00000p1").convertToDouble());
805 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x0.p1").convertToDouble());
806 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x0p1234").convertToDouble());
807 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0x0p1234").convertToDouble());
808 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x00000.p1234").convertToDouble());
809 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x0000.00000p1234").convertToDouble());
810 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x.00000p1234").convertToDouble());
811 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x0.p1234").convertToDouble());
814 TEST(APFloatTest, fromDecimalString) {
815 EXPECT_EQ(1.0, APFloat(APFloat::IEEEdouble(), "1").convertToDouble());
816 EXPECT_EQ(2.0, APFloat(APFloat::IEEEdouble(), "2.").convertToDouble());
817 EXPECT_EQ(0.5, APFloat(APFloat::IEEEdouble(), ".5").convertToDouble());
818 EXPECT_EQ(1.0, APFloat(APFloat::IEEEdouble(), "1.0").convertToDouble());
819 EXPECT_EQ(-2.0, APFloat(APFloat::IEEEdouble(), "-2").convertToDouble());
820 EXPECT_EQ(-4.0, APFloat(APFloat::IEEEdouble(), "-4.").convertToDouble());
821 EXPECT_EQ(-0.5, APFloat(APFloat::IEEEdouble(), "-.5").convertToDouble());
822 EXPECT_EQ(-1.5, APFloat(APFloat::IEEEdouble(), "-1.5").convertToDouble());
823 EXPECT_EQ(1.25e12, APFloat(APFloat::IEEEdouble(), "1.25e12").convertToDouble());
824 EXPECT_EQ(1.25e+12, APFloat(APFloat::IEEEdouble(), "1.25e+12").convertToDouble());
825 EXPECT_EQ(1.25e-12, APFloat(APFloat::IEEEdouble(), "1.25e-12").convertToDouble());
826 EXPECT_EQ(1024.0, APFloat(APFloat::IEEEdouble(), "1024.").convertToDouble());
827 EXPECT_EQ(1024.05, APFloat(APFloat::IEEEdouble(), "1024.05000").convertToDouble());
828 EXPECT_EQ(0.05, APFloat(APFloat::IEEEdouble(), ".05000").convertToDouble());
829 EXPECT_EQ(2.0, APFloat(APFloat::IEEEdouble(), "2.").convertToDouble());
830 EXPECT_EQ(2.0e2, APFloat(APFloat::IEEEdouble(), "2.e2").convertToDouble());
831 EXPECT_EQ(2.0e+2, APFloat(APFloat::IEEEdouble(), "2.e+2").convertToDouble());
832 EXPECT_EQ(2.0e-2, APFloat(APFloat::IEEEdouble(), "2.e-2").convertToDouble());
833 EXPECT_EQ(2.05e2, APFloat(APFloat::IEEEdouble(), "002.05000e2").convertToDouble());
834 EXPECT_EQ(2.05e+2, APFloat(APFloat::IEEEdouble(), "002.05000e+2").convertToDouble());
835 EXPECT_EQ(2.05e-2, APFloat(APFloat::IEEEdouble(), "002.05000e-2").convertToDouble());
836 EXPECT_EQ(2.05e12, APFloat(APFloat::IEEEdouble(), "002.05000e12").convertToDouble());
837 EXPECT_EQ(2.05e+12, APFloat(APFloat::IEEEdouble(), "002.05000e+12").convertToDouble());
838 EXPECT_EQ(2.05e-12, APFloat(APFloat::IEEEdouble(), "002.05000e-12").convertToDouble());
840 // These are "carefully selected" to overflow the fast log-base
841 // calculations in APFloat.cpp
842 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "99e99999").isInfinity());
843 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "-99e99999").isInfinity());
844 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "1e-99999").isPosZero());
845 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "-1e-99999").isNegZero());
847 EXPECT_EQ(2.71828, convertToDoubleFromString("2.71828"));
850 TEST(APFloatTest, fromHexadecimalString) {
851 EXPECT_EQ( 1.0, APFloat(APFloat::IEEEdouble(), "0x1p0").convertToDouble());
852 EXPECT_EQ(+1.0, APFloat(APFloat::IEEEdouble(), "+0x1p0").convertToDouble());
853 EXPECT_EQ(-1.0, APFloat(APFloat::IEEEdouble(), "-0x1p0").convertToDouble());
855 EXPECT_EQ( 1.0, APFloat(APFloat::IEEEdouble(), "0x1p+0").convertToDouble());
856 EXPECT_EQ(+1.0, APFloat(APFloat::IEEEdouble(), "+0x1p+0").convertToDouble());
857 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());
861 EXPECT_EQ(-1.0, APFloat(APFloat::IEEEdouble(), "-0x1p-0").convertToDouble());
864 EXPECT_EQ( 2.0, APFloat(APFloat::IEEEdouble(), "0x1p1").convertToDouble());
865 EXPECT_EQ(+2.0, APFloat(APFloat::IEEEdouble(), "+0x1p1").convertToDouble());
866 EXPECT_EQ(-2.0, APFloat(APFloat::IEEEdouble(), "-0x1p1").convertToDouble());
868 EXPECT_EQ( 2.0, APFloat(APFloat::IEEEdouble(), "0x1p+1").convertToDouble());
869 EXPECT_EQ(+2.0, APFloat(APFloat::IEEEdouble(), "+0x1p+1").convertToDouble());
870 EXPECT_EQ(-2.0, 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());
874 EXPECT_EQ(-0.5, APFloat(APFloat::IEEEdouble(), "-0x1p-1").convertToDouble());
877 EXPECT_EQ( 3.0, APFloat(APFloat::IEEEdouble(), "0x1.8p1").convertToDouble());
878 EXPECT_EQ(+3.0, APFloat(APFloat::IEEEdouble(), "+0x1.8p1").convertToDouble());
879 EXPECT_EQ(-3.0, APFloat(APFloat::IEEEdouble(), "-0x1.8p1").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());
883 EXPECT_EQ(-3.0, 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());
887 EXPECT_EQ(-0.75, APFloat(APFloat::IEEEdouble(), "-0x1.8p-1").convertToDouble());
890 EXPECT_EQ( 8192.0, APFloat(APFloat::IEEEdouble(), "0x1000.000p1").convertToDouble());
891 EXPECT_EQ(+8192.0, APFloat(APFloat::IEEEdouble(), "+0x1000.000p1").convertToDouble());
892 EXPECT_EQ(-8192.0, APFloat(APFloat::IEEEdouble(), "-0x1000.000p1").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());
896 EXPECT_EQ(-8192.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());
900 EXPECT_EQ(-2048.0, APFloat(APFloat::IEEEdouble(), "-0x1000.000p-1").convertToDouble());
903 EXPECT_EQ( 8192.0, APFloat(APFloat::IEEEdouble(), "0x1000p1").convertToDouble());
904 EXPECT_EQ(+8192.0, APFloat(APFloat::IEEEdouble(), "+0x1000p1").convertToDouble());
905 EXPECT_EQ(-8192.0, APFloat(APFloat::IEEEdouble(), "-0x1000p1").convertToDouble());
907 EXPECT_EQ( 8192.0, APFloat(APFloat::IEEEdouble(), "0x1000p+1").convertToDouble());
908 EXPECT_EQ(+8192.0, APFloat(APFloat::IEEEdouble(), "+0x1000p+1").convertToDouble());
909 EXPECT_EQ(-8192.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());
913 EXPECT_EQ(-2048.0, APFloat(APFloat::IEEEdouble(), "-0x1000p-1").convertToDouble());
916 EXPECT_EQ( 16384.0, APFloat(APFloat::IEEEdouble(), "0x10p10").convertToDouble());
917 EXPECT_EQ(+16384.0, APFloat(APFloat::IEEEdouble(), "+0x10p10").convertToDouble());
918 EXPECT_EQ(-16384.0, APFloat(APFloat::IEEEdouble(), "-0x10p10").convertToDouble());
920 EXPECT_EQ( 16384.0, APFloat(APFloat::IEEEdouble(), "0x10p+10").convertToDouble());
921 EXPECT_EQ(+16384.0, APFloat(APFloat::IEEEdouble(), "+0x10p+10").convertToDouble());
922 EXPECT_EQ(-16384.0, 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());
926 EXPECT_EQ(-0.015625, APFloat(APFloat::IEEEdouble(), "-0x10p-10").convertToDouble());
928 EXPECT_EQ(1.0625, APFloat(APFloat::IEEEdouble(), "0x1.1p0").convertToDouble());
929 EXPECT_EQ(1.0, APFloat(APFloat::IEEEdouble(), "0x1p0").convertToDouble());
931 EXPECT_EQ(convertToDoubleFromString("0x1p-150"),
932 convertToDoubleFromString("+0x800000000000000001.p-221"));
933 EXPECT_EQ(2251799813685248.5,
934 convertToDoubleFromString("0x80000000000004000000.010p-28"));
937 TEST(APFloatTest, toString) {
938 ASSERT_EQ("10", convertToString(10.0, 6, 3));
939 ASSERT_EQ("1.0E+1", convertToString(10.0, 6, 0));
940 ASSERT_EQ("10100", convertToString(1.01E+4, 5, 2));
941 ASSERT_EQ("1.01E+4", convertToString(1.01E+4, 4, 2));
942 ASSERT_EQ("1.01E+4", convertToString(1.01E+4, 5, 1));
943 ASSERT_EQ("0.0101", convertToString(1.01E-2, 5, 2));
944 ASSERT_EQ("0.0101", convertToString(1.01E-2, 4, 2));
945 ASSERT_EQ("1.01E-2", convertToString(1.01E-2, 5, 1));
946 ASSERT_EQ("0.78539816339744828", convertToString(0.78539816339744830961, 0, 3));
947 ASSERT_EQ("4.9406564584124654E-324", convertToString(4.9406564584124654e-324, 0, 3));
948 ASSERT_EQ("873.18340000000001", convertToString(873.1834, 0, 1));
949 ASSERT_EQ("8.7318340000000001E+2", convertToString(873.1834, 0, 0));
950 ASSERT_EQ("1.7976931348623157E+308", convertToString(1.7976931348623157E+308, 0, 0));
953 TEST(APFloatTest, toInteger) {
954 bool isExact = false;
955 APSInt result(5, /*isUnsigned=*/true);
957 EXPECT_EQ(APFloat::opOK,
958 APFloat(APFloat::IEEEdouble(), "10")
959 .convertToInteger(result, APFloat::rmTowardZero, &isExact));
960 EXPECT_TRUE(isExact);
961 EXPECT_EQ(APSInt(APInt(5, 10), true), result);
963 EXPECT_EQ(APFloat::opInvalidOp,
964 APFloat(APFloat::IEEEdouble(), "-10")
965 .convertToInteger(result, APFloat::rmTowardZero, &isExact));
966 EXPECT_FALSE(isExact);
967 EXPECT_EQ(APSInt::getMinValue(5, true), result);
969 EXPECT_EQ(APFloat::opInvalidOp,
970 APFloat(APFloat::IEEEdouble(), "32")
971 .convertToInteger(result, APFloat::rmTowardZero, &isExact));
972 EXPECT_FALSE(isExact);
973 EXPECT_EQ(APSInt::getMaxValue(5, true), result);
975 EXPECT_EQ(APFloat::opInexact,
976 APFloat(APFloat::IEEEdouble(), "7.9")
977 .convertToInteger(result, APFloat::rmTowardZero, &isExact));
978 EXPECT_FALSE(isExact);
979 EXPECT_EQ(APSInt(APInt(5, 7), true), result);
981 result.setIsUnsigned(false);
982 EXPECT_EQ(APFloat::opOK,
983 APFloat(APFloat::IEEEdouble(), "-10")
984 .convertToInteger(result, APFloat::rmTowardZero, &isExact));
985 EXPECT_TRUE(isExact);
986 EXPECT_EQ(APSInt(APInt(5, -10, true), false), result);
988 EXPECT_EQ(APFloat::opInvalidOp,
989 APFloat(APFloat::IEEEdouble(), "-17")
990 .convertToInteger(result, APFloat::rmTowardZero, &isExact));
991 EXPECT_FALSE(isExact);
992 EXPECT_EQ(APSInt::getMinValue(5, false), result);
994 EXPECT_EQ(APFloat::opInvalidOp,
995 APFloat(APFloat::IEEEdouble(), "16")
996 .convertToInteger(result, APFloat::rmTowardZero, &isExact));
997 EXPECT_FALSE(isExact);
998 EXPECT_EQ(APSInt::getMaxValue(5, false), result);
1001 static APInt nanbits(const fltSemantics &Sem,
1002 bool SNaN, bool Negative, uint64_t fill) {
1003 APInt apfill(64, fill);
1005 return APFloat::getSNaN(Sem, Negative, &apfill).bitcastToAPInt();
1007 return APFloat::getQNaN(Sem, Negative, &apfill).bitcastToAPInt();
1010 TEST(APFloatTest, makeNaN) {
1011 ASSERT_EQ(0x7fc00000, nanbits(APFloat::IEEEsingle(), false, false, 0));
1012 ASSERT_EQ(0xffc00000, nanbits(APFloat::IEEEsingle(), false, true, 0));
1013 ASSERT_EQ(0x7fc0ae72, nanbits(APFloat::IEEEsingle(), false, false, 0xae72));
1014 ASSERT_EQ(0x7fffae72, nanbits(APFloat::IEEEsingle(), false, false, 0xffffae72));
1015 ASSERT_EQ(0x7fa00000, nanbits(APFloat::IEEEsingle(), true, false, 0));
1016 ASSERT_EQ(0xffa00000, nanbits(APFloat::IEEEsingle(), true, true, 0));
1017 ASSERT_EQ(0x7f80ae72, nanbits(APFloat::IEEEsingle(), true, false, 0xae72));
1018 ASSERT_EQ(0x7fbfae72, nanbits(APFloat::IEEEsingle(), true, false, 0xffffae72));
1020 ASSERT_EQ(0x7ff8000000000000ULL, nanbits(APFloat::IEEEdouble(), false, false, 0));
1021 ASSERT_EQ(0xfff8000000000000ULL, nanbits(APFloat::IEEEdouble(), false, true, 0));
1022 ASSERT_EQ(0x7ff800000000ae72ULL, nanbits(APFloat::IEEEdouble(), false, false, 0xae72));
1023 ASSERT_EQ(0x7fffffffffffae72ULL, nanbits(APFloat::IEEEdouble(), false, false, 0xffffffffffffae72ULL));
1024 ASSERT_EQ(0x7ff4000000000000ULL, nanbits(APFloat::IEEEdouble(), true, false, 0));
1025 ASSERT_EQ(0xfff4000000000000ULL, nanbits(APFloat::IEEEdouble(), true, true, 0));
1026 ASSERT_EQ(0x7ff000000000ae72ULL, nanbits(APFloat::IEEEdouble(), true, false, 0xae72));
1027 ASSERT_EQ(0x7ff7ffffffffae72ULL, nanbits(APFloat::IEEEdouble(), true, false, 0xffffffffffffae72ULL));
1030 #ifdef GTEST_HAS_DEATH_TEST
1032 TEST(APFloatTest, SemanticsDeath) {
1033 EXPECT_DEATH(APFloat(APFloat::IEEEsingle(), 0.0f).convertToDouble(), "Float semantics are not IEEEdouble");
1034 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), 0.0 ).convertToFloat(), "Float semantics are not IEEEsingle");
1037 TEST(APFloatTest, StringDecimalDeath) {
1038 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), ""), "Invalid string length");
1039 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "+"), "String has no digits");
1040 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "-"), "String has no digits");
1042 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), StringRef("\0", 1)), "Invalid character in significand");
1043 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), StringRef("1\0", 2)), "Invalid character in significand");
1044 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), StringRef("1\02", 3)), "Invalid character in significand");
1045 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), StringRef("1\02e1", 5)), "Invalid character in significand");
1046 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), StringRef("1e\0", 3)), "Invalid character in exponent");
1047 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), StringRef("1e1\0", 4)), "Invalid character in exponent");
1048 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), StringRef("1e1\02", 5)), "Invalid character in exponent");
1050 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "1.0f"), "Invalid character in significand");
1052 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), ".."), "String contains multiple dots");
1053 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "..0"), "String contains multiple dots");
1054 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "1.0.0"), "String contains multiple dots");
1057 TEST(APFloatTest, StringDecimalSignificandDeath) {
1058 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "."), "Significand has no digits");
1059 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "+."), "Significand has no digits");
1060 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "-."), "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");
1065 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "-e"), "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");
1069 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");
1073 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "-.e1"), "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");
1078 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "-.e"), "Significand has no digits");
1081 TEST(APFloatTest, StringDecimalExponentDeath) {
1082 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "1e"), "Exponent has no digits");
1083 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "+1e"), "Exponent has no digits");
1084 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "-1e"), "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");
1088 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "-1.e"), "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");
1092 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "-.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");
1096 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "-1.1e"), "Exponent has no digits");
1099 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "1e+"), "Exponent has no digits");
1100 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");
1104 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), ".1e-"), "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");
1108 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "1.0e-"), "Exponent has no digits");
1111 TEST(APFloatTest, StringHexadecimalDeath) {
1112 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "0x"), "Invalid string");
1113 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "+0x"), "Invalid string");
1114 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "-0x"), "Invalid string");
1116 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "0x0"), "Hex strings require an exponent");
1117 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "+0x0"), "Hex strings require an exponent");
1118 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");
1122 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "-0x0."), "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");
1126 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "-0x.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");
1130 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "-0x0.0"), "Hex strings require an exponent");
1132 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), StringRef("0x\0", 3)), "Invalid character in significand");
1133 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), StringRef("0x1\0", 4)), "Invalid character in significand");
1134 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), StringRef("0x1\02", 5)), "Invalid character in significand");
1135 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), StringRef("0x1\02p1", 7)), "Invalid character in significand");
1136 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), StringRef("0x1p\0", 5)), "Invalid character in exponent");
1137 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), StringRef("0x1p1\0", 6)), "Invalid character in exponent");
1138 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), StringRef("0x1p1\02", 7)), "Invalid character in exponent");
1140 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "0x1p0f"), "Invalid character in exponent");
1142 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "0x..p1"), "String contains multiple dots");
1143 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "0x..0p1"), "String contains multiple dots");
1144 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "0x1.0.0p1"), "String contains multiple dots");
1147 TEST(APFloatTest, StringHexadecimalSignificandDeath) {
1148 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "0x."), "Significand has no digits");
1149 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "+0x."), "Significand has no digits");
1150 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "-0x."), "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");
1154 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");
1158 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");
1162 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "-0xp-"), "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");
1167 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");
1171 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");
1175 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "-0x.p-"), "Significand has no digits");
1178 TEST(APFloatTest, StringHexadecimalExponentDeath) {
1179 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "0x1p"), "Exponent has no digits");
1180 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "+0x1p"), "Exponent has no digits");
1181 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");
1185 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");
1189 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "-0x1p-"), "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");
1194 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");
1198 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");
1202 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "-0x1.p-"), "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");
1207 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");
1211 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");
1215 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "-0x.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");
1220 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");
1224 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");
1228 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "-0x1.1p-"), "Exponent has no digits");
1233 TEST(APFloatTest, exactInverse) {
1236 // Trivial operation.
1237 EXPECT_TRUE(APFloat(2.0).getExactInverse(&inv));
1238 EXPECT_TRUE(inv.bitwiseIsEqual(APFloat(0.5)));
1239 EXPECT_TRUE(APFloat(2.0f).getExactInverse(&inv));
1240 EXPECT_TRUE(inv.bitwiseIsEqual(APFloat(0.5f)));
1241 EXPECT_TRUE(APFloat(APFloat::IEEEquad(), "2.0").getExactInverse(&inv));
1242 EXPECT_TRUE(inv.bitwiseIsEqual(APFloat(APFloat::IEEEquad(), "0.5")));
1243 EXPECT_TRUE(APFloat(APFloat::PPCDoubleDouble(), "2.0").getExactInverse(&inv));
1244 EXPECT_TRUE(inv.bitwiseIsEqual(APFloat(APFloat::PPCDoubleDouble(), "0.5")));
1245 EXPECT_TRUE(APFloat(APFloat::x87DoubleExtended(), "2.0").getExactInverse(&inv));
1246 EXPECT_TRUE(inv.bitwiseIsEqual(APFloat(APFloat::x87DoubleExtended(), "0.5")));
1249 EXPECT_TRUE(APFloat(1.17549435e-38f).getExactInverse(&inv));
1250 EXPECT_TRUE(inv.bitwiseIsEqual(APFloat(8.5070592e+37f)));
1252 // Large float, inverse is a denormal.
1253 EXPECT_FALSE(APFloat(1.7014118e38f).getExactInverse(nullptr));
1255 EXPECT_FALSE(APFloat(0.0).getExactInverse(nullptr));
1256 // Denormalized float
1257 EXPECT_FALSE(APFloat(1.40129846e-45f).getExactInverse(nullptr));
1260 TEST(APFloatTest, roundToIntegral) {
1261 APFloat T(-0.5), S(3.14), R(APFloat::getLargest(APFloat::IEEEdouble())), P(0.0);
1264 P.roundToIntegral(APFloat::rmTowardZero);
1265 EXPECT_EQ(-0.0, P.convertToDouble());
1267 P.roundToIntegral(APFloat::rmTowardNegative);
1268 EXPECT_EQ(-1.0, P.convertToDouble());
1270 P.roundToIntegral(APFloat::rmTowardPositive);
1271 EXPECT_EQ(-0.0, P.convertToDouble());
1273 P.roundToIntegral(APFloat::rmNearestTiesToEven);
1274 EXPECT_EQ(-0.0, P.convertToDouble());
1277 P.roundToIntegral(APFloat::rmTowardZero);
1278 EXPECT_EQ(3.0, P.convertToDouble());
1280 P.roundToIntegral(APFloat::rmTowardNegative);
1281 EXPECT_EQ(3.0, P.convertToDouble());
1283 P.roundToIntegral(APFloat::rmTowardPositive);
1284 EXPECT_EQ(4.0, P.convertToDouble());
1286 P.roundToIntegral(APFloat::rmNearestTiesToEven);
1287 EXPECT_EQ(3.0, P.convertToDouble());
1290 P.roundToIntegral(APFloat::rmTowardZero);
1291 EXPECT_EQ(R.convertToDouble(), P.convertToDouble());
1293 P.roundToIntegral(APFloat::rmTowardNegative);
1294 EXPECT_EQ(R.convertToDouble(), P.convertToDouble());
1296 P.roundToIntegral(APFloat::rmTowardPositive);
1297 EXPECT_EQ(R.convertToDouble(), P.convertToDouble());
1299 P.roundToIntegral(APFloat::rmNearestTiesToEven);
1300 EXPECT_EQ(R.convertToDouble(), P.convertToDouble());
1302 P = APFloat::getZero(APFloat::IEEEdouble());
1303 P.roundToIntegral(APFloat::rmTowardZero);
1304 EXPECT_EQ(0.0, P.convertToDouble());
1305 P = APFloat::getZero(APFloat::IEEEdouble(), true);
1306 P.roundToIntegral(APFloat::rmTowardZero);
1307 EXPECT_EQ(-0.0, P.convertToDouble());
1308 P = APFloat::getNaN(APFloat::IEEEdouble());
1309 P.roundToIntegral(APFloat::rmTowardZero);
1310 EXPECT_TRUE(std::isnan(P.convertToDouble()));
1311 P = APFloat::getInf(APFloat::IEEEdouble());
1312 P.roundToIntegral(APFloat::rmTowardZero);
1313 EXPECT_TRUE(std::isinf(P.convertToDouble()) && P.convertToDouble() > 0.0);
1314 P = APFloat::getInf(APFloat::IEEEdouble(), true);
1315 P.roundToIntegral(APFloat::rmTowardZero);
1316 EXPECT_TRUE(std::isinf(P.convertToDouble()) && P.convertToDouble() < 0.0);
1319 TEST(APFloatTest, isInteger) {
1321 EXPECT_TRUE(T.isInteger());
1322 T = APFloat(3.14159);
1323 EXPECT_FALSE(T.isInteger());
1324 T = APFloat::getNaN(APFloat::IEEEdouble());
1325 EXPECT_FALSE(T.isInteger());
1326 T = APFloat::getInf(APFloat::IEEEdouble());
1327 EXPECT_FALSE(T.isInteger());
1328 T = APFloat::getInf(APFloat::IEEEdouble(), true);
1329 EXPECT_FALSE(T.isInteger());
1330 T = APFloat::getLargest(APFloat::IEEEdouble());
1331 EXPECT_TRUE(T.isInteger());
1334 TEST(APFloatTest, getLargest) {
1335 EXPECT_EQ(3.402823466e+38f, APFloat::getLargest(APFloat::IEEEsingle()).convertToFloat());
1336 EXPECT_EQ(1.7976931348623158e+308, APFloat::getLargest(APFloat::IEEEdouble()).convertToDouble());
1339 TEST(APFloatTest, getSmallest) {
1340 APFloat test = APFloat::getSmallest(APFloat::IEEEsingle(), false);
1341 APFloat expected = APFloat(APFloat::IEEEsingle(), "0x0.000002p-126");
1342 EXPECT_FALSE(test.isNegative());
1343 EXPECT_TRUE(test.isFiniteNonZero());
1344 EXPECT_TRUE(test.isDenormal());
1345 EXPECT_TRUE(test.bitwiseIsEqual(expected));
1347 test = APFloat::getSmallest(APFloat::IEEEsingle(), true);
1348 expected = APFloat(APFloat::IEEEsingle(), "-0x0.000002p-126");
1349 EXPECT_TRUE(test.isNegative());
1350 EXPECT_TRUE(test.isFiniteNonZero());
1351 EXPECT_TRUE(test.isDenormal());
1352 EXPECT_TRUE(test.bitwiseIsEqual(expected));
1354 test = APFloat::getSmallest(APFloat::IEEEquad(), false);
1355 expected = APFloat(APFloat::IEEEquad(), "0x0.0000000000000000000000000001p-16382");
1356 EXPECT_FALSE(test.isNegative());
1357 EXPECT_TRUE(test.isFiniteNonZero());
1358 EXPECT_TRUE(test.isDenormal());
1359 EXPECT_TRUE(test.bitwiseIsEqual(expected));
1361 test = APFloat::getSmallest(APFloat::IEEEquad(), true);
1362 expected = APFloat(APFloat::IEEEquad(), "-0x0.0000000000000000000000000001p-16382");
1363 EXPECT_TRUE(test.isNegative());
1364 EXPECT_TRUE(test.isFiniteNonZero());
1365 EXPECT_TRUE(test.isDenormal());
1366 EXPECT_TRUE(test.bitwiseIsEqual(expected));
1369 TEST(APFloatTest, getSmallestNormalized) {
1370 APFloat test = APFloat::getSmallestNormalized(APFloat::IEEEsingle(), false);
1371 APFloat expected = APFloat(APFloat::IEEEsingle(), "0x1p-126");
1372 EXPECT_FALSE(test.isNegative());
1373 EXPECT_TRUE(test.isFiniteNonZero());
1374 EXPECT_FALSE(test.isDenormal());
1375 EXPECT_TRUE(test.bitwiseIsEqual(expected));
1377 test = APFloat::getSmallestNormalized(APFloat::IEEEsingle(), true);
1378 expected = APFloat(APFloat::IEEEsingle(), "-0x1p-126");
1379 EXPECT_TRUE(test.isNegative());
1380 EXPECT_TRUE(test.isFiniteNonZero());
1381 EXPECT_FALSE(test.isDenormal());
1382 EXPECT_TRUE(test.bitwiseIsEqual(expected));
1384 test = APFloat::getSmallestNormalized(APFloat::IEEEquad(), false);
1385 expected = APFloat(APFloat::IEEEquad(), "0x1p-16382");
1386 EXPECT_FALSE(test.isNegative());
1387 EXPECT_TRUE(test.isFiniteNonZero());
1388 EXPECT_FALSE(test.isDenormal());
1389 EXPECT_TRUE(test.bitwiseIsEqual(expected));
1391 test = APFloat::getSmallestNormalized(APFloat::IEEEquad(), true);
1392 expected = APFloat(APFloat::IEEEquad(), "-0x1p-16382");
1393 EXPECT_TRUE(test.isNegative());
1394 EXPECT_TRUE(test.isFiniteNonZero());
1395 EXPECT_FALSE(test.isDenormal());
1396 EXPECT_TRUE(test.bitwiseIsEqual(expected));
1399 TEST(APFloatTest, getZero) {
1401 const fltSemantics *semantics;
1403 const unsigned long long bitPattern[2];
1404 const unsigned bitPatternLength;
1405 } const GetZeroTest[] = {
1406 { &APFloat::IEEEhalf(), false, {0, 0}, 1},
1407 { &APFloat::IEEEhalf(), true, {0x8000ULL, 0}, 1},
1408 { &APFloat::IEEEsingle(), false, {0, 0}, 1},
1409 { &APFloat::IEEEsingle(), true, {0x80000000ULL, 0}, 1},
1410 { &APFloat::IEEEdouble(), false, {0, 0}, 1},
1411 { &APFloat::IEEEdouble(), true, {0x8000000000000000ULL, 0}, 1},
1412 { &APFloat::IEEEquad(), false, {0, 0}, 2},
1413 { &APFloat::IEEEquad(), true, {0, 0x8000000000000000ULL}, 2},
1414 { &APFloat::PPCDoubleDouble(), false, {0, 0}, 2},
1415 { &APFloat::PPCDoubleDouble(), true, {0x8000000000000000ULL, 0}, 2},
1416 { &APFloat::x87DoubleExtended(), false, {0, 0}, 2},
1417 { &APFloat::x87DoubleExtended(), true, {0, 0x8000ULL}, 2},
1419 const unsigned NumGetZeroTests = 12;
1420 for (unsigned i = 0; i < NumGetZeroTests; ++i) {
1421 APFloat test = APFloat::getZero(*GetZeroTest[i].semantics,
1422 GetZeroTest[i].sign);
1423 const char *pattern = GetZeroTest[i].sign? "-0x0p+0" : "0x0p+0";
1424 APFloat expected = APFloat(*GetZeroTest[i].semantics,
1426 EXPECT_TRUE(test.isZero());
1427 EXPECT_TRUE(GetZeroTest[i].sign? test.isNegative() : !test.isNegative());
1428 EXPECT_TRUE(test.bitwiseIsEqual(expected));
1429 for (unsigned j = 0, je = GetZeroTest[i].bitPatternLength; j < je; ++j) {
1430 EXPECT_EQ(GetZeroTest[i].bitPattern[j],
1431 test.bitcastToAPInt().getRawData()[j]);
1436 TEST(APFloatTest, copySign) {
1437 EXPECT_TRUE(APFloat(-42.0).bitwiseIsEqual(
1438 APFloat::copySign(APFloat(42.0), APFloat(-1.0))));
1439 EXPECT_TRUE(APFloat(42.0).bitwiseIsEqual(
1440 APFloat::copySign(APFloat(-42.0), APFloat(1.0))));
1441 EXPECT_TRUE(APFloat(-42.0).bitwiseIsEqual(
1442 APFloat::copySign(APFloat(-42.0), APFloat(-1.0))));
1443 EXPECT_TRUE(APFloat(42.0).bitwiseIsEqual(
1444 APFloat::copySign(APFloat(42.0), APFloat(1.0))));
1447 TEST(APFloatTest, convert) {
1449 APFloat test(APFloat::IEEEdouble(), "1.0");
1450 test.convert(APFloat::IEEEsingle(), APFloat::rmNearestTiesToEven, &losesInfo);
1451 EXPECT_EQ(1.0f, test.convertToFloat());
1452 EXPECT_FALSE(losesInfo);
1454 test = APFloat(APFloat::x87DoubleExtended(), "0x1p-53");
1455 test.add(APFloat(APFloat::x87DoubleExtended(), "1.0"), APFloat::rmNearestTiesToEven);
1456 test.convert(APFloat::IEEEdouble(), APFloat::rmNearestTiesToEven, &losesInfo);
1457 EXPECT_EQ(1.0, test.convertToDouble());
1458 EXPECT_TRUE(losesInfo);
1460 test = APFloat(APFloat::IEEEquad(), "0x1p-53");
1461 test.add(APFloat(APFloat::IEEEquad(), "1.0"), APFloat::rmNearestTiesToEven);
1462 test.convert(APFloat::IEEEdouble(), APFloat::rmNearestTiesToEven, &losesInfo);
1463 EXPECT_EQ(1.0, test.convertToDouble());
1464 EXPECT_TRUE(losesInfo);
1466 test = APFloat(APFloat::x87DoubleExtended(), "0xf.fffffffp+28");
1467 test.convert(APFloat::IEEEdouble(), APFloat::rmNearestTiesToEven, &losesInfo);
1468 EXPECT_EQ(4294967295.0, test.convertToDouble());
1469 EXPECT_FALSE(losesInfo);
1471 test = APFloat::getSNaN(APFloat::IEEEsingle());
1472 APFloat X87SNaN = APFloat::getSNaN(APFloat::x87DoubleExtended());
1473 test.convert(APFloat::x87DoubleExtended(), APFloat::rmNearestTiesToEven,
1475 EXPECT_TRUE(test.bitwiseIsEqual(X87SNaN));
1476 EXPECT_FALSE(losesInfo);
1478 test = APFloat::getQNaN(APFloat::IEEEsingle());
1479 APFloat X87QNaN = APFloat::getQNaN(APFloat::x87DoubleExtended());
1480 test.convert(APFloat::x87DoubleExtended(), APFloat::rmNearestTiesToEven,
1482 EXPECT_TRUE(test.bitwiseIsEqual(X87QNaN));
1483 EXPECT_FALSE(losesInfo);
1485 test = APFloat::getSNaN(APFloat::x87DoubleExtended());
1486 test.convert(APFloat::x87DoubleExtended(), APFloat::rmNearestTiesToEven,
1488 EXPECT_TRUE(test.bitwiseIsEqual(X87SNaN));
1489 EXPECT_FALSE(losesInfo);
1491 test = APFloat::getQNaN(APFloat::x87DoubleExtended());
1492 test.convert(APFloat::x87DoubleExtended(), APFloat::rmNearestTiesToEven,
1494 EXPECT_TRUE(test.bitwiseIsEqual(X87QNaN));
1495 EXPECT_FALSE(losesInfo);
1498 TEST(APFloatTest, PPCDoubleDouble) {
1499 APFloat test(APFloat::PPCDoubleDouble(), "1.0");
1500 EXPECT_EQ(0x3ff0000000000000ull, test.bitcastToAPInt().getRawData()[0]);
1501 EXPECT_EQ(0x0000000000000000ull, test.bitcastToAPInt().getRawData()[1]);
1504 test = APFloat(APFloat::PPCDoubleDouble(), "1.79769313486231580793728971405301e+308");
1505 EXPECT_EQ(0x7fefffffffffffffull, test.bitcastToAPInt().getRawData()[0]);
1506 EXPECT_EQ(0x7c8ffffffffffffeull, test.bitcastToAPInt().getRawData()[1]);
1509 test = APFloat(APFloat::PPCDoubleDouble(), "2.00416836000897277799610805135016e-292");
1510 EXPECT_EQ(0x0360000000000000ull, test.bitcastToAPInt().getRawData()[0]);
1511 EXPECT_EQ(0x0000000000000000ull, test.bitcastToAPInt().getRawData()[1]);
1515 auto Result = APFloat(APFloat::PPCDoubleDouble(), "1.0") +
1516 APFloat(APFloat::PPCDoubleDouble(), "1.0");
1517 EXPECT_EQ(&APFloat::PPCDoubleDouble(), &Result.getSemantics());
1519 Result = APFloat(APFloat::PPCDoubleDouble(), "1.0") -
1520 APFloat(APFloat::PPCDoubleDouble(), "1.0");
1521 EXPECT_EQ(&APFloat::PPCDoubleDouble(), &Result.getSemantics());
1523 Result = APFloat(APFloat::PPCDoubleDouble(), "1.0") *
1524 APFloat(APFloat::PPCDoubleDouble(), "1.0");
1525 EXPECT_EQ(&APFloat::PPCDoubleDouble(), &Result.getSemantics());
1527 Result = APFloat(APFloat::PPCDoubleDouble(), "1.0") /
1528 APFloat(APFloat::PPCDoubleDouble(), "1.0");
1529 EXPECT_EQ(&APFloat::PPCDoubleDouble(), &Result.getSemantics());
1532 Result = frexp(APFloat(APFloat::PPCDoubleDouble(), "1.0"), Exp,
1533 APFloat::rmNearestTiesToEven);
1534 EXPECT_EQ(&APFloat::PPCDoubleDouble(), &Result.getSemantics());
1536 Result = scalbn(APFloat(APFloat::PPCDoubleDouble(), "1.0"), 1,
1537 APFloat::rmNearestTiesToEven);
1538 EXPECT_EQ(&APFloat::PPCDoubleDouble(), &Result.getSemantics());
1542 TEST(APFloatTest, isNegative) {
1543 APFloat t(APFloat::IEEEsingle(), "0x1p+0");
1544 EXPECT_FALSE(t.isNegative());
1545 t = APFloat(APFloat::IEEEsingle(), "-0x1p+0");
1546 EXPECT_TRUE(t.isNegative());
1548 EXPECT_FALSE(APFloat::getInf(APFloat::IEEEsingle(), false).isNegative());
1549 EXPECT_TRUE(APFloat::getInf(APFloat::IEEEsingle(), true).isNegative());
1551 EXPECT_FALSE(APFloat::getZero(APFloat::IEEEsingle(), false).isNegative());
1552 EXPECT_TRUE(APFloat::getZero(APFloat::IEEEsingle(), true).isNegative());
1554 EXPECT_FALSE(APFloat::getNaN(APFloat::IEEEsingle(), false).isNegative());
1555 EXPECT_TRUE(APFloat::getNaN(APFloat::IEEEsingle(), true).isNegative());
1557 EXPECT_FALSE(APFloat::getSNaN(APFloat::IEEEsingle(), false).isNegative());
1558 EXPECT_TRUE(APFloat::getSNaN(APFloat::IEEEsingle(), true).isNegative());
1561 TEST(APFloatTest, isNormal) {
1562 APFloat t(APFloat::IEEEsingle(), "0x1p+0");
1563 EXPECT_TRUE(t.isNormal());
1565 EXPECT_FALSE(APFloat::getInf(APFloat::IEEEsingle(), false).isNormal());
1566 EXPECT_FALSE(APFloat::getZero(APFloat::IEEEsingle(), false).isNormal());
1567 EXPECT_FALSE(APFloat::getNaN(APFloat::IEEEsingle(), false).isNormal());
1568 EXPECT_FALSE(APFloat::getSNaN(APFloat::IEEEsingle(), false).isNormal());
1569 EXPECT_FALSE(APFloat(APFloat::IEEEsingle(), "0x1p-149").isNormal());
1572 TEST(APFloatTest, isFinite) {
1573 APFloat t(APFloat::IEEEsingle(), "0x1p+0");
1574 EXPECT_TRUE(t.isFinite());
1575 EXPECT_FALSE(APFloat::getInf(APFloat::IEEEsingle(), false).isFinite());
1576 EXPECT_TRUE(APFloat::getZero(APFloat::IEEEsingle(), false).isFinite());
1577 EXPECT_FALSE(APFloat::getNaN(APFloat::IEEEsingle(), false).isFinite());
1578 EXPECT_FALSE(APFloat::getSNaN(APFloat::IEEEsingle(), false).isFinite());
1579 EXPECT_TRUE(APFloat(APFloat::IEEEsingle(), "0x1p-149").isFinite());
1582 TEST(APFloatTest, isInfinity) {
1583 APFloat t(APFloat::IEEEsingle(), "0x1p+0");
1584 EXPECT_FALSE(t.isInfinity());
1585 EXPECT_TRUE(APFloat::getInf(APFloat::IEEEsingle(), false).isInfinity());
1586 EXPECT_FALSE(APFloat::getZero(APFloat::IEEEsingle(), false).isInfinity());
1587 EXPECT_FALSE(APFloat::getNaN(APFloat::IEEEsingle(), false).isInfinity());
1588 EXPECT_FALSE(APFloat::getSNaN(APFloat::IEEEsingle(), false).isInfinity());
1589 EXPECT_FALSE(APFloat(APFloat::IEEEsingle(), "0x1p-149").isInfinity());
1592 TEST(APFloatTest, isNaN) {
1593 APFloat t(APFloat::IEEEsingle(), "0x1p+0");
1594 EXPECT_FALSE(t.isNaN());
1595 EXPECT_FALSE(APFloat::getInf(APFloat::IEEEsingle(), false).isNaN());
1596 EXPECT_FALSE(APFloat::getZero(APFloat::IEEEsingle(), false).isNaN());
1597 EXPECT_TRUE(APFloat::getNaN(APFloat::IEEEsingle(), false).isNaN());
1598 EXPECT_TRUE(APFloat::getSNaN(APFloat::IEEEsingle(), false).isNaN());
1599 EXPECT_FALSE(APFloat(APFloat::IEEEsingle(), "0x1p-149").isNaN());
1602 TEST(APFloatTest, isFiniteNonZero) {
1603 // Test positive/negative normal value.
1604 EXPECT_TRUE(APFloat(APFloat::IEEEsingle(), "0x1p+0").isFiniteNonZero());
1605 EXPECT_TRUE(APFloat(APFloat::IEEEsingle(), "-0x1p+0").isFiniteNonZero());
1607 // Test positive/negative denormal value.
1608 EXPECT_TRUE(APFloat(APFloat::IEEEsingle(), "0x1p-149").isFiniteNonZero());
1609 EXPECT_TRUE(APFloat(APFloat::IEEEsingle(), "-0x1p-149").isFiniteNonZero());
1611 // Test +/- Infinity.
1612 EXPECT_FALSE(APFloat::getInf(APFloat::IEEEsingle(), false).isFiniteNonZero());
1613 EXPECT_FALSE(APFloat::getInf(APFloat::IEEEsingle(), true).isFiniteNonZero());
1616 EXPECT_FALSE(APFloat::getZero(APFloat::IEEEsingle(), false).isFiniteNonZero());
1617 EXPECT_FALSE(APFloat::getZero(APFloat::IEEEsingle(), true).isFiniteNonZero());
1619 // Test +/- qNaN. +/- dont mean anything with qNaN but paranoia can't hurt in
1621 EXPECT_FALSE(APFloat::getNaN(APFloat::IEEEsingle(), false).isFiniteNonZero());
1622 EXPECT_FALSE(APFloat::getNaN(APFloat::IEEEsingle(), true).isFiniteNonZero());
1624 // Test +/- sNaN. +/- dont mean anything with sNaN but paranoia can't hurt in
1626 EXPECT_FALSE(APFloat::getSNaN(APFloat::IEEEsingle(), false).isFiniteNonZero());
1627 EXPECT_FALSE(APFloat::getSNaN(APFloat::IEEEsingle(), true).isFiniteNonZero());
1630 TEST(APFloatTest, add) {
1631 // Test Special Cases against each other and normal values.
1634 // 1. Since we perform only default exception handling all operations with
1635 // signaling NaNs should have a result that is a quiet NaN. Currently they
1638 APFloat PInf = APFloat::getInf(APFloat::IEEEsingle(), false);
1639 APFloat MInf = APFloat::getInf(APFloat::IEEEsingle(), true);
1640 APFloat PZero = APFloat::getZero(APFloat::IEEEsingle(), false);
1641 APFloat MZero = APFloat::getZero(APFloat::IEEEsingle(), true);
1642 APFloat QNaN = APFloat::getNaN(APFloat::IEEEsingle(), false);
1643 APFloat SNaN = APFloat::getSNaN(APFloat::IEEEsingle(), false);
1644 APFloat PNormalValue = APFloat(APFloat::IEEEsingle(), "0x1p+0");
1645 APFloat MNormalValue = APFloat(APFloat::IEEEsingle(), "-0x1p+0");
1646 APFloat PLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), false);
1647 APFloat MLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), true);
1648 APFloat PSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), false);
1649 APFloat MSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), true);
1650 APFloat PSmallestNormalized =
1651 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), false);
1652 APFloat MSmallestNormalized =
1653 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), true);
1655 const int OverflowStatus = APFloat::opOverflow | APFloat::opInexact;
1657 const unsigned NumTests = 169;
1664 } SpecialCaseTests[NumTests] = {
1665 { PInf, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1666 { PInf, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1667 { PInf, PZero, "inf", APFloat::opOK, APFloat::fcInfinity },
1668 { PInf, MZero, "inf", APFloat::opOK, APFloat::fcInfinity },
1669 { PInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1672 { PInf, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1674 { PInf, PNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
1675 { PInf, MNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
1676 { PInf, PLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
1677 { PInf, MLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
1678 { PInf, PSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
1679 { PInf, MSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
1680 { PInf, PSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity },
1681 { PInf, MSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity },
1682 { MInf, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1683 { MInf, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1684 { MInf, PZero, "-inf", APFloat::opOK, APFloat::fcInfinity },
1685 { MInf, MZero, "-inf", APFloat::opOK, APFloat::fcInfinity },
1686 { MInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1689 { MInf, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1691 { MInf, PNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
1692 { MInf, MNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
1693 { MInf, PLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
1694 { MInf, MLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
1695 { MInf, PSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
1696 { MInf, MSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
1697 { MInf, PSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity },
1698 { MInf, MSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity },
1699 { PZero, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1700 { PZero, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1701 { PZero, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1702 { PZero, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1703 { PZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1706 { PZero, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1708 { PZero, PNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
1709 { PZero, MNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
1710 { PZero, PLargestValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
1711 { PZero, MLargestValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
1712 { PZero, PSmallestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
1713 { PZero, MSmallestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
1714 { PZero, PSmallestNormalized, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
1715 { PZero, MSmallestNormalized, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
1716 { MZero, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1717 { MZero, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1718 { MZero, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1719 { MZero, MZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
1720 { MZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1723 { MZero, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1725 { MZero, PNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
1726 { MZero, MNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
1727 { MZero, PLargestValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
1728 { MZero, MLargestValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
1729 { MZero, PSmallestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
1730 { MZero, MSmallestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
1731 { MZero, PSmallestNormalized, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
1732 { MZero, MSmallestNormalized, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
1733 { QNaN, PInf, "nan", APFloat::opOK, APFloat::fcNaN },
1734 { QNaN, MInf, "nan", APFloat::opOK, APFloat::fcNaN },
1735 { QNaN, PZero, "nan", APFloat::opOK, APFloat::fcNaN },
1736 { QNaN, MZero, "nan", APFloat::opOK, APFloat::fcNaN },
1737 { QNaN, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1740 { QNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1742 { QNaN, PNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
1743 { QNaN, MNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
1744 { QNaN, PLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
1745 { QNaN, MLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
1746 { QNaN, PSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
1747 { QNaN, MSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
1748 { QNaN, PSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
1749 { QNaN, MSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
1752 { SNaN, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1753 { SNaN, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1754 { SNaN, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1755 { SNaN, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1756 { SNaN, QNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1757 { SNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1758 { SNaN, PNormalValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1759 { SNaN, MNormalValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1760 { SNaN, PLargestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1761 { SNaN, MLargestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1762 { SNaN, PSmallestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1763 { SNaN, MSmallestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1764 { SNaN, PSmallestNormalized, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1765 { SNaN, MSmallestNormalized, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1767 { PNormalValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1768 { PNormalValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1769 { PNormalValue, PZero, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
1770 { PNormalValue, MZero, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
1771 { PNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1774 { PNormalValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1776 { PNormalValue, PNormalValue, "0x1p+1", APFloat::opOK, APFloat::fcNormal },
1777 { PNormalValue, MNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1778 { PNormalValue, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1779 { PNormalValue, MLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1780 { PNormalValue, PSmallestValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1781 { PNormalValue, MSmallestValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1782 { PNormalValue, PSmallestNormalized, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1783 { PNormalValue, MSmallestNormalized, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1784 { MNormalValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1785 { MNormalValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1786 { MNormalValue, PZero, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
1787 { MNormalValue, MZero, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
1788 { MNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1791 { MNormalValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1793 { MNormalValue, PNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1794 { MNormalValue, MNormalValue, "-0x1p+1", APFloat::opOK, APFloat::fcNormal },
1795 { MNormalValue, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1796 { MNormalValue, MLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1797 { MNormalValue, PSmallestValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1798 { MNormalValue, MSmallestValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1799 { MNormalValue, PSmallestNormalized, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1800 { MNormalValue, MSmallestNormalized, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1801 { PLargestValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1802 { PLargestValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1803 { PLargestValue, PZero, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
1804 { PLargestValue, MZero, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
1805 { PLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1808 { PLargestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1810 { PLargestValue, PNormalValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1811 { PLargestValue, MNormalValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1812 { PLargestValue, PLargestValue, "inf", OverflowStatus, APFloat::fcInfinity },
1813 { PLargestValue, MLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1814 { PLargestValue, PSmallestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1815 { PLargestValue, MSmallestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1816 { PLargestValue, PSmallestNormalized, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1817 { PLargestValue, MSmallestNormalized, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1818 { MLargestValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1819 { MLargestValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1820 { MLargestValue, PZero, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
1821 { MLargestValue, MZero, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
1822 { MLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1825 { MLargestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1827 { MLargestValue, PNormalValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1828 { MLargestValue, MNormalValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1829 { MLargestValue, PLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1830 { MLargestValue, MLargestValue, "-inf", OverflowStatus, APFloat::fcInfinity },
1831 { MLargestValue, PSmallestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1832 { MLargestValue, MSmallestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1833 { MLargestValue, PSmallestNormalized, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1834 { MLargestValue, MSmallestNormalized, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1835 { PSmallestValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1836 { PSmallestValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1837 { PSmallestValue, PZero, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
1838 { PSmallestValue, MZero, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
1839 { PSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1842 { PSmallestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1844 { PSmallestValue, PNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1845 { PSmallestValue, MNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1846 { PSmallestValue, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1847 { PSmallestValue, MLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1848 { PSmallestValue, PSmallestValue, "0x1p-148", APFloat::opOK, APFloat::fcNormal },
1849 { PSmallestValue, MSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1850 { PSmallestValue, PSmallestNormalized, "0x1.000002p-126", APFloat::opOK, APFloat::fcNormal },
1851 { PSmallestValue, MSmallestNormalized, "-0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal },
1852 { MSmallestValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1853 { MSmallestValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1854 { MSmallestValue, PZero, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
1855 { MSmallestValue, MZero, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
1856 { MSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1859 { MSmallestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1861 { MSmallestValue, PNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1862 { MSmallestValue, MNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1863 { MSmallestValue, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1864 { MSmallestValue, MLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1865 { MSmallestValue, PSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1866 { MSmallestValue, MSmallestValue, "-0x1p-148", APFloat::opOK, APFloat::fcNormal },
1867 { MSmallestValue, PSmallestNormalized, "0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal },
1868 { MSmallestValue, MSmallestNormalized, "-0x1.000002p-126", APFloat::opOK, APFloat::fcNormal },
1869 { PSmallestNormalized, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1870 { PSmallestNormalized, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1871 { PSmallestNormalized, PZero, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
1872 { PSmallestNormalized, MZero, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
1873 { PSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1876 { PSmallestNormalized, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1878 { PSmallestNormalized, PNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1879 { PSmallestNormalized, MNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1880 { PSmallestNormalized, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1881 { PSmallestNormalized, MLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1882 { PSmallestNormalized, PSmallestValue, "0x1.000002p-126", APFloat::opOK, APFloat::fcNormal },
1883 { PSmallestNormalized, MSmallestValue, "0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal },
1884 { PSmallestNormalized, PSmallestNormalized, "0x1p-125", APFloat::opOK, APFloat::fcNormal },
1885 { PSmallestNormalized, MSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1886 { MSmallestNormalized, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1887 { MSmallestNormalized, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1888 { MSmallestNormalized, PZero, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
1889 { MSmallestNormalized, MZero, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
1890 { MSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1893 { MSmallestNormalized, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1895 { MSmallestNormalized, PNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1896 { MSmallestNormalized, MNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1897 { MSmallestNormalized, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1898 { MSmallestNormalized, MLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1899 { MSmallestNormalized, PSmallestValue, "-0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal },
1900 { MSmallestNormalized, MSmallestValue, "-0x1.000002p-126", APFloat::opOK, APFloat::fcNormal },
1901 { MSmallestNormalized, PSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1902 { MSmallestNormalized, MSmallestNormalized, "-0x1p-125", APFloat::opOK, APFloat::fcNormal }
1905 for (size_t i = 0; i < NumTests; ++i) {
1906 APFloat x(SpecialCaseTests[i].x);
1907 APFloat y(SpecialCaseTests[i].y);
1908 APFloat::opStatus status = x.add(y, APFloat::rmNearestTiesToEven);
1910 APFloat result(APFloat::IEEEsingle(), SpecialCaseTests[i].result);
1912 EXPECT_TRUE(result.bitwiseIsEqual(x));
1913 EXPECT_TRUE((int)status == SpecialCaseTests[i].status);
1914 EXPECT_TRUE((int)x.getCategory() == SpecialCaseTests[i].category);
1918 TEST(APFloatTest, subtract) {
1919 // Test Special Cases against each other and normal values.
1922 // 1. Since we perform only default exception handling all operations with
1923 // signaling NaNs should have a result that is a quiet NaN. Currently they
1926 APFloat PInf = APFloat::getInf(APFloat::IEEEsingle(), false);
1927 APFloat MInf = APFloat::getInf(APFloat::IEEEsingle(), true);
1928 APFloat PZero = APFloat::getZero(APFloat::IEEEsingle(), false);
1929 APFloat MZero = APFloat::getZero(APFloat::IEEEsingle(), true);
1930 APFloat QNaN = APFloat::getNaN(APFloat::IEEEsingle(), false);
1931 APFloat SNaN = APFloat::getSNaN(APFloat::IEEEsingle(), false);
1932 APFloat PNormalValue = APFloat(APFloat::IEEEsingle(), "0x1p+0");
1933 APFloat MNormalValue = APFloat(APFloat::IEEEsingle(), "-0x1p+0");
1934 APFloat PLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), false);
1935 APFloat MLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), true);
1936 APFloat PSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), false);
1937 APFloat MSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), true);
1938 APFloat PSmallestNormalized =
1939 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), false);
1940 APFloat MSmallestNormalized =
1941 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), true);
1943 const int OverflowStatus = APFloat::opOverflow | APFloat::opInexact;
1945 const unsigned NumTests = 169;
1952 } SpecialCaseTests[NumTests] = {
1953 { PInf, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1954 { PInf, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1955 { PInf, PZero, "inf", APFloat::opOK, APFloat::fcInfinity },
1956 { PInf, MZero, "inf", APFloat::opOK, APFloat::fcInfinity },
1957 { PInf, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
1960 { PInf, SNaN, "-nan", APFloat::opInvalidOp, APFloat::fcNaN },
1962 { PInf, PNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
1963 { PInf, MNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
1964 { PInf, PLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
1965 { PInf, MLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
1966 { PInf, PSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
1967 { PInf, MSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
1968 { PInf, PSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity },
1969 { PInf, MSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity },
1970 { MInf, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1971 { MInf, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1972 { MInf, PZero, "-inf", APFloat::opOK, APFloat::fcInfinity },
1973 { MInf, MZero, "-inf", APFloat::opOK, APFloat::fcInfinity },
1974 { MInf, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
1977 { MInf, SNaN, "-nan", APFloat::opInvalidOp, APFloat::fcNaN },
1979 { MInf, PNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
1980 { MInf, MNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
1981 { MInf, PLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
1982 { MInf, MLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
1983 { MInf, PSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
1984 { MInf, MSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
1985 { MInf, PSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity },
1986 { MInf, MSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity },
1987 { PZero, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1988 { PZero, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1989 { PZero, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1990 { PZero, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1991 { PZero, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
1994 { PZero, SNaN, "-nan", APFloat::opInvalidOp, APFloat::fcNaN },
1996 { PZero, PNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
1997 { PZero, MNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
1998 { PZero, PLargestValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
1999 { PZero, MLargestValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2000 { PZero, PSmallestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2001 { PZero, MSmallestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2002 { PZero, PSmallestNormalized, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2003 { PZero, MSmallestNormalized, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2004 { MZero, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2005 { MZero, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2006 { MZero, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2007 { MZero, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2008 { MZero, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
2011 { MZero, SNaN, "-nan", APFloat::opInvalidOp, APFloat::fcNaN },
2013 { MZero, PNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2014 { MZero, MNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2015 { MZero, PLargestValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2016 { MZero, MLargestValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2017 { MZero, PSmallestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2018 { MZero, MSmallestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2019 { MZero, PSmallestNormalized, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2020 { MZero, MSmallestNormalized, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2021 { QNaN, PInf, "nan", APFloat::opOK, APFloat::fcNaN },
2022 { QNaN, MInf, "nan", APFloat::opOK, APFloat::fcNaN },
2023 { QNaN, PZero, "nan", APFloat::opOK, APFloat::fcNaN },
2024 { QNaN, MZero, "nan", APFloat::opOK, APFloat::fcNaN },
2025 { QNaN, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2028 { QNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2030 { QNaN, PNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
2031 { QNaN, MNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
2032 { QNaN, PLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2033 { QNaN, MLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2034 { QNaN, PSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2035 { QNaN, MSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2036 { QNaN, PSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
2037 { QNaN, MSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
2040 { SNaN, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2041 { SNaN, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2042 { SNaN, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2043 { SNaN, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2044 { SNaN, QNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2045 { SNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2046 { SNaN, PNormalValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2047 { SNaN, MNormalValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2048 { SNaN, PLargestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2049 { SNaN, MLargestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2050 { SNaN, PSmallestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2051 { SNaN, MSmallestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2052 { SNaN, PSmallestNormalized, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2053 { SNaN, MSmallestNormalized, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2055 { PNormalValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2056 { PNormalValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2057 { PNormalValue, PZero, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2058 { PNormalValue, MZero, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2059 { PNormalValue, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
2062 { PNormalValue, SNaN, "-nan", APFloat::opInvalidOp, APFloat::fcNaN },
2064 { PNormalValue, PNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2065 { PNormalValue, MNormalValue, "0x1p+1", APFloat::opOK, APFloat::fcNormal },
2066 { PNormalValue, PLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2067 { PNormalValue, MLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2068 { PNormalValue, PSmallestValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2069 { PNormalValue, MSmallestValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2070 { PNormalValue, PSmallestNormalized, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2071 { PNormalValue, MSmallestNormalized, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2072 { MNormalValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2073 { MNormalValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2074 { MNormalValue, PZero, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2075 { MNormalValue, MZero, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2076 { MNormalValue, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
2079 { MNormalValue, SNaN, "-nan", APFloat::opInvalidOp, APFloat::fcNaN },
2081 { MNormalValue, PNormalValue, "-0x1p+1", APFloat::opOK, APFloat::fcNormal },
2082 { MNormalValue, MNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2083 { MNormalValue, PLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2084 { MNormalValue, MLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2085 { MNormalValue, PSmallestValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2086 { MNormalValue, MSmallestValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2087 { MNormalValue, PSmallestNormalized, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2088 { MNormalValue, MSmallestNormalized, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2089 { PLargestValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2090 { PLargestValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2091 { PLargestValue, PZero, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2092 { PLargestValue, MZero, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2093 { PLargestValue, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
2096 { PLargestValue, SNaN, "-nan", APFloat::opInvalidOp, APFloat::fcNaN },
2098 { PLargestValue, PNormalValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2099 { PLargestValue, MNormalValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2100 { PLargestValue, PLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2101 { PLargestValue, MLargestValue, "inf", OverflowStatus, APFloat::fcInfinity },
2102 { PLargestValue, PSmallestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2103 { PLargestValue, MSmallestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2104 { PLargestValue, PSmallestNormalized, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2105 { PLargestValue, MSmallestNormalized, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2106 { MLargestValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2107 { MLargestValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2108 { MLargestValue, PZero, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2109 { MLargestValue, MZero, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2110 { MLargestValue, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
2113 { MLargestValue, SNaN, "-nan", APFloat::opInvalidOp, APFloat::fcNaN },
2115 { MLargestValue, PNormalValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2116 { MLargestValue, MNormalValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2117 { MLargestValue, PLargestValue, "-inf", OverflowStatus, APFloat::fcInfinity },
2118 { MLargestValue, MLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2119 { MLargestValue, PSmallestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2120 { MLargestValue, MSmallestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2121 { MLargestValue, PSmallestNormalized, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2122 { MLargestValue, MSmallestNormalized, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2123 { PSmallestValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2124 { PSmallestValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2125 { PSmallestValue, PZero, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2126 { PSmallestValue, MZero, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2127 { PSmallestValue, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
2130 { PSmallestValue, SNaN, "-nan", APFloat::opInvalidOp, APFloat::fcNaN },
2132 { PSmallestValue, PNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2133 { PSmallestValue, MNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2134 { PSmallestValue, PLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2135 { PSmallestValue, MLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2136 { PSmallestValue, PSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2137 { PSmallestValue, MSmallestValue, "0x1p-148", APFloat::opOK, APFloat::fcNormal },
2138 { PSmallestValue, PSmallestNormalized, "-0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal },
2139 { PSmallestValue, MSmallestNormalized, "0x1.000002p-126", APFloat::opOK, APFloat::fcNormal },
2140 { MSmallestValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2141 { MSmallestValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2142 { MSmallestValue, PZero, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2143 { MSmallestValue, MZero, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2144 { MSmallestValue, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
2147 { MSmallestValue, SNaN, "-nan", APFloat::opInvalidOp, APFloat::fcNaN },
2149 { MSmallestValue, PNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2150 { MSmallestValue, MNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2151 { MSmallestValue, PLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2152 { MSmallestValue, MLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2153 { MSmallestValue, PSmallestValue, "-0x1p-148", APFloat::opOK, APFloat::fcNormal },
2154 { MSmallestValue, MSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2155 { MSmallestValue, PSmallestNormalized, "-0x1.000002p-126", APFloat::opOK, APFloat::fcNormal },
2156 { MSmallestValue, MSmallestNormalized, "0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal },
2157 { PSmallestNormalized, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2158 { PSmallestNormalized, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2159 { PSmallestNormalized, PZero, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2160 { PSmallestNormalized, MZero, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2161 { PSmallestNormalized, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
2164 { PSmallestNormalized, SNaN, "-nan", APFloat::opInvalidOp, APFloat::fcNaN },
2166 { PSmallestNormalized, PNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2167 { PSmallestNormalized, MNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2168 { PSmallestNormalized, PLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2169 { PSmallestNormalized, MLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2170 { PSmallestNormalized, PSmallestValue, "0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal },
2171 { PSmallestNormalized, MSmallestValue, "0x1.000002p-126", APFloat::opOK, APFloat::fcNormal },
2172 { PSmallestNormalized, PSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2173 { PSmallestNormalized, MSmallestNormalized, "0x1p-125", APFloat::opOK, APFloat::fcNormal },
2174 { MSmallestNormalized, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2175 { MSmallestNormalized, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2176 { MSmallestNormalized, PZero, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2177 { MSmallestNormalized, MZero, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2178 { MSmallestNormalized, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
2181 { MSmallestNormalized, SNaN, "-nan", APFloat::opInvalidOp, APFloat::fcNaN },
2183 { MSmallestNormalized, PNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2184 { MSmallestNormalized, MNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2185 { MSmallestNormalized, PLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2186 { MSmallestNormalized, MLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2187 { MSmallestNormalized, PSmallestValue, "-0x1.000002p-126", APFloat::opOK, APFloat::fcNormal },
2188 { MSmallestNormalized, MSmallestValue, "-0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal },
2189 { MSmallestNormalized, PSmallestNormalized, "-0x1p-125", APFloat::opOK, APFloat::fcNormal },
2190 { MSmallestNormalized, MSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero }
2193 for (size_t i = 0; i < NumTests; ++i) {
2194 APFloat x(SpecialCaseTests[i].x);
2195 APFloat y(SpecialCaseTests[i].y);
2196 APFloat::opStatus status = x.subtract(y, APFloat::rmNearestTiesToEven);
2198 APFloat result(APFloat::IEEEsingle(), SpecialCaseTests[i].result);
2200 EXPECT_TRUE(result.bitwiseIsEqual(x));
2201 EXPECT_TRUE((int)status == SpecialCaseTests[i].status);
2202 EXPECT_TRUE((int)x.getCategory() == SpecialCaseTests[i].category);
2206 TEST(APFloatTest, multiply) {
2207 // Test Special Cases against each other and normal values.
2210 // 1. Since we perform only default exception handling all operations with
2211 // signaling NaNs should have a result that is a quiet NaN. Currently they
2214 APFloat PInf = APFloat::getInf(APFloat::IEEEsingle(), false);
2215 APFloat MInf = APFloat::getInf(APFloat::IEEEsingle(), true);
2216 APFloat PZero = APFloat::getZero(APFloat::IEEEsingle(), false);
2217 APFloat MZero = APFloat::getZero(APFloat::IEEEsingle(), true);
2218 APFloat QNaN = APFloat::getNaN(APFloat::IEEEsingle(), false);
2219 APFloat SNaN = APFloat::getSNaN(APFloat::IEEEsingle(), false);
2220 APFloat PNormalValue = APFloat(APFloat::IEEEsingle(), "0x1p+0");
2221 APFloat MNormalValue = APFloat(APFloat::IEEEsingle(), "-0x1p+0");
2222 APFloat PLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), false);
2223 APFloat MLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), true);
2224 APFloat PSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), false);
2225 APFloat MSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), true);
2226 APFloat PSmallestNormalized =
2227 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), false);
2228 APFloat MSmallestNormalized =
2229 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), true);
2231 const int OverflowStatus = APFloat::opOverflow | APFloat::opInexact;
2232 const int UnderflowStatus = APFloat::opUnderflow | APFloat::opInexact;
2234 const unsigned NumTests = 169;
2241 } SpecialCaseTests[NumTests] = {
2242 { PInf, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2243 { PInf, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2244 { PInf, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2245 { PInf, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2246 { PInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2249 { PInf, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2251 { PInf, PNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2252 { PInf, MNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2253 { PInf, PLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2254 { PInf, MLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2255 { PInf, PSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2256 { PInf, MSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2257 { PInf, PSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity },
2258 { PInf, MSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity },
2259 { MInf, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2260 { MInf, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2261 { MInf, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2262 { MInf, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2263 { MInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2266 { MInf, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2268 { MInf, PNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2269 { MInf, MNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2270 { MInf, PLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2271 { MInf, MLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2272 { MInf, PSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2273 { MInf, MSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2274 { MInf, PSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity },
2275 { MInf, MSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity },
2276 { PZero, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2277 { PZero, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2278 { PZero, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2279 { PZero, MZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2280 { PZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2283 { PZero, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2285 { PZero, PNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2286 { PZero, MNormalValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2287 { PZero, PLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2288 { PZero, MLargestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2289 { PZero, PSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2290 { PZero, MSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2291 { PZero, PSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2292 { PZero, MSmallestNormalized, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2293 { MZero, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2294 { MZero, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2295 { MZero, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2296 { MZero, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2297 { MZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2300 { MZero, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2302 { MZero, PNormalValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2303 { MZero, MNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2304 { MZero, PLargestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2305 { MZero, MLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2306 { MZero, PSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2307 { MZero, MSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2308 { MZero, PSmallestNormalized, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2309 { MZero, MSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2310 { QNaN, PInf, "nan", APFloat::opOK, APFloat::fcNaN },
2311 { QNaN, MInf, "nan", APFloat::opOK, APFloat::fcNaN },
2312 { QNaN, PZero, "nan", APFloat::opOK, APFloat::fcNaN },
2313 { QNaN, MZero, "nan", APFloat::opOK, APFloat::fcNaN },
2314 { QNaN, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2317 { QNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2319 { QNaN, PNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
2320 { QNaN, MNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
2321 { QNaN, PLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2322 { QNaN, MLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2323 { QNaN, PSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2324 { QNaN, MSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2325 { QNaN, PSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
2326 { QNaN, MSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
2329 { SNaN, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2330 { SNaN, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2331 { SNaN, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2332 { SNaN, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2333 { SNaN, QNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2334 { SNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2335 { SNaN, PNormalValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2336 { SNaN, MNormalValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2337 { SNaN, PLargestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2338 { SNaN, MLargestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2339 { SNaN, PSmallestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2340 { SNaN, MSmallestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2341 { SNaN, PSmallestNormalized, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2342 { SNaN, MSmallestNormalized, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2344 { PNormalValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2345 { PNormalValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2346 { PNormalValue, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2347 { PNormalValue, MZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2348 { PNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2351 { PNormalValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2353 { PNormalValue, PNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2354 { PNormalValue, MNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2355 { PNormalValue, PLargestValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2356 { PNormalValue, MLargestValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2357 { PNormalValue, PSmallestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2358 { PNormalValue, MSmallestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2359 { PNormalValue, PSmallestNormalized, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2360 { PNormalValue, MSmallestNormalized, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2361 { MNormalValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2362 { MNormalValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2363 { MNormalValue, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2364 { MNormalValue, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2365 { MNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2368 { MNormalValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2370 { MNormalValue, PNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2371 { MNormalValue, MNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2372 { MNormalValue, PLargestValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2373 { MNormalValue, MLargestValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2374 { MNormalValue, PSmallestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2375 { MNormalValue, MSmallestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2376 { MNormalValue, PSmallestNormalized, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2377 { MNormalValue, MSmallestNormalized, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2378 { PLargestValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2379 { PLargestValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2380 { PLargestValue, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2381 { PLargestValue, MZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2382 { PLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2385 { PLargestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2387 { PLargestValue, PNormalValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2388 { PLargestValue, MNormalValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2389 { PLargestValue, PLargestValue, "inf", OverflowStatus, APFloat::fcInfinity },
2390 { PLargestValue, MLargestValue, "-inf", OverflowStatus, APFloat::fcInfinity },
2391 { PLargestValue, PSmallestValue, "0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal },
2392 { PLargestValue, MSmallestValue, "-0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal },
2393 { PLargestValue, PSmallestNormalized, "0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal },
2394 { PLargestValue, MSmallestNormalized, "-0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal },
2395 { MLargestValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2396 { MLargestValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2397 { MLargestValue, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2398 { MLargestValue, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2399 { MLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2402 { MLargestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2404 { MLargestValue, PNormalValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2405 { MLargestValue, MNormalValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2406 { MLargestValue, PLargestValue, "-inf", OverflowStatus, APFloat::fcInfinity },
2407 { MLargestValue, MLargestValue, "inf", OverflowStatus, APFloat::fcInfinity },
2408 { MLargestValue, PSmallestValue, "-0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal },
2409 { MLargestValue, MSmallestValue, "0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal },
2410 { MLargestValue, PSmallestNormalized, "-0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal },
2411 { MLargestValue, MSmallestNormalized, "0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal },
2412 { PSmallestValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2413 { PSmallestValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2414 { PSmallestValue, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2415 { PSmallestValue, MZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2416 { PSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2419 { PSmallestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2421 { PSmallestValue, PNormalValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2422 { PSmallestValue, MNormalValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2423 { PSmallestValue, PLargestValue, "0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal },
2424 { PSmallestValue, MLargestValue, "-0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal },
2425 { PSmallestValue, PSmallestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero },
2426 { PSmallestValue, MSmallestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2427 { PSmallestValue, PSmallestNormalized, "0x0p+0", UnderflowStatus, APFloat::fcZero },
2428 { PSmallestValue, MSmallestNormalized, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2429 { MSmallestValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2430 { MSmallestValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2431 { MSmallestValue, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2432 { MSmallestValue, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2433 { MSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2436 { MSmallestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2438 { MSmallestValue, PNormalValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2439 { MSmallestValue, MNormalValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2440 { MSmallestValue, PLargestValue, "-0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal },
2441 { MSmallestValue, MLargestValue, "0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal },
2442 { MSmallestValue, PSmallestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2443 { MSmallestValue, MSmallestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero },
2444 { MSmallestValue, PSmallestNormalized, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2445 { MSmallestValue, MSmallestNormalized, "0x0p+0", UnderflowStatus, APFloat::fcZero },
2446 { PSmallestNormalized, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2447 { PSmallestNormalized, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2448 { PSmallestNormalized, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2449 { PSmallestNormalized, MZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2450 { PSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2453 { PSmallestNormalized, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2455 { PSmallestNormalized, PNormalValue, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2456 { PSmallestNormalized, MNormalValue, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2457 { PSmallestNormalized, PLargestValue, "0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal },
2458 { PSmallestNormalized, MLargestValue, "-0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal },
2459 { PSmallestNormalized, PSmallestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero },
2460 { PSmallestNormalized, MSmallestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2461 { PSmallestNormalized, PSmallestNormalized, "0x0p+0", UnderflowStatus, APFloat::fcZero },
2462 { PSmallestNormalized, MSmallestNormalized, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2463 { MSmallestNormalized, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2464 { MSmallestNormalized, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2465 { MSmallestNormalized, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2466 { MSmallestNormalized, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2467 { MSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2470 { MSmallestNormalized, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2472 { MSmallestNormalized, PNormalValue, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2473 { MSmallestNormalized, MNormalValue, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2474 { MSmallestNormalized, PLargestValue, "-0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal },
2475 { MSmallestNormalized, MLargestValue, "0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal },
2476 { MSmallestNormalized, PSmallestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2477 { MSmallestNormalized, MSmallestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero },
2478 { MSmallestNormalized, PSmallestNormalized, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2479 { MSmallestNormalized, MSmallestNormalized, "0x0p+0", UnderflowStatus, APFloat::fcZero }
2482 for (size_t i = 0; i < NumTests; ++i) {
2483 APFloat x(SpecialCaseTests[i].x);
2484 APFloat y(SpecialCaseTests[i].y);
2485 APFloat::opStatus status = x.multiply(y, APFloat::rmNearestTiesToEven);
2487 APFloat result(APFloat::IEEEsingle(), SpecialCaseTests[i].result);
2489 EXPECT_TRUE(result.bitwiseIsEqual(x));
2490 EXPECT_TRUE((int)status == SpecialCaseTests[i].status);
2491 EXPECT_TRUE((int)x.getCategory() == SpecialCaseTests[i].category);
2495 TEST(APFloatTest, divide) {
2496 // Test Special Cases against each other and normal values.
2499 // 1. Since we perform only default exception handling all operations with
2500 // signaling NaNs should have a result that is a quiet NaN. Currently they
2503 APFloat PInf = APFloat::getInf(APFloat::IEEEsingle(), false);
2504 APFloat MInf = APFloat::getInf(APFloat::IEEEsingle(), true);
2505 APFloat PZero = APFloat::getZero(APFloat::IEEEsingle(), false);
2506 APFloat MZero = APFloat::getZero(APFloat::IEEEsingle(), true);
2507 APFloat QNaN = APFloat::getNaN(APFloat::IEEEsingle(), false);
2508 APFloat SNaN = APFloat::getSNaN(APFloat::IEEEsingle(), false);
2509 APFloat PNormalValue = APFloat(APFloat::IEEEsingle(), "0x1p+0");
2510 APFloat MNormalValue = APFloat(APFloat::IEEEsingle(), "-0x1p+0");
2511 APFloat PLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), false);
2512 APFloat MLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), true);
2513 APFloat PSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), false);
2514 APFloat MSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), true);
2515 APFloat PSmallestNormalized =
2516 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), false);
2517 APFloat MSmallestNormalized =
2518 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), true);
2520 const int OverflowStatus = APFloat::opOverflow | APFloat::opInexact;
2521 const int UnderflowStatus = APFloat::opUnderflow | APFloat::opInexact;
2523 const unsigned NumTests = 169;
2530 } SpecialCaseTests[NumTests] = {
2531 { PInf, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2532 { PInf, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2533 { PInf, PZero, "inf", APFloat::opOK, APFloat::fcInfinity },
2534 { PInf, MZero, "-inf", APFloat::opOK, APFloat::fcInfinity },
2535 { PInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2538 { PInf, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2540 { PInf, PNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2541 { PInf, MNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2542 { PInf, PLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2543 { PInf, MLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2544 { PInf, PSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2545 { PInf, MSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2546 { PInf, PSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity },
2547 { PInf, MSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity },
2548 { MInf, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2549 { MInf, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2550 { MInf, PZero, "-inf", APFloat::opOK, APFloat::fcInfinity },
2551 { MInf, MZero, "inf", APFloat::opOK, APFloat::fcInfinity },
2552 { MInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2555 { MInf, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2557 { MInf, PNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2558 { MInf, MNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2559 { MInf, PLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2560 { MInf, MLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2561 { MInf, PSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2562 { MInf, MSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2563 { MInf, PSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity },
2564 { MInf, MSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity },
2565 { PZero, PInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2566 { PZero, MInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2567 { PZero, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2568 { PZero, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2569 { PZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2572 { PZero, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2574 { PZero, PNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2575 { PZero, MNormalValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2576 { PZero, PLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2577 { PZero, MLargestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2578 { PZero, PSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2579 { PZero, MSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2580 { PZero, PSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2581 { PZero, MSmallestNormalized, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2582 { MZero, PInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2583 { MZero, MInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2584 { MZero, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2585 { MZero, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2586 { MZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2589 { MZero, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2591 { MZero, PNormalValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2592 { MZero, MNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2593 { MZero, PLargestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2594 { MZero, MLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2595 { MZero, PSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2596 { MZero, MSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2597 { MZero, PSmallestNormalized, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2598 { MZero, MSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2599 { QNaN, PInf, "nan", APFloat::opOK, APFloat::fcNaN },
2600 { QNaN, MInf, "nan", APFloat::opOK, APFloat::fcNaN },
2601 { QNaN, PZero, "nan", APFloat::opOK, APFloat::fcNaN },
2602 { QNaN, MZero, "nan", APFloat::opOK, APFloat::fcNaN },
2603 { QNaN, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2606 { QNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2608 { QNaN, PNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
2609 { QNaN, MNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
2610 { QNaN, PLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2611 { QNaN, MLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2612 { QNaN, PSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2613 { QNaN, MSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2614 { QNaN, PSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
2615 { QNaN, MSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
2618 { SNaN, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2619 { SNaN, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2620 { SNaN, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2621 { SNaN, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2622 { SNaN, QNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2623 { SNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2624 { SNaN, PNormalValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2625 { SNaN, MNormalValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2626 { SNaN, PLargestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2627 { SNaN, MLargestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2628 { SNaN, PSmallestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2629 { SNaN, MSmallestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2630 { SNaN, PSmallestNormalized, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2631 { SNaN, MSmallestNormalized, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2633 { PNormalValue, PInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2634 { PNormalValue, MInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2635 { PNormalValue, PZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
2636 { PNormalValue, MZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
2637 { PNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2640 { PNormalValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2642 { PNormalValue, PNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2643 { PNormalValue, MNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2644 { PNormalValue, PLargestValue, "0x1p-128", UnderflowStatus, APFloat::fcNormal },
2645 { PNormalValue, MLargestValue, "-0x1p-128", UnderflowStatus, APFloat::fcNormal },
2646 { PNormalValue, PSmallestValue, "inf", OverflowStatus, APFloat::fcInfinity },
2647 { PNormalValue, MSmallestValue, "-inf", OverflowStatus, APFloat::fcInfinity },
2648 { PNormalValue, PSmallestNormalized, "0x1p+126", APFloat::opOK, APFloat::fcNormal },
2649 { PNormalValue, MSmallestNormalized, "-0x1p+126", APFloat::opOK, APFloat::fcNormal },
2650 { MNormalValue, PInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2651 { MNormalValue, MInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2652 { MNormalValue, PZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
2653 { MNormalValue, MZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
2654 { MNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2657 { MNormalValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2659 { MNormalValue, PNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2660 { MNormalValue, MNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2661 { MNormalValue, PLargestValue, "-0x1p-128", UnderflowStatus, APFloat::fcNormal },
2662 { MNormalValue, MLargestValue, "0x1p-128", UnderflowStatus, APFloat::fcNormal },
2663 { MNormalValue, PSmallestValue, "-inf", OverflowStatus, APFloat::fcInfinity },
2664 { MNormalValue, MSmallestValue, "inf", OverflowStatus, APFloat::fcInfinity },
2665 { MNormalValue, PSmallestNormalized, "-0x1p+126", APFloat::opOK, APFloat::fcNormal },
2666 { MNormalValue, MSmallestNormalized, "0x1p+126", APFloat::opOK, APFloat::fcNormal },
2667 { PLargestValue, PInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2668 { PLargestValue, MInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2669 { PLargestValue, PZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
2670 { PLargestValue, MZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
2671 { PLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2674 { PLargestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2676 { PLargestValue, PNormalValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2677 { PLargestValue, MNormalValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2678 { PLargestValue, PLargestValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2679 { PLargestValue, MLargestValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2680 { PLargestValue, PSmallestValue, "inf", OverflowStatus, APFloat::fcInfinity },
2681 { PLargestValue, MSmallestValue, "-inf", OverflowStatus, APFloat::fcInfinity },
2682 { PLargestValue, PSmallestNormalized, "inf", OverflowStatus, APFloat::fcInfinity },
2683 { PLargestValue, MSmallestNormalized, "-inf", OverflowStatus, APFloat::fcInfinity },
2684 { MLargestValue, PInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2685 { MLargestValue, MInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2686 { MLargestValue, PZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
2687 { MLargestValue, MZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
2688 { MLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2691 { MLargestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2693 { MLargestValue, PNormalValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2694 { MLargestValue, MNormalValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2695 { MLargestValue, PLargestValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2696 { MLargestValue, MLargestValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2697 { MLargestValue, PSmallestValue, "-inf", OverflowStatus, APFloat::fcInfinity },
2698 { MLargestValue, MSmallestValue, "inf", OverflowStatus, APFloat::fcInfinity },
2699 { MLargestValue, PSmallestNormalized, "-inf", OverflowStatus, APFloat::fcInfinity },
2700 { MLargestValue, MSmallestNormalized, "inf", OverflowStatus, APFloat::fcInfinity },
2701 { PSmallestValue, PInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2702 { PSmallestValue, MInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2703 { PSmallestValue, PZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
2704 { PSmallestValue, MZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
2705 { PSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2708 { PSmallestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2710 { PSmallestValue, PNormalValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2711 { PSmallestValue, MNormalValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2712 { PSmallestValue, PLargestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero },
2713 { PSmallestValue, MLargestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2714 { PSmallestValue, PSmallestValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2715 { PSmallestValue, MSmallestValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2716 { PSmallestValue, PSmallestNormalized, "0x1p-23", APFloat::opOK, APFloat::fcNormal },
2717 { PSmallestValue, MSmallestNormalized, "-0x1p-23", APFloat::opOK, APFloat::fcNormal },
2718 { MSmallestValue, PInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2719 { MSmallestValue, MInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2720 { MSmallestValue, PZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
2721 { MSmallestValue, MZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
2722 { MSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2725 { MSmallestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2727 { MSmallestValue, PNormalValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2728 { MSmallestValue, MNormalValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2729 { MSmallestValue, PLargestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2730 { MSmallestValue, MLargestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero },
2731 { MSmallestValue, PSmallestValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2732 { MSmallestValue, MSmallestValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2733 { MSmallestValue, PSmallestNormalized, "-0x1p-23", APFloat::opOK, APFloat::fcNormal },
2734 { MSmallestValue, MSmallestNormalized, "0x1p-23", APFloat::opOK, APFloat::fcNormal },
2735 { PSmallestNormalized, PInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2736 { PSmallestNormalized, MInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2737 { PSmallestNormalized, PZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
2738 { PSmallestNormalized, MZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
2739 { PSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2742 { PSmallestNormalized, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2744 { PSmallestNormalized, PNormalValue, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2745 { PSmallestNormalized, MNormalValue, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2746 { PSmallestNormalized, PLargestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero },
2747 { PSmallestNormalized, MLargestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2748 { PSmallestNormalized, PSmallestValue, "0x1p+23", APFloat::opOK, APFloat::fcNormal },
2749 { PSmallestNormalized, MSmallestValue, "-0x1p+23", APFloat::opOK, APFloat::fcNormal },
2750 { PSmallestNormalized, PSmallestNormalized, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2751 { PSmallestNormalized, MSmallestNormalized, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2752 { MSmallestNormalized, PInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2753 { MSmallestNormalized, MInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2754 { MSmallestNormalized, PZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
2755 { MSmallestNormalized, MZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
2756 { MSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2759 { MSmallestNormalized, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2761 { MSmallestNormalized, PNormalValue, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2762 { MSmallestNormalized, MNormalValue, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2763 { MSmallestNormalized, PLargestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2764 { MSmallestNormalized, MLargestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero },
2765 { MSmallestNormalized, PSmallestValue, "-0x1p+23", APFloat::opOK, APFloat::fcNormal },
2766 { MSmallestNormalized, MSmallestValue, "0x1p+23", APFloat::opOK, APFloat::fcNormal },
2767 { MSmallestNormalized, PSmallestNormalized, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2768 { MSmallestNormalized, MSmallestNormalized, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2771 for (size_t i = 0; i < NumTests; ++i) {
2772 APFloat x(SpecialCaseTests[i].x);
2773 APFloat y(SpecialCaseTests[i].y);
2774 APFloat::opStatus status = x.divide(y, APFloat::rmNearestTiesToEven);
2776 APFloat result(APFloat::IEEEsingle(), SpecialCaseTests[i].result);
2778 EXPECT_TRUE(result.bitwiseIsEqual(x));
2779 EXPECT_TRUE((int)status == SpecialCaseTests[i].status);
2780 EXPECT_TRUE((int)x.getCategory() == SpecialCaseTests[i].category);
2784 TEST(APFloatTest, operatorOverloads) {
2785 // This is mostly testing that these operator overloads compile.
2786 APFloat One = APFloat(APFloat::IEEEsingle(), "0x1p+0");
2787 APFloat Two = APFloat(APFloat::IEEEsingle(), "0x2p+0");
2788 EXPECT_TRUE(Two.bitwiseIsEqual(One + One));
2789 EXPECT_TRUE(One.bitwiseIsEqual(Two - One));
2790 EXPECT_TRUE(Two.bitwiseIsEqual(One * Two));
2791 EXPECT_TRUE(One.bitwiseIsEqual(Two / Two));
2794 TEST(APFloatTest, abs) {
2795 APFloat PInf = APFloat::getInf(APFloat::IEEEsingle(), false);
2796 APFloat MInf = APFloat::getInf(APFloat::IEEEsingle(), true);
2797 APFloat PZero = APFloat::getZero(APFloat::IEEEsingle(), false);
2798 APFloat MZero = APFloat::getZero(APFloat::IEEEsingle(), true);
2799 APFloat PQNaN = APFloat::getNaN(APFloat::IEEEsingle(), false);
2800 APFloat MQNaN = APFloat::getNaN(APFloat::IEEEsingle(), true);
2801 APFloat PSNaN = APFloat::getSNaN(APFloat::IEEEsingle(), false);
2802 APFloat MSNaN = APFloat::getSNaN(APFloat::IEEEsingle(), true);
2803 APFloat PNormalValue = APFloat(APFloat::IEEEsingle(), "0x1p+0");
2804 APFloat MNormalValue = APFloat(APFloat::IEEEsingle(), "-0x1p+0");
2805 APFloat PLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), false);
2806 APFloat MLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), true);
2807 APFloat PSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), false);
2808 APFloat MSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), true);
2809 APFloat PSmallestNormalized =
2810 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), false);
2811 APFloat MSmallestNormalized =
2812 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), true);
2814 EXPECT_TRUE(PInf.bitwiseIsEqual(abs(PInf)));
2815 EXPECT_TRUE(PInf.bitwiseIsEqual(abs(MInf)));
2816 EXPECT_TRUE(PZero.bitwiseIsEqual(abs(PZero)));
2817 EXPECT_TRUE(PZero.bitwiseIsEqual(abs(MZero)));
2818 EXPECT_TRUE(PQNaN.bitwiseIsEqual(abs(PQNaN)));
2819 EXPECT_TRUE(PQNaN.bitwiseIsEqual(abs(MQNaN)));
2820 EXPECT_TRUE(PSNaN.bitwiseIsEqual(abs(PSNaN)));
2821 EXPECT_TRUE(PSNaN.bitwiseIsEqual(abs(MSNaN)));
2822 EXPECT_TRUE(PNormalValue.bitwiseIsEqual(abs(PNormalValue)));
2823 EXPECT_TRUE(PNormalValue.bitwiseIsEqual(abs(MNormalValue)));
2824 EXPECT_TRUE(PLargestValue.bitwiseIsEqual(abs(PLargestValue)));
2825 EXPECT_TRUE(PLargestValue.bitwiseIsEqual(abs(MLargestValue)));
2826 EXPECT_TRUE(PSmallestValue.bitwiseIsEqual(abs(PSmallestValue)));
2827 EXPECT_TRUE(PSmallestValue.bitwiseIsEqual(abs(MSmallestValue)));
2828 EXPECT_TRUE(PSmallestNormalized.bitwiseIsEqual(abs(PSmallestNormalized)));
2829 EXPECT_TRUE(PSmallestNormalized.bitwiseIsEqual(abs(MSmallestNormalized)));
2832 TEST(APFloatTest, ilogb) {
2833 EXPECT_EQ(-1074, ilogb(APFloat::getSmallest(APFloat::IEEEdouble(), false)));
2834 EXPECT_EQ(-1074, ilogb(APFloat::getSmallest(APFloat::IEEEdouble(), true)));
2835 EXPECT_EQ(-1023, ilogb(APFloat(APFloat::IEEEdouble(), "0x1.ffffffffffffep-1024")));
2836 EXPECT_EQ(-1023, ilogb(APFloat(APFloat::IEEEdouble(), "0x1.ffffffffffffep-1023")));
2837 EXPECT_EQ(-1023, ilogb(APFloat(APFloat::IEEEdouble(), "-0x1.ffffffffffffep-1023")));
2838 EXPECT_EQ(-51, ilogb(APFloat(APFloat::IEEEdouble(), "0x1p-51")));
2839 EXPECT_EQ(-1023, ilogb(APFloat(APFloat::IEEEdouble(), "0x1.c60f120d9f87cp-1023")));
2840 EXPECT_EQ(-2, ilogb(APFloat(APFloat::IEEEdouble(), "0x0.ffffp-1")));
2841 EXPECT_EQ(-1023, ilogb(APFloat(APFloat::IEEEdouble(), "0x1.fffep-1023")));
2842 EXPECT_EQ(1023, ilogb(APFloat::getLargest(APFloat::IEEEdouble(), false)));
2843 EXPECT_EQ(1023, ilogb(APFloat::getLargest(APFloat::IEEEdouble(), true)));
2846 EXPECT_EQ(0, ilogb(APFloat(APFloat::IEEEsingle(), "0x1p+0")));
2847 EXPECT_EQ(0, ilogb(APFloat(APFloat::IEEEsingle(), "-0x1p+0")));
2848 EXPECT_EQ(42, ilogb(APFloat(APFloat::IEEEsingle(), "0x1p+42")));
2849 EXPECT_EQ(-42, ilogb(APFloat(APFloat::IEEEsingle(), "0x1p-42")));
2851 EXPECT_EQ(APFloat::IEK_Inf,
2852 ilogb(APFloat::getInf(APFloat::IEEEsingle(), false)));
2853 EXPECT_EQ(APFloat::IEK_Inf,
2854 ilogb(APFloat::getInf(APFloat::IEEEsingle(), true)));
2855 EXPECT_EQ(APFloat::IEK_Zero,
2856 ilogb(APFloat::getZero(APFloat::IEEEsingle(), false)));
2857 EXPECT_EQ(APFloat::IEK_Zero,
2858 ilogb(APFloat::getZero(APFloat::IEEEsingle(), true)));
2859 EXPECT_EQ(APFloat::IEK_NaN,
2860 ilogb(APFloat::getNaN(APFloat::IEEEsingle(), false)));
2861 EXPECT_EQ(APFloat::IEK_NaN,
2862 ilogb(APFloat::getSNaN(APFloat::IEEEsingle(), false)));
2864 EXPECT_EQ(127, ilogb(APFloat::getLargest(APFloat::IEEEsingle(), false)));
2865 EXPECT_EQ(127, ilogb(APFloat::getLargest(APFloat::IEEEsingle(), true)));
2867 EXPECT_EQ(-149, ilogb(APFloat::getSmallest(APFloat::IEEEsingle(), false)));
2868 EXPECT_EQ(-149, ilogb(APFloat::getSmallest(APFloat::IEEEsingle(), true)));
2870 ilogb(APFloat::getSmallestNormalized(APFloat::IEEEsingle(), false)));
2872 ilogb(APFloat::getSmallestNormalized(APFloat::IEEEsingle(), true)));
2875 TEST(APFloatTest, scalbn) {
2877 const APFloat::roundingMode RM = APFloat::rmNearestTiesToEven;
2879 APFloat(APFloat::IEEEsingle(), "0x1p+0")
2880 .bitwiseIsEqual(scalbn(APFloat(APFloat::IEEEsingle(), "0x1p+0"), 0, RM)));
2882 APFloat(APFloat::IEEEsingle(), "0x1p+42")
2883 .bitwiseIsEqual(scalbn(APFloat(APFloat::IEEEsingle(), "0x1p+0"), 42, RM)));
2885 APFloat(APFloat::IEEEsingle(), "0x1p-42")
2886 .bitwiseIsEqual(scalbn(APFloat(APFloat::IEEEsingle(), "0x1p+0"), -42, RM)));
2888 APFloat PInf = APFloat::getInf(APFloat::IEEEsingle(), false);
2889 APFloat MInf = APFloat::getInf(APFloat::IEEEsingle(), true);
2890 APFloat PZero = APFloat::getZero(APFloat::IEEEsingle(), false);
2891 APFloat MZero = APFloat::getZero(APFloat::IEEEsingle(), true);
2892 APFloat QPNaN = APFloat::getNaN(APFloat::IEEEsingle(), false);
2893 APFloat QMNaN = APFloat::getNaN(APFloat::IEEEsingle(), true);
2894 APFloat SNaN = APFloat::getSNaN(APFloat::IEEEsingle(), false);
2896 EXPECT_TRUE(PInf.bitwiseIsEqual(scalbn(PInf, 0, RM)));
2897 EXPECT_TRUE(MInf.bitwiseIsEqual(scalbn(MInf, 0, RM)));
2898 EXPECT_TRUE(PZero.bitwiseIsEqual(scalbn(PZero, 0, RM)));
2899 EXPECT_TRUE(MZero.bitwiseIsEqual(scalbn(MZero, 0, RM)));
2900 EXPECT_TRUE(QPNaN.bitwiseIsEqual(scalbn(QPNaN, 0, RM)));
2901 EXPECT_TRUE(QMNaN.bitwiseIsEqual(scalbn(QMNaN, 0, RM)));
2902 EXPECT_FALSE(scalbn(SNaN, 0, RM).isSignaling());
2904 APFloat ScalbnSNaN = scalbn(SNaN, 1, RM);
2905 EXPECT_TRUE(ScalbnSNaN.isNaN() && !ScalbnSNaN.isSignaling());
2907 // Make sure highest bit of payload is preserved.
2908 const APInt Payload(64, (UINT64_C(1) << 50) |
2909 (UINT64_C(1) << 49) |
2910 (UINT64_C(1234) << 32) |
2913 APFloat SNaNWithPayload = APFloat::getSNaN(APFloat::IEEEdouble(), false,
2915 APFloat QuietPayload = scalbn(SNaNWithPayload, 1, RM);
2916 EXPECT_TRUE(QuietPayload.isNaN() && !QuietPayload.isSignaling());
2917 EXPECT_EQ(Payload, QuietPayload.bitcastToAPInt().getLoBits(51));
2919 EXPECT_TRUE(PInf.bitwiseIsEqual(
2920 scalbn(APFloat(APFloat::IEEEsingle(), "0x1p+0"), 128, RM)));
2921 EXPECT_TRUE(MInf.bitwiseIsEqual(
2922 scalbn(APFloat(APFloat::IEEEsingle(), "-0x1p+0"), 128, RM)));
2923 EXPECT_TRUE(PInf.bitwiseIsEqual(
2924 scalbn(APFloat(APFloat::IEEEsingle(), "0x1p+127"), 1, RM)));
2925 EXPECT_TRUE(PZero.bitwiseIsEqual(
2926 scalbn(APFloat(APFloat::IEEEsingle(), "0x1p-127"), -127, RM)));
2927 EXPECT_TRUE(MZero.bitwiseIsEqual(
2928 scalbn(APFloat(APFloat::IEEEsingle(), "-0x1p-127"), -127, RM)));
2929 EXPECT_TRUE(APFloat(APFloat::IEEEsingle(), "-0x1p-149").bitwiseIsEqual(
2930 scalbn(APFloat(APFloat::IEEEsingle(), "-0x1p-127"), -22, RM)));
2931 EXPECT_TRUE(PZero.bitwiseIsEqual(
2932 scalbn(APFloat(APFloat::IEEEsingle(), "0x1p-126"), -24, RM)));
2935 APFloat SmallestF64 = APFloat::getSmallest(APFloat::IEEEdouble(), false);
2936 APFloat NegSmallestF64 = APFloat::getSmallest(APFloat::IEEEdouble(), true);
2938 APFloat LargestF64 = APFloat::getLargest(APFloat::IEEEdouble(), false);
2939 APFloat NegLargestF64 = APFloat::getLargest(APFloat::IEEEdouble(), true);
2941 APFloat SmallestNormalizedF64
2942 = APFloat::getSmallestNormalized(APFloat::IEEEdouble(), false);
2943 APFloat NegSmallestNormalizedF64
2944 = APFloat::getSmallestNormalized(APFloat::IEEEdouble(), true);
2946 APFloat LargestDenormalF64(APFloat::IEEEdouble(), "0x1.ffffffffffffep-1023");
2947 APFloat NegLargestDenormalF64(APFloat::IEEEdouble(), "-0x1.ffffffffffffep-1023");
2950 EXPECT_TRUE(SmallestF64.bitwiseIsEqual(
2951 scalbn(APFloat(APFloat::IEEEdouble(), "0x1p-1074"), 0, RM)));
2952 EXPECT_TRUE(NegSmallestF64.bitwiseIsEqual(
2953 scalbn(APFloat(APFloat::IEEEdouble(), "-0x1p-1074"), 0, RM)));
2955 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1p+1023")
2956 .bitwiseIsEqual(scalbn(SmallestF64, 2097, RM)));
2958 EXPECT_TRUE(scalbn(SmallestF64, -2097, RM).isPosZero());
2959 EXPECT_TRUE(scalbn(SmallestF64, -2098, RM).isPosZero());
2960 EXPECT_TRUE(scalbn(SmallestF64, -2099, RM).isPosZero());
2961 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1p+1022")
2962 .bitwiseIsEqual(scalbn(SmallestF64, 2096, RM)));
2963 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1p+1023")
2964 .bitwiseIsEqual(scalbn(SmallestF64, 2097, RM)));
2965 EXPECT_TRUE(scalbn(SmallestF64, 2098, RM).isInfinity());
2966 EXPECT_TRUE(scalbn(SmallestF64, 2099, RM).isInfinity());
2968 // Test for integer overflows when adding to exponent.
2969 EXPECT_TRUE(scalbn(SmallestF64, -INT_MAX, RM).isPosZero());
2970 EXPECT_TRUE(scalbn(LargestF64, INT_MAX, RM).isInfinity());
2972 EXPECT_TRUE(LargestDenormalF64
2973 .bitwiseIsEqual(scalbn(LargestDenormalF64, 0, RM)));
2974 EXPECT_TRUE(NegLargestDenormalF64
2975 .bitwiseIsEqual(scalbn(NegLargestDenormalF64, 0, RM)));
2977 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.ffffffffffffep-1022")
2978 .bitwiseIsEqual(scalbn(LargestDenormalF64, 1, RM)));
2979 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "-0x1.ffffffffffffep-1021")
2980 .bitwiseIsEqual(scalbn(NegLargestDenormalF64, 2, RM)));
2982 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.ffffffffffffep+1")
2983 .bitwiseIsEqual(scalbn(LargestDenormalF64, 1024, RM)));
2984 EXPECT_TRUE(scalbn(LargestDenormalF64, -1023, RM).isPosZero());
2985 EXPECT_TRUE(scalbn(LargestDenormalF64, -1024, RM).isPosZero());
2986 EXPECT_TRUE(scalbn(LargestDenormalF64, -2048, RM).isPosZero());
2987 EXPECT_TRUE(scalbn(LargestDenormalF64, 2047, RM).isInfinity());
2988 EXPECT_TRUE(scalbn(LargestDenormalF64, 2098, RM).isInfinity());
2989 EXPECT_TRUE(scalbn(LargestDenormalF64, 2099, RM).isInfinity());
2991 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.ffffffffffffep-2")
2992 .bitwiseIsEqual(scalbn(LargestDenormalF64, 1021, RM)));
2993 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.ffffffffffffep-1")
2994 .bitwiseIsEqual(scalbn(LargestDenormalF64, 1022, RM)));
2995 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.ffffffffffffep+0")
2996 .bitwiseIsEqual(scalbn(LargestDenormalF64, 1023, RM)));
2997 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.ffffffffffffep+1023")
2998 .bitwiseIsEqual(scalbn(LargestDenormalF64, 2046, RM)));
2999 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1p+974")
3000 .bitwiseIsEqual(scalbn(SmallestF64, 2048, RM)));
3002 APFloat RandomDenormalF64(APFloat::IEEEdouble(), "0x1.c60f120d9f87cp+51");
3003 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.c60f120d9f87cp-972")
3004 .bitwiseIsEqual(scalbn(RandomDenormalF64, -1023, RM)));
3005 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.c60f120d9f87cp-1")
3006 .bitwiseIsEqual(scalbn(RandomDenormalF64, -52, RM)));
3007 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.c60f120d9f87cp-2")
3008 .bitwiseIsEqual(scalbn(RandomDenormalF64, -53, RM)));
3009 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.c60f120d9f87cp+0")
3010 .bitwiseIsEqual(scalbn(RandomDenormalF64, -51, RM)));
3012 EXPECT_TRUE(scalbn(RandomDenormalF64, -2097, RM).isPosZero());
3013 EXPECT_TRUE(scalbn(RandomDenormalF64, -2090, RM).isPosZero());
3017 APFloat(APFloat::IEEEdouble(), "-0x1p-1073")
3018 .bitwiseIsEqual(scalbn(NegLargestF64, -2097, RM)));
3021 APFloat(APFloat::IEEEdouble(), "-0x1p-1024")
3022 .bitwiseIsEqual(scalbn(NegLargestF64, -2048, RM)));
3025 APFloat(APFloat::IEEEdouble(), "0x1p-1073")
3026 .bitwiseIsEqual(scalbn(LargestF64, -2097, RM)));
3029 APFloat(APFloat::IEEEdouble(), "0x1p-1074")
3030 .bitwiseIsEqual(scalbn(LargestF64, -2098, RM)));
3031 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "-0x1p-1074")
3032 .bitwiseIsEqual(scalbn(NegLargestF64, -2098, RM)));
3033 EXPECT_TRUE(scalbn(NegLargestF64, -2099, RM).isNegZero());
3034 EXPECT_TRUE(scalbn(LargestF64, 1, RM).isInfinity());
3038 APFloat(APFloat::IEEEdouble(), "0x1p+0")
3039 .bitwiseIsEqual(scalbn(APFloat(APFloat::IEEEdouble(), "0x1p+52"), -52, RM)));
3042 APFloat(APFloat::IEEEdouble(), "0x1p-103")
3043 .bitwiseIsEqual(scalbn(APFloat(APFloat::IEEEdouble(), "0x1p-51"), -52, RM)));
3046 TEST(APFloatTest, frexp) {
3047 const APFloat::roundingMode RM = APFloat::rmNearestTiesToEven;
3049 APFloat PZero = APFloat::getZero(APFloat::IEEEdouble(), false);
3050 APFloat MZero = APFloat::getZero(APFloat::IEEEdouble(), true);
3056 APFloat LargestDenormal(APFloat::IEEEdouble(), "0x1.ffffffffffffep-1023");
3057 APFloat NegLargestDenormal(APFloat::IEEEdouble(), "-0x1.ffffffffffffep-1023");
3059 APFloat Smallest = APFloat::getSmallest(APFloat::IEEEdouble(), false);
3060 APFloat NegSmallest = APFloat::getSmallest(APFloat::IEEEdouble(), true);
3062 APFloat Largest = APFloat::getLargest(APFloat::IEEEdouble(), false);
3063 APFloat NegLargest = APFloat::getLargest(APFloat::IEEEdouble(), true);
3065 APFloat PInf = APFloat::getInf(APFloat::IEEEdouble(), false);
3066 APFloat MInf = APFloat::getInf(APFloat::IEEEdouble(), true);
3068 APFloat QPNaN = APFloat::getNaN(APFloat::IEEEdouble(), false);
3069 APFloat QMNaN = APFloat::getNaN(APFloat::IEEEdouble(), true);
3070 APFloat SNaN = APFloat::getSNaN(APFloat::IEEEdouble(), false);
3072 // Make sure highest bit of payload is preserved.
3073 const APInt Payload(64, (UINT64_C(1) << 50) |
3074 (UINT64_C(1) << 49) |
3075 (UINT64_C(1234) << 32) |
3078 APFloat SNaNWithPayload = APFloat::getSNaN(APFloat::IEEEdouble(), false,
3081 APFloat SmallestNormalized
3082 = APFloat::getSmallestNormalized(APFloat::IEEEdouble(), false);
3083 APFloat NegSmallestNormalized
3084 = APFloat::getSmallestNormalized(APFloat::IEEEdouble(), true);
3087 APFloat Frac(APFloat::IEEEdouble());
3090 Frac = frexp(PZero, Exp, RM);
3092 EXPECT_TRUE(Frac.isPosZero());
3094 Frac = frexp(MZero, Exp, RM);
3096 EXPECT_TRUE(Frac.isNegZero());
3099 Frac = frexp(One, Exp, RM);
3101 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1p-1").bitwiseIsEqual(Frac));
3103 Frac = frexp(MOne, Exp, RM);
3105 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "-0x1p-1").bitwiseIsEqual(Frac));
3107 Frac = frexp(LargestDenormal, Exp, RM);
3108 EXPECT_EQ(-1022, Exp);
3109 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.ffffffffffffep-1").bitwiseIsEqual(Frac));
3111 Frac = frexp(NegLargestDenormal, Exp, RM);
3112 EXPECT_EQ(-1022, Exp);
3113 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "-0x1.ffffffffffffep-1").bitwiseIsEqual(Frac));
3116 Frac = frexp(Smallest, Exp, RM);
3117 EXPECT_EQ(-1073, Exp);
3118 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1p-1").bitwiseIsEqual(Frac));
3120 Frac = frexp(NegSmallest, Exp, RM);
3121 EXPECT_EQ(-1073, Exp);
3122 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "-0x1p-1").bitwiseIsEqual(Frac));
3125 Frac = frexp(Largest, Exp, RM);
3126 EXPECT_EQ(1024, Exp);
3127 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.fffffffffffffp-1").bitwiseIsEqual(Frac));
3129 Frac = frexp(NegLargest, Exp, RM);
3130 EXPECT_EQ(1024, Exp);
3131 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "-0x1.fffffffffffffp-1").bitwiseIsEqual(Frac));
3134 Frac = frexp(PInf, Exp, RM);
3135 EXPECT_EQ(INT_MAX, Exp);
3136 EXPECT_TRUE(Frac.isInfinity() && !Frac.isNegative());
3138 Frac = frexp(MInf, Exp, RM);
3139 EXPECT_EQ(INT_MAX, Exp);
3140 EXPECT_TRUE(Frac.isInfinity() && Frac.isNegative());
3142 Frac = frexp(QPNaN, Exp, RM);
3143 EXPECT_EQ(INT_MIN, Exp);
3144 EXPECT_TRUE(Frac.isNaN());
3146 Frac = frexp(QMNaN, Exp, RM);
3147 EXPECT_EQ(INT_MIN, Exp);
3148 EXPECT_TRUE(Frac.isNaN());
3150 Frac = frexp(SNaN, Exp, RM);
3151 EXPECT_EQ(INT_MIN, Exp);
3152 EXPECT_TRUE(Frac.isNaN() && !Frac.isSignaling());
3154 Frac = frexp(SNaNWithPayload, Exp, RM);
3155 EXPECT_EQ(INT_MIN, Exp);
3156 EXPECT_TRUE(Frac.isNaN() && !Frac.isSignaling());
3157 EXPECT_EQ(Payload, Frac.bitcastToAPInt().getLoBits(51));
3159 Frac = frexp(APFloat(APFloat::IEEEdouble(), "0x0.ffffp-1"), Exp, RM);
3161 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.fffep-1").bitwiseIsEqual(Frac));
3163 Frac = frexp(APFloat(APFloat::IEEEdouble(), "0x1p-51"), Exp, RM);
3164 EXPECT_EQ(-50, Exp);
3165 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1p-1").bitwiseIsEqual(Frac));
3167 Frac = frexp(APFloat(APFloat::IEEEdouble(), "0x1.c60f120d9f87cp+51"), Exp, RM);
3169 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.c60f120d9f87cp-1").bitwiseIsEqual(Frac));
3172 TEST(APFloatTest, PPCDoubleDoubleAddSpecial) {
3173 using DataType = std::tuple<uint64_t, uint64_t, uint64_t, uint64_t,
3174 APFloat::fltCategory, APFloat::roundingMode>;
3176 // (1 + 0) + (-1 + 0) = fcZero
3177 std::make_tuple(0x3ff0000000000000ull, 0, 0xbff0000000000000ull, 0,
3178 APFloat::fcZero, APFloat::rmNearestTiesToEven),
3179 // LDBL_MAX + (1.1 >> (1023 - 106) + 0)) = fcInfinity
3180 std::make_tuple(0x7fefffffffffffffull, 0x7c8ffffffffffffeull,
3181 0x7948000000000000ull, 0ull, APFloat::fcInfinity,
3182 APFloat::rmNearestTiesToEven),
3183 // TODO: change the 4th 0x75effffffffffffe to 0x75efffffffffffff when
3184 // PPCDoubleDoubleImpl is gone.
3185 // LDBL_MAX + (1.011111... >> (1023 - 106) + (1.1111111...0 >> (1023 -
3186 // 160))) = fcNormal
3187 std::make_tuple(0x7fefffffffffffffull, 0x7c8ffffffffffffeull,
3188 0x7947ffffffffffffull, 0x75effffffffffffeull,
3189 APFloat::fcNormal, APFloat::rmNearestTiesToEven),
3190 // LDBL_MAX + (1.1 >> (1023 - 106) + 0)) = fcInfinity
3191 std::make_tuple(0x7fefffffffffffffull, 0x7c8ffffffffffffeull,
3192 0x7fefffffffffffffull, 0x7c8ffffffffffffeull,
3193 APFloat::fcInfinity, APFloat::rmNearestTiesToEven),
3194 // NaN + (1 + 0) = fcNaN
3195 std::make_tuple(0x7ff8000000000000ull, 0, 0x3ff0000000000000ull, 0,
3196 APFloat::fcNaN, APFloat::rmNearestTiesToEven),
3199 for (auto Tp : Data) {
3200 uint64_t Op1[2], Op2[2];
3201 APFloat::fltCategory Expected;
3202 APFloat::roundingMode RM;
3203 std::tie(Op1[0], Op1[1], Op2[0], Op2[1], Expected, RM) = Tp;
3205 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
3206 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
3209 EXPECT_EQ(Expected, A1.getCategory())
3210 << formatv("({0:x} + {1:x}) + ({2:x} + {3:x})", Op1[0], Op1[1], Op2[0],
3216 TEST(APFloatTest, PPCDoubleDoubleAdd) {
3217 using DataType = std::tuple<uint64_t, uint64_t, uint64_t, uint64_t, uint64_t,
3218 uint64_t, APFloat::roundingMode>;
3220 // (1 + 0) + (1e-105 + 0) = (1 + 1e-105)
3221 std::make_tuple(0x3ff0000000000000ull, 0, 0x3960000000000000ull, 0,
3222 0x3ff0000000000000ull, 0x3960000000000000ull,
3223 APFloat::rmNearestTiesToEven),
3224 // (1 + 0) + (1e-106 + 0) = (1 + 1e-106)
3225 std::make_tuple(0x3ff0000000000000ull, 0, 0x3950000000000000ull, 0,
3226 0x3ff0000000000000ull, 0x3950000000000000ull,
3227 APFloat::rmNearestTiesToEven),
3228 // (1 + 1e-106) + (1e-106 + 0) = (1 + 1e-105)
3229 std::make_tuple(0x3ff0000000000000ull, 0x3950000000000000ull,
3230 0x3950000000000000ull, 0, 0x3ff0000000000000ull,
3231 0x3960000000000000ull, APFloat::rmNearestTiesToEven),
3232 // (1 + 0) + (epsilon + 0) = (1 + epsilon)
3233 std::make_tuple(0x3ff0000000000000ull, 0, 0x0000000000000001ull, 0,
3234 0x3ff0000000000000ull, 0x0000000000000001ull,
3235 APFloat::rmNearestTiesToEven),
3236 // TODO: change 0xf950000000000000 to 0xf940000000000000, when
3237 // PPCDoubleDoubleImpl is gone.
3238 // (DBL_MAX - 1 << (1023 - 105)) + (1 << (1023 - 53) + 0) = DBL_MAX +
3239 // 1.11111... << (1023 - 52)
3240 std::make_tuple(0x7fefffffffffffffull, 0xf950000000000000ull,
3241 0x7c90000000000000ull, 0, 0x7fefffffffffffffull,
3242 0x7c8ffffffffffffeull, APFloat::rmNearestTiesToEven),
3243 // TODO: change 0xf950000000000000 to 0xf940000000000000, when
3244 // PPCDoubleDoubleImpl is gone.
3245 // (1 << (1023 - 53) + 0) + (DBL_MAX - 1 << (1023 - 105)) = DBL_MAX +
3246 // 1.11111... << (1023 - 52)
3247 std::make_tuple(0x7c90000000000000ull, 0, 0x7fefffffffffffffull,
3248 0xf950000000000000ull, 0x7fefffffffffffffull,
3249 0x7c8ffffffffffffeull, APFloat::rmNearestTiesToEven),
3252 for (auto Tp : Data) {
3253 uint64_t Op1[2], Op2[2], Expected[2];
3254 APFloat::roundingMode RM;
3255 std::tie(Op1[0], Op1[1], Op2[0], Op2[1], Expected[0], Expected[1], RM) = Tp;
3257 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
3258 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
3261 EXPECT_EQ(Expected[0], A1.bitcastToAPInt().getRawData()[0])
3262 << formatv("({0:x} + {1:x}) + ({2:x} + {3:x})", Op1[0], Op1[1], Op2[0],
3265 EXPECT_EQ(Expected[1], A1.getSecondFloat().bitcastToAPInt().getRawData()[0])
3266 << formatv("({0:x} + {1:x}) + ({2:x} + {3:x})", Op1[0], Op1[1], Op2[0],
3272 TEST(APFloatTest, PPCDoubleDoubleSubtract) {
3273 using DataType = std::tuple<uint64_t, uint64_t, uint64_t, uint64_t, uint64_t,
3274 uint64_t, APFloat::roundingMode>;
3276 // (1 + 0) - (-1e-105 + 0) = (1 + 1e-105)
3277 std::make_tuple(0x3ff0000000000000ull, 0, 0xb960000000000000ull, 0,
3278 0x3ff0000000000000ull, 0x3960000000000000ull,
3279 APFloat::rmNearestTiesToEven),
3280 // (1 + 0) - (-1e-106 + 0) = (1 + 1e-106)
3281 std::make_tuple(0x3ff0000000000000ull, 0, 0xb950000000000000ull, 0,
3282 0x3ff0000000000000ull, 0x3950000000000000ull,
3283 APFloat::rmNearestTiesToEven),
3286 for (auto Tp : Data) {
3287 uint64_t Op1[2], Op2[2], Expected[2];
3288 APFloat::roundingMode RM;
3289 std::tie(Op1[0], Op1[1], Op2[0], Op2[1], Expected[0], Expected[1], RM) = Tp;
3291 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
3292 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
3293 A1.subtract(A2, RM);
3295 EXPECT_EQ(Expected[0], A1.bitcastToAPInt().getRawData()[0])
3296 << formatv("({0:x} + {1:x}) - ({2:x} + {3:x})", Op1[0], Op1[1], Op2[0],
3299 EXPECT_EQ(Expected[1], A1.getSecondFloat().bitcastToAPInt().getRawData()[0])
3300 << formatv("({0:x} + {1:x}) - ({2:x} + {3:x})", Op1[0], Op1[1], Op2[0],
3306 TEST(APFloatTest, PPCDoubleDoubleMultiply) {
3307 using DataType = std::tuple<uint64_t, uint64_t, uint64_t, uint64_t, uint64_t,
3308 uint64_t, APFloat::roundingMode>;
3309 // TODO: Only a sanity check for now. Add more edge cases when the
3310 // double-double algorithm is implemented.
3313 std::make_tuple(0x3fd5555555555555ull, 0x3c75555555555556ull,
3314 0x4008000000000000ull, 0, 0x3ff0000000000000ull, 0,
3315 APFloat::rmNearestTiesToEven),
3318 for (auto Tp : Data) {
3319 uint64_t Op1[2], Op2[2], Expected[2];
3320 APFloat::roundingMode RM;
3321 std::tie(Op1[0], Op1[1], Op2[0], Op2[1], Expected[0], Expected[1], RM) = Tp;
3323 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
3324 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
3325 A1.multiply(A2, RM);
3327 EXPECT_EQ(Expected[0], A1.bitcastToAPInt().getRawData()[0])
3328 << formatv("({0:x} + {1:x}) * ({2:x} + {3:x})", Op1[0], Op1[1], Op2[0],
3331 EXPECT_EQ(Expected[1], A1.bitcastToAPInt().getRawData()[1])
3332 << formatv("({0:x} + {1:x}) * ({2:x} + {3:x})", Op1[0], Op1[1], Op2[0],
3338 TEST(APFloatTest, PPCDoubleDoubleDivide) {
3339 using DataType = std::tuple<uint64_t, uint64_t, uint64_t, uint64_t, uint64_t,
3340 uint64_t, APFloat::roundingMode>;
3341 // TODO: Only a sanity check for now. Add more edge cases when the
3342 // double-double algorithm is implemented.
3345 std::make_tuple(0x3ff0000000000000ull, 0, 0x4008000000000000ull, 0,
3346 0x3fd5555555555555ull, 0x3c75555555555556ull,
3347 APFloat::rmNearestTiesToEven),
3350 for (auto Tp : Data) {
3351 uint64_t Op1[2], Op2[2], Expected[2];
3352 APFloat::roundingMode RM;
3353 std::tie(Op1[0], Op1[1], Op2[0], Op2[1], Expected[0], Expected[1], RM) = Tp;
3355 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
3356 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
3359 EXPECT_EQ(Expected[0], A1.bitcastToAPInt().getRawData()[0])
3360 << formatv("({0:x} + {1:x}) / ({2:x} + {3:x})", Op1[0], Op1[1], Op2[0],
3363 EXPECT_EQ(Expected[1], A1.bitcastToAPInt().getRawData()[1])
3364 << formatv("({0:x} + {1:x}) / ({2:x} + {3:x})", Op1[0], Op1[1], Op2[0],
3370 TEST(APFloatTest, PPCDoubleDoubleRemainder) {
3372 std::tuple<uint64_t, uint64_t, uint64_t, uint64_t, uint64_t, uint64_t>;
3374 // remainder(3.0 + 3.0 << 53, 1.25 + 1.25 << 53) = (0.5 + 0.5 << 53)
3375 std::make_tuple(0x4008000000000000ull, 0x3cb8000000000000ull,
3376 0x3ff4000000000000ull, 0x3ca4000000000000ull,
3377 0x3fe0000000000000ull, 0x3c90000000000000ull),
3378 // remainder(3.0 + 3.0 << 53, 1.75 + 1.75 << 53) = (-0.5 - 0.5 << 53)
3379 std::make_tuple(0x4008000000000000ull, 0x3cb8000000000000ull,
3380 0x3ffc000000000000ull, 0x3cac000000000000ull,
3381 0xbfe0000000000000ull, 0xbc90000000000000ull),
3384 for (auto Tp : Data) {
3385 uint64_t Op1[2], Op2[2], Expected[2];
3386 std::tie(Op1[0], Op1[1], Op2[0], Op2[1], Expected[0], Expected[1]) = Tp;
3388 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
3389 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
3392 EXPECT_EQ(Expected[0], A1.bitcastToAPInt().getRawData()[0])
3393 << formatv("remainder({0:x} + {1:x}), ({2:x} + {3:x}))", Op1[0], Op1[1],
3396 EXPECT_EQ(Expected[1], A1.bitcastToAPInt().getRawData()[1])
3397 << formatv("remainder(({0:x} + {1:x}), ({2:x} + {3:x}))", Op1[0],
3398 Op1[1], Op2[0], Op2[1])
3403 TEST(APFloatTest, PPCDoubleDoubleMod) {
3405 std::tuple<uint64_t, uint64_t, uint64_t, uint64_t, uint64_t, uint64_t>;
3407 // mod(3.0 + 3.0 << 53, 1.25 + 1.25 << 53) = (0.5 + 0.5 << 53)
3408 std::make_tuple(0x4008000000000000ull, 0x3cb8000000000000ull,
3409 0x3ff4000000000000ull, 0x3ca4000000000000ull,
3410 0x3fe0000000000000ull, 0x3c90000000000000ull),
3411 // mod(3.0 + 3.0 << 53, 1.75 + 1.75 << 53) = (1.25 + 1.25 << 53)
3412 // 0xbc98000000000000 doesn't seem right, but it's what we currently have.
3413 // TODO: investigate
3414 std::make_tuple(0x4008000000000000ull, 0x3cb8000000000000ull,
3415 0x3ffc000000000000ull, 0x3cac000000000000ull,
3416 0x3ff4000000000001ull, 0xbc98000000000000ull),
3419 for (auto Tp : Data) {
3420 uint64_t Op1[2], Op2[2], Expected[2];
3421 std::tie(Op1[0], Op1[1], Op2[0], Op2[1], Expected[0], Expected[1]) = Tp;
3423 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
3424 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
3427 EXPECT_EQ(Expected[0], A1.bitcastToAPInt().getRawData()[0])
3428 << formatv("fmod(({0:x} + {1:x}), ({2:x} + {3:x}))", Op1[0], Op1[1],
3431 EXPECT_EQ(Expected[1], A1.bitcastToAPInt().getRawData()[1])
3432 << formatv("fmod(({0:x} + {1:x}), ({2:x} + {3:x}))", Op1[0], Op1[1],
3438 TEST(APFloatTest, PPCDoubleDoubleFMA) {
3439 // Sanity check for now.
3440 APFloat A(APFloat::PPCDoubleDouble(), "2");
3441 A.fusedMultiplyAdd(APFloat(APFloat::PPCDoubleDouble(), "3"),
3442 APFloat(APFloat::PPCDoubleDouble(), "4"),
3443 APFloat::rmNearestTiesToEven);
3444 EXPECT_EQ(APFloat::cmpEqual,
3445 APFloat(APFloat::PPCDoubleDouble(), "10").compare(A));
3448 TEST(APFloatTest, PPCDoubleDoubleRoundToIntegral) {
3450 APFloat A(APFloat::PPCDoubleDouble(), "1.5");
3451 A.roundToIntegral(APFloat::rmNearestTiesToEven);
3452 EXPECT_EQ(APFloat::cmpEqual,
3453 APFloat(APFloat::PPCDoubleDouble(), "2").compare(A));
3456 APFloat A(APFloat::PPCDoubleDouble(), "2.5");
3457 A.roundToIntegral(APFloat::rmNearestTiesToEven);
3458 EXPECT_EQ(APFloat::cmpEqual,
3459 APFloat(APFloat::PPCDoubleDouble(), "2").compare(A));
3463 TEST(APFloatTest, PPCDoubleDoubleCompare) {
3465 std::tuple<uint64_t, uint64_t, uint64_t, uint64_t, APFloat::cmpResult>;
3468 // (1 + 0) = (1 + 0)
3469 std::make_tuple(0x3ff0000000000000ull, 0, 0x3ff0000000000000ull, 0,
3471 // (1 + 0) < (1.00...1 + 0)
3472 std::make_tuple(0x3ff0000000000000ull, 0, 0x3ff0000000000001ull, 0,
3473 APFloat::cmpLessThan),
3474 // (1.00...1 + 0) > (1 + 0)
3475 std::make_tuple(0x3ff0000000000001ull, 0, 0x3ff0000000000000ull, 0,
3476 APFloat::cmpGreaterThan),
3477 // (1 + 0) < (1 + epsilon)
3478 std::make_tuple(0x3ff0000000000000ull, 0, 0x3ff0000000000001ull,
3479 0x0000000000000001ull, APFloat::cmpLessThan),
3481 std::make_tuple(0x7ff8000000000000ull, 0, 0x7ff8000000000000ull, 0,
3482 APFloat::cmpUnordered),
3484 std::make_tuple(0x3ff0000000000000ull, 0, 0x7ff8000000000000ull, 0,
3485 APFloat::cmpUnordered),
3487 std::make_tuple(0x7ff0000000000000ull, 0, 0x7ff0000000000000ull, 0,
3491 for (auto Tp : Data) {
3492 uint64_t Op1[2], Op2[2];
3493 APFloat::cmpResult Expected;
3494 std::tie(Op1[0], Op1[1], Op2[0], Op2[1], Expected) = Tp;
3496 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
3497 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
3498 EXPECT_EQ(Expected, A1.compare(A2))
3499 << formatv("({0:x} + {1:x}) - ({2:x} + {3:x})", Op1[0], Op1[1], Op2[0],
3505 TEST(APFloatTest, PPCDoubleDoubleChangeSign) {
3507 0x400f000000000000ull, 0xbcb0000000000000ull,
3509 APFloat Float(APFloat::PPCDoubleDouble(), APInt(128, 2, Data));
3512 APFloat::copySign(Float, APFloat(APFloat::IEEEdouble(), "1"));
3513 EXPECT_EQ(0x400f000000000000ull, Actual.bitcastToAPInt().getRawData()[0]);
3514 EXPECT_EQ(0xbcb0000000000000ull, Actual.bitcastToAPInt().getRawData()[1]);
3518 APFloat::copySign(Float, APFloat(APFloat::IEEEdouble(), "-1"));
3519 EXPECT_EQ(0xc00f000000000000ull, Actual.bitcastToAPInt().getRawData()[0]);
3520 EXPECT_EQ(0x3cb0000000000000ull, Actual.bitcastToAPInt().getRawData()[1]);
3524 TEST(APFloatTest, PPCDoubleDoubleFactories) {
3529 EXPECT_EQ(APInt(128, 2, Data),
3530 APFloat::getZero(APFloat::PPCDoubleDouble()).bitcastToAPInt());
3534 0x0000000000000001ull, 0,
3537 APInt(128, 2, Data),
3538 APFloat::getSmallest(APFloat::PPCDoubleDouble()).bitcastToAPInt());
3541 uint64_t Data[] = {0x0360000000000000ull, 0};
3542 EXPECT_EQ(APInt(128, 2, Data),
3543 APFloat::getSmallestNormalized(APFloat::PPCDoubleDouble())
3548 0x8000000000000000ull, 0x0000000000000000ull,
3551 APInt(128, 2, Data),
3552 APFloat::getZero(APFloat::PPCDoubleDouble(), true).bitcastToAPInt());
3556 0x8000000000000001ull, 0x0000000000000000ull,
3558 EXPECT_EQ(APInt(128, 2, Data),
3559 APFloat::getSmallest(APFloat::PPCDoubleDouble(), true)
3563 EXPECT_EQ(0x8360000000000000ull,
3564 APFloat::getSmallestNormalized(APFloat::PPCDoubleDouble(), true)
3567 EXPECT_EQ(0x0000000000000000ull,
3568 APFloat::getSmallestNormalized(APFloat::PPCDoubleDouble(), true)
3573 EXPECT_TRUE(APFloat::getSmallest(APFloat::PPCDoubleDouble()).isSmallest());
3574 EXPECT_TRUE(APFloat::getLargest(APFloat::PPCDoubleDouble()).isLargest());