1 //===- llvm/unittest/ADT/APFloat.cpp - APFloat unit tests ---------------------===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 10 #include "llvm/ADT/APFloat.h" 11 #include "llvm/ADT/APSInt.h" 12 #include "llvm/ADT/SmallVector.h" 13 #include "llvm/Support/raw_ostream.h" 14 #include "gtest/gtest.h" 15 #include <cmath> 16 #include <ostream> 17 #include <string> 18 19 using namespace llvm; 20 21 static double convertToDoubleFromString(const char *Str) { 22 llvm::APFloat F(0.0); 23 F.convertFromString(Str, llvm::APFloat::rmNearestTiesToEven); 24 return F.convertToDouble(); 25 } 26 27 static std::string convertToString(double d, unsigned Prec, unsigned Pad) { 28 llvm::SmallVector<char, 100> Buffer; 29 llvm::APFloat F(d); 30 F.toString(Buffer, Prec, Pad); 31 return std::string(Buffer.data(), Buffer.size()); 32 } 33 34 namespace { 35 36 TEST(APFloatTest, isSignaling) { 37 // We test qNaN, -qNaN, +sNaN, -sNaN with and without payloads. *NOTE* The 38 // positive/negative distinction is included only since the getQNaN/getSNaN 39 // API provides the option. 40 APInt payload = APInt::getOneBitSet(4, 2); 41 EXPECT_FALSE(APFloat::getQNaN(APFloat::IEEEsingle, false).isSignaling()); 42 EXPECT_FALSE(APFloat::getQNaN(APFloat::IEEEsingle, true).isSignaling()); 43 EXPECT_FALSE(APFloat::getQNaN(APFloat::IEEEsingle, false, &payload).isSignaling()); 44 EXPECT_FALSE(APFloat::getQNaN(APFloat::IEEEsingle, true, &payload).isSignaling()); 45 EXPECT_TRUE(APFloat::getSNaN(APFloat::IEEEsingle, false).isSignaling()); 46 EXPECT_TRUE(APFloat::getSNaN(APFloat::IEEEsingle, true).isSignaling()); 47 EXPECT_TRUE(APFloat::getSNaN(APFloat::IEEEsingle, false, &payload).isSignaling()); 48 EXPECT_TRUE(APFloat::getSNaN(APFloat::IEEEsingle, true, &payload).isSignaling()); 49 } 50 51 TEST(APFloatTest, next) { 52 53 APFloat test(APFloat::IEEEquad, APFloat::uninitialized); 54 APFloat expected(APFloat::IEEEquad, APFloat::uninitialized); 55 56 // 1. Test Special Cases Values. 57 // 58 // Test all special values for nextUp and nextDown perscribed by IEEE-754R 59 // 2008. These are: 60 // 1. +inf 61 // 2. -inf 62 // 3. getLargest() 63 // 4. -getLargest() 64 // 5. getSmallest() 65 // 6. -getSmallest() 66 // 7. qNaN 67 // 8. sNaN 68 // 9. +0 69 // 10. -0 70 71 // nextUp(+inf) = +inf. 72 test = APFloat::getInf(APFloat::IEEEquad, false); 73 expected = APFloat::getInf(APFloat::IEEEquad, false); 74 EXPECT_EQ(test.next(false), APFloat::opOK); 75 EXPECT_TRUE(test.isInfinity()); 76 EXPECT_TRUE(!test.isNegative()); 77 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 78 79 // nextDown(+inf) = -nextUp(-inf) = -(-getLargest()) = getLargest() 80 test = APFloat::getInf(APFloat::IEEEquad, false); 81 expected = APFloat::getLargest(APFloat::IEEEquad, false); 82 EXPECT_EQ(test.next(true), APFloat::opOK); 83 EXPECT_TRUE(!test.isNegative()); 84 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 85 86 // nextUp(-inf) = -getLargest() 87 test = APFloat::getInf(APFloat::IEEEquad, true); 88 expected = APFloat::getLargest(APFloat::IEEEquad, true); 89 EXPECT_EQ(test.next(false), APFloat::opOK); 90 EXPECT_TRUE(test.isNegative()); 91 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 92 93 // nextDown(-inf) = -nextUp(+inf) = -(+inf) = -inf. 94 test = APFloat::getInf(APFloat::IEEEquad, true); 95 expected = APFloat::getInf(APFloat::IEEEquad, true); 96 EXPECT_EQ(test.next(true), APFloat::opOK); 97 EXPECT_TRUE(test.isInfinity() && test.isNegative()); 98 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 99 100 // nextUp(getLargest()) = +inf 101 test = APFloat::getLargest(APFloat::IEEEquad, false); 102 expected = APFloat::getInf(APFloat::IEEEquad, false); 103 EXPECT_EQ(test.next(false), APFloat::opOK); 104 EXPECT_TRUE(test.isInfinity() && !test.isNegative()); 105 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 106 107 // nextDown(getLargest()) = -nextUp(-getLargest()) 108 // = -(-getLargest() + inc) 109 // = getLargest() - inc. 110 test = APFloat::getLargest(APFloat::IEEEquad, false); 111 expected = APFloat(APFloat::IEEEquad, 112 "0x1.fffffffffffffffffffffffffffep+16383"); 113 EXPECT_EQ(test.next(true), APFloat::opOK); 114 EXPECT_TRUE(!test.isInfinity() && !test.isNegative()); 115 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 116 117 // nextUp(-getLargest()) = -getLargest() + inc. 118 test = APFloat::getLargest(APFloat::IEEEquad, true); 119 expected = APFloat(APFloat::IEEEquad, 120 "-0x1.fffffffffffffffffffffffffffep+16383"); 121 EXPECT_EQ(test.next(false), APFloat::opOK); 122 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 123 124 // nextDown(-getLargest()) = -nextUp(getLargest()) = -(inf) = -inf. 125 test = APFloat::getLargest(APFloat::IEEEquad, true); 126 expected = APFloat::getInf(APFloat::IEEEquad, true); 127 EXPECT_EQ(test.next(true), APFloat::opOK); 128 EXPECT_TRUE(test.isInfinity() && test.isNegative()); 129 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 130 131 // nextUp(getSmallest()) = getSmallest() + inc. 132 test = APFloat(APFloat::IEEEquad, "0x0.0000000000000000000000000001p-16382"); 133 expected = APFloat(APFloat::IEEEquad, 134 "0x0.0000000000000000000000000002p-16382"); 135 EXPECT_EQ(test.next(false), APFloat::opOK); 136 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 137 138 // nextDown(getSmallest()) = -nextUp(-getSmallest()) = -(-0) = +0. 139 test = APFloat(APFloat::IEEEquad, "0x0.0000000000000000000000000001p-16382"); 140 expected = APFloat::getZero(APFloat::IEEEquad, false); 141 EXPECT_EQ(test.next(true), APFloat::opOK); 142 EXPECT_TRUE(test.isPosZero()); 143 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 144 145 // nextUp(-getSmallest()) = -0. 146 test = APFloat(APFloat::IEEEquad, "-0x0.0000000000000000000000000001p-16382"); 147 expected = APFloat::getZero(APFloat::IEEEquad, true); 148 EXPECT_EQ(test.next(false), APFloat::opOK); 149 EXPECT_TRUE(test.isNegZero()); 150 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 151 152 // nextDown(-getSmallest()) = -nextUp(getSmallest()) = -getSmallest() - inc. 153 test = APFloat(APFloat::IEEEquad, "-0x0.0000000000000000000000000001p-16382"); 154 expected = APFloat(APFloat::IEEEquad, 155 "-0x0.0000000000000000000000000002p-16382"); 156 EXPECT_EQ(test.next(true), APFloat::opOK); 157 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 158 159 // nextUp(qNaN) = qNaN 160 test = APFloat::getQNaN(APFloat::IEEEquad, false); 161 expected = APFloat::getQNaN(APFloat::IEEEquad, false); 162 EXPECT_EQ(test.next(false), APFloat::opOK); 163 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 164 165 // nextDown(qNaN) = qNaN 166 test = APFloat::getQNaN(APFloat::IEEEquad, false); 167 expected = APFloat::getQNaN(APFloat::IEEEquad, false); 168 EXPECT_EQ(test.next(true), APFloat::opOK); 169 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 170 171 // nextUp(sNaN) = qNaN 172 test = APFloat::getSNaN(APFloat::IEEEquad, false); 173 expected = APFloat::getQNaN(APFloat::IEEEquad, false); 174 EXPECT_EQ(test.next(false), APFloat::opInvalidOp); 175 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 176 177 // nextDown(sNaN) = qNaN 178 test = APFloat::getSNaN(APFloat::IEEEquad, false); 179 expected = APFloat::getQNaN(APFloat::IEEEquad, false); 180 EXPECT_EQ(test.next(true), APFloat::opInvalidOp); 181 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 182 183 // nextUp(+0) = +getSmallest() 184 test = APFloat::getZero(APFloat::IEEEquad, false); 185 expected = APFloat::getSmallest(APFloat::IEEEquad, false); 186 EXPECT_EQ(test.next(false), APFloat::opOK); 187 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 188 189 // nextDown(+0) = -nextUp(-0) = -getSmallest() 190 test = APFloat::getZero(APFloat::IEEEquad, false); 191 expected = APFloat::getSmallest(APFloat::IEEEquad, true); 192 EXPECT_EQ(test.next(true), APFloat::opOK); 193 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 194 195 // nextUp(-0) = +getSmallest() 196 test = APFloat::getZero(APFloat::IEEEquad, true); 197 expected = APFloat::getSmallest(APFloat::IEEEquad, false); 198 EXPECT_EQ(test.next(false), APFloat::opOK); 199 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 200 201 // nextDown(-0) = -nextUp(0) = -getSmallest() 202 test = APFloat::getZero(APFloat::IEEEquad, true); 203 expected = APFloat::getSmallest(APFloat::IEEEquad, true); 204 EXPECT_EQ(test.next(true), APFloat::opOK); 205 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 206 207 // 2. Binade Boundary Tests. 208 209 // 2a. Test denormal <-> normal binade boundaries. 210 // * nextUp(+Largest Denormal) -> +Smallest Normal. 211 // * nextDown(-Largest Denormal) -> -Smallest Normal. 212 // * nextUp(-Smallest Normal) -> -Largest Denormal. 213 // * nextDown(+Smallest Normal) -> +Largest Denormal. 214 215 // nextUp(+Largest Denormal) -> +Smallest Normal. 216 test = APFloat(APFloat::IEEEquad, "0x0.ffffffffffffffffffffffffffffp-16382"); 217 expected = APFloat(APFloat::IEEEquad, 218 "0x1.0000000000000000000000000000p-16382"); 219 EXPECT_EQ(test.next(false), APFloat::opOK); 220 EXPECT_FALSE(test.isDenormal()); 221 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 222 223 // nextDown(-Largest Denormal) -> -Smallest Normal. 224 test = APFloat(APFloat::IEEEquad, 225 "-0x0.ffffffffffffffffffffffffffffp-16382"); 226 expected = APFloat(APFloat::IEEEquad, 227 "-0x1.0000000000000000000000000000p-16382"); 228 EXPECT_EQ(test.next(true), APFloat::opOK); 229 EXPECT_FALSE(test.isDenormal()); 230 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 231 232 // nextUp(-Smallest Normal) -> -LargestDenormal. 233 test = APFloat(APFloat::IEEEquad, 234 "-0x1.0000000000000000000000000000p-16382"); 235 expected = APFloat(APFloat::IEEEquad, 236 "-0x0.ffffffffffffffffffffffffffffp-16382"); 237 EXPECT_EQ(test.next(false), APFloat::opOK); 238 EXPECT_TRUE(test.isDenormal()); 239 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 240 241 // nextDown(+Smallest Normal) -> +Largest Denormal. 242 test = APFloat(APFloat::IEEEquad, 243 "+0x1.0000000000000000000000000000p-16382"); 244 expected = APFloat(APFloat::IEEEquad, 245 "+0x0.ffffffffffffffffffffffffffffp-16382"); 246 EXPECT_EQ(test.next(true), APFloat::opOK); 247 EXPECT_TRUE(test.isDenormal()); 248 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 249 250 // 2b. Test normal <-> normal binade boundaries. 251 // * nextUp(-Normal Binade Boundary) -> -Normal Binade Boundary + 1. 252 // * nextDown(+Normal Binade Boundary) -> +Normal Binade Boundary - 1. 253 // * nextUp(+Normal Binade Boundary - 1) -> +Normal Binade Boundary. 254 // * nextDown(-Normal Binade Boundary + 1) -> -Normal Binade Boundary. 255 256 // nextUp(-Normal Binade Boundary) -> -Normal Binade Boundary + 1. 257 test = APFloat(APFloat::IEEEquad, "-0x1p+1"); 258 expected = APFloat(APFloat::IEEEquad, 259 "-0x1.ffffffffffffffffffffffffffffp+0"); 260 EXPECT_EQ(test.next(false), APFloat::opOK); 261 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 262 263 // nextDown(+Normal Binade Boundary) -> +Normal Binade Boundary - 1. 264 test = APFloat(APFloat::IEEEquad, "0x1p+1"); 265 expected = APFloat(APFloat::IEEEquad, "0x1.ffffffffffffffffffffffffffffp+0"); 266 EXPECT_EQ(test.next(true), APFloat::opOK); 267 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 268 269 // nextUp(+Normal Binade Boundary - 1) -> +Normal Binade Boundary. 270 test = APFloat(APFloat::IEEEquad, "0x1.ffffffffffffffffffffffffffffp+0"); 271 expected = APFloat(APFloat::IEEEquad, "0x1p+1"); 272 EXPECT_EQ(test.next(false), APFloat::opOK); 273 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 274 275 // nextDown(-Normal Binade Boundary + 1) -> -Normal Binade Boundary. 276 test = APFloat(APFloat::IEEEquad, "-0x1.ffffffffffffffffffffffffffffp+0"); 277 expected = APFloat(APFloat::IEEEquad, "-0x1p+1"); 278 EXPECT_EQ(test.next(true), APFloat::opOK); 279 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 280 281 // 2c. Test using next at binade boundaries with a direction away from the 282 // binade boundary. Away from denormal <-> normal boundaries. 283 // 284 // This is to make sure that even though we are at a binade boundary, since 285 // we are rounding away, we do not trigger the binade boundary code. Thus we 286 // test: 287 // * nextUp(-Largest Denormal) -> -Largest Denormal + inc. 288 // * nextDown(+Largest Denormal) -> +Largest Denormal - inc. 289 // * nextUp(+Smallest Normal) -> +Smallest Normal + inc. 290 // * nextDown(-Smallest Normal) -> -Smallest Normal - inc. 291 292 // nextUp(-Largest Denormal) -> -Largest Denormal + inc. 293 test = APFloat(APFloat::IEEEquad, "-0x0.ffffffffffffffffffffffffffffp-16382"); 294 expected = APFloat(APFloat::IEEEquad, 295 "-0x0.fffffffffffffffffffffffffffep-16382"); 296 EXPECT_EQ(test.next(false), APFloat::opOK); 297 EXPECT_TRUE(test.isDenormal()); 298 EXPECT_TRUE(test.isNegative()); 299 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 300 301 // nextDown(+Largest Denormal) -> +Largest Denormal - inc. 302 test = APFloat(APFloat::IEEEquad, "0x0.ffffffffffffffffffffffffffffp-16382"); 303 expected = APFloat(APFloat::IEEEquad, 304 "0x0.fffffffffffffffffffffffffffep-16382"); 305 EXPECT_EQ(test.next(true), APFloat::opOK); 306 EXPECT_TRUE(test.isDenormal()); 307 EXPECT_TRUE(!test.isNegative()); 308 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 309 310 // nextUp(+Smallest Normal) -> +Smallest Normal + inc. 311 test = APFloat(APFloat::IEEEquad, "0x1.0000000000000000000000000000p-16382"); 312 expected = APFloat(APFloat::IEEEquad, 313 "0x1.0000000000000000000000000001p-16382"); 314 EXPECT_EQ(test.next(false), APFloat::opOK); 315 EXPECT_TRUE(!test.isDenormal()); 316 EXPECT_TRUE(!test.isNegative()); 317 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 318 319 // nextDown(-Smallest Normal) -> -Smallest Normal - inc. 320 test = APFloat(APFloat::IEEEquad, "-0x1.0000000000000000000000000000p-16382"); 321 expected = APFloat(APFloat::IEEEquad, 322 "-0x1.0000000000000000000000000001p-16382"); 323 EXPECT_EQ(test.next(true), APFloat::opOK); 324 EXPECT_TRUE(!test.isDenormal()); 325 EXPECT_TRUE(test.isNegative()); 326 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 327 328 // 2d. Test values which cause our exponent to go to min exponent. This 329 // is to ensure that guards in the code to check for min exponent 330 // trigger properly. 331 // * nextUp(-0x1p-16381) -> -0x1.ffffffffffffffffffffffffffffp-16382 332 // * nextDown(-0x1.ffffffffffffffffffffffffffffp-16382) -> 333 // -0x1p-16381 334 // * nextUp(0x1.ffffffffffffffffffffffffffffp-16382) -> 0x1p-16382 335 // * nextDown(0x1p-16382) -> 0x1.ffffffffffffffffffffffffffffp-16382 336 337 // nextUp(-0x1p-16381) -> -0x1.ffffffffffffffffffffffffffffp-16382 338 test = APFloat(APFloat::IEEEquad, "-0x1p-16381"); 339 expected = APFloat(APFloat::IEEEquad, 340 "-0x1.ffffffffffffffffffffffffffffp-16382"); 341 EXPECT_EQ(test.next(false), APFloat::opOK); 342 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 343 344 // nextDown(-0x1.ffffffffffffffffffffffffffffp-16382) -> 345 // -0x1p-16381 346 test = APFloat(APFloat::IEEEquad, "-0x1.ffffffffffffffffffffffffffffp-16382"); 347 expected = APFloat(APFloat::IEEEquad, "-0x1p-16381"); 348 EXPECT_EQ(test.next(true), APFloat::opOK); 349 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 350 351 // nextUp(0x1.ffffffffffffffffffffffffffffp-16382) -> 0x1p-16381 352 test = APFloat(APFloat::IEEEquad, "0x1.ffffffffffffffffffffffffffffp-16382"); 353 expected = APFloat(APFloat::IEEEquad, "0x1p-16381"); 354 EXPECT_EQ(test.next(false), APFloat::opOK); 355 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 356 357 // nextDown(0x1p-16381) -> 0x1.ffffffffffffffffffffffffffffp-16382 358 test = APFloat(APFloat::IEEEquad, "0x1p-16381"); 359 expected = APFloat(APFloat::IEEEquad, 360 "0x1.ffffffffffffffffffffffffffffp-16382"); 361 EXPECT_EQ(test.next(true), APFloat::opOK); 362 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 363 364 // 3. Now we test both denormal/normal computation which will not cause us 365 // to go across binade boundaries. Specifically we test: 366 // * nextUp(+Denormal) -> +Denormal. 367 // * nextDown(+Denormal) -> +Denormal. 368 // * nextUp(-Denormal) -> -Denormal. 369 // * nextDown(-Denormal) -> -Denormal. 370 // * nextUp(+Normal) -> +Normal. 371 // * nextDown(+Normal) -> +Normal. 372 // * nextUp(-Normal) -> -Normal. 373 // * nextDown(-Normal) -> -Normal. 374 375 // nextUp(+Denormal) -> +Denormal. 376 test = APFloat(APFloat::IEEEquad, 377 "0x0.ffffffffffffffffffffffff000cp-16382"); 378 expected = APFloat(APFloat::IEEEquad, 379 "0x0.ffffffffffffffffffffffff000dp-16382"); 380 EXPECT_EQ(test.next(false), APFloat::opOK); 381 EXPECT_TRUE(test.isDenormal()); 382 EXPECT_TRUE(!test.isNegative()); 383 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 384 385 // nextDown(+Denormal) -> +Denormal. 386 test = APFloat(APFloat::IEEEquad, 387 "0x0.ffffffffffffffffffffffff000cp-16382"); 388 expected = APFloat(APFloat::IEEEquad, 389 "0x0.ffffffffffffffffffffffff000bp-16382"); 390 EXPECT_EQ(test.next(true), APFloat::opOK); 391 EXPECT_TRUE(test.isDenormal()); 392 EXPECT_TRUE(!test.isNegative()); 393 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 394 395 // nextUp(-Denormal) -> -Denormal. 396 test = APFloat(APFloat::IEEEquad, 397 "-0x0.ffffffffffffffffffffffff000cp-16382"); 398 expected = APFloat(APFloat::IEEEquad, 399 "-0x0.ffffffffffffffffffffffff000bp-16382"); 400 EXPECT_EQ(test.next(false), APFloat::opOK); 401 EXPECT_TRUE(test.isDenormal()); 402 EXPECT_TRUE(test.isNegative()); 403 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 404 405 // nextDown(-Denormal) -> -Denormal 406 test = APFloat(APFloat::IEEEquad, 407 "-0x0.ffffffffffffffffffffffff000cp-16382"); 408 expected = APFloat(APFloat::IEEEquad, 409 "-0x0.ffffffffffffffffffffffff000dp-16382"); 410 EXPECT_EQ(test.next(true), APFloat::opOK); 411 EXPECT_TRUE(test.isDenormal()); 412 EXPECT_TRUE(test.isNegative()); 413 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 414 415 // nextUp(+Normal) -> +Normal. 416 test = APFloat(APFloat::IEEEquad, 417 "0x1.ffffffffffffffffffffffff000cp-16000"); 418 expected = APFloat(APFloat::IEEEquad, 419 "0x1.ffffffffffffffffffffffff000dp-16000"); 420 EXPECT_EQ(test.next(false), APFloat::opOK); 421 EXPECT_TRUE(!test.isDenormal()); 422 EXPECT_TRUE(!test.isNegative()); 423 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 424 425 // nextDown(+Normal) -> +Normal. 426 test = APFloat(APFloat::IEEEquad, 427 "0x1.ffffffffffffffffffffffff000cp-16000"); 428 expected = APFloat(APFloat::IEEEquad, 429 "0x1.ffffffffffffffffffffffff000bp-16000"); 430 EXPECT_EQ(test.next(true), APFloat::opOK); 431 EXPECT_TRUE(!test.isDenormal()); 432 EXPECT_TRUE(!test.isNegative()); 433 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 434 435 // nextUp(-Normal) -> -Normal. 436 test = APFloat(APFloat::IEEEquad, 437 "-0x1.ffffffffffffffffffffffff000cp-16000"); 438 expected = APFloat(APFloat::IEEEquad, 439 "-0x1.ffffffffffffffffffffffff000bp-16000"); 440 EXPECT_EQ(test.next(false), APFloat::opOK); 441 EXPECT_TRUE(!test.isDenormal()); 442 EXPECT_TRUE(test.isNegative()); 443 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 444 445 // nextDown(-Normal) -> -Normal. 446 test = APFloat(APFloat::IEEEquad, 447 "-0x1.ffffffffffffffffffffffff000cp-16000"); 448 expected = APFloat(APFloat::IEEEquad, 449 "-0x1.ffffffffffffffffffffffff000dp-16000"); 450 EXPECT_EQ(test.next(true), APFloat::opOK); 451 EXPECT_TRUE(!test.isDenormal()); 452 EXPECT_TRUE(test.isNegative()); 453 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 454 } 455 456 TEST(APFloatTest, FMA) { 457 APFloat::roundingMode rdmd = APFloat::rmNearestTiesToEven; 458 459 { 460 APFloat f1(14.5f); 461 APFloat f2(-14.5f); 462 APFloat f3(225.0f); 463 f1.fusedMultiplyAdd(f2, f3, APFloat::rmNearestTiesToEven); 464 EXPECT_EQ(14.75f, f1.convertToFloat()); 465 } 466 467 { 468 APFloat Val2(2.0f); 469 APFloat f1((float)1.17549435e-38F); 470 APFloat f2((float)1.17549435e-38F); 471 f1.divide(Val2, rdmd); 472 f2.divide(Val2, rdmd); 473 APFloat f3(12.0f); 474 f1.fusedMultiplyAdd(f2, f3, APFloat::rmNearestTiesToEven); 475 EXPECT_EQ(12.0f, f1.convertToFloat()); 476 } 477 478 // Test for correct zero sign when answer is exactly zero. 479 // fma(1.0, -1.0, 1.0) -> +ve 0. 480 { 481 APFloat f1(1.0); 482 APFloat f2(-1.0); 483 APFloat f3(1.0); 484 f1.fusedMultiplyAdd(f2, f3, APFloat::rmNearestTiesToEven); 485 EXPECT_TRUE(!f1.isNegative() && f1.isZero()); 486 } 487 488 // Test for correct zero sign when answer is exactly zero and rounding towards 489 // negative. 490 // fma(1.0, -1.0, 1.0) -> +ve 0. 491 { 492 APFloat f1(1.0); 493 APFloat f2(-1.0); 494 APFloat f3(1.0); 495 f1.fusedMultiplyAdd(f2, f3, APFloat::rmTowardNegative); 496 EXPECT_TRUE(f1.isNegative() && f1.isZero()); 497 } 498 499 // Test for correct (in this case -ve) sign when adding like signed zeros. 500 // Test fma(0.0, -0.0, -0.0) -> -ve 0. 501 { 502 APFloat f1(0.0); 503 APFloat f2(-0.0); 504 APFloat f3(-0.0); 505 f1.fusedMultiplyAdd(f2, f3, APFloat::rmNearestTiesToEven); 506 EXPECT_TRUE(f1.isNegative() && f1.isZero()); 507 } 508 509 // Test -ve sign preservation when small negative results underflow. 510 { 511 APFloat f1(APFloat::IEEEdouble, "-0x1p-1074"); 512 APFloat f2(APFloat::IEEEdouble, "+0x1p-1074"); 513 APFloat f3(0.0); 514 f1.fusedMultiplyAdd(f2, f3, APFloat::rmNearestTiesToEven); 515 EXPECT_TRUE(f1.isNegative() && f1.isZero()); 516 } 517 518 // Test x87 extended precision case from http://llvm.org/PR20728. 519 { 520 APFloat M1(APFloat::x87DoubleExtended, 1.0); 521 APFloat M2(APFloat::x87DoubleExtended, 1.0); 522 APFloat A(APFloat::x87DoubleExtended, 3.0); 523 524 bool losesInfo = false; 525 M1.fusedMultiplyAdd(M1, A, APFloat::rmNearestTiesToEven); 526 M1.convert(APFloat::IEEEsingle, APFloat::rmNearestTiesToEven, &losesInfo); 527 EXPECT_FALSE(losesInfo); 528 EXPECT_EQ(4.0f, M1.convertToFloat()); 529 } 530 } 531 532 TEST(APFloatTest, MinNum) { 533 APFloat f1(1.0); 534 APFloat f2(2.0); 535 APFloat nan = APFloat::getNaN(APFloat::IEEEdouble); 536 537 EXPECT_EQ(1.0, minnum(f1, f2).convertToDouble()); 538 EXPECT_EQ(1.0, minnum(f2, f1).convertToDouble()); 539 EXPECT_EQ(1.0, minnum(f1, nan).convertToDouble()); 540 EXPECT_EQ(1.0, minnum(nan, f1).convertToDouble()); 541 } 542 543 TEST(APFloatTest, MaxNum) { 544 APFloat f1(1.0); 545 APFloat f2(2.0); 546 APFloat nan = APFloat::getNaN(APFloat::IEEEdouble); 547 548 EXPECT_EQ(2.0, maxnum(f1, f2).convertToDouble()); 549 EXPECT_EQ(2.0, maxnum(f2, f1).convertToDouble()); 550 EXPECT_EQ(1.0, maxnum(f1, nan).convertToDouble()); 551 EXPECT_EQ(1.0, minnum(nan, f1).convertToDouble()); 552 } 553 554 TEST(APFloatTest, Denormal) { 555 APFloat::roundingMode rdmd = APFloat::rmNearestTiesToEven; 556 557 // Test single precision 558 { 559 const char *MinNormalStr = "1.17549435082228750797e-38"; 560 EXPECT_FALSE(APFloat(APFloat::IEEEsingle, MinNormalStr).isDenormal()); 561 EXPECT_FALSE(APFloat(APFloat::IEEEsingle, 0.0).isDenormal()); 562 563 APFloat Val2(APFloat::IEEEsingle, 2.0e0); 564 APFloat T(APFloat::IEEEsingle, MinNormalStr); 565 T.divide(Val2, rdmd); 566 EXPECT_TRUE(T.isDenormal()); 567 } 568 569 // Test double precision 570 { 571 const char *MinNormalStr = "2.22507385850720138309e-308"; 572 EXPECT_FALSE(APFloat(APFloat::IEEEdouble, MinNormalStr).isDenormal()); 573 EXPECT_FALSE(APFloat(APFloat::IEEEdouble, 0.0).isDenormal()); 574 575 APFloat Val2(APFloat::IEEEdouble, 2.0e0); 576 APFloat T(APFloat::IEEEdouble, MinNormalStr); 577 T.divide(Val2, rdmd); 578 EXPECT_TRUE(T.isDenormal()); 579 } 580 581 // Test Intel double-ext 582 { 583 const char *MinNormalStr = "3.36210314311209350626e-4932"; 584 EXPECT_FALSE(APFloat(APFloat::x87DoubleExtended, MinNormalStr).isDenormal()); 585 EXPECT_FALSE(APFloat(APFloat::x87DoubleExtended, 0.0).isDenormal()); 586 587 APFloat Val2(APFloat::x87DoubleExtended, 2.0e0); 588 APFloat T(APFloat::x87DoubleExtended, MinNormalStr); 589 T.divide(Val2, rdmd); 590 EXPECT_TRUE(T.isDenormal()); 591 } 592 593 // Test quadruple precision 594 { 595 const char *MinNormalStr = "3.36210314311209350626267781732175260e-4932"; 596 EXPECT_FALSE(APFloat(APFloat::IEEEquad, MinNormalStr).isDenormal()); 597 EXPECT_FALSE(APFloat(APFloat::IEEEquad, 0.0).isDenormal()); 598 599 APFloat Val2(APFloat::IEEEquad, 2.0e0); 600 APFloat T(APFloat::IEEEquad, MinNormalStr); 601 T.divide(Val2, rdmd); 602 EXPECT_TRUE(T.isDenormal()); 603 } 604 } 605 606 TEST(APFloatTest, Zero) { 607 EXPECT_EQ(0.0f, APFloat(0.0f).convertToFloat()); 608 EXPECT_EQ(-0.0f, APFloat(-0.0f).convertToFloat()); 609 EXPECT_TRUE(APFloat(-0.0f).isNegative()); 610 611 EXPECT_EQ(0.0, APFloat(0.0).convertToDouble()); 612 EXPECT_EQ(-0.0, APFloat(-0.0).convertToDouble()); 613 EXPECT_TRUE(APFloat(-0.0).isNegative()); 614 } 615 616 TEST(APFloatTest, DecimalStringsWithoutNullTerminators) { 617 // Make sure that we can parse strings without null terminators. 618 // rdar://14323230. 619 APFloat Val(APFloat::IEEEdouble); 620 Val.convertFromString(StringRef("0.00", 3), 621 llvm::APFloat::rmNearestTiesToEven); 622 EXPECT_EQ(Val.convertToDouble(), 0.0); 623 Val.convertFromString(StringRef("0.01", 3), 624 llvm::APFloat::rmNearestTiesToEven); 625 EXPECT_EQ(Val.convertToDouble(), 0.0); 626 Val.convertFromString(StringRef("0.09", 3), 627 llvm::APFloat::rmNearestTiesToEven); 628 EXPECT_EQ(Val.convertToDouble(), 0.0); 629 Val.convertFromString(StringRef("0.095", 4), 630 llvm::APFloat::rmNearestTiesToEven); 631 EXPECT_EQ(Val.convertToDouble(), 0.09); 632 Val.convertFromString(StringRef("0.00e+3", 7), 633 llvm::APFloat::rmNearestTiesToEven); 634 EXPECT_EQ(Val.convertToDouble(), 0.00); 635 Val.convertFromString(StringRef("0e+3", 4), 636 llvm::APFloat::rmNearestTiesToEven); 637 EXPECT_EQ(Val.convertToDouble(), 0.00); 638 639 } 640 641 TEST(APFloatTest, fromZeroDecimalString) { 642 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0").convertToDouble()); 643 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0").convertToDouble()); 644 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0").convertToDouble()); 645 646 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0.").convertToDouble()); 647 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0.").convertToDouble()); 648 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0.").convertToDouble()); 649 650 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, ".0").convertToDouble()); 651 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+.0").convertToDouble()); 652 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-.0").convertToDouble()); 653 654 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0.0").convertToDouble()); 655 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0.0").convertToDouble()); 656 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0.0").convertToDouble()); 657 658 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "00000.").convertToDouble()); 659 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+00000.").convertToDouble()); 660 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-00000.").convertToDouble()); 661 662 EXPECT_EQ(0.0, APFloat(APFloat::IEEEdouble, ".00000").convertToDouble()); 663 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+.00000").convertToDouble()); 664 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-.00000").convertToDouble()); 665 666 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0000.00000").convertToDouble()); 667 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0000.00000").convertToDouble()); 668 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0000.00000").convertToDouble()); 669 } 670 671 TEST(APFloatTest, fromZeroDecimalSingleExponentString) { 672 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0e1").convertToDouble()); 673 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0e1").convertToDouble()); 674 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0e1").convertToDouble()); 675 676 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0e+1").convertToDouble()); 677 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0e+1").convertToDouble()); 678 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0e+1").convertToDouble()); 679 680 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0e-1").convertToDouble()); 681 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0e-1").convertToDouble()); 682 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0e-1").convertToDouble()); 683 684 685 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0.e1").convertToDouble()); 686 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0.e1").convertToDouble()); 687 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0.e1").convertToDouble()); 688 689 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0.e+1").convertToDouble()); 690 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0.e+1").convertToDouble()); 691 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0.e+1").convertToDouble()); 692 693 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0.e-1").convertToDouble()); 694 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0.e-1").convertToDouble()); 695 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0.e-1").convertToDouble()); 696 697 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, ".0e1").convertToDouble()); 698 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+.0e1").convertToDouble()); 699 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-.0e1").convertToDouble()); 700 701 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, ".0e+1").convertToDouble()); 702 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+.0e+1").convertToDouble()); 703 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-.0e+1").convertToDouble()); 704 705 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, ".0e-1").convertToDouble()); 706 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+.0e-1").convertToDouble()); 707 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-.0e-1").convertToDouble()); 708 709 710 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0.0e1").convertToDouble()); 711 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0.0e1").convertToDouble()); 712 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0.0e1").convertToDouble()); 713 714 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0.0e+1").convertToDouble()); 715 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0.0e+1").convertToDouble()); 716 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0.0e+1").convertToDouble()); 717 718 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0.0e-1").convertToDouble()); 719 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0.0e-1").convertToDouble()); 720 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0.0e-1").convertToDouble()); 721 722 723 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "000.0000e1").convertToDouble()); 724 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+000.0000e+1").convertToDouble()); 725 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-000.0000e+1").convertToDouble()); 726 } 727 728 TEST(APFloatTest, fromZeroDecimalLargeExponentString) { 729 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0e1234").convertToDouble()); 730 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0e1234").convertToDouble()); 731 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0e1234").convertToDouble()); 732 733 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0e+1234").convertToDouble()); 734 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0e+1234").convertToDouble()); 735 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0e+1234").convertToDouble()); 736 737 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0e-1234").convertToDouble()); 738 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0e-1234").convertToDouble()); 739 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0e-1234").convertToDouble()); 740 741 EXPECT_EQ(0.0, APFloat(APFloat::IEEEdouble, "000.0000e1234").convertToDouble()); 742 EXPECT_EQ(0.0, APFloat(APFloat::IEEEdouble, "000.0000e-1234").convertToDouble()); 743 744 EXPECT_EQ(0.0, APFloat(APFloat::IEEEdouble, StringRef("0e1234\02", 6)).convertToDouble()); 745 } 746 747 TEST(APFloatTest, fromZeroHexadecimalString) { 748 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x0p1").convertToDouble()); 749 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0x0p1").convertToDouble()); 750 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0x0p1").convertToDouble()); 751 752 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x0p+1").convertToDouble()); 753 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0x0p+1").convertToDouble()); 754 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0x0p+1").convertToDouble()); 755 756 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x0p-1").convertToDouble()); 757 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0x0p-1").convertToDouble()); 758 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0x0p-1").convertToDouble()); 759 760 761 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x0.p1").convertToDouble()); 762 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0x0.p1").convertToDouble()); 763 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0x0.p1").convertToDouble()); 764 765 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x0.p+1").convertToDouble()); 766 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0x0.p+1").convertToDouble()); 767 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0x0.p+1").convertToDouble()); 768 769 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x0.p-1").convertToDouble()); 770 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0x0.p-1").convertToDouble()); 771 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0x0.p-1").convertToDouble()); 772 773 774 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x.0p1").convertToDouble()); 775 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0x.0p1").convertToDouble()); 776 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0x.0p1").convertToDouble()); 777 778 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x.0p+1").convertToDouble()); 779 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0x.0p+1").convertToDouble()); 780 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0x.0p+1").convertToDouble()); 781 782 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x.0p-1").convertToDouble()); 783 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0x.0p-1").convertToDouble()); 784 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0x.0p-1").convertToDouble()); 785 786 787 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x0.0p1").convertToDouble()); 788 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0x0.0p1").convertToDouble()); 789 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0x0.0p1").convertToDouble()); 790 791 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x0.0p+1").convertToDouble()); 792 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0x0.0p+1").convertToDouble()); 793 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0x0.0p+1").convertToDouble()); 794 795 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x0.0p-1").convertToDouble()); 796 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0x0.0p-1").convertToDouble()); 797 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0x0.0p-1").convertToDouble()); 798 799 800 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x00000.p1").convertToDouble()); 801 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x0000.00000p1").convertToDouble()); 802 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x.00000p1").convertToDouble()); 803 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x0.p1").convertToDouble()); 804 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x0p1234").convertToDouble()); 805 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0x0p1234").convertToDouble()); 806 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x00000.p1234").convertToDouble()); 807 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x0000.00000p1234").convertToDouble()); 808 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x.00000p1234").convertToDouble()); 809 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x0.p1234").convertToDouble()); 810 } 811 812 TEST(APFloatTest, fromDecimalString) { 813 EXPECT_EQ(1.0, APFloat(APFloat::IEEEdouble, "1").convertToDouble()); 814 EXPECT_EQ(2.0, APFloat(APFloat::IEEEdouble, "2.").convertToDouble()); 815 EXPECT_EQ(0.5, APFloat(APFloat::IEEEdouble, ".5").convertToDouble()); 816 EXPECT_EQ(1.0, APFloat(APFloat::IEEEdouble, "1.0").convertToDouble()); 817 EXPECT_EQ(-2.0, APFloat(APFloat::IEEEdouble, "-2").convertToDouble()); 818 EXPECT_EQ(-4.0, APFloat(APFloat::IEEEdouble, "-4.").convertToDouble()); 819 EXPECT_EQ(-0.5, APFloat(APFloat::IEEEdouble, "-.5").convertToDouble()); 820 EXPECT_EQ(-1.5, APFloat(APFloat::IEEEdouble, "-1.5").convertToDouble()); 821 EXPECT_EQ(1.25e12, APFloat(APFloat::IEEEdouble, "1.25e12").convertToDouble()); 822 EXPECT_EQ(1.25e+12, APFloat(APFloat::IEEEdouble, "1.25e+12").convertToDouble()); 823 EXPECT_EQ(1.25e-12, APFloat(APFloat::IEEEdouble, "1.25e-12").convertToDouble()); 824 EXPECT_EQ(1024.0, APFloat(APFloat::IEEEdouble, "1024.").convertToDouble()); 825 EXPECT_EQ(1024.05, APFloat(APFloat::IEEEdouble, "1024.05000").convertToDouble()); 826 EXPECT_EQ(0.05, APFloat(APFloat::IEEEdouble, ".05000").convertToDouble()); 827 EXPECT_EQ(2.0, APFloat(APFloat::IEEEdouble, "2.").convertToDouble()); 828 EXPECT_EQ(2.0e2, APFloat(APFloat::IEEEdouble, "2.e2").convertToDouble()); 829 EXPECT_EQ(2.0e+2, APFloat(APFloat::IEEEdouble, "2.e+2").convertToDouble()); 830 EXPECT_EQ(2.0e-2, APFloat(APFloat::IEEEdouble, "2.e-2").convertToDouble()); 831 EXPECT_EQ(2.05e2, APFloat(APFloat::IEEEdouble, "002.05000e2").convertToDouble()); 832 EXPECT_EQ(2.05e+2, APFloat(APFloat::IEEEdouble, "002.05000e+2").convertToDouble()); 833 EXPECT_EQ(2.05e-2, APFloat(APFloat::IEEEdouble, "002.05000e-2").convertToDouble()); 834 EXPECT_EQ(2.05e12, APFloat(APFloat::IEEEdouble, "002.05000e12").convertToDouble()); 835 EXPECT_EQ(2.05e+12, APFloat(APFloat::IEEEdouble, "002.05000e+12").convertToDouble()); 836 EXPECT_EQ(2.05e-12, APFloat(APFloat::IEEEdouble, "002.05000e-12").convertToDouble()); 837 838 // These are "carefully selected" to overflow the fast log-base 839 // calculations in APFloat.cpp 840 EXPECT_TRUE(APFloat(APFloat::IEEEdouble, "99e99999").isInfinity()); 841 EXPECT_TRUE(APFloat(APFloat::IEEEdouble, "-99e99999").isInfinity()); 842 EXPECT_TRUE(APFloat(APFloat::IEEEdouble, "1e-99999").isPosZero()); 843 EXPECT_TRUE(APFloat(APFloat::IEEEdouble, "-1e-99999").isNegZero()); 844 845 EXPECT_EQ(2.71828, convertToDoubleFromString("2.71828")); 846 } 847 848 TEST(APFloatTest, fromHexadecimalString) { 849 EXPECT_EQ( 1.0, APFloat(APFloat::IEEEdouble, "0x1p0").convertToDouble()); 850 EXPECT_EQ(+1.0, APFloat(APFloat::IEEEdouble, "+0x1p0").convertToDouble()); 851 EXPECT_EQ(-1.0, APFloat(APFloat::IEEEdouble, "-0x1p0").convertToDouble()); 852 853 EXPECT_EQ( 1.0, APFloat(APFloat::IEEEdouble, "0x1p+0").convertToDouble()); 854 EXPECT_EQ(+1.0, APFloat(APFloat::IEEEdouble, "+0x1p+0").convertToDouble()); 855 EXPECT_EQ(-1.0, APFloat(APFloat::IEEEdouble, "-0x1p+0").convertToDouble()); 856 857 EXPECT_EQ( 1.0, APFloat(APFloat::IEEEdouble, "0x1p-0").convertToDouble()); 858 EXPECT_EQ(+1.0, APFloat(APFloat::IEEEdouble, "+0x1p-0").convertToDouble()); 859 EXPECT_EQ(-1.0, APFloat(APFloat::IEEEdouble, "-0x1p-0").convertToDouble()); 860 861 862 EXPECT_EQ( 2.0, APFloat(APFloat::IEEEdouble, "0x1p1").convertToDouble()); 863 EXPECT_EQ(+2.0, APFloat(APFloat::IEEEdouble, "+0x1p1").convertToDouble()); 864 EXPECT_EQ(-2.0, APFloat(APFloat::IEEEdouble, "-0x1p1").convertToDouble()); 865 866 EXPECT_EQ( 2.0, APFloat(APFloat::IEEEdouble, "0x1p+1").convertToDouble()); 867 EXPECT_EQ(+2.0, APFloat(APFloat::IEEEdouble, "+0x1p+1").convertToDouble()); 868 EXPECT_EQ(-2.0, APFloat(APFloat::IEEEdouble, "-0x1p+1").convertToDouble()); 869 870 EXPECT_EQ( 0.5, APFloat(APFloat::IEEEdouble, "0x1p-1").convertToDouble()); 871 EXPECT_EQ(+0.5, APFloat(APFloat::IEEEdouble, "+0x1p-1").convertToDouble()); 872 EXPECT_EQ(-0.5, APFloat(APFloat::IEEEdouble, "-0x1p-1").convertToDouble()); 873 874 875 EXPECT_EQ( 3.0, APFloat(APFloat::IEEEdouble, "0x1.8p1").convertToDouble()); 876 EXPECT_EQ(+3.0, APFloat(APFloat::IEEEdouble, "+0x1.8p1").convertToDouble()); 877 EXPECT_EQ(-3.0, APFloat(APFloat::IEEEdouble, "-0x1.8p1").convertToDouble()); 878 879 EXPECT_EQ( 3.0, APFloat(APFloat::IEEEdouble, "0x1.8p+1").convertToDouble()); 880 EXPECT_EQ(+3.0, APFloat(APFloat::IEEEdouble, "+0x1.8p+1").convertToDouble()); 881 EXPECT_EQ(-3.0, APFloat(APFloat::IEEEdouble, "-0x1.8p+1").convertToDouble()); 882 883 EXPECT_EQ( 0.75, APFloat(APFloat::IEEEdouble, "0x1.8p-1").convertToDouble()); 884 EXPECT_EQ(+0.75, APFloat(APFloat::IEEEdouble, "+0x1.8p-1").convertToDouble()); 885 EXPECT_EQ(-0.75, APFloat(APFloat::IEEEdouble, "-0x1.8p-1").convertToDouble()); 886 887 888 EXPECT_EQ( 8192.0, APFloat(APFloat::IEEEdouble, "0x1000.000p1").convertToDouble()); 889 EXPECT_EQ(+8192.0, APFloat(APFloat::IEEEdouble, "+0x1000.000p1").convertToDouble()); 890 EXPECT_EQ(-8192.0, APFloat(APFloat::IEEEdouble, "-0x1000.000p1").convertToDouble()); 891 892 EXPECT_EQ( 8192.0, APFloat(APFloat::IEEEdouble, "0x1000.000p+1").convertToDouble()); 893 EXPECT_EQ(+8192.0, APFloat(APFloat::IEEEdouble, "+0x1000.000p+1").convertToDouble()); 894 EXPECT_EQ(-8192.0, APFloat(APFloat::IEEEdouble, "-0x1000.000p+1").convertToDouble()); 895 896 EXPECT_EQ( 2048.0, APFloat(APFloat::IEEEdouble, "0x1000.000p-1").convertToDouble()); 897 EXPECT_EQ(+2048.0, APFloat(APFloat::IEEEdouble, "+0x1000.000p-1").convertToDouble()); 898 EXPECT_EQ(-2048.0, APFloat(APFloat::IEEEdouble, "-0x1000.000p-1").convertToDouble()); 899 900 901 EXPECT_EQ( 8192.0, APFloat(APFloat::IEEEdouble, "0x1000p1").convertToDouble()); 902 EXPECT_EQ(+8192.0, APFloat(APFloat::IEEEdouble, "+0x1000p1").convertToDouble()); 903 EXPECT_EQ(-8192.0, APFloat(APFloat::IEEEdouble, "-0x1000p1").convertToDouble()); 904 905 EXPECT_EQ( 8192.0, APFloat(APFloat::IEEEdouble, "0x1000p+1").convertToDouble()); 906 EXPECT_EQ(+8192.0, APFloat(APFloat::IEEEdouble, "+0x1000p+1").convertToDouble()); 907 EXPECT_EQ(-8192.0, APFloat(APFloat::IEEEdouble, "-0x1000p+1").convertToDouble()); 908 909 EXPECT_EQ( 2048.0, APFloat(APFloat::IEEEdouble, "0x1000p-1").convertToDouble()); 910 EXPECT_EQ(+2048.0, APFloat(APFloat::IEEEdouble, "+0x1000p-1").convertToDouble()); 911 EXPECT_EQ(-2048.0, APFloat(APFloat::IEEEdouble, "-0x1000p-1").convertToDouble()); 912 913 914 EXPECT_EQ( 16384.0, APFloat(APFloat::IEEEdouble, "0x10p10").convertToDouble()); 915 EXPECT_EQ(+16384.0, APFloat(APFloat::IEEEdouble, "+0x10p10").convertToDouble()); 916 EXPECT_EQ(-16384.0, APFloat(APFloat::IEEEdouble, "-0x10p10").convertToDouble()); 917 918 EXPECT_EQ( 16384.0, APFloat(APFloat::IEEEdouble, "0x10p+10").convertToDouble()); 919 EXPECT_EQ(+16384.0, APFloat(APFloat::IEEEdouble, "+0x10p+10").convertToDouble()); 920 EXPECT_EQ(-16384.0, APFloat(APFloat::IEEEdouble, "-0x10p+10").convertToDouble()); 921 922 EXPECT_EQ( 0.015625, APFloat(APFloat::IEEEdouble, "0x10p-10").convertToDouble()); 923 EXPECT_EQ(+0.015625, APFloat(APFloat::IEEEdouble, "+0x10p-10").convertToDouble()); 924 EXPECT_EQ(-0.015625, APFloat(APFloat::IEEEdouble, "-0x10p-10").convertToDouble()); 925 926 EXPECT_EQ(1.0625, APFloat(APFloat::IEEEdouble, "0x1.1p0").convertToDouble()); 927 EXPECT_EQ(1.0, APFloat(APFloat::IEEEdouble, "0x1p0").convertToDouble()); 928 929 EXPECT_EQ(convertToDoubleFromString("0x1p-150"), 930 convertToDoubleFromString("+0x800000000000000001.p-221")); 931 EXPECT_EQ(2251799813685248.5, 932 convertToDoubleFromString("0x80000000000004000000.010p-28")); 933 } 934 935 TEST(APFloatTest, toString) { 936 ASSERT_EQ("10", convertToString(10.0, 6, 3)); 937 ASSERT_EQ("1.0E+1", convertToString(10.0, 6, 0)); 938 ASSERT_EQ("10100", convertToString(1.01E+4, 5, 2)); 939 ASSERT_EQ("1.01E+4", convertToString(1.01E+4, 4, 2)); 940 ASSERT_EQ("1.01E+4", convertToString(1.01E+4, 5, 1)); 941 ASSERT_EQ("0.0101", convertToString(1.01E-2, 5, 2)); 942 ASSERT_EQ("0.0101", convertToString(1.01E-2, 4, 2)); 943 ASSERT_EQ("1.01E-2", convertToString(1.01E-2, 5, 1)); 944 ASSERT_EQ("0.78539816339744828", convertToString(0.78539816339744830961, 0, 3)); 945 ASSERT_EQ("4.9406564584124654E-324", convertToString(4.9406564584124654e-324, 0, 3)); 946 ASSERT_EQ("873.18340000000001", convertToString(873.1834, 0, 1)); 947 ASSERT_EQ("8.7318340000000001E+2", convertToString(873.1834, 0, 0)); 948 ASSERT_EQ("1.7976931348623157E+308", convertToString(1.7976931348623157E+308, 0, 0)); 949 } 950 951 TEST(APFloatTest, toInteger) { 952 bool isExact = false; 953 APSInt result(5, /*isUnsigned=*/true); 954 955 EXPECT_EQ(APFloat::opOK, 956 APFloat(APFloat::IEEEdouble, "10") 957 .convertToInteger(result, APFloat::rmTowardZero, &isExact)); 958 EXPECT_TRUE(isExact); 959 EXPECT_EQ(APSInt(APInt(5, 10), true), result); 960 961 EXPECT_EQ(APFloat::opInvalidOp, 962 APFloat(APFloat::IEEEdouble, "-10") 963 .convertToInteger(result, APFloat::rmTowardZero, &isExact)); 964 EXPECT_FALSE(isExact); 965 EXPECT_EQ(APSInt::getMinValue(5, true), result); 966 967 EXPECT_EQ(APFloat::opInvalidOp, 968 APFloat(APFloat::IEEEdouble, "32") 969 .convertToInteger(result, APFloat::rmTowardZero, &isExact)); 970 EXPECT_FALSE(isExact); 971 EXPECT_EQ(APSInt::getMaxValue(5, true), result); 972 973 EXPECT_EQ(APFloat::opInexact, 974 APFloat(APFloat::IEEEdouble, "7.9") 975 .convertToInteger(result, APFloat::rmTowardZero, &isExact)); 976 EXPECT_FALSE(isExact); 977 EXPECT_EQ(APSInt(APInt(5, 7), true), result); 978 979 result.setIsUnsigned(false); 980 EXPECT_EQ(APFloat::opOK, 981 APFloat(APFloat::IEEEdouble, "-10") 982 .convertToInteger(result, APFloat::rmTowardZero, &isExact)); 983 EXPECT_TRUE(isExact); 984 EXPECT_EQ(APSInt(APInt(5, -10, true), false), result); 985 986 EXPECT_EQ(APFloat::opInvalidOp, 987 APFloat(APFloat::IEEEdouble, "-17") 988 .convertToInteger(result, APFloat::rmTowardZero, &isExact)); 989 EXPECT_FALSE(isExact); 990 EXPECT_EQ(APSInt::getMinValue(5, false), result); 991 992 EXPECT_EQ(APFloat::opInvalidOp, 993 APFloat(APFloat::IEEEdouble, "16") 994 .convertToInteger(result, APFloat::rmTowardZero, &isExact)); 995 EXPECT_FALSE(isExact); 996 EXPECT_EQ(APSInt::getMaxValue(5, false), result); 997 } 998 999 static APInt nanbits(const fltSemantics &Sem, 1000 bool SNaN, bool Negative, uint64_t fill) { 1001 APInt apfill(64, fill); 1002 if (SNaN) 1003 return APFloat::getSNaN(Sem, Negative, &apfill).bitcastToAPInt(); 1004 else 1005 return APFloat::getQNaN(Sem, Negative, &apfill).bitcastToAPInt(); 1006 } 1007 1008 TEST(APFloatTest, makeNaN) { 1009 ASSERT_EQ(0x7fc00000, nanbits(APFloat::IEEEsingle, false, false, 0)); 1010 ASSERT_EQ(0xffc00000, nanbits(APFloat::IEEEsingle, false, true, 0)); 1011 ASSERT_EQ(0x7fc0ae72, nanbits(APFloat::IEEEsingle, false, false, 0xae72)); 1012 ASSERT_EQ(0x7fffae72, nanbits(APFloat::IEEEsingle, false, false, 0xffffae72)); 1013 ASSERT_EQ(0x7fa00000, nanbits(APFloat::IEEEsingle, true, false, 0)); 1014 ASSERT_EQ(0xffa00000, nanbits(APFloat::IEEEsingle, true, true, 0)); 1015 ASSERT_EQ(0x7f80ae72, nanbits(APFloat::IEEEsingle, true, false, 0xae72)); 1016 ASSERT_EQ(0x7fbfae72, nanbits(APFloat::IEEEsingle, true, false, 0xffffae72)); 1017 1018 ASSERT_EQ(0x7ff8000000000000ULL, nanbits(APFloat::IEEEdouble, false, false, 0)); 1019 ASSERT_EQ(0xfff8000000000000ULL, nanbits(APFloat::IEEEdouble, false, true, 0)); 1020 ASSERT_EQ(0x7ff800000000ae72ULL, nanbits(APFloat::IEEEdouble, false, false, 0xae72)); 1021 ASSERT_EQ(0x7fffffffffffae72ULL, nanbits(APFloat::IEEEdouble, false, false, 0xffffffffffffae72ULL)); 1022 ASSERT_EQ(0x7ff4000000000000ULL, nanbits(APFloat::IEEEdouble, true, false, 0)); 1023 ASSERT_EQ(0xfff4000000000000ULL, nanbits(APFloat::IEEEdouble, true, true, 0)); 1024 ASSERT_EQ(0x7ff000000000ae72ULL, nanbits(APFloat::IEEEdouble, true, false, 0xae72)); 1025 ASSERT_EQ(0x7ff7ffffffffae72ULL, nanbits(APFloat::IEEEdouble, true, false, 0xffffffffffffae72ULL)); 1026 } 1027 1028 #ifdef GTEST_HAS_DEATH_TEST 1029 #ifndef NDEBUG 1030 TEST(APFloatTest, SemanticsDeath) { 1031 EXPECT_DEATH(APFloat(APFloat::IEEEsingle, 0.0f).convertToDouble(), "Float semantics are not IEEEdouble"); 1032 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, 0.0 ).convertToFloat(), "Float semantics are not IEEEsingle"); 1033 } 1034 1035 TEST(APFloatTest, StringDecimalDeath) { 1036 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, ""), "Invalid string length"); 1037 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+"), "String has no digits"); 1038 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-"), "String has no digits"); 1039 1040 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("\0", 1)), "Invalid character in significand"); 1041 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("1\0", 2)), "Invalid character in significand"); 1042 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("1\02", 3)), "Invalid character in significand"); 1043 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("1\02e1", 5)), "Invalid character in significand"); 1044 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("1e\0", 3)), "Invalid character in exponent"); 1045 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("1e1\0", 4)), "Invalid character in exponent"); 1046 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("1e1\02", 5)), "Invalid character in exponent"); 1047 1048 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "1.0f"), "Invalid character in significand"); 1049 1050 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, ".."), "String contains multiple dots"); 1051 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "..0"), "String contains multiple dots"); 1052 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "1.0.0"), "String contains multiple dots"); 1053 } 1054 1055 TEST(APFloatTest, StringDecimalSignificandDeath) { 1056 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "."), "Significand has no digits"); 1057 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+."), "Significand has no digits"); 1058 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-."), "Significand has no digits"); 1059 1060 1061 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "e"), "Significand has no digits"); 1062 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+e"), "Significand has no digits"); 1063 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-e"), "Significand has no digits"); 1064 1065 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "e1"), "Significand has no digits"); 1066 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+e1"), "Significand has no digits"); 1067 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-e1"), "Significand has no digits"); 1068 1069 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, ".e1"), "Significand has no digits"); 1070 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+.e1"), "Significand has no digits"); 1071 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-.e1"), "Significand has no digits"); 1072 1073 1074 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, ".e"), "Significand has no digits"); 1075 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+.e"), "Significand has no digits"); 1076 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-.e"), "Significand has no digits"); 1077 } 1078 1079 TEST(APFloatTest, StringDecimalExponentDeath) { 1080 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "1e"), "Exponent has no digits"); 1081 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+1e"), "Exponent has no digits"); 1082 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-1e"), "Exponent has no digits"); 1083 1084 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "1.e"), "Exponent has no digits"); 1085 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+1.e"), "Exponent has no digits"); 1086 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-1.e"), "Exponent has no digits"); 1087 1088 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, ".1e"), "Exponent has no digits"); 1089 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+.1e"), "Exponent has no digits"); 1090 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-.1e"), "Exponent has no digits"); 1091 1092 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "1.1e"), "Exponent has no digits"); 1093 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+1.1e"), "Exponent has no digits"); 1094 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-1.1e"), "Exponent has no digits"); 1095 1096 1097 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "1e+"), "Exponent has no digits"); 1098 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "1e-"), "Exponent has no digits"); 1099 1100 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, ".1e"), "Exponent has no digits"); 1101 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, ".1e+"), "Exponent has no digits"); 1102 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, ".1e-"), "Exponent has no digits"); 1103 1104 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "1.0e"), "Exponent has no digits"); 1105 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "1.0e+"), "Exponent has no digits"); 1106 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "1.0e-"), "Exponent has no digits"); 1107 } 1108 1109 TEST(APFloatTest, StringHexadecimalDeath) { 1110 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x"), "Invalid string"); 1111 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x"), "Invalid string"); 1112 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x"), "Invalid string"); 1113 1114 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x0"), "Hex strings require an exponent"); 1115 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x0"), "Hex strings require an exponent"); 1116 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x0"), "Hex strings require an exponent"); 1117 1118 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x0."), "Hex strings require an exponent"); 1119 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x0."), "Hex strings require an exponent"); 1120 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x0."), "Hex strings require an exponent"); 1121 1122 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x.0"), "Hex strings require an exponent"); 1123 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x.0"), "Hex strings require an exponent"); 1124 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x.0"), "Hex strings require an exponent"); 1125 1126 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x0.0"), "Hex strings require an exponent"); 1127 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x0.0"), "Hex strings require an exponent"); 1128 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x0.0"), "Hex strings require an exponent"); 1129 1130 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("0x\0", 3)), "Invalid character in significand"); 1131 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("0x1\0", 4)), "Invalid character in significand"); 1132 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("0x1\02", 5)), "Invalid character in significand"); 1133 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("0x1\02p1", 7)), "Invalid character in significand"); 1134 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("0x1p\0", 5)), "Invalid character in exponent"); 1135 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("0x1p1\0", 6)), "Invalid character in exponent"); 1136 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("0x1p1\02", 7)), "Invalid character in exponent"); 1137 1138 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x1p0f"), "Invalid character in exponent"); 1139 1140 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x..p1"), "String contains multiple dots"); 1141 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x..0p1"), "String contains multiple dots"); 1142 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x1.0.0p1"), "String contains multiple dots"); 1143 } 1144 1145 TEST(APFloatTest, StringHexadecimalSignificandDeath) { 1146 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x."), "Significand has no digits"); 1147 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x."), "Significand has no digits"); 1148 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x."), "Significand has no digits"); 1149 1150 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0xp"), "Significand has no digits"); 1151 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0xp"), "Significand has no digits"); 1152 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0xp"), "Significand has no digits"); 1153 1154 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0xp+"), "Significand has no digits"); 1155 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0xp+"), "Significand has no digits"); 1156 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0xp+"), "Significand has no digits"); 1157 1158 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0xp-"), "Significand has no digits"); 1159 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0xp-"), "Significand has no digits"); 1160 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0xp-"), "Significand has no digits"); 1161 1162 1163 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x.p"), "Significand has no digits"); 1164 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x.p"), "Significand has no digits"); 1165 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x.p"), "Significand has no digits"); 1166 1167 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x.p+"), "Significand has no digits"); 1168 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x.p+"), "Significand has no digits"); 1169 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x.p+"), "Significand has no digits"); 1170 1171 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x.p-"), "Significand has no digits"); 1172 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x.p-"), "Significand has no digits"); 1173 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x.p-"), "Significand has no digits"); 1174 } 1175 1176 TEST(APFloatTest, StringHexadecimalExponentDeath) { 1177 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x1p"), "Exponent has no digits"); 1178 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x1p"), "Exponent has no digits"); 1179 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x1p"), "Exponent has no digits"); 1180 1181 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x1p+"), "Exponent has no digits"); 1182 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x1p+"), "Exponent has no digits"); 1183 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x1p+"), "Exponent has no digits"); 1184 1185 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x1p-"), "Exponent has no digits"); 1186 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x1p-"), "Exponent has no digits"); 1187 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x1p-"), "Exponent has no digits"); 1188 1189 1190 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x1.p"), "Exponent has no digits"); 1191 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x1.p"), "Exponent has no digits"); 1192 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x1.p"), "Exponent has no digits"); 1193 1194 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x1.p+"), "Exponent has no digits"); 1195 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x1.p+"), "Exponent has no digits"); 1196 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x1.p+"), "Exponent has no digits"); 1197 1198 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x1.p-"), "Exponent has no digits"); 1199 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x1.p-"), "Exponent has no digits"); 1200 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x1.p-"), "Exponent has no digits"); 1201 1202 1203 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x.1p"), "Exponent has no digits"); 1204 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x.1p"), "Exponent has no digits"); 1205 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x.1p"), "Exponent has no digits"); 1206 1207 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x.1p+"), "Exponent has no digits"); 1208 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x.1p+"), "Exponent has no digits"); 1209 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x.1p+"), "Exponent has no digits"); 1210 1211 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x.1p-"), "Exponent has no digits"); 1212 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x.1p-"), "Exponent has no digits"); 1213 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x.1p-"), "Exponent has no digits"); 1214 1215 1216 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x1.1p"), "Exponent has no digits"); 1217 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x1.1p"), "Exponent has no digits"); 1218 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x1.1p"), "Exponent has no digits"); 1219 1220 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x1.1p+"), "Exponent has no digits"); 1221 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x1.1p+"), "Exponent has no digits"); 1222 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x1.1p+"), "Exponent has no digits"); 1223 1224 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x1.1p-"), "Exponent has no digits"); 1225 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x1.1p-"), "Exponent has no digits"); 1226 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x1.1p-"), "Exponent has no digits"); 1227 } 1228 #endif 1229 #endif 1230 1231 TEST(APFloatTest, exactInverse) { 1232 APFloat inv(0.0f); 1233 1234 // Trivial operation. 1235 EXPECT_TRUE(APFloat(2.0).getExactInverse(&inv)); 1236 EXPECT_TRUE(inv.bitwiseIsEqual(APFloat(0.5))); 1237 EXPECT_TRUE(APFloat(2.0f).getExactInverse(&inv)); 1238 EXPECT_TRUE(inv.bitwiseIsEqual(APFloat(0.5f))); 1239 EXPECT_TRUE(APFloat(APFloat::IEEEquad, "2.0").getExactInverse(&inv)); 1240 EXPECT_TRUE(inv.bitwiseIsEqual(APFloat(APFloat::IEEEquad, "0.5"))); 1241 EXPECT_TRUE(APFloat(APFloat::PPCDoubleDouble, "2.0").getExactInverse(&inv)); 1242 EXPECT_TRUE(inv.bitwiseIsEqual(APFloat(APFloat::PPCDoubleDouble, "0.5"))); 1243 EXPECT_TRUE(APFloat(APFloat::x87DoubleExtended, "2.0").getExactInverse(&inv)); 1244 EXPECT_TRUE(inv.bitwiseIsEqual(APFloat(APFloat::x87DoubleExtended, "0.5"))); 1245 1246 // FLT_MIN 1247 EXPECT_TRUE(APFloat(1.17549435e-38f).getExactInverse(&inv)); 1248 EXPECT_TRUE(inv.bitwiseIsEqual(APFloat(8.5070592e+37f))); 1249 1250 // Large float, inverse is a denormal. 1251 EXPECT_FALSE(APFloat(1.7014118e38f).getExactInverse(nullptr)); 1252 // Zero 1253 EXPECT_FALSE(APFloat(0.0).getExactInverse(nullptr)); 1254 // Denormalized float 1255 EXPECT_FALSE(APFloat(1.40129846e-45f).getExactInverse(nullptr)); 1256 } 1257 1258 TEST(APFloatTest, roundToIntegral) { 1259 APFloat T(-0.5), S(3.14), R(APFloat::getLargest(APFloat::IEEEdouble)), P(0.0); 1260 1261 P = T; 1262 P.roundToIntegral(APFloat::rmTowardZero); 1263 EXPECT_EQ(-0.0, P.convertToDouble()); 1264 P = T; 1265 P.roundToIntegral(APFloat::rmTowardNegative); 1266 EXPECT_EQ(-1.0, P.convertToDouble()); 1267 P = T; 1268 P.roundToIntegral(APFloat::rmTowardPositive); 1269 EXPECT_EQ(-0.0, P.convertToDouble()); 1270 P = T; 1271 P.roundToIntegral(APFloat::rmNearestTiesToEven); 1272 EXPECT_EQ(-0.0, P.convertToDouble()); 1273 1274 P = S; 1275 P.roundToIntegral(APFloat::rmTowardZero); 1276 EXPECT_EQ(3.0, P.convertToDouble()); 1277 P = S; 1278 P.roundToIntegral(APFloat::rmTowardNegative); 1279 EXPECT_EQ(3.0, P.convertToDouble()); 1280 P = S; 1281 P.roundToIntegral(APFloat::rmTowardPositive); 1282 EXPECT_EQ(4.0, P.convertToDouble()); 1283 P = S; 1284 P.roundToIntegral(APFloat::rmNearestTiesToEven); 1285 EXPECT_EQ(3.0, P.convertToDouble()); 1286 1287 P = R; 1288 P.roundToIntegral(APFloat::rmTowardZero); 1289 EXPECT_EQ(R.convertToDouble(), P.convertToDouble()); 1290 P = R; 1291 P.roundToIntegral(APFloat::rmTowardNegative); 1292 EXPECT_EQ(R.convertToDouble(), P.convertToDouble()); 1293 P = R; 1294 P.roundToIntegral(APFloat::rmTowardPositive); 1295 EXPECT_EQ(R.convertToDouble(), P.convertToDouble()); 1296 P = R; 1297 P.roundToIntegral(APFloat::rmNearestTiesToEven); 1298 EXPECT_EQ(R.convertToDouble(), P.convertToDouble()); 1299 1300 P = APFloat::getZero(APFloat::IEEEdouble); 1301 P.roundToIntegral(APFloat::rmTowardZero); 1302 EXPECT_EQ(0.0, P.convertToDouble()); 1303 P = APFloat::getZero(APFloat::IEEEdouble, true); 1304 P.roundToIntegral(APFloat::rmTowardZero); 1305 EXPECT_EQ(-0.0, P.convertToDouble()); 1306 P = APFloat::getNaN(APFloat::IEEEdouble); 1307 P.roundToIntegral(APFloat::rmTowardZero); 1308 EXPECT_TRUE(std::isnan(P.convertToDouble())); 1309 P = APFloat::getInf(APFloat::IEEEdouble); 1310 P.roundToIntegral(APFloat::rmTowardZero); 1311 EXPECT_TRUE(std::isinf(P.convertToDouble()) && P.convertToDouble() > 0.0); 1312 P = APFloat::getInf(APFloat::IEEEdouble, true); 1313 P.roundToIntegral(APFloat::rmTowardZero); 1314 EXPECT_TRUE(std::isinf(P.convertToDouble()) && P.convertToDouble() < 0.0); 1315 } 1316 1317 TEST(APFloatTest, isInteger) { 1318 APFloat T(-0.0); 1319 EXPECT_TRUE(T.isInteger()); 1320 T = APFloat(3.14159); 1321 EXPECT_FALSE(T.isInteger()); 1322 T = APFloat::getNaN(APFloat::IEEEdouble); 1323 EXPECT_FALSE(T.isInteger()); 1324 T = APFloat::getInf(APFloat::IEEEdouble); 1325 EXPECT_FALSE(T.isInteger()); 1326 T = APFloat::getInf(APFloat::IEEEdouble, true); 1327 EXPECT_FALSE(T.isInteger()); 1328 T = APFloat::getLargest(APFloat::IEEEdouble); 1329 EXPECT_TRUE(T.isInteger()); 1330 } 1331 1332 TEST(APFloatTest, getLargest) { 1333 EXPECT_EQ(3.402823466e+38f, APFloat::getLargest(APFloat::IEEEsingle).convertToFloat()); 1334 EXPECT_EQ(1.7976931348623158e+308, APFloat::getLargest(APFloat::IEEEdouble).convertToDouble()); 1335 } 1336 1337 TEST(APFloatTest, getSmallest) { 1338 APFloat test = APFloat::getSmallest(APFloat::IEEEsingle, false); 1339 APFloat expected = APFloat(APFloat::IEEEsingle, "0x0.000002p-126"); 1340 EXPECT_FALSE(test.isNegative()); 1341 EXPECT_TRUE(test.isFiniteNonZero()); 1342 EXPECT_TRUE(test.isDenormal()); 1343 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 1344 1345 test = APFloat::getSmallest(APFloat::IEEEsingle, true); 1346 expected = APFloat(APFloat::IEEEsingle, "-0x0.000002p-126"); 1347 EXPECT_TRUE(test.isNegative()); 1348 EXPECT_TRUE(test.isFiniteNonZero()); 1349 EXPECT_TRUE(test.isDenormal()); 1350 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 1351 1352 test = APFloat::getSmallest(APFloat::IEEEquad, false); 1353 expected = APFloat(APFloat::IEEEquad, "0x0.0000000000000000000000000001p-16382"); 1354 EXPECT_FALSE(test.isNegative()); 1355 EXPECT_TRUE(test.isFiniteNonZero()); 1356 EXPECT_TRUE(test.isDenormal()); 1357 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 1358 1359 test = APFloat::getSmallest(APFloat::IEEEquad, true); 1360 expected = APFloat(APFloat::IEEEquad, "-0x0.0000000000000000000000000001p-16382"); 1361 EXPECT_TRUE(test.isNegative()); 1362 EXPECT_TRUE(test.isFiniteNonZero()); 1363 EXPECT_TRUE(test.isDenormal()); 1364 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 1365 } 1366 1367 TEST(APFloatTest, getSmallestNormalized) { 1368 APFloat test = APFloat::getSmallestNormalized(APFloat::IEEEsingle, false); 1369 APFloat expected = APFloat(APFloat::IEEEsingle, "0x1p-126"); 1370 EXPECT_FALSE(test.isNegative()); 1371 EXPECT_TRUE(test.isFiniteNonZero()); 1372 EXPECT_FALSE(test.isDenormal()); 1373 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 1374 1375 test = APFloat::getSmallestNormalized(APFloat::IEEEsingle, true); 1376 expected = APFloat(APFloat::IEEEsingle, "-0x1p-126"); 1377 EXPECT_TRUE(test.isNegative()); 1378 EXPECT_TRUE(test.isFiniteNonZero()); 1379 EXPECT_FALSE(test.isDenormal()); 1380 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 1381 1382 test = APFloat::getSmallestNormalized(APFloat::IEEEquad, false); 1383 expected = APFloat(APFloat::IEEEquad, "0x1p-16382"); 1384 EXPECT_FALSE(test.isNegative()); 1385 EXPECT_TRUE(test.isFiniteNonZero()); 1386 EXPECT_FALSE(test.isDenormal()); 1387 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 1388 1389 test = APFloat::getSmallestNormalized(APFloat::IEEEquad, true); 1390 expected = APFloat(APFloat::IEEEquad, "-0x1p-16382"); 1391 EXPECT_TRUE(test.isNegative()); 1392 EXPECT_TRUE(test.isFiniteNonZero()); 1393 EXPECT_FALSE(test.isDenormal()); 1394 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 1395 } 1396 1397 TEST(APFloatTest, getZero) { 1398 struct { 1399 const fltSemantics *semantics; 1400 const bool sign; 1401 const unsigned long long bitPattern[2]; 1402 const unsigned bitPatternLength; 1403 } const GetZeroTest[] = { 1404 { &APFloat::IEEEhalf, false, {0, 0}, 1}, 1405 { &APFloat::IEEEhalf, true, {0x8000ULL, 0}, 1}, 1406 { &APFloat::IEEEsingle, false, {0, 0}, 1}, 1407 { &APFloat::IEEEsingle, true, {0x80000000ULL, 0}, 1}, 1408 { &APFloat::IEEEdouble, false, {0, 0}, 1}, 1409 { &APFloat::IEEEdouble, true, {0x8000000000000000ULL, 0}, 1}, 1410 { &APFloat::IEEEquad, false, {0, 0}, 2}, 1411 { &APFloat::IEEEquad, true, {0, 0x8000000000000000ULL}, 2}, 1412 { &APFloat::PPCDoubleDouble, false, {0, 0}, 2}, 1413 { &APFloat::PPCDoubleDouble, true, {0x8000000000000000ULL, 0}, 2}, 1414 { &APFloat::x87DoubleExtended, false, {0, 0}, 2}, 1415 { &APFloat::x87DoubleExtended, true, {0, 0x8000ULL}, 2}, 1416 }; 1417 const unsigned NumGetZeroTests = 12; 1418 for (unsigned i = 0; i < NumGetZeroTests; ++i) { 1419 APFloat test = APFloat::getZero(*GetZeroTest[i].semantics, 1420 GetZeroTest[i].sign); 1421 const char *pattern = GetZeroTest[i].sign? "-0x0p+0" : "0x0p+0"; 1422 APFloat expected = APFloat(*GetZeroTest[i].semantics, 1423 pattern); 1424 EXPECT_TRUE(test.isZero()); 1425 EXPECT_TRUE(GetZeroTest[i].sign? test.isNegative() : !test.isNegative()); 1426 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 1427 for (unsigned j = 0, je = GetZeroTest[i].bitPatternLength; j < je; ++j) { 1428 EXPECT_EQ(GetZeroTest[i].bitPattern[j], 1429 test.bitcastToAPInt().getRawData()[j]); 1430 } 1431 } 1432 } 1433 1434 TEST(APFloatTest, copySign) { 1435 EXPECT_TRUE(APFloat(-42.0).bitwiseIsEqual( 1436 APFloat::copySign(APFloat(42.0), APFloat(-1.0)))); 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 } 1444 1445 TEST(APFloatTest, convert) { 1446 bool losesInfo; 1447 APFloat test(APFloat::IEEEdouble, "1.0"); 1448 test.convert(APFloat::IEEEsingle, APFloat::rmNearestTiesToEven, &losesInfo); 1449 EXPECT_EQ(1.0f, test.convertToFloat()); 1450 EXPECT_FALSE(losesInfo); 1451 1452 test = APFloat(APFloat::x87DoubleExtended, "0x1p-53"); 1453 test.add(APFloat(APFloat::x87DoubleExtended, "1.0"), APFloat::rmNearestTiesToEven); 1454 test.convert(APFloat::IEEEdouble, APFloat::rmNearestTiesToEven, &losesInfo); 1455 EXPECT_EQ(1.0, test.convertToDouble()); 1456 EXPECT_TRUE(losesInfo); 1457 1458 test = APFloat(APFloat::IEEEquad, "0x1p-53"); 1459 test.add(APFloat(APFloat::IEEEquad, "1.0"), APFloat::rmNearestTiesToEven); 1460 test.convert(APFloat::IEEEdouble, APFloat::rmNearestTiesToEven, &losesInfo); 1461 EXPECT_EQ(1.0, test.convertToDouble()); 1462 EXPECT_TRUE(losesInfo); 1463 1464 test = APFloat(APFloat::x87DoubleExtended, "0xf.fffffffp+28"); 1465 test.convert(APFloat::IEEEdouble, APFloat::rmNearestTiesToEven, &losesInfo); 1466 EXPECT_EQ(4294967295.0, test.convertToDouble()); 1467 EXPECT_FALSE(losesInfo); 1468 1469 test = APFloat::getSNaN(APFloat::IEEEsingle); 1470 APFloat X87SNaN = APFloat::getSNaN(APFloat::x87DoubleExtended); 1471 test.convert(APFloat::x87DoubleExtended, APFloat::rmNearestTiesToEven, 1472 &losesInfo); 1473 EXPECT_TRUE(test.bitwiseIsEqual(X87SNaN)); 1474 EXPECT_FALSE(losesInfo); 1475 1476 test = APFloat::getQNaN(APFloat::IEEEsingle); 1477 APFloat X87QNaN = APFloat::getQNaN(APFloat::x87DoubleExtended); 1478 test.convert(APFloat::x87DoubleExtended, APFloat::rmNearestTiesToEven, 1479 &losesInfo); 1480 EXPECT_TRUE(test.bitwiseIsEqual(X87QNaN)); 1481 EXPECT_FALSE(losesInfo); 1482 1483 test = APFloat::getSNaN(APFloat::x87DoubleExtended); 1484 test.convert(APFloat::x87DoubleExtended, APFloat::rmNearestTiesToEven, 1485 &losesInfo); 1486 EXPECT_TRUE(test.bitwiseIsEqual(X87SNaN)); 1487 EXPECT_FALSE(losesInfo); 1488 1489 test = APFloat::getQNaN(APFloat::x87DoubleExtended); 1490 test.convert(APFloat::x87DoubleExtended, APFloat::rmNearestTiesToEven, 1491 &losesInfo); 1492 EXPECT_TRUE(test.bitwiseIsEqual(X87QNaN)); 1493 EXPECT_FALSE(losesInfo); 1494 } 1495 1496 TEST(APFloatTest, PPCDoubleDouble) { 1497 APFloat test(APFloat::PPCDoubleDouble, "1.0"); 1498 EXPECT_EQ(0x3ff0000000000000ull, test.bitcastToAPInt().getRawData()[0]); 1499 EXPECT_EQ(0x0000000000000000ull, test.bitcastToAPInt().getRawData()[1]); 1500 1501 test.divide(APFloat(APFloat::PPCDoubleDouble, "3.0"), APFloat::rmNearestTiesToEven); 1502 EXPECT_EQ(0x3fd5555555555555ull, test.bitcastToAPInt().getRawData()[0]); 1503 EXPECT_EQ(0x3c75555555555556ull, test.bitcastToAPInt().getRawData()[1]); 1504 1505 // LDBL_MAX 1506 test = APFloat(APFloat::PPCDoubleDouble, "1.79769313486231580793728971405301e+308"); 1507 EXPECT_EQ(0x7fefffffffffffffull, test.bitcastToAPInt().getRawData()[0]); 1508 EXPECT_EQ(0x7c8ffffffffffffeull, test.bitcastToAPInt().getRawData()[1]); 1509 1510 // LDBL_MIN 1511 test = APFloat(APFloat::PPCDoubleDouble, "2.00416836000897277799610805135016e-292"); 1512 EXPECT_EQ(0x0360000000000000ull, test.bitcastToAPInt().getRawData()[0]); 1513 EXPECT_EQ(0x0000000000000000ull, test.bitcastToAPInt().getRawData()[1]); 1514 1515 test = APFloat(APFloat::PPCDoubleDouble, "1.0"); 1516 test.add(APFloat(APFloat::PPCDoubleDouble, "0x1p-105"), APFloat::rmNearestTiesToEven); 1517 EXPECT_EQ(0x3ff0000000000000ull, test.bitcastToAPInt().getRawData()[0]); 1518 EXPECT_EQ(0x3960000000000000ull, test.bitcastToAPInt().getRawData()[1]); 1519 1520 test = APFloat(APFloat::PPCDoubleDouble, "1.0"); 1521 test.add(APFloat(APFloat::PPCDoubleDouble, "0x1p-106"), APFloat::rmNearestTiesToEven); 1522 EXPECT_EQ(0x3ff0000000000000ull, test.bitcastToAPInt().getRawData()[0]); 1523 #if 0 // XFAIL 1524 // This is what we would expect with a true double-double implementation 1525 EXPECT_EQ(0x3950000000000000ull, test.bitcastToAPInt().getRawData()[1]); 1526 #else 1527 // This is what we get with our 106-bit mantissa approximation 1528 EXPECT_EQ(0x0000000000000000ull, test.bitcastToAPInt().getRawData()[1]); 1529 #endif 1530 1531 // PR30869 1532 { 1533 auto Result = APFloat(APFloat::PPCDoubleDouble, "1.0") + 1534 APFloat(APFloat::PPCDoubleDouble, "1.0"); 1535 EXPECT_EQ(&APFloat::PPCDoubleDouble, &Result.getSemantics()); 1536 1537 Result = APFloat(APFloat::PPCDoubleDouble, "1.0") - 1538 APFloat(APFloat::PPCDoubleDouble, "1.0"); 1539 EXPECT_EQ(&APFloat::PPCDoubleDouble, &Result.getSemantics()); 1540 1541 Result = APFloat(APFloat::PPCDoubleDouble, "1.0") * 1542 APFloat(APFloat::PPCDoubleDouble, "1.0"); 1543 EXPECT_EQ(&APFloat::PPCDoubleDouble, &Result.getSemantics()); 1544 1545 Result = APFloat(APFloat::PPCDoubleDouble, "1.0") / 1546 APFloat(APFloat::PPCDoubleDouble, "1.0"); 1547 EXPECT_EQ(&APFloat::PPCDoubleDouble, &Result.getSemantics()); 1548 1549 int Exp; 1550 Result = frexp(APFloat(APFloat::PPCDoubleDouble, "1.0"), Exp, 1551 APFloat::rmNearestTiesToEven); 1552 EXPECT_EQ(&APFloat::PPCDoubleDouble, &Result.getSemantics()); 1553 1554 Result = scalbn(APFloat(APFloat::PPCDoubleDouble, "1.0"), 1, 1555 APFloat::rmNearestTiesToEven); 1556 EXPECT_EQ(&APFloat::PPCDoubleDouble, &Result.getSemantics()); 1557 } 1558 } 1559 1560 TEST(APFloatTest, isNegative) { 1561 APFloat t(APFloat::IEEEsingle, "0x1p+0"); 1562 EXPECT_FALSE(t.isNegative()); 1563 t = APFloat(APFloat::IEEEsingle, "-0x1p+0"); 1564 EXPECT_TRUE(t.isNegative()); 1565 1566 EXPECT_FALSE(APFloat::getInf(APFloat::IEEEsingle, false).isNegative()); 1567 EXPECT_TRUE(APFloat::getInf(APFloat::IEEEsingle, true).isNegative()); 1568 1569 EXPECT_FALSE(APFloat::getZero(APFloat::IEEEsingle, false).isNegative()); 1570 EXPECT_TRUE(APFloat::getZero(APFloat::IEEEsingle, true).isNegative()); 1571 1572 EXPECT_FALSE(APFloat::getNaN(APFloat::IEEEsingle, false).isNegative()); 1573 EXPECT_TRUE(APFloat::getNaN(APFloat::IEEEsingle, true).isNegative()); 1574 1575 EXPECT_FALSE(APFloat::getSNaN(APFloat::IEEEsingle, false).isNegative()); 1576 EXPECT_TRUE(APFloat::getSNaN(APFloat::IEEEsingle, true).isNegative()); 1577 } 1578 1579 TEST(APFloatTest, isNormal) { 1580 APFloat t(APFloat::IEEEsingle, "0x1p+0"); 1581 EXPECT_TRUE(t.isNormal()); 1582 1583 EXPECT_FALSE(APFloat::getInf(APFloat::IEEEsingle, false).isNormal()); 1584 EXPECT_FALSE(APFloat::getZero(APFloat::IEEEsingle, false).isNormal()); 1585 EXPECT_FALSE(APFloat::getNaN(APFloat::IEEEsingle, false).isNormal()); 1586 EXPECT_FALSE(APFloat::getSNaN(APFloat::IEEEsingle, false).isNormal()); 1587 EXPECT_FALSE(APFloat(APFloat::IEEEsingle, "0x1p-149").isNormal()); 1588 } 1589 1590 TEST(APFloatTest, isFinite) { 1591 APFloat t(APFloat::IEEEsingle, "0x1p+0"); 1592 EXPECT_TRUE(t.isFinite()); 1593 EXPECT_FALSE(APFloat::getInf(APFloat::IEEEsingle, false).isFinite()); 1594 EXPECT_TRUE(APFloat::getZero(APFloat::IEEEsingle, false).isFinite()); 1595 EXPECT_FALSE(APFloat::getNaN(APFloat::IEEEsingle, false).isFinite()); 1596 EXPECT_FALSE(APFloat::getSNaN(APFloat::IEEEsingle, false).isFinite()); 1597 EXPECT_TRUE(APFloat(APFloat::IEEEsingle, "0x1p-149").isFinite()); 1598 } 1599 1600 TEST(APFloatTest, isInfinity) { 1601 APFloat t(APFloat::IEEEsingle, "0x1p+0"); 1602 EXPECT_FALSE(t.isInfinity()); 1603 EXPECT_TRUE(APFloat::getInf(APFloat::IEEEsingle, false).isInfinity()); 1604 EXPECT_FALSE(APFloat::getZero(APFloat::IEEEsingle, false).isInfinity()); 1605 EXPECT_FALSE(APFloat::getNaN(APFloat::IEEEsingle, false).isInfinity()); 1606 EXPECT_FALSE(APFloat::getSNaN(APFloat::IEEEsingle, false).isInfinity()); 1607 EXPECT_FALSE(APFloat(APFloat::IEEEsingle, "0x1p-149").isInfinity()); 1608 } 1609 1610 TEST(APFloatTest, isNaN) { 1611 APFloat t(APFloat::IEEEsingle, "0x1p+0"); 1612 EXPECT_FALSE(t.isNaN()); 1613 EXPECT_FALSE(APFloat::getInf(APFloat::IEEEsingle, false).isNaN()); 1614 EXPECT_FALSE(APFloat::getZero(APFloat::IEEEsingle, false).isNaN()); 1615 EXPECT_TRUE(APFloat::getNaN(APFloat::IEEEsingle, false).isNaN()); 1616 EXPECT_TRUE(APFloat::getSNaN(APFloat::IEEEsingle, false).isNaN()); 1617 EXPECT_FALSE(APFloat(APFloat::IEEEsingle, "0x1p-149").isNaN()); 1618 } 1619 1620 TEST(APFloatTest, isFiniteNonZero) { 1621 // Test positive/negative normal value. 1622 EXPECT_TRUE(APFloat(APFloat::IEEEsingle, "0x1p+0").isFiniteNonZero()); 1623 EXPECT_TRUE(APFloat(APFloat::IEEEsingle, "-0x1p+0").isFiniteNonZero()); 1624 1625 // Test positive/negative denormal value. 1626 EXPECT_TRUE(APFloat(APFloat::IEEEsingle, "0x1p-149").isFiniteNonZero()); 1627 EXPECT_TRUE(APFloat(APFloat::IEEEsingle, "-0x1p-149").isFiniteNonZero()); 1628 1629 // Test +/- Infinity. 1630 EXPECT_FALSE(APFloat::getInf(APFloat::IEEEsingle, false).isFiniteNonZero()); 1631 EXPECT_FALSE(APFloat::getInf(APFloat::IEEEsingle, true).isFiniteNonZero()); 1632 1633 // Test +/- Zero. 1634 EXPECT_FALSE(APFloat::getZero(APFloat::IEEEsingle, false).isFiniteNonZero()); 1635 EXPECT_FALSE(APFloat::getZero(APFloat::IEEEsingle, true).isFiniteNonZero()); 1636 1637 // Test +/- qNaN. +/- dont mean anything with qNaN but paranoia can't hurt in 1638 // this instance. 1639 EXPECT_FALSE(APFloat::getNaN(APFloat::IEEEsingle, false).isFiniteNonZero()); 1640 EXPECT_FALSE(APFloat::getNaN(APFloat::IEEEsingle, true).isFiniteNonZero()); 1641 1642 // Test +/- sNaN. +/- dont mean anything with sNaN but paranoia can't hurt in 1643 // this instance. 1644 EXPECT_FALSE(APFloat::getSNaN(APFloat::IEEEsingle, false).isFiniteNonZero()); 1645 EXPECT_FALSE(APFloat::getSNaN(APFloat::IEEEsingle, true).isFiniteNonZero()); 1646 } 1647 1648 TEST(APFloatTest, add) { 1649 // Test Special Cases against each other and normal values. 1650 1651 // TODOS/NOTES: 1652 // 1. Since we perform only default exception handling all operations with 1653 // signaling NaNs should have a result that is a quiet NaN. Currently they 1654 // return sNaN. 1655 1656 APFloat PInf = APFloat::getInf(APFloat::IEEEsingle, false); 1657 APFloat MInf = APFloat::getInf(APFloat::IEEEsingle, true); 1658 APFloat PZero = APFloat::getZero(APFloat::IEEEsingle, false); 1659 APFloat MZero = APFloat::getZero(APFloat::IEEEsingle, true); 1660 APFloat QNaN = APFloat::getNaN(APFloat::IEEEsingle, false); 1661 APFloat SNaN = APFloat::getSNaN(APFloat::IEEEsingle, false); 1662 APFloat PNormalValue = APFloat(APFloat::IEEEsingle, "0x1p+0"); 1663 APFloat MNormalValue = APFloat(APFloat::IEEEsingle, "-0x1p+0"); 1664 APFloat PLargestValue = APFloat::getLargest(APFloat::IEEEsingle, false); 1665 APFloat MLargestValue = APFloat::getLargest(APFloat::IEEEsingle, true); 1666 APFloat PSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle, false); 1667 APFloat MSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle, true); 1668 APFloat PSmallestNormalized = 1669 APFloat::getSmallestNormalized(APFloat::IEEEsingle, false); 1670 APFloat MSmallestNormalized = 1671 APFloat::getSmallestNormalized(APFloat::IEEEsingle, true); 1672 1673 const int OverflowStatus = APFloat::opOverflow | APFloat::opInexact; 1674 1675 const unsigned NumTests = 169; 1676 struct { 1677 APFloat x; 1678 APFloat y; 1679 const char *result; 1680 int status; 1681 int category; 1682 } SpecialCaseTests[NumTests] = { 1683 { PInf, PInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 1684 { PInf, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 1685 { PInf, PZero, "inf", APFloat::opOK, APFloat::fcInfinity }, 1686 { PInf, MZero, "inf", APFloat::opOK, APFloat::fcInfinity }, 1687 { PInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 1688 #if 0 1689 // See Note 1. 1690 { PInf, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 1691 #endif 1692 { PInf, PNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity }, 1693 { PInf, MNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity }, 1694 { PInf, PLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity }, 1695 { PInf, MLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity }, 1696 { PInf, PSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity }, 1697 { PInf, MSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity }, 1698 { PInf, PSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity }, 1699 { PInf, MSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity }, 1700 { MInf, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 1701 { MInf, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 1702 { MInf, PZero, "-inf", APFloat::opOK, APFloat::fcInfinity }, 1703 { MInf, MZero, "-inf", APFloat::opOK, APFloat::fcInfinity }, 1704 { MInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 1705 #if 0 1706 // See Note 1. 1707 { MInf, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 1708 #endif 1709 { MInf, PNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity }, 1710 { MInf, MNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity }, 1711 { MInf, PLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity }, 1712 { MInf, MLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity }, 1713 { MInf, PSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity }, 1714 { MInf, MSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity }, 1715 { MInf, PSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity }, 1716 { MInf, MSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity }, 1717 { PZero, PInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 1718 { PZero, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 1719 { PZero, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 1720 { PZero, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 1721 { PZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 1722 #if 0 1723 // See Note 1. 1724 { PZero, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 1725 #endif 1726 { PZero, PNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal }, 1727 { PZero, MNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal }, 1728 { PZero, PLargestValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal }, 1729 { PZero, MLargestValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal }, 1730 { PZero, PSmallestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal }, 1731 { PZero, MSmallestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal }, 1732 { PZero, PSmallestNormalized, "0x1p-126", APFloat::opOK, APFloat::fcNormal }, 1733 { PZero, MSmallestNormalized, "-0x1p-126", APFloat::opOK, APFloat::fcNormal }, 1734 { MZero, PInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 1735 { MZero, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 1736 { MZero, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 1737 { MZero, MZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 1738 { MZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 1739 #if 0 1740 // See Note 1. 1741 { MZero, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 1742 #endif 1743 { MZero, PNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal }, 1744 { MZero, MNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal }, 1745 { MZero, PLargestValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal }, 1746 { MZero, MLargestValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal }, 1747 { MZero, PSmallestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal }, 1748 { MZero, MSmallestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal }, 1749 { MZero, PSmallestNormalized, "0x1p-126", APFloat::opOK, APFloat::fcNormal }, 1750 { MZero, MSmallestNormalized, "-0x1p-126", APFloat::opOK, APFloat::fcNormal }, 1751 { QNaN, PInf, "nan", APFloat::opOK, APFloat::fcNaN }, 1752 { QNaN, MInf, "nan", APFloat::opOK, APFloat::fcNaN }, 1753 { QNaN, PZero, "nan", APFloat::opOK, APFloat::fcNaN }, 1754 { QNaN, MZero, "nan", APFloat::opOK, APFloat::fcNaN }, 1755 { QNaN, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 1756 #if 0 1757 // See Note 1. 1758 { QNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 1759 #endif 1760 { QNaN, PNormalValue, "nan", APFloat::opOK, APFloat::fcNaN }, 1761 { QNaN, MNormalValue, "nan", APFloat::opOK, APFloat::fcNaN }, 1762 { QNaN, PLargestValue, "nan", APFloat::opOK, APFloat::fcNaN }, 1763 { QNaN, MLargestValue, "nan", APFloat::opOK, APFloat::fcNaN }, 1764 { QNaN, PSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN }, 1765 { QNaN, MSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN }, 1766 { QNaN, PSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN }, 1767 { QNaN, MSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN }, 1768 #if 0 1769 // See Note 1. 1770 { SNaN, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 1771 { SNaN, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 1772 { SNaN, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 1773 { SNaN, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 1774 { SNaN, QNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 1775 { SNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 1776 { SNaN, PNormalValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 1777 { SNaN, MNormalValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 1778 { SNaN, PLargestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 1779 { SNaN, MLargestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 1780 { SNaN, PSmallestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 1781 { SNaN, MSmallestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 1782 { SNaN, PSmallestNormalized, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 1783 { SNaN, MSmallestNormalized, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 1784 #endif 1785 { PNormalValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 1786 { PNormalValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 1787 { PNormalValue, PZero, "0x1p+0", APFloat::opOK, APFloat::fcNormal }, 1788 { PNormalValue, MZero, "0x1p+0", APFloat::opOK, APFloat::fcNormal }, 1789 { PNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 1790 #if 0 1791 // See Note 1. 1792 { PNormalValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 1793 #endif 1794 { PNormalValue, PNormalValue, "0x1p+1", APFloat::opOK, APFloat::fcNormal }, 1795 { PNormalValue, MNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 1796 { PNormalValue, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 1797 { PNormalValue, MLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 1798 { PNormalValue, PSmallestValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 1799 { PNormalValue, MSmallestValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 1800 { PNormalValue, PSmallestNormalized, "0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 1801 { PNormalValue, MSmallestNormalized, "0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 1802 { MNormalValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 1803 { MNormalValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 1804 { MNormalValue, PZero, "-0x1p+0", APFloat::opOK, APFloat::fcNormal }, 1805 { MNormalValue, MZero, "-0x1p+0", APFloat::opOK, APFloat::fcNormal }, 1806 { MNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 1807 #if 0 1808 // See Note 1. 1809 { MNormalValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 1810 #endif 1811 { MNormalValue, PNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 1812 { MNormalValue, MNormalValue, "-0x1p+1", APFloat::opOK, APFloat::fcNormal }, 1813 { MNormalValue, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 1814 { MNormalValue, MLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 1815 { MNormalValue, PSmallestValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 1816 { MNormalValue, MSmallestValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 1817 { MNormalValue, PSmallestNormalized, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 1818 { MNormalValue, MSmallestNormalized, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 1819 { PLargestValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 1820 { PLargestValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 1821 { PLargestValue, PZero, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal }, 1822 { PLargestValue, MZero, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal }, 1823 { PLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 1824 #if 0 1825 // See Note 1. 1826 { PLargestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 1827 #endif 1828 { PLargestValue, PNormalValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 1829 { PLargestValue, MNormalValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 1830 { PLargestValue, PLargestValue, "inf", OverflowStatus, APFloat::fcInfinity }, 1831 { PLargestValue, MLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 1832 { PLargestValue, PSmallestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 1833 { PLargestValue, MSmallestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 1834 { PLargestValue, PSmallestNormalized, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 1835 { PLargestValue, MSmallestNormalized, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 1836 { MLargestValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 1837 { MLargestValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 1838 { MLargestValue, PZero, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal }, 1839 { MLargestValue, MZero, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal }, 1840 { MLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 1841 #if 0 1842 // See Note 1. 1843 { MLargestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 1844 #endif 1845 { MLargestValue, PNormalValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 1846 { MLargestValue, MNormalValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 1847 { MLargestValue, PLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 1848 { MLargestValue, MLargestValue, "-inf", OverflowStatus, APFloat::fcInfinity }, 1849 { MLargestValue, PSmallestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 1850 { MLargestValue, MSmallestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 1851 { MLargestValue, PSmallestNormalized, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 1852 { MLargestValue, MSmallestNormalized, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 1853 { PSmallestValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 1854 { PSmallestValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 1855 { PSmallestValue, PZero, "0x1p-149", APFloat::opOK, APFloat::fcNormal }, 1856 { PSmallestValue, MZero, "0x1p-149", APFloat::opOK, APFloat::fcNormal }, 1857 { PSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 1858 #if 0 1859 // See Note 1. 1860 { PSmallestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 1861 #endif 1862 { PSmallestValue, PNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 1863 { PSmallestValue, MNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 1864 { PSmallestValue, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 1865 { PSmallestValue, MLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 1866 { PSmallestValue, PSmallestValue, "0x1p-148", APFloat::opOK, APFloat::fcNormal }, 1867 { PSmallestValue, MSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 1868 { PSmallestValue, PSmallestNormalized, "0x1.000002p-126", APFloat::opOK, APFloat::fcNormal }, 1869 { PSmallestValue, MSmallestNormalized, "-0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal }, 1870 { MSmallestValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 1871 { MSmallestValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 1872 { MSmallestValue, PZero, "-0x1p-149", APFloat::opOK, APFloat::fcNormal }, 1873 { MSmallestValue, MZero, "-0x1p-149", APFloat::opOK, APFloat::fcNormal }, 1874 { MSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 1875 #if 0 1876 // See Note 1. 1877 { MSmallestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 1878 #endif 1879 { MSmallestValue, PNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 1880 { MSmallestValue, MNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 1881 { MSmallestValue, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 1882 { MSmallestValue, MLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 1883 { MSmallestValue, PSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 1884 { MSmallestValue, MSmallestValue, "-0x1p-148", APFloat::opOK, APFloat::fcNormal }, 1885 { MSmallestValue, PSmallestNormalized, "0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal }, 1886 { MSmallestValue, MSmallestNormalized, "-0x1.000002p-126", APFloat::opOK, APFloat::fcNormal }, 1887 { PSmallestNormalized, PInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 1888 { PSmallestNormalized, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 1889 { PSmallestNormalized, PZero, "0x1p-126", APFloat::opOK, APFloat::fcNormal }, 1890 { PSmallestNormalized, MZero, "0x1p-126", APFloat::opOK, APFloat::fcNormal }, 1891 { PSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 1892 #if 0 1893 // See Note 1. 1894 { PSmallestNormalized, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 1895 #endif 1896 { PSmallestNormalized, PNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 1897 { PSmallestNormalized, MNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 1898 { PSmallestNormalized, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 1899 { PSmallestNormalized, MLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 1900 { PSmallestNormalized, PSmallestValue, "0x1.000002p-126", APFloat::opOK, APFloat::fcNormal }, 1901 { PSmallestNormalized, MSmallestValue, "0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal }, 1902 { PSmallestNormalized, PSmallestNormalized, "0x1p-125", APFloat::opOK, APFloat::fcNormal }, 1903 { PSmallestNormalized, MSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 1904 { MSmallestNormalized, PInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 1905 { MSmallestNormalized, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 1906 { MSmallestNormalized, PZero, "-0x1p-126", APFloat::opOK, APFloat::fcNormal }, 1907 { MSmallestNormalized, MZero, "-0x1p-126", APFloat::opOK, APFloat::fcNormal }, 1908 { MSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 1909 #if 0 1910 // See Note 1. 1911 { MSmallestNormalized, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 1912 #endif 1913 { MSmallestNormalized, PNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 1914 { MSmallestNormalized, MNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 1915 { MSmallestNormalized, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 1916 { MSmallestNormalized, MLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 1917 { MSmallestNormalized, PSmallestValue, "-0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal }, 1918 { MSmallestNormalized, MSmallestValue, "-0x1.000002p-126", APFloat::opOK, APFloat::fcNormal }, 1919 { MSmallestNormalized, PSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 1920 { MSmallestNormalized, MSmallestNormalized, "-0x1p-125", APFloat::opOK, APFloat::fcNormal } 1921 }; 1922 1923 for (size_t i = 0; i < NumTests; ++i) { 1924 APFloat x(SpecialCaseTests[i].x); 1925 APFloat y(SpecialCaseTests[i].y); 1926 APFloat::opStatus status = x.add(y, APFloat::rmNearestTiesToEven); 1927 1928 APFloat result(APFloat::IEEEsingle, SpecialCaseTests[i].result); 1929 1930 EXPECT_TRUE(result.bitwiseIsEqual(x)); 1931 EXPECT_TRUE((int)status == SpecialCaseTests[i].status); 1932 EXPECT_TRUE((int)x.getCategory() == SpecialCaseTests[i].category); 1933 } 1934 } 1935 1936 TEST(APFloatTest, subtract) { 1937 // Test Special Cases against each other and normal values. 1938 1939 // TODOS/NOTES: 1940 // 1. Since we perform only default exception handling all operations with 1941 // signaling NaNs should have a result that is a quiet NaN. Currently they 1942 // return sNaN. 1943 1944 APFloat PInf = APFloat::getInf(APFloat::IEEEsingle, false); 1945 APFloat MInf = APFloat::getInf(APFloat::IEEEsingle, true); 1946 APFloat PZero = APFloat::getZero(APFloat::IEEEsingle, false); 1947 APFloat MZero = APFloat::getZero(APFloat::IEEEsingle, true); 1948 APFloat QNaN = APFloat::getNaN(APFloat::IEEEsingle, false); 1949 APFloat SNaN = APFloat::getSNaN(APFloat::IEEEsingle, false); 1950 APFloat PNormalValue = APFloat(APFloat::IEEEsingle, "0x1p+0"); 1951 APFloat MNormalValue = APFloat(APFloat::IEEEsingle, "-0x1p+0"); 1952 APFloat PLargestValue = APFloat::getLargest(APFloat::IEEEsingle, false); 1953 APFloat MLargestValue = APFloat::getLargest(APFloat::IEEEsingle, true); 1954 APFloat PSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle, false); 1955 APFloat MSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle, true); 1956 APFloat PSmallestNormalized = 1957 APFloat::getSmallestNormalized(APFloat::IEEEsingle, false); 1958 APFloat MSmallestNormalized = 1959 APFloat::getSmallestNormalized(APFloat::IEEEsingle, true); 1960 1961 const int OverflowStatus = APFloat::opOverflow | APFloat::opInexact; 1962 1963 const unsigned NumTests = 169; 1964 struct { 1965 APFloat x; 1966 APFloat y; 1967 const char *result; 1968 int status; 1969 int category; 1970 } SpecialCaseTests[NumTests] = { 1971 { PInf, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 1972 { PInf, MInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 1973 { PInf, PZero, "inf", APFloat::opOK, APFloat::fcInfinity }, 1974 { PInf, MZero, "inf", APFloat::opOK, APFloat::fcInfinity }, 1975 { PInf, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN }, 1976 #if 0 1977 // See Note 1. 1978 { PInf, SNaN, "-nan", APFloat::opInvalidOp, APFloat::fcNaN }, 1979 #endif 1980 { PInf, PNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity }, 1981 { PInf, MNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity }, 1982 { PInf, PLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity }, 1983 { PInf, MLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity }, 1984 { PInf, PSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity }, 1985 { PInf, MSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity }, 1986 { PInf, PSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity }, 1987 { PInf, MSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity }, 1988 { MInf, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 1989 { MInf, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 1990 { MInf, PZero, "-inf", APFloat::opOK, APFloat::fcInfinity }, 1991 { MInf, MZero, "-inf", APFloat::opOK, APFloat::fcInfinity }, 1992 { MInf, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN }, 1993 #if 0 1994 // See Note 1. 1995 { MInf, SNaN, "-nan", APFloat::opInvalidOp, APFloat::fcNaN }, 1996 #endif 1997 { MInf, PNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity }, 1998 { MInf, MNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity }, 1999 { MInf, PLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2000 { MInf, MLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2001 { MInf, PSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2002 { MInf, MSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2003 { MInf, PSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2004 { MInf, MSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2005 { PZero, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2006 { PZero, MInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 2007 { PZero, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2008 { PZero, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2009 { PZero, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN }, 2010 #if 0 2011 // See Note 1. 2012 { PZero, SNaN, "-nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2013 #endif 2014 { PZero, PNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal }, 2015 { PZero, MNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal }, 2016 { PZero, PLargestValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal }, 2017 { PZero, MLargestValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal }, 2018 { PZero, PSmallestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal }, 2019 { PZero, MSmallestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal }, 2020 { PZero, PSmallestNormalized, "-0x1p-126", APFloat::opOK, APFloat::fcNormal }, 2021 { PZero, MSmallestNormalized, "0x1p-126", APFloat::opOK, APFloat::fcNormal }, 2022 { MZero, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2023 { MZero, MInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 2024 { MZero, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2025 { MZero, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2026 { MZero, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN }, 2027 #if 0 2028 // See Note 1. 2029 { MZero, SNaN, "-nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2030 #endif 2031 { MZero, PNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal }, 2032 { MZero, MNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal }, 2033 { MZero, PLargestValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal }, 2034 { MZero, MLargestValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal }, 2035 { MZero, PSmallestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal }, 2036 { MZero, MSmallestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal }, 2037 { MZero, PSmallestNormalized, "-0x1p-126", APFloat::opOK, APFloat::fcNormal }, 2038 { MZero, MSmallestNormalized, "0x1p-126", APFloat::opOK, APFloat::fcNormal }, 2039 { QNaN, PInf, "nan", APFloat::opOK, APFloat::fcNaN }, 2040 { QNaN, MInf, "nan", APFloat::opOK, APFloat::fcNaN }, 2041 { QNaN, PZero, "nan", APFloat::opOK, APFloat::fcNaN }, 2042 { QNaN, MZero, "nan", APFloat::opOK, APFloat::fcNaN }, 2043 { QNaN, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2044 #if 0 2045 // See Note 1. 2046 { QNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2047 #endif 2048 { QNaN, PNormalValue, "nan", APFloat::opOK, APFloat::fcNaN }, 2049 { QNaN, MNormalValue, "nan", APFloat::opOK, APFloat::fcNaN }, 2050 { QNaN, PLargestValue, "nan", APFloat::opOK, APFloat::fcNaN }, 2051 { QNaN, MLargestValue, "nan", APFloat::opOK, APFloat::fcNaN }, 2052 { QNaN, PSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN }, 2053 { QNaN, MSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN }, 2054 { QNaN, PSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN }, 2055 { QNaN, MSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN }, 2056 #if 0 2057 // See Note 1. 2058 { SNaN, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2059 { SNaN, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2060 { SNaN, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2061 { SNaN, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2062 { SNaN, QNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2063 { SNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2064 { SNaN, PNormalValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2065 { SNaN, MNormalValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2066 { SNaN, PLargestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2067 { SNaN, MLargestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2068 { SNaN, PSmallestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2069 { SNaN, MSmallestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2070 { SNaN, PSmallestNormalized, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2071 { SNaN, MSmallestNormalized, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2072 #endif 2073 { PNormalValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2074 { PNormalValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 2075 { PNormalValue, PZero, "0x1p+0", APFloat::opOK, APFloat::fcNormal }, 2076 { PNormalValue, MZero, "0x1p+0", APFloat::opOK, APFloat::fcNormal }, 2077 { PNormalValue, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN }, 2078 #if 0 2079 // See Note 1. 2080 { PNormalValue, SNaN, "-nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2081 #endif 2082 { PNormalValue, PNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2083 { PNormalValue, MNormalValue, "0x1p+1", APFloat::opOK, APFloat::fcNormal }, 2084 { PNormalValue, PLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 2085 { PNormalValue, MLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 2086 { PNormalValue, PSmallestValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 2087 { PNormalValue, MSmallestValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 2088 { PNormalValue, PSmallestNormalized, "0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 2089 { PNormalValue, MSmallestNormalized, "0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 2090 { MNormalValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2091 { MNormalValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 2092 { MNormalValue, PZero, "-0x1p+0", APFloat::opOK, APFloat::fcNormal }, 2093 { MNormalValue, MZero, "-0x1p+0", APFloat::opOK, APFloat::fcNormal }, 2094 { MNormalValue, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN }, 2095 #if 0 2096 // See Note 1. 2097 { MNormalValue, SNaN, "-nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2098 #endif 2099 { MNormalValue, PNormalValue, "-0x1p+1", APFloat::opOK, APFloat::fcNormal }, 2100 { MNormalValue, MNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2101 { MNormalValue, PLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 2102 { MNormalValue, MLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 2103 { MNormalValue, PSmallestValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 2104 { MNormalValue, MSmallestValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 2105 { MNormalValue, PSmallestNormalized, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 2106 { MNormalValue, MSmallestNormalized, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 2107 { PLargestValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2108 { PLargestValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 2109 { PLargestValue, PZero, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal }, 2110 { PLargestValue, MZero, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal }, 2111 { PLargestValue, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN }, 2112 #if 0 2113 // See Note 1. 2114 { PLargestValue, SNaN, "-nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2115 #endif 2116 { PLargestValue, PNormalValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 2117 { PLargestValue, MNormalValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 2118 { PLargestValue, PLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2119 { PLargestValue, MLargestValue, "inf", OverflowStatus, APFloat::fcInfinity }, 2120 { PLargestValue, PSmallestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 2121 { PLargestValue, MSmallestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 2122 { PLargestValue, PSmallestNormalized, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 2123 { PLargestValue, MSmallestNormalized, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 2124 { MLargestValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2125 { MLargestValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 2126 { MLargestValue, PZero, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal }, 2127 { MLargestValue, MZero, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal }, 2128 { MLargestValue, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN }, 2129 #if 0 2130 // See Note 1. 2131 { MLargestValue, SNaN, "-nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2132 #endif 2133 { MLargestValue, PNormalValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 2134 { MLargestValue, MNormalValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 2135 { MLargestValue, PLargestValue, "-inf", OverflowStatus, APFloat::fcInfinity }, 2136 { MLargestValue, MLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2137 { MLargestValue, PSmallestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 2138 { MLargestValue, MSmallestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 2139 { MLargestValue, PSmallestNormalized, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 2140 { MLargestValue, MSmallestNormalized, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 2141 { PSmallestValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2142 { PSmallestValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 2143 { PSmallestValue, PZero, "0x1p-149", APFloat::opOK, APFloat::fcNormal }, 2144 { PSmallestValue, MZero, "0x1p-149", APFloat::opOK, APFloat::fcNormal }, 2145 { PSmallestValue, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN }, 2146 #if 0 2147 // See Note 1. 2148 { PSmallestValue, SNaN, "-nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2149 #endif 2150 { PSmallestValue, PNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 2151 { PSmallestValue, MNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 2152 { PSmallestValue, PLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 2153 { PSmallestValue, MLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 2154 { PSmallestValue, PSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2155 { PSmallestValue, MSmallestValue, "0x1p-148", APFloat::opOK, APFloat::fcNormal }, 2156 { PSmallestValue, PSmallestNormalized, "-0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal }, 2157 { PSmallestValue, MSmallestNormalized, "0x1.000002p-126", APFloat::opOK, APFloat::fcNormal }, 2158 { MSmallestValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2159 { MSmallestValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 2160 { MSmallestValue, PZero, "-0x1p-149", APFloat::opOK, APFloat::fcNormal }, 2161 { MSmallestValue, MZero, "-0x1p-149", APFloat::opOK, APFloat::fcNormal }, 2162 { MSmallestValue, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN }, 2163 #if 0 2164 // See Note 1. 2165 { MSmallestValue, SNaN, "-nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2166 #endif 2167 { MSmallestValue, PNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 2168 { MSmallestValue, MNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 2169 { MSmallestValue, PLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 2170 { MSmallestValue, MLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 2171 { MSmallestValue, PSmallestValue, "-0x1p-148", APFloat::opOK, APFloat::fcNormal }, 2172 { MSmallestValue, MSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2173 { MSmallestValue, PSmallestNormalized, "-0x1.000002p-126", APFloat::opOK, APFloat::fcNormal }, 2174 { MSmallestValue, MSmallestNormalized, "0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal }, 2175 { PSmallestNormalized, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2176 { PSmallestNormalized, MInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 2177 { PSmallestNormalized, PZero, "0x1p-126", APFloat::opOK, APFloat::fcNormal }, 2178 { PSmallestNormalized, MZero, "0x1p-126", APFloat::opOK, APFloat::fcNormal }, 2179 { PSmallestNormalized, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN }, 2180 #if 0 2181 // See Note 1. 2182 { PSmallestNormalized, SNaN, "-nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2183 #endif 2184 { PSmallestNormalized, PNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 2185 { PSmallestNormalized, MNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 2186 { PSmallestNormalized, PLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 2187 { PSmallestNormalized, MLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 2188 { PSmallestNormalized, PSmallestValue, "0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal }, 2189 { PSmallestNormalized, MSmallestValue, "0x1.000002p-126", APFloat::opOK, APFloat::fcNormal }, 2190 { PSmallestNormalized, PSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2191 { PSmallestNormalized, MSmallestNormalized, "0x1p-125", APFloat::opOK, APFloat::fcNormal }, 2192 { MSmallestNormalized, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2193 { MSmallestNormalized, MInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 2194 { MSmallestNormalized, PZero, "-0x1p-126", APFloat::opOK, APFloat::fcNormal }, 2195 { MSmallestNormalized, MZero, "-0x1p-126", APFloat::opOK, APFloat::fcNormal }, 2196 { MSmallestNormalized, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN }, 2197 #if 0 2198 // See Note 1. 2199 { MSmallestNormalized, SNaN, "-nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2200 #endif 2201 { MSmallestNormalized, PNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 2202 { MSmallestNormalized, MNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 2203 { MSmallestNormalized, PLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 2204 { MSmallestNormalized, MLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 2205 { MSmallestNormalized, PSmallestValue, "-0x1.000002p-126", APFloat::opOK, APFloat::fcNormal }, 2206 { MSmallestNormalized, MSmallestValue, "-0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal }, 2207 { MSmallestNormalized, PSmallestNormalized, "-0x1p-125", APFloat::opOK, APFloat::fcNormal }, 2208 { MSmallestNormalized, MSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero } 2209 }; 2210 2211 for (size_t i = 0; i < NumTests; ++i) { 2212 APFloat x(SpecialCaseTests[i].x); 2213 APFloat y(SpecialCaseTests[i].y); 2214 APFloat::opStatus status = x.subtract(y, APFloat::rmNearestTiesToEven); 2215 2216 APFloat result(APFloat::IEEEsingle, SpecialCaseTests[i].result); 2217 2218 EXPECT_TRUE(result.bitwiseIsEqual(x)); 2219 EXPECT_TRUE((int)status == SpecialCaseTests[i].status); 2220 EXPECT_TRUE((int)x.getCategory() == SpecialCaseTests[i].category); 2221 } 2222 } 2223 2224 TEST(APFloatTest, multiply) { 2225 // Test Special Cases against each other and normal values. 2226 2227 // TODOS/NOTES: 2228 // 1. Since we perform only default exception handling all operations with 2229 // signaling NaNs should have a result that is a quiet NaN. Currently they 2230 // return sNaN. 2231 2232 APFloat PInf = APFloat::getInf(APFloat::IEEEsingle, false); 2233 APFloat MInf = APFloat::getInf(APFloat::IEEEsingle, true); 2234 APFloat PZero = APFloat::getZero(APFloat::IEEEsingle, false); 2235 APFloat MZero = APFloat::getZero(APFloat::IEEEsingle, true); 2236 APFloat QNaN = APFloat::getNaN(APFloat::IEEEsingle, false); 2237 APFloat SNaN = APFloat::getSNaN(APFloat::IEEEsingle, false); 2238 APFloat PNormalValue = APFloat(APFloat::IEEEsingle, "0x1p+0"); 2239 APFloat MNormalValue = APFloat(APFloat::IEEEsingle, "-0x1p+0"); 2240 APFloat PLargestValue = APFloat::getLargest(APFloat::IEEEsingle, false); 2241 APFloat MLargestValue = APFloat::getLargest(APFloat::IEEEsingle, true); 2242 APFloat PSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle, false); 2243 APFloat MSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle, true); 2244 APFloat PSmallestNormalized = 2245 APFloat::getSmallestNormalized(APFloat::IEEEsingle, false); 2246 APFloat MSmallestNormalized = 2247 APFloat::getSmallestNormalized(APFloat::IEEEsingle, true); 2248 2249 const int OverflowStatus = APFloat::opOverflow | APFloat::opInexact; 2250 const int UnderflowStatus = APFloat::opUnderflow | APFloat::opInexact; 2251 2252 const unsigned NumTests = 169; 2253 struct { 2254 APFloat x; 2255 APFloat y; 2256 const char *result; 2257 int status; 2258 int category; 2259 } SpecialCaseTests[NumTests] = { 2260 { PInf, PInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 2261 { PInf, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2262 { PInf, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2263 { PInf, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2264 { PInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2265 #if 0 2266 // See Note 1. 2267 { PInf, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2268 #endif 2269 { PInf, PNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity }, 2270 { PInf, MNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2271 { PInf, PLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity }, 2272 { PInf, MLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2273 { PInf, PSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity }, 2274 { PInf, MSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2275 { PInf, PSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity }, 2276 { PInf, MSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2277 { MInf, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2278 { MInf, MInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 2279 { MInf, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2280 { MInf, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2281 { MInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2282 #if 0 2283 // See Note 1. 2284 { MInf, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2285 #endif 2286 { MInf, PNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2287 { MInf, MNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity }, 2288 { MInf, PLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2289 { MInf, MLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity }, 2290 { MInf, PSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2291 { MInf, MSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity }, 2292 { MInf, PSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2293 { MInf, MSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity }, 2294 { PZero, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2295 { PZero, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2296 { PZero, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2297 { PZero, MZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2298 { PZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2299 #if 0 2300 // See Note 1. 2301 { PZero, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2302 #endif 2303 { PZero, PNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2304 { PZero, MNormalValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2305 { PZero, PLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2306 { PZero, MLargestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2307 { PZero, PSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2308 { PZero, MSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2309 { PZero, PSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2310 { PZero, MSmallestNormalized, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2311 { MZero, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2312 { MZero, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2313 { MZero, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2314 { MZero, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2315 { MZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2316 #if 0 2317 // See Note 1. 2318 { MZero, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2319 #endif 2320 { MZero, PNormalValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2321 { MZero, MNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2322 { MZero, PLargestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2323 { MZero, MLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2324 { MZero, PSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2325 { MZero, MSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2326 { MZero, PSmallestNormalized, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2327 { MZero, MSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2328 { QNaN, PInf, "nan", APFloat::opOK, APFloat::fcNaN }, 2329 { QNaN, MInf, "nan", APFloat::opOK, APFloat::fcNaN }, 2330 { QNaN, PZero, "nan", APFloat::opOK, APFloat::fcNaN }, 2331 { QNaN, MZero, "nan", APFloat::opOK, APFloat::fcNaN }, 2332 { QNaN, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2333 #if 0 2334 // See Note 1. 2335 { QNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2336 #endif 2337 { QNaN, PNormalValue, "nan", APFloat::opOK, APFloat::fcNaN }, 2338 { QNaN, MNormalValue, "nan", APFloat::opOK, APFloat::fcNaN }, 2339 { QNaN, PLargestValue, "nan", APFloat::opOK, APFloat::fcNaN }, 2340 { QNaN, MLargestValue, "nan", APFloat::opOK, APFloat::fcNaN }, 2341 { QNaN, PSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN }, 2342 { QNaN, MSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN }, 2343 { QNaN, PSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN }, 2344 { QNaN, MSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN }, 2345 #if 0 2346 // See Note 1. 2347 { SNaN, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2348 { SNaN, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2349 { SNaN, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2350 { SNaN, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2351 { SNaN, QNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2352 { SNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2353 { SNaN, PNormalValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2354 { SNaN, MNormalValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2355 { SNaN, PLargestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2356 { SNaN, MLargestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2357 { SNaN, PSmallestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2358 { SNaN, MSmallestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2359 { SNaN, PSmallestNormalized, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2360 { SNaN, MSmallestNormalized, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2361 #endif 2362 { PNormalValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 2363 { PNormalValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2364 { PNormalValue, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2365 { PNormalValue, MZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2366 { PNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2367 #if 0 2368 // See Note 1. 2369 { PNormalValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2370 #endif 2371 { PNormalValue, PNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal }, 2372 { PNormalValue, MNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal }, 2373 { PNormalValue, PLargestValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal }, 2374 { PNormalValue, MLargestValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal }, 2375 { PNormalValue, PSmallestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal }, 2376 { PNormalValue, MSmallestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal }, 2377 { PNormalValue, PSmallestNormalized, "0x1p-126", APFloat::opOK, APFloat::fcNormal }, 2378 { PNormalValue, MSmallestNormalized, "-0x1p-126", APFloat::opOK, APFloat::fcNormal }, 2379 { MNormalValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2380 { MNormalValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 2381 { MNormalValue, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2382 { MNormalValue, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2383 { MNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2384 #if 0 2385 // See Note 1. 2386 { MNormalValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2387 #endif 2388 { MNormalValue, PNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal }, 2389 { MNormalValue, MNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal }, 2390 { MNormalValue, PLargestValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal }, 2391 { MNormalValue, MLargestValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal }, 2392 { MNormalValue, PSmallestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal }, 2393 { MNormalValue, MSmallestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal }, 2394 { MNormalValue, PSmallestNormalized, "-0x1p-126", APFloat::opOK, APFloat::fcNormal }, 2395 { MNormalValue, MSmallestNormalized, "0x1p-126", APFloat::opOK, APFloat::fcNormal }, 2396 { PLargestValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 2397 { PLargestValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2398 { PLargestValue, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2399 { PLargestValue, MZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2400 { PLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2401 #if 0 2402 // See Note 1. 2403 { PLargestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2404 #endif 2405 { PLargestValue, PNormalValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal }, 2406 { PLargestValue, MNormalValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal }, 2407 { PLargestValue, PLargestValue, "inf", OverflowStatus, APFloat::fcInfinity }, 2408 { PLargestValue, MLargestValue, "-inf", OverflowStatus, APFloat::fcInfinity }, 2409 { PLargestValue, PSmallestValue, "0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal }, 2410 { PLargestValue, MSmallestValue, "-0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal }, 2411 { PLargestValue, PSmallestNormalized, "0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal }, 2412 { PLargestValue, MSmallestNormalized, "-0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal }, 2413 { MLargestValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2414 { MLargestValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 2415 { MLargestValue, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2416 { MLargestValue, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2417 { MLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2418 #if 0 2419 // See Note 1. 2420 { MLargestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2421 #endif 2422 { MLargestValue, PNormalValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal }, 2423 { MLargestValue, MNormalValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal }, 2424 { MLargestValue, PLargestValue, "-inf", OverflowStatus, APFloat::fcInfinity }, 2425 { MLargestValue, MLargestValue, "inf", OverflowStatus, APFloat::fcInfinity }, 2426 { MLargestValue, PSmallestValue, "-0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal }, 2427 { MLargestValue, MSmallestValue, "0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal }, 2428 { MLargestValue, PSmallestNormalized, "-0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal }, 2429 { MLargestValue, MSmallestNormalized, "0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal }, 2430 { PSmallestValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 2431 { PSmallestValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2432 { PSmallestValue, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2433 { PSmallestValue, MZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2434 { PSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2435 #if 0 2436 // See Note 1. 2437 { PSmallestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2438 #endif 2439 { PSmallestValue, PNormalValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal }, 2440 { PSmallestValue, MNormalValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal }, 2441 { PSmallestValue, PLargestValue, "0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal }, 2442 { PSmallestValue, MLargestValue, "-0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal }, 2443 { PSmallestValue, PSmallestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero }, 2444 { PSmallestValue, MSmallestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero }, 2445 { PSmallestValue, PSmallestNormalized, "0x0p+0", UnderflowStatus, APFloat::fcZero }, 2446 { PSmallestValue, MSmallestNormalized, "-0x0p+0", UnderflowStatus, APFloat::fcZero }, 2447 { MSmallestValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2448 { MSmallestValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 2449 { MSmallestValue, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2450 { MSmallestValue, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2451 { MSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2452 #if 0 2453 // See Note 1. 2454 { MSmallestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2455 #endif 2456 { MSmallestValue, PNormalValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal }, 2457 { MSmallestValue, MNormalValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal }, 2458 { MSmallestValue, PLargestValue, "-0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal }, 2459 { MSmallestValue, MLargestValue, "0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal }, 2460 { MSmallestValue, PSmallestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero }, 2461 { MSmallestValue, MSmallestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero }, 2462 { MSmallestValue, PSmallestNormalized, "-0x0p+0", UnderflowStatus, APFloat::fcZero }, 2463 { MSmallestValue, MSmallestNormalized, "0x0p+0", UnderflowStatus, APFloat::fcZero }, 2464 { PSmallestNormalized, PInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 2465 { PSmallestNormalized, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2466 { PSmallestNormalized, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2467 { PSmallestNormalized, MZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2468 { PSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2469 #if 0 2470 // See Note 1. 2471 { PSmallestNormalized, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2472 #endif 2473 { PSmallestNormalized, PNormalValue, "0x1p-126", APFloat::opOK, APFloat::fcNormal }, 2474 { PSmallestNormalized, MNormalValue, "-0x1p-126", APFloat::opOK, APFloat::fcNormal }, 2475 { PSmallestNormalized, PLargestValue, "0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal }, 2476 { PSmallestNormalized, MLargestValue, "-0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal }, 2477 { PSmallestNormalized, PSmallestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero }, 2478 { PSmallestNormalized, MSmallestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero }, 2479 { PSmallestNormalized, PSmallestNormalized, "0x0p+0", UnderflowStatus, APFloat::fcZero }, 2480 { PSmallestNormalized, MSmallestNormalized, "-0x0p+0", UnderflowStatus, APFloat::fcZero }, 2481 { MSmallestNormalized, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2482 { MSmallestNormalized, MInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 2483 { MSmallestNormalized, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2484 { MSmallestNormalized, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2485 { MSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2486 #if 0 2487 // See Note 1. 2488 { MSmallestNormalized, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2489 #endif 2490 { MSmallestNormalized, PNormalValue, "-0x1p-126", APFloat::opOK, APFloat::fcNormal }, 2491 { MSmallestNormalized, MNormalValue, "0x1p-126", APFloat::opOK, APFloat::fcNormal }, 2492 { MSmallestNormalized, PLargestValue, "-0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal }, 2493 { MSmallestNormalized, MLargestValue, "0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal }, 2494 { MSmallestNormalized, PSmallestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero }, 2495 { MSmallestNormalized, MSmallestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero }, 2496 { MSmallestNormalized, PSmallestNormalized, "-0x0p+0", UnderflowStatus, APFloat::fcZero }, 2497 { MSmallestNormalized, MSmallestNormalized, "0x0p+0", UnderflowStatus, APFloat::fcZero } 2498 }; 2499 2500 for (size_t i = 0; i < NumTests; ++i) { 2501 APFloat x(SpecialCaseTests[i].x); 2502 APFloat y(SpecialCaseTests[i].y); 2503 APFloat::opStatus status = x.multiply(y, APFloat::rmNearestTiesToEven); 2504 2505 APFloat result(APFloat::IEEEsingle, SpecialCaseTests[i].result); 2506 2507 EXPECT_TRUE(result.bitwiseIsEqual(x)); 2508 EXPECT_TRUE((int)status == SpecialCaseTests[i].status); 2509 EXPECT_TRUE((int)x.getCategory() == SpecialCaseTests[i].category); 2510 } 2511 } 2512 2513 TEST(APFloatTest, divide) { 2514 // Test Special Cases against each other and normal values. 2515 2516 // TODOS/NOTES: 2517 // 1. Since we perform only default exception handling all operations with 2518 // signaling NaNs should have a result that is a quiet NaN. Currently they 2519 // return sNaN. 2520 2521 APFloat PInf = APFloat::getInf(APFloat::IEEEsingle, false); 2522 APFloat MInf = APFloat::getInf(APFloat::IEEEsingle, true); 2523 APFloat PZero = APFloat::getZero(APFloat::IEEEsingle, false); 2524 APFloat MZero = APFloat::getZero(APFloat::IEEEsingle, true); 2525 APFloat QNaN = APFloat::getNaN(APFloat::IEEEsingle, false); 2526 APFloat SNaN = APFloat::getSNaN(APFloat::IEEEsingle, false); 2527 APFloat PNormalValue = APFloat(APFloat::IEEEsingle, "0x1p+0"); 2528 APFloat MNormalValue = APFloat(APFloat::IEEEsingle, "-0x1p+0"); 2529 APFloat PLargestValue = APFloat::getLargest(APFloat::IEEEsingle, false); 2530 APFloat MLargestValue = APFloat::getLargest(APFloat::IEEEsingle, true); 2531 APFloat PSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle, false); 2532 APFloat MSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle, true); 2533 APFloat PSmallestNormalized = 2534 APFloat::getSmallestNormalized(APFloat::IEEEsingle, false); 2535 APFloat MSmallestNormalized = 2536 APFloat::getSmallestNormalized(APFloat::IEEEsingle, true); 2537 2538 const int OverflowStatus = APFloat::opOverflow | APFloat::opInexact; 2539 const int UnderflowStatus = APFloat::opUnderflow | APFloat::opInexact; 2540 2541 const unsigned NumTests = 169; 2542 struct { 2543 APFloat x; 2544 APFloat y; 2545 const char *result; 2546 int status; 2547 int category; 2548 } SpecialCaseTests[NumTests] = { 2549 { PInf, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2550 { PInf, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2551 { PInf, PZero, "inf", APFloat::opOK, APFloat::fcInfinity }, 2552 { PInf, MZero, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2553 { PInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2554 #if 0 2555 // See Note 1. 2556 { PInf, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2557 #endif 2558 { PInf, PNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity }, 2559 { PInf, MNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2560 { PInf, PLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity }, 2561 { PInf, MLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2562 { PInf, PSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity }, 2563 { PInf, MSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2564 { PInf, PSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity }, 2565 { PInf, MSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2566 { MInf, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2567 { MInf, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2568 { MInf, PZero, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2569 { MInf, MZero, "inf", APFloat::opOK, APFloat::fcInfinity }, 2570 { MInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2571 #if 0 2572 // See Note 1. 2573 { MInf, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2574 #endif 2575 { MInf, PNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2576 { MInf, MNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity }, 2577 { MInf, PLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2578 { MInf, MLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity }, 2579 { MInf, PSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2580 { MInf, MSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity }, 2581 { MInf, PSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2582 { MInf, MSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity }, 2583 { PZero, PInf, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2584 { PZero, MInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2585 { PZero, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2586 { PZero, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2587 { PZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2588 #if 0 2589 // See Note 1. 2590 { PZero, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2591 #endif 2592 { PZero, PNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2593 { PZero, MNormalValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2594 { PZero, PLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2595 { PZero, MLargestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2596 { PZero, PSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2597 { PZero, MSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2598 { PZero, PSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2599 { PZero, MSmallestNormalized, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2600 { MZero, PInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2601 { MZero, MInf, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2602 { MZero, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2603 { MZero, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2604 { MZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2605 #if 0 2606 // See Note 1. 2607 { MZero, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2608 #endif 2609 { MZero, PNormalValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2610 { MZero, MNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2611 { MZero, PLargestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2612 { MZero, MLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2613 { MZero, PSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2614 { MZero, MSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2615 { MZero, PSmallestNormalized, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2616 { MZero, MSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2617 { QNaN, PInf, "nan", APFloat::opOK, APFloat::fcNaN }, 2618 { QNaN, MInf, "nan", APFloat::opOK, APFloat::fcNaN }, 2619 { QNaN, PZero, "nan", APFloat::opOK, APFloat::fcNaN }, 2620 { QNaN, MZero, "nan", APFloat::opOK, APFloat::fcNaN }, 2621 { QNaN, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2622 #if 0 2623 // See Note 1. 2624 { QNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2625 #endif 2626 { QNaN, PNormalValue, "nan", APFloat::opOK, APFloat::fcNaN }, 2627 { QNaN, MNormalValue, "nan", APFloat::opOK, APFloat::fcNaN }, 2628 { QNaN, PLargestValue, "nan", APFloat::opOK, APFloat::fcNaN }, 2629 { QNaN, MLargestValue, "nan", APFloat::opOK, APFloat::fcNaN }, 2630 { QNaN, PSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN }, 2631 { QNaN, MSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN }, 2632 { QNaN, PSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN }, 2633 { QNaN, MSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN }, 2634 #if 0 2635 // See Note 1. 2636 { SNaN, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2637 { SNaN, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2638 { SNaN, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2639 { SNaN, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2640 { SNaN, QNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2641 { SNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2642 { SNaN, PNormalValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2643 { SNaN, MNormalValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2644 { SNaN, PLargestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2645 { SNaN, MLargestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2646 { SNaN, PSmallestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2647 { SNaN, MSmallestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2648 { SNaN, PSmallestNormalized, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2649 { SNaN, MSmallestNormalized, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2650 #endif 2651 { PNormalValue, PInf, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2652 { PNormalValue, MInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2653 { PNormalValue, PZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity }, 2654 { PNormalValue, MZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity }, 2655 { PNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2656 #if 0 2657 // See Note 1. 2658 { PNormalValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2659 #endif 2660 { PNormalValue, PNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal }, 2661 { PNormalValue, MNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal }, 2662 { PNormalValue, PLargestValue, "0x1p-128", UnderflowStatus, APFloat::fcNormal }, 2663 { PNormalValue, MLargestValue, "-0x1p-128", UnderflowStatus, APFloat::fcNormal }, 2664 { PNormalValue, PSmallestValue, "inf", OverflowStatus, APFloat::fcInfinity }, 2665 { PNormalValue, MSmallestValue, "-inf", OverflowStatus, APFloat::fcInfinity }, 2666 { PNormalValue, PSmallestNormalized, "0x1p+126", APFloat::opOK, APFloat::fcNormal }, 2667 { PNormalValue, MSmallestNormalized, "-0x1p+126", APFloat::opOK, APFloat::fcNormal }, 2668 { MNormalValue, PInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2669 { MNormalValue, MInf, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2670 { MNormalValue, PZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity }, 2671 { MNormalValue, MZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity }, 2672 { MNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2673 #if 0 2674 // See Note 1. 2675 { MNormalValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2676 #endif 2677 { MNormalValue, PNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal }, 2678 { MNormalValue, MNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal }, 2679 { MNormalValue, PLargestValue, "-0x1p-128", UnderflowStatus, APFloat::fcNormal }, 2680 { MNormalValue, MLargestValue, "0x1p-128", UnderflowStatus, APFloat::fcNormal }, 2681 { MNormalValue, PSmallestValue, "-inf", OverflowStatus, APFloat::fcInfinity }, 2682 { MNormalValue, MSmallestValue, "inf", OverflowStatus, APFloat::fcInfinity }, 2683 { MNormalValue, PSmallestNormalized, "-0x1p+126", APFloat::opOK, APFloat::fcNormal }, 2684 { MNormalValue, MSmallestNormalized, "0x1p+126", APFloat::opOK, APFloat::fcNormal }, 2685 { PLargestValue, PInf, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2686 { PLargestValue, MInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2687 { PLargestValue, PZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity }, 2688 { PLargestValue, MZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity }, 2689 { PLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2690 #if 0 2691 // See Note 1. 2692 { PLargestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2693 #endif 2694 { PLargestValue, PNormalValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal }, 2695 { PLargestValue, MNormalValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal }, 2696 { PLargestValue, PLargestValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal }, 2697 { PLargestValue, MLargestValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal }, 2698 { PLargestValue, PSmallestValue, "inf", OverflowStatus, APFloat::fcInfinity }, 2699 { PLargestValue, MSmallestValue, "-inf", OverflowStatus, APFloat::fcInfinity }, 2700 { PLargestValue, PSmallestNormalized, "inf", OverflowStatus, APFloat::fcInfinity }, 2701 { PLargestValue, MSmallestNormalized, "-inf", OverflowStatus, APFloat::fcInfinity }, 2702 { MLargestValue, PInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2703 { MLargestValue, MInf, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2704 { MLargestValue, PZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity }, 2705 { MLargestValue, MZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity }, 2706 { MLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2707 #if 0 2708 // See Note 1. 2709 { MLargestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2710 #endif 2711 { MLargestValue, PNormalValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal }, 2712 { MLargestValue, MNormalValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal }, 2713 { MLargestValue, PLargestValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal }, 2714 { MLargestValue, MLargestValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal }, 2715 { MLargestValue, PSmallestValue, "-inf", OverflowStatus, APFloat::fcInfinity }, 2716 { MLargestValue, MSmallestValue, "inf", OverflowStatus, APFloat::fcInfinity }, 2717 { MLargestValue, PSmallestNormalized, "-inf", OverflowStatus, APFloat::fcInfinity }, 2718 { MLargestValue, MSmallestNormalized, "inf", OverflowStatus, APFloat::fcInfinity }, 2719 { PSmallestValue, PInf, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2720 { PSmallestValue, MInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2721 { PSmallestValue, PZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity }, 2722 { PSmallestValue, MZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity }, 2723 { PSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2724 #if 0 2725 // See Note 1. 2726 { PSmallestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2727 #endif 2728 { PSmallestValue, PNormalValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal }, 2729 { PSmallestValue, MNormalValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal }, 2730 { PSmallestValue, PLargestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero }, 2731 { PSmallestValue, MLargestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero }, 2732 { PSmallestValue, PSmallestValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal }, 2733 { PSmallestValue, MSmallestValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal }, 2734 { PSmallestValue, PSmallestNormalized, "0x1p-23", APFloat::opOK, APFloat::fcNormal }, 2735 { PSmallestValue, MSmallestNormalized, "-0x1p-23", APFloat::opOK, APFloat::fcNormal }, 2736 { MSmallestValue, PInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2737 { MSmallestValue, MInf, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2738 { MSmallestValue, PZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity }, 2739 { MSmallestValue, MZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity }, 2740 { MSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2741 #if 0 2742 // See Note 1. 2743 { MSmallestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2744 #endif 2745 { MSmallestValue, PNormalValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal }, 2746 { MSmallestValue, MNormalValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal }, 2747 { MSmallestValue, PLargestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero }, 2748 { MSmallestValue, MLargestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero }, 2749 { MSmallestValue, PSmallestValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal }, 2750 { MSmallestValue, MSmallestValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal }, 2751 { MSmallestValue, PSmallestNormalized, "-0x1p-23", APFloat::opOK, APFloat::fcNormal }, 2752 { MSmallestValue, MSmallestNormalized, "0x1p-23", APFloat::opOK, APFloat::fcNormal }, 2753 { PSmallestNormalized, PInf, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2754 { PSmallestNormalized, MInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2755 { PSmallestNormalized, PZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity }, 2756 { PSmallestNormalized, MZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity }, 2757 { PSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2758 #if 0 2759 // See Note 1. 2760 { PSmallestNormalized, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2761 #endif 2762 { PSmallestNormalized, PNormalValue, "0x1p-126", APFloat::opOK, APFloat::fcNormal }, 2763 { PSmallestNormalized, MNormalValue, "-0x1p-126", APFloat::opOK, APFloat::fcNormal }, 2764 { PSmallestNormalized, PLargestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero }, 2765 { PSmallestNormalized, MLargestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero }, 2766 { PSmallestNormalized, PSmallestValue, "0x1p+23", APFloat::opOK, APFloat::fcNormal }, 2767 { PSmallestNormalized, MSmallestValue, "-0x1p+23", APFloat::opOK, APFloat::fcNormal }, 2768 { PSmallestNormalized, PSmallestNormalized, "0x1p+0", APFloat::opOK, APFloat::fcNormal }, 2769 { PSmallestNormalized, MSmallestNormalized, "-0x1p+0", APFloat::opOK, APFloat::fcNormal }, 2770 { MSmallestNormalized, PInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2771 { MSmallestNormalized, MInf, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2772 { MSmallestNormalized, PZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity }, 2773 { MSmallestNormalized, MZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity }, 2774 { MSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2775 #if 0 2776 // See Note 1. 2777 { MSmallestNormalized, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2778 #endif 2779 { MSmallestNormalized, PNormalValue, "-0x1p-126", APFloat::opOK, APFloat::fcNormal }, 2780 { MSmallestNormalized, MNormalValue, "0x1p-126", APFloat::opOK, APFloat::fcNormal }, 2781 { MSmallestNormalized, PLargestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero }, 2782 { MSmallestNormalized, MLargestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero }, 2783 { MSmallestNormalized, PSmallestValue, "-0x1p+23", APFloat::opOK, APFloat::fcNormal }, 2784 { MSmallestNormalized, MSmallestValue, "0x1p+23", APFloat::opOK, APFloat::fcNormal }, 2785 { MSmallestNormalized, PSmallestNormalized, "-0x1p+0", APFloat::opOK, APFloat::fcNormal }, 2786 { MSmallestNormalized, MSmallestNormalized, "0x1p+0", APFloat::opOK, APFloat::fcNormal }, 2787 }; 2788 2789 for (size_t i = 0; i < NumTests; ++i) { 2790 APFloat x(SpecialCaseTests[i].x); 2791 APFloat y(SpecialCaseTests[i].y); 2792 APFloat::opStatus status = x.divide(y, APFloat::rmNearestTiesToEven); 2793 2794 APFloat result(APFloat::IEEEsingle, SpecialCaseTests[i].result); 2795 2796 EXPECT_TRUE(result.bitwiseIsEqual(x)); 2797 EXPECT_TRUE((int)status == SpecialCaseTests[i].status); 2798 EXPECT_TRUE((int)x.getCategory() == SpecialCaseTests[i].category); 2799 } 2800 } 2801 2802 TEST(APFloatTest, operatorOverloads) { 2803 // This is mostly testing that these operator overloads compile. 2804 APFloat One = APFloat(APFloat::IEEEsingle, "0x1p+0"); 2805 APFloat Two = APFloat(APFloat::IEEEsingle, "0x2p+0"); 2806 EXPECT_TRUE(Two.bitwiseIsEqual(One + One)); 2807 EXPECT_TRUE(One.bitwiseIsEqual(Two - One)); 2808 EXPECT_TRUE(Two.bitwiseIsEqual(One * Two)); 2809 EXPECT_TRUE(One.bitwiseIsEqual(Two / Two)); 2810 } 2811 2812 TEST(APFloatTest, abs) { 2813 APFloat PInf = APFloat::getInf(APFloat::IEEEsingle, false); 2814 APFloat MInf = APFloat::getInf(APFloat::IEEEsingle, true); 2815 APFloat PZero = APFloat::getZero(APFloat::IEEEsingle, false); 2816 APFloat MZero = APFloat::getZero(APFloat::IEEEsingle, true); 2817 APFloat PQNaN = APFloat::getNaN(APFloat::IEEEsingle, false); 2818 APFloat MQNaN = APFloat::getNaN(APFloat::IEEEsingle, true); 2819 APFloat PSNaN = APFloat::getSNaN(APFloat::IEEEsingle, false); 2820 APFloat MSNaN = APFloat::getSNaN(APFloat::IEEEsingle, true); 2821 APFloat PNormalValue = APFloat(APFloat::IEEEsingle, "0x1p+0"); 2822 APFloat MNormalValue = APFloat(APFloat::IEEEsingle, "-0x1p+0"); 2823 APFloat PLargestValue = APFloat::getLargest(APFloat::IEEEsingle, false); 2824 APFloat MLargestValue = APFloat::getLargest(APFloat::IEEEsingle, true); 2825 APFloat PSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle, false); 2826 APFloat MSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle, true); 2827 APFloat PSmallestNormalized = 2828 APFloat::getSmallestNormalized(APFloat::IEEEsingle, false); 2829 APFloat MSmallestNormalized = 2830 APFloat::getSmallestNormalized(APFloat::IEEEsingle, true); 2831 2832 EXPECT_TRUE(PInf.bitwiseIsEqual(abs(PInf))); 2833 EXPECT_TRUE(PInf.bitwiseIsEqual(abs(MInf))); 2834 EXPECT_TRUE(PZero.bitwiseIsEqual(abs(PZero))); 2835 EXPECT_TRUE(PZero.bitwiseIsEqual(abs(MZero))); 2836 EXPECT_TRUE(PQNaN.bitwiseIsEqual(abs(PQNaN))); 2837 EXPECT_TRUE(PQNaN.bitwiseIsEqual(abs(MQNaN))); 2838 EXPECT_TRUE(PSNaN.bitwiseIsEqual(abs(PSNaN))); 2839 EXPECT_TRUE(PSNaN.bitwiseIsEqual(abs(MSNaN))); 2840 EXPECT_TRUE(PNormalValue.bitwiseIsEqual(abs(PNormalValue))); 2841 EXPECT_TRUE(PNormalValue.bitwiseIsEqual(abs(MNormalValue))); 2842 EXPECT_TRUE(PLargestValue.bitwiseIsEqual(abs(PLargestValue))); 2843 EXPECT_TRUE(PLargestValue.bitwiseIsEqual(abs(MLargestValue))); 2844 EXPECT_TRUE(PSmallestValue.bitwiseIsEqual(abs(PSmallestValue))); 2845 EXPECT_TRUE(PSmallestValue.bitwiseIsEqual(abs(MSmallestValue))); 2846 EXPECT_TRUE(PSmallestNormalized.bitwiseIsEqual(abs(PSmallestNormalized))); 2847 EXPECT_TRUE(PSmallestNormalized.bitwiseIsEqual(abs(MSmallestNormalized))); 2848 } 2849 2850 TEST(APFloatTest, ilogb) { 2851 EXPECT_EQ(-1074, ilogb(APFloat::getSmallest(APFloat::IEEEdouble, false))); 2852 EXPECT_EQ(-1074, ilogb(APFloat::getSmallest(APFloat::IEEEdouble, true))); 2853 EXPECT_EQ(-1023, ilogb(APFloat(APFloat::IEEEdouble, "0x1.ffffffffffffep-1024"))); 2854 EXPECT_EQ(-1023, ilogb(APFloat(APFloat::IEEEdouble, "0x1.ffffffffffffep-1023"))); 2855 EXPECT_EQ(-1023, ilogb(APFloat(APFloat::IEEEdouble, "-0x1.ffffffffffffep-1023"))); 2856 EXPECT_EQ(-51, ilogb(APFloat(APFloat::IEEEdouble, "0x1p-51"))); 2857 EXPECT_EQ(-1023, ilogb(APFloat(APFloat::IEEEdouble, "0x1.c60f120d9f87cp-1023"))); 2858 EXPECT_EQ(-2, ilogb(APFloat(APFloat::IEEEdouble, "0x0.ffffp-1"))); 2859 EXPECT_EQ(-1023, ilogb(APFloat(APFloat::IEEEdouble, "0x1.fffep-1023"))); 2860 EXPECT_EQ(1023, ilogb(APFloat::getLargest(APFloat::IEEEdouble, false))); 2861 EXPECT_EQ(1023, ilogb(APFloat::getLargest(APFloat::IEEEdouble, true))); 2862 2863 2864 EXPECT_EQ(0, ilogb(APFloat(APFloat::IEEEsingle, "0x1p+0"))); 2865 EXPECT_EQ(0, ilogb(APFloat(APFloat::IEEEsingle, "-0x1p+0"))); 2866 EXPECT_EQ(42, ilogb(APFloat(APFloat::IEEEsingle, "0x1p+42"))); 2867 EXPECT_EQ(-42, ilogb(APFloat(APFloat::IEEEsingle, "0x1p-42"))); 2868 2869 EXPECT_EQ(APFloat::IEK_Inf, 2870 ilogb(APFloat::getInf(APFloat::IEEEsingle, false))); 2871 EXPECT_EQ(APFloat::IEK_Inf, 2872 ilogb(APFloat::getInf(APFloat::IEEEsingle, true))); 2873 EXPECT_EQ(APFloat::IEK_Zero, 2874 ilogb(APFloat::getZero(APFloat::IEEEsingle, false))); 2875 EXPECT_EQ(APFloat::IEK_Zero, 2876 ilogb(APFloat::getZero(APFloat::IEEEsingle, true))); 2877 EXPECT_EQ(APFloat::IEK_NaN, 2878 ilogb(APFloat::getNaN(APFloat::IEEEsingle, false))); 2879 EXPECT_EQ(APFloat::IEK_NaN, 2880 ilogb(APFloat::getSNaN(APFloat::IEEEsingle, false))); 2881 2882 EXPECT_EQ(127, ilogb(APFloat::getLargest(APFloat::IEEEsingle, false))); 2883 EXPECT_EQ(127, ilogb(APFloat::getLargest(APFloat::IEEEsingle, true))); 2884 2885 EXPECT_EQ(-149, ilogb(APFloat::getSmallest(APFloat::IEEEsingle, false))); 2886 EXPECT_EQ(-149, ilogb(APFloat::getSmallest(APFloat::IEEEsingle, true))); 2887 EXPECT_EQ(-126, 2888 ilogb(APFloat::getSmallestNormalized(APFloat::IEEEsingle, false))); 2889 EXPECT_EQ(-126, 2890 ilogb(APFloat::getSmallestNormalized(APFloat::IEEEsingle, true))); 2891 } 2892 2893 TEST(APFloatTest, scalbn) { 2894 2895 const APFloat::roundingMode RM = APFloat::rmNearestTiesToEven; 2896 EXPECT_TRUE( 2897 APFloat(APFloat::IEEEsingle, "0x1p+0") 2898 .bitwiseIsEqual(scalbn(APFloat(APFloat::IEEEsingle, "0x1p+0"), 0, RM))); 2899 EXPECT_TRUE( 2900 APFloat(APFloat::IEEEsingle, "0x1p+42") 2901 .bitwiseIsEqual(scalbn(APFloat(APFloat::IEEEsingle, "0x1p+0"), 42, RM))); 2902 EXPECT_TRUE( 2903 APFloat(APFloat::IEEEsingle, "0x1p-42") 2904 .bitwiseIsEqual(scalbn(APFloat(APFloat::IEEEsingle, "0x1p+0"), -42, RM))); 2905 2906 APFloat PInf = APFloat::getInf(APFloat::IEEEsingle, false); 2907 APFloat MInf = APFloat::getInf(APFloat::IEEEsingle, true); 2908 APFloat PZero = APFloat::getZero(APFloat::IEEEsingle, false); 2909 APFloat MZero = APFloat::getZero(APFloat::IEEEsingle, true); 2910 APFloat QPNaN = APFloat::getNaN(APFloat::IEEEsingle, false); 2911 APFloat QMNaN = APFloat::getNaN(APFloat::IEEEsingle, true); 2912 APFloat SNaN = APFloat::getSNaN(APFloat::IEEEsingle, false); 2913 2914 EXPECT_TRUE(PInf.bitwiseIsEqual(scalbn(PInf, 0, RM))); 2915 EXPECT_TRUE(MInf.bitwiseIsEqual(scalbn(MInf, 0, RM))); 2916 EXPECT_TRUE(PZero.bitwiseIsEqual(scalbn(PZero, 0, RM))); 2917 EXPECT_TRUE(MZero.bitwiseIsEqual(scalbn(MZero, 0, RM))); 2918 EXPECT_TRUE(QPNaN.bitwiseIsEqual(scalbn(QPNaN, 0, RM))); 2919 EXPECT_TRUE(QMNaN.bitwiseIsEqual(scalbn(QMNaN, 0, RM))); 2920 EXPECT_FALSE(scalbn(SNaN, 0, RM).isSignaling()); 2921 2922 APFloat ScalbnSNaN = scalbn(SNaN, 1, RM); 2923 EXPECT_TRUE(ScalbnSNaN.isNaN() && !ScalbnSNaN.isSignaling()); 2924 2925 // Make sure highest bit of payload is preserved. 2926 const APInt Payload(64, (UINT64_C(1) << 50) | 2927 (UINT64_C(1) << 49) | 2928 (UINT64_C(1234) << 32) | 2929 1); 2930 2931 APFloat SNaNWithPayload = APFloat::getSNaN(APFloat::IEEEdouble, false, 2932 &Payload); 2933 APFloat QuietPayload = scalbn(SNaNWithPayload, 1, RM); 2934 EXPECT_TRUE(QuietPayload.isNaN() && !QuietPayload.isSignaling()); 2935 EXPECT_EQ(Payload, QuietPayload.bitcastToAPInt().getLoBits(51)); 2936 2937 EXPECT_TRUE(PInf.bitwiseIsEqual( 2938 scalbn(APFloat(APFloat::IEEEsingle, "0x1p+0"), 128, RM))); 2939 EXPECT_TRUE(MInf.bitwiseIsEqual( 2940 scalbn(APFloat(APFloat::IEEEsingle, "-0x1p+0"), 128, RM))); 2941 EXPECT_TRUE(PInf.bitwiseIsEqual( 2942 scalbn(APFloat(APFloat::IEEEsingle, "0x1p+127"), 1, RM))); 2943 EXPECT_TRUE(PZero.bitwiseIsEqual( 2944 scalbn(APFloat(APFloat::IEEEsingle, "0x1p-127"), -127, RM))); 2945 EXPECT_TRUE(MZero.bitwiseIsEqual( 2946 scalbn(APFloat(APFloat::IEEEsingle, "-0x1p-127"), -127, RM))); 2947 EXPECT_TRUE(APFloat(APFloat::IEEEsingle, "-0x1p-149").bitwiseIsEqual( 2948 scalbn(APFloat(APFloat::IEEEsingle, "-0x1p-127"), -22, RM))); 2949 EXPECT_TRUE(PZero.bitwiseIsEqual( 2950 scalbn(APFloat(APFloat::IEEEsingle, "0x1p-126"), -24, RM))); 2951 2952 2953 APFloat SmallestF64 = APFloat::getSmallest(APFloat::IEEEdouble, false); 2954 APFloat NegSmallestF64 = APFloat::getSmallest(APFloat::IEEEdouble, true); 2955 2956 APFloat LargestF64 = APFloat::getLargest(APFloat::IEEEdouble, false); 2957 APFloat NegLargestF64 = APFloat::getLargest(APFloat::IEEEdouble, true); 2958 2959 APFloat SmallestNormalizedF64 2960 = APFloat::getSmallestNormalized(APFloat::IEEEdouble, false); 2961 APFloat NegSmallestNormalizedF64 2962 = APFloat::getSmallestNormalized(APFloat::IEEEdouble, true); 2963 2964 APFloat LargestDenormalF64(APFloat::IEEEdouble, "0x1.ffffffffffffep-1023"); 2965 APFloat NegLargestDenormalF64(APFloat::IEEEdouble, "-0x1.ffffffffffffep-1023"); 2966 2967 2968 EXPECT_TRUE(SmallestF64.bitwiseIsEqual( 2969 scalbn(APFloat(APFloat::IEEEdouble, "0x1p-1074"), 0, RM))); 2970 EXPECT_TRUE(NegSmallestF64.bitwiseIsEqual( 2971 scalbn(APFloat(APFloat::IEEEdouble, "-0x1p-1074"), 0, RM))); 2972 2973 EXPECT_TRUE(APFloat(APFloat::IEEEdouble, "0x1p+1023") 2974 .bitwiseIsEqual(scalbn(SmallestF64, 2097, RM))); 2975 2976 EXPECT_TRUE(scalbn(SmallestF64, -2097, RM).isPosZero()); 2977 EXPECT_TRUE(scalbn(SmallestF64, -2098, RM).isPosZero()); 2978 EXPECT_TRUE(scalbn(SmallestF64, -2099, RM).isPosZero()); 2979 EXPECT_TRUE(APFloat(APFloat::IEEEdouble, "0x1p+1022") 2980 .bitwiseIsEqual(scalbn(SmallestF64, 2096, RM))); 2981 EXPECT_TRUE(APFloat(APFloat::IEEEdouble, "0x1p+1023") 2982 .bitwiseIsEqual(scalbn(SmallestF64, 2097, RM))); 2983 EXPECT_TRUE(scalbn(SmallestF64, 2098, RM).isInfinity()); 2984 EXPECT_TRUE(scalbn(SmallestF64, 2099, RM).isInfinity()); 2985 2986 // Test for integer overflows when adding to exponent. 2987 EXPECT_TRUE(scalbn(SmallestF64, -INT_MAX, RM).isPosZero()); 2988 EXPECT_TRUE(scalbn(LargestF64, INT_MAX, RM).isInfinity()); 2989 2990 EXPECT_TRUE(LargestDenormalF64 2991 .bitwiseIsEqual(scalbn(LargestDenormalF64, 0, RM))); 2992 EXPECT_TRUE(NegLargestDenormalF64 2993 .bitwiseIsEqual(scalbn(NegLargestDenormalF64, 0, RM))); 2994 2995 EXPECT_TRUE(APFloat(APFloat::IEEEdouble, "0x1.ffffffffffffep-1022") 2996 .bitwiseIsEqual(scalbn(LargestDenormalF64, 1, RM))); 2997 EXPECT_TRUE(APFloat(APFloat::IEEEdouble, "-0x1.ffffffffffffep-1021") 2998 .bitwiseIsEqual(scalbn(NegLargestDenormalF64, 2, RM))); 2999 3000 EXPECT_TRUE(APFloat(APFloat::IEEEdouble, "0x1.ffffffffffffep+1") 3001 .bitwiseIsEqual(scalbn(LargestDenormalF64, 1024, RM))); 3002 EXPECT_TRUE(scalbn(LargestDenormalF64, -1023, RM).isPosZero()); 3003 EXPECT_TRUE(scalbn(LargestDenormalF64, -1024, RM).isPosZero()); 3004 EXPECT_TRUE(scalbn(LargestDenormalF64, -2048, RM).isPosZero()); 3005 EXPECT_TRUE(scalbn(LargestDenormalF64, 2047, RM).isInfinity()); 3006 EXPECT_TRUE(scalbn(LargestDenormalF64, 2098, RM).isInfinity()); 3007 EXPECT_TRUE(scalbn(LargestDenormalF64, 2099, RM).isInfinity()); 3008 3009 EXPECT_TRUE(APFloat(APFloat::IEEEdouble, "0x1.ffffffffffffep-2") 3010 .bitwiseIsEqual(scalbn(LargestDenormalF64, 1021, RM))); 3011 EXPECT_TRUE(APFloat(APFloat::IEEEdouble, "0x1.ffffffffffffep-1") 3012 .bitwiseIsEqual(scalbn(LargestDenormalF64, 1022, RM))); 3013 EXPECT_TRUE(APFloat(APFloat::IEEEdouble, "0x1.ffffffffffffep+0") 3014 .bitwiseIsEqual(scalbn(LargestDenormalF64, 1023, RM))); 3015 EXPECT_TRUE(APFloat(APFloat::IEEEdouble, "0x1.ffffffffffffep+1023") 3016 .bitwiseIsEqual(scalbn(LargestDenormalF64, 2046, RM))); 3017 EXPECT_TRUE(APFloat(APFloat::IEEEdouble, "0x1p+974") 3018 .bitwiseIsEqual(scalbn(SmallestF64, 2048, RM))); 3019 3020 APFloat RandomDenormalF64(APFloat::IEEEdouble, "0x1.c60f120d9f87cp+51"); 3021 EXPECT_TRUE(APFloat(APFloat::IEEEdouble, "0x1.c60f120d9f87cp-972") 3022 .bitwiseIsEqual(scalbn(RandomDenormalF64, -1023, RM))); 3023 EXPECT_TRUE(APFloat(APFloat::IEEEdouble, "0x1.c60f120d9f87cp-1") 3024 .bitwiseIsEqual(scalbn(RandomDenormalF64, -52, RM))); 3025 EXPECT_TRUE(APFloat(APFloat::IEEEdouble, "0x1.c60f120d9f87cp-2") 3026 .bitwiseIsEqual(scalbn(RandomDenormalF64, -53, RM))); 3027 EXPECT_TRUE(APFloat(APFloat::IEEEdouble, "0x1.c60f120d9f87cp+0") 3028 .bitwiseIsEqual(scalbn(RandomDenormalF64, -51, RM))); 3029 3030 EXPECT_TRUE(scalbn(RandomDenormalF64, -2097, RM).isPosZero()); 3031 EXPECT_TRUE(scalbn(RandomDenormalF64, -2090, RM).isPosZero()); 3032 3033 3034 EXPECT_TRUE( 3035 APFloat(APFloat::IEEEdouble, "-0x1p-1073") 3036 .bitwiseIsEqual(scalbn(NegLargestF64, -2097, RM))); 3037 3038 EXPECT_TRUE( 3039 APFloat(APFloat::IEEEdouble, "-0x1p-1024") 3040 .bitwiseIsEqual(scalbn(NegLargestF64, -2048, RM))); 3041 3042 EXPECT_TRUE( 3043 APFloat(APFloat::IEEEdouble, "0x1p-1073") 3044 .bitwiseIsEqual(scalbn(LargestF64, -2097, RM))); 3045 3046 EXPECT_TRUE( 3047 APFloat(APFloat::IEEEdouble, "0x1p-1074") 3048 .bitwiseIsEqual(scalbn(LargestF64, -2098, RM))); 3049 EXPECT_TRUE(APFloat(APFloat::IEEEdouble, "-0x1p-1074") 3050 .bitwiseIsEqual(scalbn(NegLargestF64, -2098, RM))); 3051 EXPECT_TRUE(scalbn(NegLargestF64, -2099, RM).isNegZero()); 3052 EXPECT_TRUE(scalbn(LargestF64, 1, RM).isInfinity()); 3053 3054 3055 EXPECT_TRUE( 3056 APFloat(APFloat::IEEEdouble, "0x1p+0") 3057 .bitwiseIsEqual(scalbn(APFloat(APFloat::IEEEdouble, "0x1p+52"), -52, RM))); 3058 3059 EXPECT_TRUE( 3060 APFloat(APFloat::IEEEdouble, "0x1p-103") 3061 .bitwiseIsEqual(scalbn(APFloat(APFloat::IEEEdouble, "0x1p-51"), -52, RM))); 3062 } 3063 3064 TEST(APFloatTest, frexp) { 3065 const APFloat::roundingMode RM = APFloat::rmNearestTiesToEven; 3066 3067 APFloat PZero = APFloat::getZero(APFloat::IEEEdouble, false); 3068 APFloat MZero = APFloat::getZero(APFloat::IEEEdouble, true); 3069 APFloat One(1.0); 3070 APFloat MOne(-1.0); 3071 APFloat Two(2.0); 3072 APFloat MTwo(-2.0); 3073 3074 APFloat LargestDenormal(APFloat::IEEEdouble, "0x1.ffffffffffffep-1023"); 3075 APFloat NegLargestDenormal(APFloat::IEEEdouble, "-0x1.ffffffffffffep-1023"); 3076 3077 APFloat Smallest = APFloat::getSmallest(APFloat::IEEEdouble, false); 3078 APFloat NegSmallest = APFloat::getSmallest(APFloat::IEEEdouble, true); 3079 3080 APFloat Largest = APFloat::getLargest(APFloat::IEEEdouble, false); 3081 APFloat NegLargest = APFloat::getLargest(APFloat::IEEEdouble, true); 3082 3083 APFloat PInf = APFloat::getInf(APFloat::IEEEdouble, false); 3084 APFloat MInf = APFloat::getInf(APFloat::IEEEdouble, true); 3085 3086 APFloat QPNaN = APFloat::getNaN(APFloat::IEEEdouble, false); 3087 APFloat QMNaN = APFloat::getNaN(APFloat::IEEEdouble, true); 3088 APFloat SNaN = APFloat::getSNaN(APFloat::IEEEdouble, false); 3089 3090 // Make sure highest bit of payload is preserved. 3091 const APInt Payload(64, (UINT64_C(1) << 50) | 3092 (UINT64_C(1) << 49) | 3093 (UINT64_C(1234) << 32) | 3094 1); 3095 3096 APFloat SNaNWithPayload = APFloat::getSNaN(APFloat::IEEEdouble, false, 3097 &Payload); 3098 3099 APFloat SmallestNormalized 3100 = APFloat::getSmallestNormalized(APFloat::IEEEdouble, false); 3101 APFloat NegSmallestNormalized 3102 = APFloat::getSmallestNormalized(APFloat::IEEEdouble, true); 3103 3104 int Exp; 3105 APFloat Frac(APFloat::IEEEdouble); 3106 3107 3108 Frac = frexp(PZero, Exp, RM); 3109 EXPECT_EQ(0, Exp); 3110 EXPECT_TRUE(Frac.isPosZero()); 3111 3112 Frac = frexp(MZero, Exp, RM); 3113 EXPECT_EQ(0, Exp); 3114 EXPECT_TRUE(Frac.isNegZero()); 3115 3116 3117 Frac = frexp(One, Exp, RM); 3118 EXPECT_EQ(1, Exp); 3119 EXPECT_TRUE(APFloat(APFloat::IEEEdouble, "0x1p-1").bitwiseIsEqual(Frac)); 3120 3121 Frac = frexp(MOne, Exp, RM); 3122 EXPECT_EQ(1, Exp); 3123 EXPECT_TRUE(APFloat(APFloat::IEEEdouble, "-0x1p-1").bitwiseIsEqual(Frac)); 3124 3125 Frac = frexp(LargestDenormal, Exp, RM); 3126 EXPECT_EQ(-1022, Exp); 3127 EXPECT_TRUE(APFloat(APFloat::IEEEdouble, "0x1.ffffffffffffep-1").bitwiseIsEqual(Frac)); 3128 3129 Frac = frexp(NegLargestDenormal, Exp, RM); 3130 EXPECT_EQ(-1022, Exp); 3131 EXPECT_TRUE(APFloat(APFloat::IEEEdouble, "-0x1.ffffffffffffep-1").bitwiseIsEqual(Frac)); 3132 3133 3134 Frac = frexp(Smallest, Exp, RM); 3135 EXPECT_EQ(-1073, Exp); 3136 EXPECT_TRUE(APFloat(APFloat::IEEEdouble, "0x1p-1").bitwiseIsEqual(Frac)); 3137 3138 Frac = frexp(NegSmallest, Exp, RM); 3139 EXPECT_EQ(-1073, Exp); 3140 EXPECT_TRUE(APFloat(APFloat::IEEEdouble, "-0x1p-1").bitwiseIsEqual(Frac)); 3141 3142 3143 Frac = frexp(Largest, Exp, RM); 3144 EXPECT_EQ(1024, Exp); 3145 EXPECT_TRUE(APFloat(APFloat::IEEEdouble, "0x1.fffffffffffffp-1").bitwiseIsEqual(Frac)); 3146 3147 Frac = frexp(NegLargest, Exp, RM); 3148 EXPECT_EQ(1024, Exp); 3149 EXPECT_TRUE(APFloat(APFloat::IEEEdouble, "-0x1.fffffffffffffp-1").bitwiseIsEqual(Frac)); 3150 3151 3152 Frac = frexp(PInf, Exp, RM); 3153 EXPECT_EQ(INT_MAX, Exp); 3154 EXPECT_TRUE(Frac.isInfinity() && !Frac.isNegative()); 3155 3156 Frac = frexp(MInf, Exp, RM); 3157 EXPECT_EQ(INT_MAX, Exp); 3158 EXPECT_TRUE(Frac.isInfinity() && Frac.isNegative()); 3159 3160 Frac = frexp(QPNaN, Exp, RM); 3161 EXPECT_EQ(INT_MIN, Exp); 3162 EXPECT_TRUE(Frac.isNaN()); 3163 3164 Frac = frexp(QMNaN, Exp, RM); 3165 EXPECT_EQ(INT_MIN, Exp); 3166 EXPECT_TRUE(Frac.isNaN()); 3167 3168 Frac = frexp(SNaN, Exp, RM); 3169 EXPECT_EQ(INT_MIN, Exp); 3170 EXPECT_TRUE(Frac.isNaN() && !Frac.isSignaling()); 3171 3172 Frac = frexp(SNaNWithPayload, Exp, RM); 3173 EXPECT_EQ(INT_MIN, Exp); 3174 EXPECT_TRUE(Frac.isNaN() && !Frac.isSignaling()); 3175 EXPECT_EQ(Payload, Frac.bitcastToAPInt().getLoBits(51)); 3176 3177 Frac = frexp(APFloat(APFloat::IEEEdouble, "0x0.ffffp-1"), Exp, RM); 3178 EXPECT_EQ(-1, Exp); 3179 EXPECT_TRUE(APFloat(APFloat::IEEEdouble, "0x1.fffep-1").bitwiseIsEqual(Frac)); 3180 3181 Frac = frexp(APFloat(APFloat::IEEEdouble, "0x1p-51"), Exp, RM); 3182 EXPECT_EQ(-50, Exp); 3183 EXPECT_TRUE(APFloat(APFloat::IEEEdouble, "0x1p-1").bitwiseIsEqual(Frac)); 3184 3185 Frac = frexp(APFloat(APFloat::IEEEdouble, "0x1.c60f120d9f87cp+51"), Exp, RM); 3186 EXPECT_EQ(52, Exp); 3187 EXPECT_TRUE(APFloat(APFloat::IEEEdouble, "0x1.c60f120d9f87cp-1").bitwiseIsEqual(Frac)); 3188 } 3189 } 3190